chroma 0.0.1.alpha.1 → 0.0.1.alpha.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58cd2ee5df8643fe579d9f3abbb73eb6e5abdd7e
-  data.tar.gz: 9f7fc61bf911705268bf1ad174c68106db3e8184
+  metadata.gz: 83b41e45a991b08c177b51e08ad7147ff5f22d60
+  data.tar.gz: b55cf5c98e93305486a863a38cc1642fd695b57a
 SHA512:
-  metadata.gz: fc91d84ce91dd630d8d8c5371d83e092e11748b44b6158a4281dde2246ced584fc8bd6e30f63f6a5acc12779cde30eb0892c88cb6825b38d05f4da20d55a95e7
-  data.tar.gz: e61fd039b71428b30d286d4294bef7c116efad95991dce5174fa1c0ae771da9981119b231756971f0473775d2085957ca83b5347d4e3d98ddf6a9de4a81a458d
+  metadata.gz: c6a283052b0210c1434cc8492063bf95a7653bf28c08111e840b9a0d77d936d29c6b761498bdcc940ad62e5f579df217311cf740c12d8ca7023780795571106c
+  data.tar.gz: 8e61b3b0060212abcab4ba2de3d1a3d700c91ecd6dc1b8dec3f154fa954e39149f6d7ee73627b085cd4efe245162954424e68632967f7df4317185ac33ebf807

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,37 @@
+### v0.0.1.alpha.2
+**Bug Fixes:**
+* Fixed bug with number of arguments passed to generator classes in RgbGenerator. (#1)
+* Make `FromHexStringValues.from_hex8` take alpha as second parameter instead of last.
+  Fixes incorrect color generation from hex8. (#6)
+* Ensure that string serialization rounds the alpha value where applicable. (#7)
+* Fix bug where `to_s` and `inspect` would return `<unknown>` instead of using
+  hex if the format was `:name` and the named color could not be found. (#2)
+* Fix bug where `Color` equality wasn't implemented. (#12)
+* Fix bug where passing in an instance of `Hsl` or `Hsv` to `Color.new` caused
+  their values to get changed. (#11)
+* Fix bug with `Color` equality being off due to floating point math. (#13)
+* Fix bug where `Color` instances generated from hsla and hsva strings had the
+  wrong alpha value. (#15)
+
+**Method Changes:**
+* Add optional `hex_for_unknown` parameter to `Color::Serializers#to_name`.
+  If true, it allows `to_name` to default to hex string if name is not found
+  instead of returning `'<unknown>'`. (#2)
+* Add missing conversion methods to converters (a12244f0d81c9480490cfb8a472993f54dd9fbd2)
+* Add equality (`eql?` and `==`) methods to `Color` class and `ColorModes`
+  classes. (#12, #13)
+* Add `Chroma.define_palette` for defining custom palettes. (#9)
+* Add `Color#paint` method for returning itself. (#14)
+* Tweak `Color` serialization method names. Switched to this naming primarily
+  to drop the `*_s` on the string serialization methods.
+  * `to_hsv`    -> `hsv`
+  * `to_hsv_s`  -> `to_hsv`
+  * `to_hsl`    -> `hsl`
+  * `to_hsl_s`  -> `to_hsl`
+  * `to_hex`    -> `to_basic_hex` (made private)
+  * `to_hex_s`  -> `to_hex`
+  * `to_hex8`   -> `to_basic_hex8` (made private)
+  * `to_hex8_s` -> `to_hex8`
+  * `to_rgb`    -> `rgb` (moved attr_reader to serializers and made public)
+  * `to_rgb_s`  -> `to_rgb`
+  * Removed `to_name_s` alias

data/README.md

@@ -30,7 +30,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install chroma
+    $ gem install chroma --pre
 
 ## Usage
 

data/chroma.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.7'
   spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.1.0'
 end

data/lib/chroma.rb

@@ -14,6 +14,7 @@ require 'chroma/color_modes'
 
 # Palettes
 require 'chroma/harmonies'
+require 'chroma/palette_builder'
 
 # RGB Generators
 require 'chroma/rgb_generator'
@@ -50,6 +51,11 @@ module Chroma
       hex_named_colors_map[hex]
     end
 
+    def define_palette(name, &block)
+      raise "Palette `#{name}' already exists" if Harmonies.method_defined? name
+      PaletteBuilder.build(name, &block)
+    end
+
     private
 
     def hex_named_colors_map

data/lib/chroma/color.rb

@@ -11,8 +11,20 @@ module Chroma
       @format = format || gen_format
     end
 
+    def paint
+      self
+    end
+
+    def eql?(other)
+      self.class == other.class && self == other
+    end
+
+    def ==(other)
+      to_hex == other.to_hex
+    end
+
     def complement
-      hsl = to_hsl
+      hsl = self.hsl
       hsl.h = (hsl.h + 180) % 360
       Color.new(hsl)
     end

data/lib/chroma/color/attributes.rb

@@ -16,6 +16,12 @@ module Chroma
       def brightness
         (@rgb.r * 299 + @rgb.g * 587 + @rgb.b * 114) / 1000.0
       end
+
+      private
+
+      def rounded_alpha
+        @rounded_alpha ||= (alpha * 100).round / 100.0
+      end
     end
   end
 end

data/lib/chroma/color/modifiers.rb

@@ -2,7 +2,7 @@ module Chroma
   class Color
     module Modifiers
       def lighten(amount = 10)
-        hsl = to_hsl
+        hsl = self.hsl
         hsl.l = clamp01(hsl.l + amount / 100.0)
         self.class.new(hsl, @format)
       end
@@ -20,19 +20,19 @@ module Chroma
       end
 
       def darken(amount = 10)
-        hsl = to_hsl
+        hsl = self.hsl
         hsl.l = clamp01(hsl.l - amount / 100.0)
         self.class.new(hsl, @format)
       end
 
       def desaturate(amount = 10)
-        hsl = to_hsl
+        hsl = self.hsl
         hsl.s = clamp01(hsl.s - amount / 100.0)
         self.class.new(hsl, @format)
       end
 
       def saturate(amount = 10)
-        hsl = to_hsl
+        hsl = self.hsl
         hsl.s = clamp01(hsl.s + amount / 100.0)
         self.class.new(hsl, @format)
       end
@@ -42,7 +42,7 @@ module Chroma
       end
 
       def spin(amount)
-        hsl = to_hsl
+        hsl = self.hsl
         hue = (hsl.h.round + amount) % 360
         hsl.h = hue < 0 ? 360 + hue : hue
         self.class.new(hsl, @format)

data/lib/chroma/color/serializers.rb

@@ -2,95 +2,96 @@ module Chroma
   class Color
     module Serializers
       def to_hsv
-        Converters::HsvConverter.convert_rgb(@rgb)
-      end
-
-      def to_hsv_s
-        to_hs_s(:v)
+        to_hs(:v)
       end
 
       def to_hsl
-        Converters::HslConverter.convert_rgb(@rgb)
-      end
-
-      def to_hsl_s
-        to_hs_s(:l)
+        to_hs(:l)
       end
 
       def to_hex(allow_3 = false)
-        r, g, b = [@rgb.r, @rgb.g, @rgb.b].map do |n|
-          to_2char_hex(n)
-        end
-
-        if allow_3 && r[0] == r[1] && g[0] == g[1] && b[0] == b[1]
-          return "#{r[0]}#{g[0]}#{b[0]}"
-        end
-
-        [r, g, b].flatten * ''
-      end
-
-      def to_hex_s(allow_3 = false)
-        "##{to_hex(allow_3)}"
+        "##{to_basic_hex(allow_3)}"
       end
 
       def to_hex8
-        [
-          to_2char_hex(alpha * 255),
-          to_2char_hex(@rgb.r),
-          to_2char_hex(@rgb.g),
-          to_2char_hex(@rgb.b)
-        ].join('')
-      end
-
-      def to_hex8_s
-        "##{to_hex8}"
+        "##{to_basic_hex8}"
       end
 
       def to_rgb
-        @rgb
-      end
-
-      def to_rgb_s
         middle = @rgb.to_a[0..2].map(&:round).join(', ')
 
-        to_alpha_s(:rgb, middle)
+        with_alpha(:rgb, middle)
       end
 
-      def to_name
+      def to_name(hex_for_unknown = false)
         return 'transparent' if alpha.zero?
 
-        if alpha < 1 || (name = Chroma.name_from_hex(to_hex(true))).nil?
-          '<unknown>'
+        if alpha < 1 || (name = Chroma.name_from_hex(to_basic_hex(true))).nil?
+          if hex_for_unknown
+            to_hex
+          else
+            '<unknown>'
+          end
         else
           name
         end
       end
 
-      alias_method :to_name_s, :to_name
-
       def to_s(format = @format)
-        use_alpha = alpha < 1 && alpha >= 0 && /^hex(3|6)?/ =~ format
+        use_alpha = alpha < 1 && alpha >= 0 && /^hex(3|6)?$/ =~ format
 
-        return to_rgb_s if use_alpha
+        return to_rgb if use_alpha
 
         case format.to_s
-        when 'rgb'         then to_rgb_s
-        when 'hex', 'hex6' then to_hex_s
-        when 'hex3'        then to_hex_s(true)
-        when 'hex8'        then to_hex8_s
-        when 'hsl'         then to_hsl_s
-        when 'hsv'         then to_hsv_s
-        when 'name'        then to_name
-        else                    to_hex_s
+        when 'rgb'         then to_rgb
+        when 'hex', 'hex6' then to_hex
+        when 'hex3'        then to_hex(true)
+        when 'hex8'        then to_hex8
+        when 'hsl'         then to_hsl
+        when 'hsv'         then to_hsv
+        when 'name'        then to_name(true)
+        else                    to_hex
         end
       end
 
       alias_method :inspect, :to_s
 
+      def hsv
+        Converters::HsvConverter.convert_rgb(@rgb)
+      end
+
+      def hsl
+        Converters::HslConverter.convert_rgb(@rgb)
+      end
+
+      attr_reader :rgb
+
       private
 
-      def to_hs_s(third)
-        color = send("to_hs#{third}")
+      def to_basic_hex(allow_3 = false)
+        r, g, b = [@rgb.r, @rgb.g, @rgb.b].map do |n|
+          to_2char_hex(n)
+        end
+
+        if allow_3 && r[0] == r[1] && g[0] == g[1] && b[0] == b[1]
+          return "#{r[0]}#{g[0]}#{b[0]}"
+        end
+
+        "#{[r, g, b].flatten * ''}"
+      end
+
+      def to_basic_hex8
+        [
+          to_2char_hex(alpha * 255),
+          to_2char_hex(@rgb.r),
+          to_2char_hex(@rgb.g),
+          to_2char_hex(@rgb.b)
+        ].join('')
+      end
+
+      def to_hs(third)
+        name = "hs#{third}"
+        color = send(name)
 
         h = color.h.round
         s = (color.s * 100).round
@@ -98,12 +99,12 @@ module Chroma
 
         middle = "#{h}, #{s}%, #{lv}%"
 
-        to_alpha_s("hs#{third}", middle)
+        with_alpha(name, middle)
       end
 
-      def to_alpha_s(mode, middle)
+      def with_alpha(mode, middle)
         if alpha < 1
-          "#{mode}a(#{middle}, #{alpha})"
+          "#{mode}a(#{middle}, #{rounded_alpha})"
         else
           "#{mode}(#{middle})"
         end

data/lib/chroma/converters/hsl_converter.rb

@@ -34,6 +34,14 @@ module Chroma
 
         ColorModes::Hsl.new(h * 360, s, l, @input.a)
       end
+
+      def convert_hsl
+        @input
+      end
+
+      def convert_hsv
+        HsvConverter.convert_rgb(RgbConverter.convert_hsl(@input))
+      end
     end
   end
 end

data/lib/chroma/converters/hsv_converter.rb

@@ -28,6 +28,14 @@ module Chroma
 
         ColorModes::Hsv.new(h * 360, s, v, @input.a)
       end
+
+      def convert_hsl
+        HslConverter.convert_rgb(RgbConverter.convert_hsv(@input))
+      end
+
+      def convert_hsv
+        @input
+      end
     end
   end
 end

data/lib/chroma/converters/rgb_converter.rb

@@ -1,6 +1,10 @@
 module Chroma
   module Converters
     class RgbConverter < Base
+      def convert_rgb
+        @input
+      end
+
       def convert_hsl
         h, s, l = @input
 
@@ -18,7 +22,7 @@ module Chroma
           b = hue_to_rgb(p, q, h - 1/3.0) * 255
         end
 
-        ColorModes::Rgb.new(r, g, b)
+        ColorModes::Rgb.new(r, g, b, bound_alpha(@input.a))
       end
 
       def convert_hsv
@@ -39,7 +43,7 @@ module Chroma
         g = [t, v, v, q, p, p][mod] * 255
         b = [p, p, t, v, v, q][mod] * 255
 
-        ColorModes::Rgb.new(r, g, b)
+        ColorModes::Rgb.new(r, g, b, bound_alpha(@input.a))
       end
 
       private

data/lib/chroma/harmonies.rb

@@ -21,7 +21,7 @@ module Chroma
     end
 
     def analogous(results = 6, slices = 30)
-      hsl = @color.to_hsl
+      hsl = @color.hsl
       part = 360 / slices
       hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360
 
@@ -32,7 +32,7 @@ module Chroma
     end
 
     def monochromatic(results = 6)
-      h, s, v = @color.to_hsv
+      h, s, v = @color.hsv
       modification = 1.0 / results
 
       results.times.map do
@@ -45,7 +45,7 @@ module Chroma
     private
 
     def hsl_map(degrees)
-      h, s, l = @color.to_hsl
+      h, s, l = @color.hsl
 
       degrees.map do |deg|
         Color.new(ColorModes::Hsl.new((h + deg) % 360, s, l))

data/lib/chroma/palette_builder.rb

@@ -0,0 +1,58 @@
+module Chroma
+  class PaletteBuilder
+    def self.build(name, &block)
+      new(name, &block).build
+    end
+
+    def initialize(name, &block)
+      @name = name
+      @block = block
+    end
+
+    def build
+      dsl = PaletteBuilderDsl.new
+      dsl.instance_eval(&@block)
+      conversions = dsl.conversions
+
+      Harmonies.send(:define_method, @name) do
+        conversions.map do |color_calls|
+          color_calls.evaluate(@color)
+        end.unshift(@color)
+      end
+    end
+
+    private
+
+    class PaletteBuilderDsl
+      attr_reader :conversions
+
+      def initialize
+        @conversions = []
+      end
+
+      def method_missing(name, *args)
+        ColorCalls.new(name, args).tap do |color_calls|
+          @conversions << color_calls
+        end
+      end
+
+      class ColorCalls
+        attr_reader :name, :args
+
+        def initialize(name, args)
+          @calls = [[name, args]]
+        end
+
+        def evaluate(color)
+          @calls.reduce(color) do |c, (name, args)|
+            c.send(name, *args)
+          end
+        end
+
+        def method_missing(name, *args)
+          @calls << [name, args]
+        end
+      end
+    end
+  end
+end

data/lib/chroma/rgb_generator.rb

@@ -19,7 +19,7 @@ module Chroma
                 when ColorModes::Rgb then FromRgb
                 end
 
-        klass.new(input)
+        klass.new(nil, input)
       end
 
       def round(n)

data/lib/chroma/rgb_generator/from_hex_string_values.rb

@@ -21,7 +21,7 @@ module Chroma
           new(format, r, g, b)
         end
 
-        def from_hex8(format, r, g, b, a)
+        def from_hex8(format, a, r, g, b)
           new(format || :hex8, r, g, b, a)
         end
       end

data/lib/chroma/rgb_generator/from_hsl.rb

@@ -2,12 +2,12 @@ module Chroma
   module RgbGenerator
     class FromHsl < Base
       def initialize(format, hsl)
-        @format = format || :hsl
+        @format = format
         @hsl = hsl
       end
 
       def generate
-        [Converters::RgbConverter.convert_hsl(@hsl), @format]
+        FromHslValues.new(@format, *@hsl.to_a).generate
       end
     end
   end

data/lib/chroma/rgb_generator/from_hsl_values.rb

@@ -5,12 +5,12 @@ module Chroma
         s = to_percentage(s)
         l = to_percentage(l)
 
-        @format = format
+        @format = format || :hsl
         @hsl = ColorModes::Hsl.new(h, s, l, a)
       end
 
       def generate
-        FromHsl.new(@format, @hsl).generate
+        [Converters::RgbConverter.convert_hsl(@hsl), @format]
       end
     end
   end

data/lib/chroma/rgb_generator/from_hsv.rb

@@ -2,12 +2,12 @@ module Chroma
   module RgbGenerator
     class FromHsv < Base
       def initialize(format, hsv)
-        @format = format || :hsv
+        @format = format
         @hsv = hsv
       end
 
       def generate
-        [Converters::RgbConverter.convert_hsv(@hsv), @format]
+        FromHsvValues.new(@format, *@hsv.to_a).generate
       end
     end
   end

data/lib/chroma/rgb_generator/from_hsv_values.rb

@@ -5,12 +5,12 @@ module Chroma
         s = to_percentage(s)
         v = to_percentage(v)
 
-        @format = format
+        @format = format || :hsv
         @hsv = ColorModes::Hsv.new(h, s, v, a)
       end
 
       def generate
-        FromHsv.new(@format, @hsv).generate
+        [Converters::RgbConverter.convert_hsv(@hsv), @format]
       end
     end
   end

data/lib/chroma/rgb_generator/from_string.rb

@@ -28,7 +28,7 @@ module Chroma
         end
       end
 
-      def initialize(input)
+      def initialize(format, input)
         @input = normalize_input(input)
       end
 

data/lib/chroma/version.rb

@@ -1,3 +1,3 @@
 module Chroma
-  VERSION = '0.0.1.alpha.1'
+  VERSION = '0.0.1.alpha.2'
 end

data/spec/chroma/define_palette_spec.rb

@@ -0,0 +1,33 @@
+describe Chroma, '.define_palette' do
+  def add_palette
+    Chroma.define_palette :foo do
+      spin 60
+      spin 180
+      spin(60).brighten(20)
+      greyscale
+    end
+  end
+
+  def remove_palette
+    if Chroma::Harmonies.method_defined? :foo
+      Chroma::Harmonies.send(:remove_method, :foo)
+    end
+  end
+
+  after(:example) { remove_palette }
+
+  let(:red) { '#ff0000'.paint }
+
+  it 'adds the new palette method' do
+    expect(red.palette).to_not respond_to(:foo)
+    add_palette
+    expect(red.palette).to respond_to(:foo)
+  end
+
+  it 'generates the correct colors' do
+    add_palette
+
+    expect(red.palette.foo).
+      to generate_palette %w(#ff0000 #ffff00 #00ffff #ffff33 #808080)
+  end
+end

data/spec/chroma/paint_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Chroma do
+  describe '.paint' do
+    context 'with named color' do
+      it 'creates a color' do
+        expect(Chroma.paint('red')).to be_a(Chroma::Color)
+      end
+    end
+
+    context 'with 6 character hexadecimal' do
+      it 'creates a color' do
+        expect(Chroma.paint('#ff0000')).to be_a(Chroma::Color)
+        expect(Chroma.paint('ff0000')).to be_a(Chroma::Color)
+      end
+    end
+
+    context 'with 3 character hexadecimal' do
+      it 'creates a color' do
+        expect(Chroma.paint('#f00')).to be_a(Chroma::Color)
+        expect(Chroma.paint('f00')).to be_a(Chroma::Color)
+      end
+    end
+
+    context 'with 8 character hexadecimal' do
+      let(:hex) { '#80ff0000' }
+
+      it 'creates a color' do
+        expect(Chroma.paint(hex)).to be_a(Chroma::Color)
+        expect(Chroma.paint(hex[1..-1])).to be_a(Chroma::Color)
+      end
+
+      it 'sets alpha' do
+        expect(Chroma.paint(hex).alpha).to be_within(0.1).of(0.5)
+      end
+    end
+
+    context 'with rgb' do
+      it 'creates a color' do
+        expect(Chroma.paint('rgb(255, 0, 0)')).to be_a(Chroma::Color)
+        expect(Chroma.paint('rgba(255, 0, 0, 0.5)')).to be_a(Chroma::Color)
+      end
+
+      it 'sets alpha' do
+        expect(Chroma.paint('rgba(255, 0, 0, 0.5)').alpha).to eq(0.5)
+      end
+    end
+
+    context 'with hsl' do
+      it 'creates a color' do
+        expect(Chroma.paint('hsl(120, 100%, 50%)')).to be_a(Chroma::Color)
+      end
+    end
+  end
+end

data/spec/color/modifiers_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Chroma::Color do
+  describe '#spin' do
+    it 'generates the correct color' do
+      expect('red'.paint.spin(60)).to eq('yellow'.paint)
+    end
+  end
+end

data/spec/color/serializers_spec.rb

@@ -0,0 +1,152 @@
+describe Chroma::Color do
+  context 'with serializers' do
+    let(:green)       { 'green'.paint }
+    let(:blue)        { 'rgba(0, 0, 255, 0.5)'.paint }
+    let(:transparent) { 'rgba(0, 0, 0, 0)'.paint }
+
+    describe '#to_hsv' do
+      it 'returns the hsv string' do
+        expect(green.to_hsv).to eq('hsv(120, 100%, 50%)')
+        expect(blue.to_hsv).to  eq('hsva(240, 100%, 100%, 0.5)')
+      end
+    end
+
+    describe '#to_hsl' do
+      it 'returns the hsl string' do
+        expect(green.to_hsl).to eq('hsl(120, 100%, 25%)')
+        expect(blue.to_hsl).to  eq('hsla(240, 100%, 50%, 0.5)')
+      end
+    end
+
+    describe '#to_hex' do
+      context 'with allow_3 set to false' do
+        it 'returns the hex string' do
+          expect(green.to_hex).to eq('#008000')
+          expect(blue.to_hex).to  eq('#0000ff')
+        end
+      end
+
+      context 'with allow_3 set to true' do
+        it 'returns the hex string' do
+          expect(green.to_hex(true)).to eq('#008000')
+          expect(blue.to_hex(true)).to  eq('#00f')
+        end
+      end
+    end
+
+    describe '#to_hex8' do
+      it 'returns the hex8 string' do
+        expect(green.to_hex8).to eq('#ff008000')
+        expect(blue.to_hex8).to  eq('#800000ff')
+      end
+    end
+
+    describe '#to_rgb' do
+      it 'returns the rgb string' do
+        expect(green.to_rgb).to eq('rgb(0, 128, 0)')
+        expect(blue.to_rgb).to  eq('rgba(0, 0, 255, 0.5)')
+      end
+    end
+
+    describe '#to_name' do
+      context 'with hex_for_unknown set to false' do
+        context 'with known named color' do
+          context 'when alpha = 1' do
+            it 'returns the named color' do
+              expect(green.to_name).to eq('green')
+            end
+          end
+
+          context 'when alpha < 1' do
+            it 'returns "<unknown>"' do
+              expect(blue.to_name).to eq('<unknown>')
+            end
+          end
+        end
+
+        context 'when alpha = 0' do
+          it 'returns "transparent"' do
+            expect(transparent.to_name).to eq('transparent')
+          end
+        end
+
+        context 'with unknown named color' do
+          it 'returns "<unknown>"' do
+            expect('#123'.paint.to_name).to eq('<unknown>')
+          end
+        end
+      end
+
+      context 'with hex_for_unknown set to true' do
+        context 'with known named color' do
+          context 'when alpha = 1' do
+            it 'returns the named color' do
+              expect(green.to_name(true)).to eq('green')
+            end
+          end
+
+          context 'when alpha < 1' do
+            it 'returns the hex string' do
+              expect(blue.to_name(true)).to eq('#0000ff')
+            end
+          end
+        end
+
+        context 'when alpha = 0' do
+          it 'returns "transparent"' do
+            expect(transparent.to_name(true)).to eq('transparent')
+          end
+        end
+
+        context 'with unknown named color' do
+          it 'returns returns the hex string' do
+            expect('#123'.paint.to_name(true)).to eq('#112233')
+          end
+        end
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the appropriate string according to format' do
+        expect('#ff0000'.paint.to_s).to                    eq('#ff0000')
+        expect('#f00'.paint.to_s).to                       eq('#f00')
+        expect('#80ff0000'.paint.to_s).to                  eq('#80ff0000')
+        expect('hsl(120, 100%, 50%)'.paint.to_s).to        eq('hsl(120, 100%, 50%)')
+        expect('hsla(120, 100%, 50%, 0.5)'.paint.to_s).to  eq('hsla(120, 100%, 50%, 0.5)')
+        expect('hsv(120, 100%, 50%)'.paint.to_s).to        eq('hsv(120, 100%, 50%)')
+        expect('hsva(120, 100%, 50%, 0.5)'.paint.to_s).to  eq('hsva(120, 100%, 50%, 0.5)')
+        expect('red'.paint.to_s).to                        eq('red')
+      end
+    end
+
+    describe '#hsv' do
+      it 'returns an hsv instance' do
+        hsv = green.hsv
+
+        expect(hsv).to be_a(Chroma::ColorModes::Hsv)
+        expect(hsv.h).to be_within(0.01).of(120)
+        expect(hsv.s).to be_within(0.01).of(1)
+        expect(hsv.v).to be_within(0.01).of(0.5)
+        expect(hsv.a).to eq(1)
+      end
+    end
+
+    describe '#hsl' do
+      it 'returns an hsl instance' do
+        hsl = green.hsl
+
+        expect(hsl).to be_a(Chroma::ColorModes::Hsl)
+        expect(hsl.h).to be_within(0.01).of(120)
+        expect(hsl.s).to be_within(0.01).of(1)
+        expect(hsl.l).to be_within(0.01).of(0.25)
+        expect(hsl.a).to eq(1)
+      end
+    end
+
+    describe '#rgb' do
+      it 'returns the underlying @rgb iv' do
+        expect(green.rgb).to equal(green.instance_variable_get(:@rgb))
+      end
+    end
+  end
+end

data/spec/color_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Chroma::Color do
+  let(:red)       { 'red'.paint }
+  let(:other_red) { '#f00'.paint }
+  let(:blue)      { 'blue'.paint }
+
+  context 'with equality' do
+    it 'equals itself' do
+      expect(red).to eql(red)
+      expect(red).to eq(red)
+    end
+
+    it 'equals another instance of the same color' do
+      expect(red).to eql(other_red)
+      expect(red).to eq(other_red)
+    end
+
+    it 'does not equal another instance of a different color' do
+      expect(red).to_not eql(blue)
+      expect(red).to_not eq(blue)
+    end
+  end
+
+  describe '#paint' do
+    it 'returns itself' do
+      expect(red.paint).to equal(red)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,99 @@
+require 'chroma'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end
+
+RSpec::Matchers.define :generate_palette do |expected|
+  expected.map!(&:paint)
+
+  match do |actual|
+    actual == expected
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chroma
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha.1
+  version: 0.0.1.alpha.2
 platform: ruby
 authors:
 - Jeremy Fairbank
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-11 00:00:00.000000000 Z
+date: 2015-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
 description: Chroma is a color manipulation and palette generation gem.
 email:
 - elpapapollo@gmail.com
@@ -46,6 +60,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -64,6 +80,7 @@ files:
 - lib/chroma/extensions/string.rb
 - lib/chroma/harmonies.rb
 - lib/chroma/helpers/bounders.rb
+- lib/chroma/palette_builder.rb
 - lib/chroma/rgb_generator.rb
 - lib/chroma/rgb_generator/base.rb
 - lib/chroma/rgb_generator/from_hex_string_values.rb
@@ -76,6 +93,12 @@ files:
 - lib/chroma/rgb_generator/from_string.rb
 - lib/chroma/version.rb
 - lib/support/named_colors.yml
+- spec/chroma/define_palette_spec.rb
+- spec/chroma/paint_spec.rb
+- spec/color/modifiers_spec.rb
+- spec/color/serializers_spec.rb
+- spec/color_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/jfairbank/chroma
 licenses:
 - MIT
@@ -100,4 +123,10 @@ rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Color manipulation and palette generation.
-test_files: []
+test_files:
+- spec/chroma/define_palette_spec.rb
+- spec/chroma/paint_spec.rb
+- spec/color/modifiers_spec.rb
+- spec/color/serializers_spec.rb
+- spec/color_spec.rb
+- spec/spec_helper.rb