bar: add text-related attributes

* Added attributes textposition, textfont, insidetextfont and
  outsidetextfont.

* All these attributes accept arrays.

Author: n-riesco

src/plot_api/helpers.js

@@ -298,7 +298,7 @@ exports.cleanData = function(data, existingData) {
             trace.scene = Plots.subplotsRegistry.gl3d.cleanId(trace.scene);
         }
 
-        if(!Registry.traceIs(trace, 'pie')) {
+        if(!Registry.traceIs(trace, 'pie') && !Registry.traceIs(trace, 'bar')) {
             if(Array.isArray(trace.textposition)) {
                 trace.textposition = trace.textposition.map(cleanTextPosition);
             }

src/traces/bar/attributes.js

@@ -12,6 +12,7 @@ var scatterAttrs = require('../scatter/attributes');
 var colorAttributes = require('../../components/colorscale/color_attributes');
 var errorBarAttrs = require('../../components/errorbars/attributes');
 var colorbarAttrs = require('../../components/colorbar/attributes');
+var fontAttrs = require('../../plots/font_attributes');
 
 var extendFlat = require('../../lib/extend').extendFlat;
 
@@ -40,8 +41,35 @@ module.exports = {
     y: scatterAttrs.y,
     y0: scatterAttrs.y0,
     dy: scatterAttrs.dy,
+
     text: scatterAttrs.text,
 
+    textposition: {
+        valType: 'enumerated',
+        role: 'info',
+        values: ['inside', 'outside', 'auto', 'none'],
+        dflt: 'none',
+        arrayOk: true,
+        description: [
+            'Specifies the location of the `textinfo`.'
+        ].join(' ')
+    },
+
+    textfont: extendFlat({}, fontAttrs, {
+        arrayOk: true,
+        description: 'Sets the font used for `textinfo`.'
+    }),
+
+    insidetextfont: extendFlat({}, fontAttrs, {
+        arrayOk: true,
+        description: 'Sets the font used for `textinfo` lying inside the bar.'
+    }),
+
+    outsidetextfont: extendFlat({}, fontAttrs, {
+        arrayOk: true,
+        description: 'Sets the font used for `textinfo` lying outside the bar.'
+    }),
+
     orientation: {
         valType: 'enumerated',
         role: 'info',

src/traces/bar/defaults.js

@@ -9,6 +9,9 @@
 
 'use strict';
 
+var isNumeric = require('fast-isnumeric');
+var tinycolor = require('tinycolor2');
+
 var Lib = require('../../lib');
 var Color = require('../../components/color');
 
@@ -23,6 +26,125 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
         return Lib.coerce(traceIn, traceOut, attributes, attr, dflt);
     }
 
+    function coerceEnumerated(attributeDefinition, value, defaultValue) {
+        if(attributeDefinition.coerceNumber) value = +value;
+
+        if(attributeDefinition.values.indexOf(value) !== -1) return value;
+
+        return (defaultValue !== undefined) ?
+            defaultValue :
+            attributeDefinition.dflt;
+    }
+
+    function coerceString(attributeDefinition, value, defaultValue) {
+        if(typeof value === 'string') {
+            if(value || !attributeDefinition.noBlank) return value;
+        }
+        else if(typeof value === 'number') {
+            if(!attributeDefinition.strict) return String(value);
+        }
+
+        return (defaultValue !== undefined) ?
+            defaultValue :
+            attributeDefinition.dflt;
+    }
+
+    function coerceNumber(attributeDefinition, value, defaultValue) {
+        if(isNumeric(value)) {
+            value = +value;
+
+            var min = attributeDefinition.min,
+                max = attributeDefinition.max,
+                isOutOfBounds = (min !== undefined && value < min) ||
+                    (max !== undefined && value > max);
+
+            if(!isOutOfBounds) return value;
+        }
+
+        return (defaultValue !== undefined) ?
+            defaultValue :
+            attributeDefinition.dflt;
+    }
+
+    function coerceColor(attributeDefinition, value, defaultValue) {
+        if(tinycolor(value).isValid()) return value;
+
+        return (defaultValue !== undefined) ?
+            defaultValue :
+            attributeDefinition.dflt;
+    }
+
+    function coerceFont(attributeDefinition, value, defaultValue) {
+        value = value || {};
+        defaultValue = defaultValue || {};
+
+        return {
+            family: coerceString(
+                attributeDefinition.family, value.family, defaultValue.family),
+            size: coerceNumber(
+                attributeDefinition.size, value.size, defaultValue.size),
+            color: coerceColor(
+                attributeDefinition.color, value.color, defaultValue.color)
+        };
+    }
+
+    function coerceArray(attribute, coerceFunction, defaultValue, defaultValue2) {
+        var attributeDefinition = attributes[attribute],
+            arrayOk = attributeDefinition.arrayOk,
+            inValue = traceIn[attribute],
+            inValueIsArray = Array.isArray(inValue),
+            defaultValueIsArray = Array.isArray(defaultValue),
+            outValue,
+            i;
+
+        // Case: inValue and defaultValue not treated as arrays
+        if(!arrayOk || (!inValueIsArray && !defaultValueIsArray)) {
+            outValue = coerceFunction(
+                attributeDefinition, inValue, defaultValue);
+            traceOut[attribute] = outValue;
+            return outValue;
+        }
+
+        // Coerce into an array
+        outValue = [];
+
+        // Case: defaultValue is an array and inValue isn't
+        if(!inValueIsArray) {
+            for(i = 0; i < defaultValue.length; i++) {
+                outValue.push(
+                    coerceFunction(
+                        attributeDefinition, inValue, defaultValue[i]));
+            }
+        }
+
+        // Case: inValue is an array and defaultValue isn't
+        else if(!defaultValueIsArray) {
+            for(i = 0; i < inValue.length; i++) {
+                outValue.push(
+                    coerceFunction(
+                        attributeDefinition, inValue[i], defaultValue));
+            }
+        }
+
+        // Case: inValue and defaultValue are both arrays
+        else {
+            for(i = 0; i < defaultValue.length; i++) {
+                outValue.push(
+                    coerceFunction(
+                        attributeDefinition, inValue[i], defaultValue[i]));
+            }
+            for(; i < inValue.length; i++) {
+                outValue.push(
+                    coerceFunction(
+                        attributeDefinition, inValue[i], defaultValue2));
+            }
+        }
+
+        traceOut[attribute] = outValue;
+
+        return outValue;
+    }
+
     var len = handleXYDefaults(traceIn, traceOut, coerce);
     if(!len) {
         traceOut.visible = false;
@@ -33,7 +155,23 @@ module.exports = function supplyDefaults(traceIn, traceOut, defaultColor, layout
     coerce('base');
     coerce('offset');
     coerce('width');
-    coerce('text');
+
+    coerceArray('text', coerceString);
+
+    var textPosition = coerceArray('textposition', coerceEnumerated);
+
+    var hasBoth = Array.isArray(textPosition) || textPosition === 'auto',
+        hasInside = hasBoth || textPosition === 'inside',
+        hasOutside = hasBoth || textPosition === 'outside';
+    if(hasInside || hasOutside) {
+        var textFont = coerceArray('textfont', coerceFont, layout.font);
+        if(hasInside) {
+            coerceArray('insidetextfont', coerceFont, textFont, layout.font);
+        }
+        if(hasOutside) {
+            coerceArray('outsidetextfont', coerceFont, textFont, layout.font);
+        }
+    }
 
     handleStyleDefaults(traceIn, traceOut, coerce, defaultColor, layout);