Add post enumeration modification to generate.ts

src/config.ts

@@ -93,7 +93,11 @@ export interface QueryConfig {
   maxCardinalityForShape?: number;
   typeMatchesSchemaType?: boolean;
 
-  // Effectiveness Preference
+  // STYLIZE
+  smallBandSizeForHighCardinalityOrFacet?: {maxCardinality: number, bandSize: number};
+  nominalColorScaleForHighCardinality?: {maxCardinality: number, palette: string};
+
+  // EFFECTIVENESS PREFERENCE
   maxGoodCardinalityForColor?: number; // FIXME: revise
   maxGoodCardinalityForFacet?: number; // FIXME: revise
 }
@@ -156,8 +160,11 @@ export const DEFAULT_QUERY_CONFIG: QueryConfig = {
   maxCardinalityForShape: 6,
   typeMatchesSchemaType: true,
 
-  // Ranking Preference
+  // STYLIZE
+  smallBandSizeForHighCardinalityOrFacet: {maxCardinality: 10, bandSize: 12},
+  nominalColorScaleForHighCardinality: {maxCardinality: 10, palette: 'categorical20'},
 
+  // RANKING PREFERENCE
   maxGoodCardinalityForFacet: 5, // FIXME: revise
   maxGoodCardinalityForColor: 7, // FIXME: revise
 };

src/generate.ts

@@ -4,6 +4,7 @@ import {QueryConfig, DEFAULT_QUERY_CONFIG} from './config';
 import {SpecQueryModel} from './model';
 import {SpecQuery} from './query/spec';
 import {Schema} from './schema';
+import {stylize} from './stylize';
 
 export function generate(specQ: SpecQuery, schema: Schema, opt: QueryConfig = DEFAULT_QUERY_CONFIG) {
   // 1. Build a SpecQueryModel, which also contains enumSpecIndex
@@ -22,5 +23,9 @@ export function generate(specQ: SpecQuery, schema: Schema, opt: QueryConfig = DE
     }
   });
 
+  if ((opt.nominalColorScaleForHighCardinality !== null) || (opt.smallBandSizeForHighCardinalityOrFacet !== null)) {
+    return stylize(answerSet, schema, opt);
+  }
+
   return answerSet;
 }

src/stylize.ts

@@ -0,0 +1,99 @@
+import {Channel} from 'vega-lite/src/channel';
+import {ScaleType} from 'vega-lite/src/scale';
+import {Type} from 'vega-lite/src/type';
+
+import {QueryConfig} from './config';
+import {SpecQueryModel} from './model';
+import {EncodingQuery, ScaleQuery, scaleType} from './query/encoding';
+import {Schema} from './schema';
+import {contains, Dict} from './util';
+
+export function stylize(answerSet: SpecQueryModel[], schema: Schema, opt: QueryConfig): SpecQueryModel[] {
+  answerSet = answerSet.map(function(specM) {
+    if (opt.smallBandSizeForHighCardinalityOrFacet) {
+      specM = smallBandSizeForHighCardinalityOrFacet(specM, schema);
+     }
+
+    if (opt.nominalColorScaleForHighCardinality) {
+      specM = nominalColorScaleForHighCardinality(specM, schema);
+    }
+    return specM;
+  });
+
+  return answerSet;
+}
+
+let encQIndex: Dict<EncodingQuery> = {};
+
+export function smallBandSizeForHighCardinalityOrFacet(specM: SpecQueryModel, schema: Schema): SpecQueryModel {
+ [Channel.ROW, Channel.Y, Channel.COLUMN, Channel.X].forEach((channel) => {
+        encQIndex[channel] = specM.getEncodingQueryByChannel(channel);
+      });
+
+  const yEncQ = encQIndex[Channel.Y];
+  if (yEncQ !== undefined) {
+    if (encQIndex[Channel.ROW] ||
+        schema.cardinality(yEncQ) > 10) {
+
+      // We check for undefined rather than
+      // yEncQ.scale = yEncQ.scale || {} to cover the case where
+      // yEncQ.scale has been set to false/null.
+      // This prevents us from incorrectly overriding scale and
+      // assigning a bandSize when scale is set to false.
+      if (yEncQ.scale === undefined) {
+        yEncQ.scale = {};
+      }
+
+      // We do not want to assign a bandSize if scale is set to false
+      // and we only apply this if the scale is (or can be) an ordinal scale.
+      if (yEncQ.scale && contains([ScaleType.ORDINAL, undefined], scaleType((yEncQ.scale as ScaleQuery).type, yEncQ.timeUnit, yEncQ.type))) {
+        if (!(yEncQ.scale as ScaleQuery).bandSize) {
+          (yEncQ.scale as ScaleQuery).bandSize = 12;
+        }
+      }
+    }
+  }
+
+  const xEncQ = encQIndex[Channel.X];
+  if (xEncQ !== undefined) {
+    if (encQIndex[Channel.COLUMN] ||
+        schema.cardinality(xEncQ) > 10) {
+
+      // Just like y, we don't want to do this if scale is null/false
+      if (xEncQ.scale === undefined) {
+        xEncQ.scale = {};
+      }
+
+      // We do not want to assign a bandSize if scale is set to false
+      // and we only apply this if the scale is (or can be) an ordinal scale.
+      if (xEncQ.scale && contains([ScaleType.ORDINAL, undefined], scaleType((xEncQ.scale as ScaleQuery).type, xEncQ.timeUnit, xEncQ.type))) {
+        if (!(xEncQ.scale as ScaleQuery).bandSize) {
+          (xEncQ.scale as ScaleQuery).bandSize = 12;
+        }
+      }
+    }
+  }
+
+  return specM;
+}
+
+export function nominalColorScaleForHighCardinality(specM: SpecQueryModel, schema: Schema): SpecQueryModel {
+  encQIndex[Channel.COLOR] = specM.getEncodingQueryByChannel(Channel.COLOR);
+
+  const colorEncQ = encQIndex[Channel.COLOR];
+  if ((colorEncQ !== undefined) && (colorEncQ.type === Type.NOMINAL) &&
+      (schema.cardinality(colorEncQ) > 10)) {
+
+    if (colorEncQ.scale === undefined) {
+      colorEncQ.scale = {};
+    }
+
+    if (colorEncQ.scale) {
+      if (!(colorEncQ.scale as ScaleQuery).range) {
+        (colorEncQ.scale as ScaleQuery).range = 'category20';
+      }
+    }
+  }
+
+  return specM;
+}

test/generate.test.ts

@@ -539,26 +539,26 @@ describe('generate', function () {
   describe('autoAddCount', () => {
     describe('ordinal only', () => {
       it('should output autoCount in the answer set', () => {
-        const query = {
+        const specQ = {
           mark: Mark.POINT,
           encodings: [
               { channel: Channel.X, field: 'O', type: Type.ORDINAL},
           ]
         };
-        const answerSet = generate(query, schema, CONFIG_WITH_AUTO_ADD_COUNT);
+        const answerSet = generate(specQ, schema, CONFIG_WITH_AUTO_ADD_COUNT);
         assert.equal(answerSet.length, 1);
         assert.isTrue(answerSet[0].getEncodings()[1].autoCount);
       });
     });
 
     describe('non-binned quantitative only', () => {
-      const query = {
+      const specQ = {
         mark: Mark.POINT,
         encodings: [
           { channel: Channel.X, field: 'Q', type: Type.QUANTITATIVE},
         ]
       };
-      const answerSet = generate(query, schema, CONFIG_WITH_AUTO_ADD_COUNT);
+      const answerSet = generate(specQ, schema, CONFIG_WITH_AUTO_ADD_COUNT);
 
       it('should output autoCount=false', () => {
         assert.isFalse(answerSet[0].getEncodingQueryByIndex(1).autoCount);
@@ -570,7 +570,7 @@ describe('generate', function () {
     });
 
     describe('enumerate channel for a non-binned quantitative field', () => {
-      const query = {
+      const specQ = {
         mark: Mark.POINT,
         encodings: [
           {
@@ -580,7 +580,7 @@ describe('generate', function () {
           }
         ]
       };
-      const answerSet = generate(query, schema, CONFIG_WITH_AUTO_ADD_COUNT);
+      const answerSet = generate(specQ, schema, CONFIG_WITH_AUTO_ADD_COUNT);
 
       it('should not output point with only size for color', () => {
         answerSet.forEach((model) => {
@@ -592,4 +592,85 @@ describe('generate', function () {
       });
     });
   });
+
+  describe('stylizer', () => {
+    it('should generate answerSet when all stylizers are turned off', () => {
+      const specQ = {
+        mark: Mark.POINT,
+        encodings: [
+          {
+            channel: Channel.X,
+            field: 'A',
+            type: Type.QUANTITATIVE
+          }
+        ]
+      };
+
+      const CONFIG_WITHOUT_HIGH_CARDINALITY_OR_FACET = extend(
+        {}, DEFAULT_QUERY_CONFIG, {nominalColorScaleForHighCardinality: null}, {smallBandSizeForHighCardinalityOrFacet: null});
+
+      const answerSet = generate(specQ, schema, CONFIG_WITHOUT_HIGH_CARDINALITY_OR_FACET);
+      assert.equal(answerSet.length, 1);
+    });
+
+    describe('nominalColorScaleForHighCardinality', () => {
+      it('should output range = category20', () => {
+        const specQ = {
+          mark: Mark.POINT,
+          encodings: [
+            {
+              channel: Channel.COLOR,
+              field: 'N20',
+              scale: {},
+              type: Type.NOMINAL
+            }
+          ]
+        };
+
+        const answerSet = generate(specQ, schema, DEFAULT_QUERY_CONFIG);
+        assert.equal((answerSet[0].getEncodingQueryByIndex(0).scale as ScaleQuery).range, 'category20');
+      });
+    });
+
+    describe('smallBandSizeForHighCardinalityOrFacet', () => {
+      it('should output bandSize = 12', () => {
+        const specQ = {
+          mark: Mark.BAR,
+          encodings: [
+            {
+              channel: Channel.Y,
+              field: 'O_100',
+              scale: {},
+              type: Type.ORDINAL
+            }
+          ]
+        };
+
+        const answerSet = generate(specQ, schema, DEFAULT_QUERY_CONFIG);
+        assert.equal((answerSet[0].getEncodingQueryByIndex(0).scale as ScaleQuery).bandSize, 12);
+      });
+
+      it('should output bandSize = 12', () => {
+        const specQ = {
+          mark: Mark.BAR,
+          encodings: [
+            {
+              channel: Channel.Y,
+              field: 'A',
+              scale: {},
+              type: Type.ORDINAL
+            },
+            {
+              channel: Channel.ROW,
+              field: 'A',
+              type: Type.ORDINAL
+            }
+          ]
+        };
+
+        const answerSet = generate(specQ, schema, DEFAULT_QUERY_CONFIG);
+        assert.equal((answerSet[0].getEncodingQueryByIndex(0).scale as ScaleQuery).bandSize, 12);
+      });
+    });
+  });
 });