docks_theme_api 1.0.2

data/source/vendor/index.js

@@ -0,0 +1 @@
+import "./array_includes";

data/source/vendor/matrix.js

@@ -0,0 +1,399 @@
+(function () {
+
+"use strict";
+
+// a CSSMatrix shim
+// http://www.w3.org/TR/css3-3d-transforms/#cssmatrix-interface
+// http://www.w3.org/TR/css3-2d-transforms/#cssmatrix-interface
+
+
+// decimal values in WebKitCSSMatrix.prototype.toString are truncated to 6 digits
+var SMALL_NUMBER = 1e-6;
+
+/**
+ * CSSMatrix Shim
+ * @constructor
+ */
+function CSSMatrix() {
+  var a = [].slice.call(arguments),
+    m = this;
+  if (a.length) for (var i = a.length; i--;) {
+    if (Math.abs(a[i]) < SMALL_NUMBER) a[i] = 0;
+  }
+  setIdentity(m);
+  if (a.length == 16) {
+    m.m11 = m.a = a[0];  m.m12 = m.b = a[1];  m.m13 = a[2];  m.m14 = a[3];
+    m.m21 = m.c = a[4];  m.m22 = m.d = a[5];  m.m23 = a[6];  m.m24 = a[7];
+    m.m31 = a[8];  m.m32 = a[9];  m.m33 = a[10]; m.m34 = a[11];
+    m.m41 = m.e = a[12]; m.m42 = m.f = a[13]; m.m43 = a[14]; m.m44 = a[15];
+  } else if (a.length == 6) {
+    m.m11 = m.a = a[0]; m.m12 = m.b = a[1];
+    m.m21 = m.c = a[2]; m.m22 = m.d = a[3];
+    m.m41 = m.e = a[4]; m.m42 = m.f = a[5];
+  } else if (typeof a[0] == 'string') {
+    m.setMatrixValue(a[0]);
+  } else if (a.length > 0) {
+    throw new TypeError('Invalid Matrix Value');
+  }
+}
+
+// Transformations
+
+// http://en.wikipedia.org/wiki/Rotation_matrix
+function rotate(rx, ry, rz) {
+  rx *= Math.PI / 180;
+  ry *= Math.PI / 180;
+  rz *= Math.PI / 180;
+  // minus sin() because of right-handed system
+  var cosx = Math.cos(rx), sinx = - Math.sin(rx);
+  var cosy = Math.cos(ry), siny = - Math.sin(ry);
+  var cosz = Math.cos(rz), sinz = - Math.sin(rz);
+  var m = new CSSMatrix();
+
+  m.m11 = m.a = cosy * cosz;
+  m.m12 = m.b = - cosy * sinz;
+  m.m13 = siny;
+
+  m.m21 = m.c = sinx * siny * cosz + cosx * sinz;
+  m.m22 = m.d = cosx * cosz - sinx * siny * sinz;
+  m.m23 = - sinx * cosy;
+
+  m.m31 = sinx * sinz - cosx * siny * cosz;
+  m.m32 = sinx * cosz + cosx * siny * sinz;
+  m.m33 = cosx * cosy;
+
+  return m;
+}
+
+
+function rotateAxisAngle(x, y, z, angle) {
+  angle *= Math.PI / 360;
+
+  var sinA = Math.sin(angle), cosA = Math.cos(angle), sinA2 = sinA * sinA;
+  var length = Math.sqrt(x * x + y * y + z * z);
+
+  if (length === 0) {
+    // bad vector length, use something reasonable
+    x = 0;
+    y = 0;
+    z = 1;
+  } else {
+    x /= length;
+    y /= length;
+    z /= length;
+  }
+
+  var x2 = x * x, y2 = y * y, z2 = z * z;
+
+  var m = new CSSMatrix();
+  m.m11 = m.a = 1 - 2 * (y2 + z2) * sinA2;
+  m.m12 = m.b = 2 * (x * y * sinA2 + z * sinA * cosA);
+  m.m13 = 2 * (x * z * sinA2 - y * sinA * cosA);
+  m.m21 = m.c = 2 * (y * x * sinA2 - z * sinA * cosA);
+  m.m22 = m.d = 1 - 2 * (z2 + x2) * sinA2;
+  m.m23 = 2 * (y * z * sinA2 + x * sinA * cosA);
+  m.m31 = 2 * (z * x * sinA2 + y * sinA * cosA);
+  m.m32 = 2 * (z * y * sinA2 - x * sinA * cosA);
+  m.m33 = 1 - 2 * (x2 + y2) * sinA2;
+  m.m14 = m.m24 = m.m34 = 0;
+  m.m41 = m.e = m.m42 = m.f = m.m43 = 0;
+  m.m44 = 1;
+
+  return m;
+}
+
+
+function scale(x, y, z) {
+  var m = new CSSMatrix();
+  m.m11 = m.a = x;
+  m.m22 = m.d = y;
+  m.m33 = z;
+  return m;
+}
+
+
+function skewX(angle) {
+  angle *= Math.PI / 180;
+  var m = new CSSMatrix();
+  m.m21 = m.c = Math.tan(angle);
+  return m;
+}
+
+
+function skewY(angle) {
+  angle *= Math.PI / 180;
+  var m = new CSSMatrix();
+  m.m12 = m.b = Math.tan(angle);
+  return m;
+}
+
+
+function translate(x, y, z) {
+  var m = new CSSMatrix();
+  m.m41 = m.e = x;
+  m.m42 = m.f = y;
+  m.m43 = z;
+  return m;
+}
+
+
+function inverse(m) {
+  throw new Error('the inverse() method is not implemented (yet).');
+}
+
+
+function multiply(m1, m2) {
+
+  var m11 = m2.m11 * m1.m11 + m2.m12 * m1.m21 + m2.m13 * m1.m31 + m2.m14 * m1.m41,
+    m12 = m2.m11 * m1.m12 + m2.m12 * m1.m22 + m2.m13 * m1.m32 + m2.m14 * m1.m42,
+    m13 = m2.m11 * m1.m13 + m2.m12 * m1.m23 + m2.m13 * m1.m33 + m2.m14 * m1.m43,
+    m14 = m2.m11 * m1.m14 + m2.m12 * m1.m24 + m2.m13 * m1.m34 + m2.m14 * m1.m44,
+
+    m21 = m2.m21 * m1.m11 + m2.m22 * m1.m21 + m2.m23 * m1.m31 + m2.m24 * m1.m41,
+    m22 = m2.m21 * m1.m12 + m2.m22 * m1.m22 + m2.m23 * m1.m32 + m2.m24 * m1.m42,
+    m23 = m2.m21 * m1.m13 + m2.m22 * m1.m23 + m2.m23 * m1.m33 + m2.m24 * m1.m43,
+    m24 = m2.m21 * m1.m14 + m2.m22 * m1.m24 + m2.m23 * m1.m34 + m2.m24 * m1.m44,
+
+    m31 = m2.m31 * m1.m11 + m2.m32 * m1.m21 + m2.m33 * m1.m31 + m2.m34 * m1.m41,
+    m32 = m2.m31 * m1.m12 + m2.m32 * m1.m22 + m2.m33 * m1.m32 + m2.m34 * m1.m42,
+    m33 = m2.m31 * m1.m13 + m2.m32 * m1.m23 + m2.m33 * m1.m33 + m2.m34 * m1.m43,
+    m34 = m2.m31 * m1.m14 + m2.m32 * m1.m24 + m2.m33 * m1.m34 + m2.m34 * m1.m44,
+
+    m41 = m2.m41 * m1.m11 + m2.m42 * m1.m21 + m2.m43 * m1.m31 + m2.m44 * m1.m41,
+    m42 = m2.m41 * m1.m12 + m2.m42 * m1.m22 + m2.m43 * m1.m32 + m2.m44 * m1.m42,
+    m43 = m2.m41 * m1.m13 + m2.m42 * m1.m23 + m2.m43 * m1.m33 + m2.m44 * m1.m43,
+    m44 = m2.m41 * m1.m14 + m2.m42 * m1.m24 + m2.m43 * m1.m34 + m2.m44 * m1.m44;
+
+  return new CSSMatrix(
+    m11, m12, m13, m14,
+    m21, m22, m23, m24,
+    m31, m32, m33, m34,
+    m41, m42, m43, m44
+  );
+}
+
+// Helpers
+
+/**
+ * Set the specified matrix to the identity form
+ *
+ * @return {CSSMatrix} the matrix
+ */
+function setIdentity(m) {
+  m.m11 = m.a = 1; m.m12 = m.b = 0; m.m13 = 0; m.m14 = 0;
+  m.m21 = m.c = 0; m.m22 = m.d = 1; m.m23 = 0; m.m24 = 0;
+  m.m31 = 0; m.m32 = 0; m.m33 = 1; m.m34 = 0;
+  m.m41 = m.e = 0; m.m42 = m.f = 0; m.m43 = 0; m.m44 = 1;
+  return m;
+}
+
+/**
+ * Returns true of the given matrix is affine
+ *
+ * @return {boolean} affine
+ */
+function isAffine(m) {
+  if (!(m.m13 || m.m14 ||
+    m.m23 || m.m24 ||
+    m.m31 || m.m32 || m.m33 !== 1 || m.m34 ||
+    m.m43 || m.m44 !== 1)) return true;
+  return false;
+}
+
+
+// w3c defined methods
+
+/**
+ * The setMatrixValue method replaces the existing matrix with one computed
+ * from parsing the passed string as though it had been assigned to the
+ * transform property in a CSS style rule.
+ * @param {String} string The string to parse.
+ */
+CSSMatrix.prototype.setMatrixValue = function(string) {
+  var i, m = this,
+    parts = [],
+    patternNone = /^none$/,
+    patternMatrix = /^matrix\((.*)\)/,
+    patternMatrix3d = /^matrix3d\((.*)\)/;
+
+  string = String(string).trim();
+  setIdentity(m);
+
+  if (patternNone.test(string)) return m;
+
+  parts = string.replace(/^.*\((.*)\)$/g, "$1").split(/\s*,\s*/);
+  for (i = parts.length; i--;) parts[i] = parseFloat(parts[i]);
+
+  if (patternMatrix.test(string) && parts.length === 6) {
+    m.m11 = m.a = parts[0]; m.m12 = m.b = parts[2]; m.m41 = m.e = parts[4];
+    m.m21 = m.c = parts[1]; m.m22 = m.d = parts[3]; m.m42 = m.f = parts[5];
+  } else if (patternMatrix3d.test(string) && parts.length === 16) {
+    m.m11 = m.a = parts[0]; m.m12 = m.b = parts[1]; m.m13 = parts[2];  m.m14 = parts[3];
+    m.m21 = m.c = parts[4]; m.m22 = m.d = parts[5]; m.m23 = parts[6];  m.m24 = parts[7];
+    m.m31 = parts[8]; m.m32 = parts[9]; m.m33 = parts[10]; m.m34 = parts[11];
+    m.m41 = m.e = parts[12]; m.m42 = m.f = parts[13]; m.m43 = parts[14]; m.m44 = parts[15];
+  } else {
+    throw new TypeError('Invalid Matrix Value');
+  }
+  return m;
+};
+
+
+/**
+ * The multiply method returns a new CSSMatrix which is the result of this
+ * matrix multiplied by the passed matrix, with the passed matrix to the right.
+ * This matrix is not modified.
+ *
+ * @param {CSSMatrix} m2
+ * @return {CSSMatrix} The result matrix.
+ */
+CSSMatrix.prototype.multiply = function(m2) {
+  return multiply(this, m2);
+};
+
+
+/**
+ * The inverse method returns a new matrix which is the inverse of this matrix.
+ * This matrix is not modified.
+ *
+ * method not implemented yet
+ */
+CSSMatrix.prototype.inverse = function() {
+  return inverse(this);
+};
+
+
+/**
+ * The translate method returns a new matrix which is this matrix post
+ * multiplied by a translation matrix containing the passed values. If the z
+ * component is undefined, a 0 value is used in its place. This matrix is not
+ * modified.
+ *
+ * @param {number} x X component of the translation value.
+ * @param {number} y Y component of the translation value.
+ * @param {number=} z Z component of the translation value.
+ * @return {CSSMatrix} The result matrix
+ */
+CSSMatrix.prototype.translate = function(x, y, z) {
+  if (typeof z == 'undefined') z = 0;
+  return multiply(this, translate(x, y, z));
+};
+
+
+/**
+ * The scale method returns a new matrix which is this matrix post multiplied by
+ * a scale matrix containing the passed values. If the z component is undefined,
+ * a 1 value is used in its place. If the y component is undefined, the x
+ * component value is used in its place. This matrix is not modified.
+ *
+ * @param {number} x The X component of the scale value.
+ * @param {number=} y The Y component of the scale value.
+ * @param {number=} z The Z component of the scale value.
+ * @return {CSSMatrix} The result matrix
+ */
+CSSMatrix.prototype.scale = function(x, y, z) {
+  if (typeof y == 'undefined') y = x;
+  if (typeof z == 'undefined') z = 1;
+  return multiply(this, scale(x, y, z));
+};
+
+
+/**
+ * The rotate method returns a new matrix which is this matrix post multiplied
+ * by each of 3 rotation matrices about the major axes, first X, then Y, then Z.
+ * If the y and z components are undefined, the x value is used to rotate the
+ * object about the z axis, as though the vector (0,0,x) were passed. All
+ * rotation values are in degrees. This matrix is not modified.
+ *
+ * @param {number} rx The X component of the rotation value, or the Z component if the rotY and rotZ parameters are undefined.
+ * @param {number=} ry The (optional) Y component of the rotation value.
+ * @param {number=} rz The (optional) Z component of the rotation value.
+ * @return {CSSMatrix} The result matrix
+ */
+CSSMatrix.prototype.rotate = function(rx, ry, rz) {
+  if (typeof ry == 'undefined') ry = rx;
+  if (typeof rz == 'undefined') rz = rx;
+  return multiply(this, rotate(rx, ry, rz));
+};
+
+
+/**
+ * The rotateAxisAngle method returns a new matrix which is this matrix post
+ * multiplied by a rotation matrix with the given axis and angle. The right-hand
+ * rule is used to determine the direction of rotation. All rotation values are
+ * in degrees. This matrix is not modified.
+ *
+ * @param {number} x The X component of the axis vector.
+ * @param {number=} y The Y component of the axis vector.
+ * @param {number=} z The Z component of the axis vector.
+ * @param {number} angle The angle of rotation about the axis vector, in degrees.
+ * @return {CSSMatrix} The result matrix
+ */
+CSSMatrix.prototype.rotateAxisAngle = function(x, y, z, angle) {
+  if (typeof y == 'undefined') y = x;
+  if (typeof z == 'undefined') z = x;
+  return multiply(this, rotateAxisAngle(x, y, z, angle));
+};
+
+
+/**
+ * Returns a string representation of the matrix.
+ * @return {string}
+ */
+CSSMatrix.prototype.toString = function() {
+  var affine, m = this,
+    fix = function (val) {
+      return val.toFixed(6);
+    };
+
+  if (isAffine(m)) affine = true;
+
+  if (affine) {
+    return  'matrix(' + [
+      m.a, m.b,
+      m.c, m.d,
+      m.e, m.f
+    ].map(fix).join(', ') + ')';
+  }
+  // note: the elements here are transposed
+  return  'matrix3d(' + [
+    m.m11, m.m12, m.m13, m.m14,
+    m.m21, m.m22, m.m23, m.m24,
+    m.m31, m.m32, m.m33, m.m34,
+    m.m41, m.m42, m.m43, m.m44
+  ].map(fix).join(', ') + ')';
+};
+
+
+// Defined in WebKitCSSMatrix, but not in the w3c draft
+
+/**
+ * Specifies a skew transformation along the x-axis by the given angle.
+ *
+ * @param {number} angle The angle amount in degrees to skew.
+ * @return {CSSMatrix} The result matrix
+ */
+CSSMatrix.prototype.skewX = function(angle) {
+  return multiply(skewX(angle), this);
+};
+
+/**
+ * Specifies a skew transformation along the x-axis by the given angle.
+ *
+ * @param {number} angle The angle amount in degrees to skew.
+ * @return {CSSMatrix} The result matrix
+ */
+CSSMatrix.prototype.skewY = function(angle) {
+  return multiply(skewY(angle), this);
+};
+
+if (typeof exports !== 'undefined') {
+  if (typeof module !== 'undefined' && module.exports) {
+    exports = module.exports = CSSMatrix;
+  }
+  exports.CSSMatrix = CSSMatrix;
+} else {
+  window.CSSMatrix = CSSMatrix;
+}
+
+})();

data/source/vendor/query_string.js

@@ -0,0 +1,66 @@
+/*!
+  query-string
+  Parse and stringify URL query strings
+  https://github.com/sindresorhus/query-string
+  by Sindre Sorhus
+  MIT License
+*/
+(function () {
+  'use strict';
+  var queryString = {};
+
+  queryString.parse = function (str) {
+    if (typeof str !== 'string') {
+      return {};
+    }
+
+    str = str.trim().replace(/^(\?|#)/, '');
+
+    if (!str) {
+      return {};
+    }
+
+    return str.trim().split('&').reduce(function (ret, param) {
+      var parts = param.replace(/\+/g, ' ').split('=');
+      var key = parts[0];
+      var val = parts[1];
+
+      key = decodeURIComponent(key);
+      // missing `=` should be `null`:
+      // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+      val = val === undefined ? null : decodeURIComponent(val);
+
+      if (!ret.hasOwnProperty(key)) {
+        ret[key] = val;
+      } else if (Array.isArray(ret[key])) {
+        ret[key].push(val);
+      } else {
+        ret[key] = [ret[key], val];
+      }
+
+      return ret;
+    }, {});
+  };
+
+  queryString.stringify = function (obj) {
+    return obj ? Object.keys(obj).map(function (key) {
+      var val = obj[key];
+
+      if (Array.isArray(val)) {
+        return val.map(function (val2) {
+          return encodeURIComponent(key) + '=' + encodeURIComponent(val2);
+        }).join('&');
+      }
+
+      return encodeURIComponent(key) + '=' + encodeURIComponent(val);
+    }).join('&') : '';
+  };
+
+  if (typeof define === 'function' && define.amd) {
+    define(function() { return queryString; });
+  } else if (typeof module !== 'undefined' && module.exports) {
+    module.exports = queryString;
+  } else {
+    window.queryString = queryString;
+  }
+})();

data/spec/assets/.eslintrc

@@ -0,0 +1,9 @@
+{
+  "env": {
+    "browser": true,
+    "jquery": true,
+    "mocha": true,
+    "node": true,
+    "es6": true
+  }
+}

data/spec/assets/spec_fixture.js

@@ -0,0 +1,33 @@
+var Fixture;
+
+Fixture = {
+  node: null,
+
+  prepare() {
+    var node;
+
+    this.clean();
+
+    node = document.createElement("div");
+    node.id = "Fixture";
+    node.style.visibility = "hidden";
+    document.body.appendChild(node);
+
+    this.node = node;
+  },
+
+  clean() {
+    var parent;
+
+    if(!this.node) { return; }
+    parent = this.node.parentNode;
+    if(parent) { parent.removeChild(this.node); }
+  },
+
+  load(content) {
+    this.node.innerHTML = content;
+    return this.node;
+  }
+};
+
+export default Fixture;

data/spec/assets/spec_helper.js

@@ -0,0 +1,19 @@
+import sinon from "sinon";
+import { expect } from "chai";
+import Fixture from "./spec_fixture";
+
+global.expect = expect;
+global.sinon = sinon;
+global.Fixture = Fixture;
+
+mocha.setup("bdd");
+
+beforeEach(() => {
+  Fixture.prepare();
+  global.sandbox = sinon.sandbox.create();
+});
+
+afterEach(() => {
+  Fixture.clean();
+  global.sandbox.restore();
+});

data/spec/lib/components/base_component_spec.rb

@@ -0,0 +1,156 @@
+require "spec_helper"
+
+describe Docks::Themes::API::Components::Base do
+  subject { described_class }
+  let(:view) { OpenStruct.new }
+
+  describe "#classes" do
+    let(:classes) { %w(foo bar baz) }
+    let(:other_classes) { %w(qux fuzz) }
+    let(:expected_class) { classes.join(" ") }
+    let(:expected_other_class) { other_classes.join(" ") }
+
+    it "allows specifying classes as a hash of strings, hash of arrays, string, or array" do
+      expect(subject.new(view, classes: classes).classes).to eq expected_class
+      expect(subject.new(view, classes: expected_class).classes).to eq expected_class
+      expect(subject.new(view, classes: { base: expected_class }).classes).to eq expected_class
+      expect(subject.new(view, classes: { base: classes }).classes).to eq expected_class
+    end
+
+    it "returns classes for the root class by default" do
+      expect(subject.new(view, classes: { base: classes, subcomponent: other_classes }).classes).to eq expected_class
+    end
+
+    it "returns classes for the specified component" do
+      expect(subject.new(view, classes: { base: classes, subcomponent: other_classes }).classes(:subcomponent)).to eq expected_other_class
+    end
+
+    it "is aliased to #classes_for" do
+      component = subject.new(view, classes: { base: classes, subcomponent: other_classes })
+      expect(component.classes).to eq component.classes_for
+      expect(component.classes(:subcomponent)).to eq component.classes_for(:subcomponent)
+    end
+  end
+
+  describe "#block" do
+    it "stores the passed block" do
+      block = -> { true }
+      component = subject.new(view, &block)
+      expect(component.block).to be block
+    end
+  end
+
+  describe "#method_missing" do
+    let(:component) { subject.new(view, name: "foo") }
+
+    it "returns the value of a configured option" do
+      expect(component.name).to eq "foo"
+    end
+
+    it "calls the regular method missing for keys that don't exist" do
+      expect { component.foo }.to raise_error(NoMethodError)
+    end
+  end
+end
+
+describe Docks::Themes::API::Components::Config do
+  let(:component_class) { Docks::Themes::API::Components::Base }
+  let(:view) { OpenStruct.new }
+
+  describe "#defaults" do
+    it "sets the attributes to the passed defaults" do
+      component = component_class.new(view, name: "foo")
+      component.configure do |config|
+        config.defaults name: "bar", something_else: "baz"
+      end
+
+      expect(component.name).to eq "foo"
+      expect(component.something_else).to eq "baz"
+    end
+  end
+
+  describe "#classes" do
+    it "merges the passed and default classes" do
+      component = component_class.new(view, classes: { base: "foo", subcomponent_one: "bar" })
+      component.configure do |config|
+        config.classes base: "fizz", subcomponent_one: %w(bar baz), subcomponent_two: "qux"
+      end
+
+      expect(component.classes_for(:base)).to eq "foo fizz"
+      expect(component.classes_for(:subcomponent_one)).to eq "bar baz"
+      expect(component.classes_for(:subcomponent_two)).to eq "qux"
+    end
+  end
+
+  describe "#conditional_classes" do
+    subject { component_class.new(view, foo: true, bar: false, size: :large) }
+    let(:klass_one) { "one" }
+    let(:klass_two) { "two" }
+    let(:klass_three) { "three" }
+
+    context "when the if option is passed" do
+      it "adds the class only when the attribute exists and is true" do
+        subject.configure do |config|
+          config.conditional_classes if: :foo, base: klass_one
+          config.conditional_classes if: :bar, base: klass_two
+          config.conditional_classes if: :baz, base: klass_three
+        end
+
+        expect(subject.classes).to eq klass_one
+      end
+    end
+
+    context "when the unless option is passed" do
+      it "adds the class when the attribute does not exist or is false" do
+        subject.configure do |config|
+          config.conditional_classes unless: :foo, base: klass_one
+          config.conditional_classes unless: :bar, base: klass_two
+          config.conditional_classes unless: :baz, base: klass_three
+        end
+
+        expect(subject.classes).to eq "#{klass_two} #{klass_three}"
+      end
+    end
+
+    context "when the with option is passed" do
+      it "does nothing when no block is passed" do
+        subject.configure do |config|
+          config.conditional_classes with: :size
+        end
+
+        expect(subject.classes).to eq ""
+      end
+
+      it "yields the value of the passed attribute and uses the returned classes" do
+        yielded = nil
+        subject.configure do |config|
+          config.conditional_classes(with: :size) do |size|
+            yielded = size
+            { base: klass_two }
+          end
+        end
+
+        expect(yielded).to eq subject.size
+        expect(subject.classes).to eq klass_two
+      end
+    end
+
+    context "when the from option is passed" do
+      it "does nothing when the passed attribute does not exist" do
+        subject.configure do |config|
+          config.conditional_classes from: :type, regular: { base: klass_one }
+        end
+
+        expect(subject.classes).to eq ""
+      end
+
+      it "uses the value of the passed attribute to determine which classes to use" do
+        subject.configure do |config|
+          config.conditional_classes from: :size, regular: { base: klass_one }, large: { base: klass_two }
+        end
+
+        expect(subject.classes).to eq klass_two
+      end
+    end
+  end
+end