chroma 0.0.1.alpha.3 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 763b7f5b0794c7dc09cd95962cd7735112f6d097
-  data.tar.gz: 03ff16e0f2504635475ae9d310ca3d8aef338fd3
+  metadata.gz: 50d3030c7ac81f4ced369d991d94ae827af946c3
+  data.tar.gz: 20fba6d256719e631c6f0333aeb32afcf13c0fc1
 SHA512:
-  metadata.gz: 5fd92090950985a25e34d1ecf90387cc1e409473e9907f153e31c6b41aff2be6f835eb3b1a0ff69e6308f427b424ac62f1c803fc53d34bc21e45679f55f25dd3
-  data.tar.gz: 64e588328d689f4774d9154681549b80dee94f2944686b97f8029a136d0b796dc1427097ff45fe8d19194913d91061e957bcf1b09eac778f4c003383754746c9
+  metadata.gz: 95b1f6fa55a3f8fc40c35a069c94c45a47a1bf6a889382971285bc4bb052331133f45b5f5e253d1a3f69340f928b1ae2026d959ed887d07feea44759c5382257
+  data.tar.gz: 085c7c08e31045167d3e57832f1f518f5ad6a8309881be5bceaf1a747a402d6831d426cdeec2551825207cbbebdc045a3029a30c1671fffea28dd261d6489666

data/.travis.yml

@@ -0,0 +1,10 @@
+langage: ruby
+
+rvm:
+  - 2.2.0
+  - 2.1.5
+  - 1.9.3
+  - jruby
+
+script:
+  - rake spec

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+### v0.0.1 - 2015-01-14
+
+**Method Changes:**
+
+* Renamed options for analogous palette method.
+  * `:results` -> `:size`
+  * `:slices` -> `:slice_by`
+* Renamed option for monochromatic palette method.
+  * `:results` -> `:size`
+
+**Miscellaneous Changes:**
+
+* Add remaining specs for public API.
+* Add "transparent" as color name for `Chroma.paint`.
+* Minor API doc example fixes.
+* Add public API usage examples to README.
+
 ### [v0.0.1.alpha.3] - 2015-01-13
 
 **Bug Fixes:**

data/README.md

@@ -1,6 +1,7 @@
 # Chroma
 
 [![Gem Version](https://badge.fury.io/rb/chroma.svg)](http://badge.fury.io/rb/chroma)
+[![Build Status](https://travis-ci.org/jfairbank/chroma.svg?branch=master)](https://travis-ci.org/jfairbank/chroma)
 
 Chroma is a color manipulation and palette generation library. It is heavily
 inspired by and a very close Ruby port of the
@@ -8,22 +9,16 @@ inspired by and a very close Ruby port of the
 library. Many thanks to [Brian Grinstead](http://www.briangrinstead.com/blog/)
 for his hard work on that library.
 
-Chroma is in alpha stage at the moment. Most of the API methods from tinycolor
-have been ported over with a few exceptions. However, I will be working on
-cleaning up the API where needed, adding docs and examples, and adding tests
-before a first release. Because this is currently in alpha, please be
-prepared for possible API changes or bugs.
-
-Please don't hesitate to examine the code and make issues or pull requests
-where you feel it is necessary. Please refer to the
-[Contributing](#contributing) section below.
+Please don't hesitate to examine the code and make issues, feature requests,
+or pull requests. Please refer to the [Contributing](#contributing) section
+below.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'chroma', '0.0.1.alpha.3'
+gem 'chroma'
 ```
 
 And then execute:
@@ -32,37 +27,329 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install chroma --pre
+    $ gem install chroma
+
+## Creating Colors
 
-## Usage
+Colors are created via the `Chroma.paint` method. It expects any one of
+many possible color formats as a string, including names, hexadecimal, rgb,
+hsl, and hsv. As a convenience, a `String#paint` is also available for more
+succinct color creation.
+
+```ruby
+# With Chroma.paint
+Chroma.paint 'red'                       # named colors
+Chroma.paint '#00ff00'                   # 6 character hexadecimal
+Chroma.paint '#00f'                      # 3 character hexadecimal
+Chroma.paint 'rgb(255, 255, 0)'          # rgb
+Chroma.paint 'rgba(255, 255, 0, 0.5)'    # rgba
+Chroma.paint 'hsl(60, 100%, 50%)'        # hsl with percentages
+Chroma.paint 'hsl(60, 1, 0.5)'           # hsl with decimals
+Chroma.paint 'hsla(60, 100%, 50%, 0.5)'  # hsla
+Chroma.paint 'hsv(60, 100%, 50%)'        # hsv with percentages
+Chroma.paint 'hsv(60, 1, 0.5)'           # hsv with decimals
+Chroma.paint 'hsva(60, 100%, 50%, 0.75)' # hsva
 
-Chroma adds several of the methods available in
-[tinycolor.js](https://github.com/bgrins/TinyColor) but renamed appropriately
-for Ruby conventions (i.e. `isDark` becomes `dark?`).
+# With String#paint
+'red'.paint
+'#00ff00'.paint
+'#00f'.paint
+'rgb(255, 255, 0)'.paint
+'rgba(255, 255, 0, 0.5)'.paint
+'hsl(60, 100%, 50%)'.paint
+'hsla(60, 100%, 50%, 0.5)'.paint
+'hsv(60, 100%, 50%)'.paint
+'hsva(60, 100%, 50%. 0.5)'.paint
+```
 
-To create a color, just call the `Chroma.paint` method, passing in a string
-that represents a color.
+## Motivation
+
+Chroma's major strength is manipulating colors and generating color palettes,
+which allows you to easily generate dynamic colors, dynamic themes for a web
+application, and more.
+
+## Color Manipulation
+
+#### Lighten
+
+Lighten the color by a given amount. Defaults to 10.
 
 ```ruby
-Chroma.paint 'red'                    # named colors
-Chroma.paint '#00ff00'                # 6 character hexadecimal
-Chroma.paint '#00f'                   # 3 character hexadecimal
-Chroma.paint 'rgb(255, 255, 0)'       # rgb
-Chroma.paint 'rgba(255, 255, 0, 0.5)' # rgba
-Chroma.paint 'hsl(60, 100%, 50%)'     # hsl with percentages
-Chroma.paint 'hsl(60, 1, 0.5)'        # hsl with decimals
-Chroma.paint 'hsv(60, 100%, 50%)'     # hsv with percentages
-Chroma.paint 'hsv(60, 1, 0.5)'        # hsv with decimals
+'red'.paint.lighten     #=> #ff3333
+'red'.paint.lighten(20) #=> #ff6666
 ```
 
-To work directly from a string you can also use the `String#paint` method:
+#### Brighten
+
+Brighten the color by a given amount. Defaults to 10.
 
 ```ruby
-'red'.paint
-'#00f'.paint
-'rgb(255, 255, 0)'.paint
+'red'.paint.brighten     #=> #ff1a1a
+'red'.paint.brighten(20) #=> #ff3333
+```
+
+#### Darken
+
+Darken the color by a given amount. Defaults to 10.
+
+```ruby
+'red'.paint.darken     #=> #cc0000
+'red'.paint.darken(20) #=> #990000
+```
+
+#### Desaturate
+
+Desaturate the color by a given amount. Defaults to 10.
+
+```ruby
+'red'.paint.desaturate     #=> #f20d0d
+'red'.paint.desaturate(20) #=> #e61919
+```
+
+#### Saturate
+
+Saturate the color by a given amount. Defaults to 10.
+
+```ruby
+'#123'.paint.saturate     #=> #0e2236
+'#123'.paint.saturate(20) #=> #0a223a
+```
+
+#### Grayscale
+
+Convert the color to grayscale.
+
+```ruby
+'green'.paint.grayscale #=> #404040
+
+# greyscale is an alias
+'red'.paint.greyscale   #=> #808080
+```
+
+#### Spin
+
+Spin a given amount in degrees around the hue wheel.
+
+```ruby
+'red'.paint.spin(30) #=> #ff8000
+'red'.paint.spin(60) #=> yellow
+'red'.paint.spin(90) #=> #80ff00
+```
+
+## Generating Palettes
+
+Chroma's most powerful feature is palette generation. You can use the default
+palettes available or even create your own custom palettes.
+
+Palette methods are available via `Color#palette` and by default output an
+array of colors. If you want the underlying color strings, you can pass in
+the desired format via the `:as` option.
+
+#### Available Formats
+
+* name
+* rgb
+* hex
+* hex6 (alias for hex)
+* hex3
+* hex8 (includes the alpha value in the highest order byte)
+* hsl
+* hsv
+
+#### Complement
+
+Generate a complement palette.
+
+```ruby
+'red'.paint.palette.complement            #=> [red, cyan]
+'red'.paint.palette.complement(as: :name) #=> ['red', 'cyan']
+'red'.paint.palette.complement(as: :hex)  #=> ['#ff0000', '#00ffff']
+```
+
+#### Triad
+
+Generate a triad palette.
+
+```ruby
+'red'.paint.palette.triad            #=> [red, lime, blue]
+'red'.paint.palette.triad(as: :name) #=> ['red', 'lime', 'blue']
+'red'.paint.palette.triad(as: :hex)  #=> ['#ff0000', '#00ff00', '#0000ff']
+```
+
+#### Tetrad
+
+Generate a tetrad palette.
+
+```ruby
+'red'.paint.palette.tetrad
+#=> [red, #80ff00, cyan, #7f00ff]
+
+'red'.paint.palette.tetrad(as: :name)
+#=> ['red', '#80ff00', 'cyan', '#7f00ff']
+
+'red'.paint.palette.tetrad(as: :hex)
+#=> ['#ff0000', '#80ff00', '#00ffff', '#7f00ff']
+```
+
+#### Split Complement
+
+Generate a split complement palette.
+
+```ruby
+'red'.paint.palette.split_complement
+#=> [red, #ccff00, #0066ff]
+
+'red'.paint.palette.split_complement(as: :name)
+#=> ['red', '#ccff00', '#0066ff']
+
+'red'.paint.palette.split_complement(as: :hex)
+#=> ['#ff0000', '#ccff00', '#0066ff']
+```
+
+#### Analogous
+
+Generate an analogous palette. Pass in a `:size` option to specify the size
+of the palette (defaults to 6). Pass in a `:slice_by` option to specify the
+angle size to slice into the hue wheel (defaults to 30 degrees).
+
+```ruby
+'red'.paint.palette.analogous
+#=> [red, #ff0066, #ff0033, red, #ff3300, #ff6600]
+
+'red'.paint.palette.analogous(as: :hex)
+#=> ['#f00', '#f06', '#f03', '#f00', '#f30', '#f60']
+
+'red'.paint.palette.analogous(size: 3)
+#=> [red, #ff001a, #ff1a00]
+
+'red'.paint.palette.analogous(size: 3, slice_by: 60)
+#=> [red, #ff000d, #ff0d00]
+```
+
+#### Monochromatic
+
+Generate a monochromatic palette. Pass in a `:size` option to specify the size
+of the palette (defaults to 6).
+
+```ruby
+'red'.paint.palette.monochromatic
+#=> [red, #2a0000, #550000, maroon, #aa0000, #d40000]
+
+'red'.paint.palette.monochromatic(as: :hex)
+#=> ['#ff0000', '#2a0000', '#550000', '#800000', '#aa0000', '#d40000']
+
+'red'.paint.palette.monochromatic(size: 3)
+#=> [red, #550000, #aa0000]
+```
+
+## Defining Custom Palettes
+
+Chroma allows you to define your own custom palettes if the default ones aren't
+all you're looking for. You can define a custom palette by calling
+`Chroma.define_palette`, passing in a palette name and definition block. The
+definition block uses the color manipulation methods (i.e. `lighten`, `spin`,
+etc.) as its DSL. Every DSL call defines a new color that will be included
+in the palette. Your seed color (i.e. the color from which you call the
+palette method) will be included as the first color in your palette too.
+
+```ruby
+red = 'red'.paint
+
+red.palette.respond_to? :my_palette #=> false
+
+# Define a palette with 5 colors including the seed color
+Chroma.define_palette :my_palette do
+  spin 60
+  spin 180
+  spin(60).brighten(20) # chain calls as well
+  greyscale
+end
+
+red.palette.respond_to? :my_palette #=> true
+
+red.palette.my_palette #=> [#ff0000 #ffff00 #00ffff #ffff33 #808080]
+```
+
+## Serializing Colors
+
+Colors offer several methods to output to different string color [formats](#available-formats).
+
+| Method    | Description                                                                                                      |
+| --------- | ---------------------------------------------------------------------------------------------------------------- |
+| `to_hsv`  | output to hsv string, outputs hsva if alpha < 1                                                                  |
+| `to_hsl`  | output to hsl string, outputs hsla if alpha < 1                                                                  |
+| `to_hex`  | output to hex string, optional argument allows 3-character hex output if possible                                |
+| `to_hex8` | output to 8-character hex string with alpha value in the highest order byte                                      |
+| `to_rgb`  | output to rgb string, outputs rgba if alpha < 1                                                                  |
+| `to_name` | output to color name string if available, otherwise `'<unknown>'` or `to_hex` output based on optional arg value |
+| `to_s`    | output to the appropriate string format based on how the color was created, optional arg forces the format       |
+
+```ruby
+# to_hsv
+'red'.paint.to_hsv                  #=> 'hsv(0, 100%, 100%)'
+'rgba(255, 0, 0, 0.5)'.paint.to_hsv #=> 'hsva(0, 100%, 100%, 0.5)'
+
+# to_hsl
+'red'.paint.to_hsl                  #=> 'hsl(0, 100%, 50%)'
+'rgba(255, 0, 0, 0.5)'.paint.to_hsl #=> 'hsla(0, 100%, 50%, 0.5)'
+
+# to_hex
+'red'.paint.to_hex                  #=> '#ff0000'
+'red'.paint.to_hex(true)            #=> '#f00'
+'rgba(255, 0, 0, 0.5)'.paint.to_hex #=> '#ff0000'
+'red'.paint.to_hex                  #=> '#ffff0000'
+'rgba(255, 0, 0, 0.5)'.paint.to_hex #=> '#80ff0000'
+
+# to_rgb
+'red'.paint.to_rgb                  #=> 'rgb(255, 0, 0)'
+'rgba(255, 0, 0, 0.5)'.paint.to_rgb #=> 'rgb(255, 0, 0, 0.5)'
+
+# to_name
+'red'.paint.to_name                  #=> 'red'
+'#00f'.paint.to_name                 #=> 'blue'
+'rgba(255, 0, 0, 0.5)'.paint.to_name #=> '<unknown>'
+'#123'.paint.to_name(true)           #=> '#112233'
+
+# to_s
+'red'.paint.to_s             #=> 'red'
+'rgb(255, 0, 0)'.paint.to_s  #=> 'rgb(255, 0, 0)'
+'#f00'.paint.to_s            #=> '#f00'
+'#80ff0000'.paint.to_s(:rgb) #=> 'rgba(255, 0, 0, 0.5)'
+```
+
+## Other Methods
+
+Colors also have a few other helper methods:
+
+| Method       | Description                                            |
+| ------------ | ------------------------------------------------------ |
+| `dark?`      | is the color dark?                                     |
+| `light?`     | is the color light?                                    |
+| `alpha`      | retrieve the alpha value                               |
+| `brightness` | calculate the brightness as a number between 0 and 255 |
+| `complement` | return the complementary color                         |
+
+```ruby
+# dark?
+'red'.paint.dark?    #=> true
+'yellow'.paint.dark? #=> false
+
+# light?
+'red'.paint.light?    #=> false
+'yellow'.paint.light? #=> true
+
+# alpha
+'red'.paint.alpha                #=> 1.0
+'rgba(0, 0, 0, 0.5)'.paint.alpha #=> 0.5
+
+# brightness
+'red'.paint.brightness    #=> 76.245
+'yellow'.paint.brightness #=> 225.93
+'white'.paint.brightness  #=> 255.0
+'black'.paint.brightness  #=> 0.0
 
-# etc...
+# complement
+'red'.paint.complement #=> cyan
 ```
 
 ## Contributing

data/lib/chroma/color/modifiers.rb

@@ -19,14 +19,14 @@ module Chroma
       # Brightens the color by the given `amount`.
       #
       # @example
-      #   'red'.paint.brighten     #=> #ff1919
+      #   'red'.paint.brighten     #=> #ff1a1a
       #   'red'.paint.brighten(20) #=> #ff3333
       #
       # @param amount [Fixnum]
       # @return       [Color]
       def brighten(amount = 10)
         # Don't include alpha
-        rgb = @rgb.to_a[0..2].map(&:round)
+        rgb = @rgb.to_a[0..2]
         amount = (255 * (-amount / 100.0)).round
 
         rgb.map! do |n|
@@ -81,7 +81,7 @@ module Chroma
       # Converts the color to grayscale.
       #
       # @example
-      #   'green'.paint.greyscale #=> #404040
+      #   'green'.paint.grayscale #=> #404040
       #
       # @return [Color]
       def grayscale
@@ -93,7 +93,7 @@ module Chroma
       # Spins around the hue color wheel by `amount` in degrees.
       #
       # @example
-      #   'red'.paint.spin(30) #=> #ff80000
+      #   'red'.paint.spin(30) #=> #ff8000
       #   'red'.paint.spin(60) #=> yellow
       #   'red'.paint.spin(90) #=> #80ff00
       #

data/lib/chroma/harmonies.rb

@@ -65,26 +65,26 @@ module Chroma
     # Generate an analogous palette.
     #
     # @example
-    #   'red'.paint.palette.analogous                         #=> [red, #ff0066, #ff0033, red, #ff3300, #ff6600]
-    #   'red'.paint.palette.analogous(as: :hex)               #=> ['#f00', '#f06', '#f03', '#f00', '#f30', '#f60']
-    #   'red'.paint.palette.analogous(results: 3)             #=> [red, #ff001a, #ff1a00]
-    #   'red'.paint.palette.analogous(results: 3, slices: 60) #=> [red, #ff000d, #ff0d00]
+    #   'red'.paint.palette.analogous                        #=> [red, #ff0066, #ff0033, red, #ff3300, #ff6600]
+    #   'red'.paint.palette.analogous(as: :hex)              #=> ['#f00', '#f06', '#f03', '#f00', '#f30', '#f60']
+    #   'red'.paint.palette.analogous(size: 3)               #=> [red, #ff001a, #ff1a00]
+    #   'red'.paint.palette.analogous(size: 3, slice_by: 60) #=> [red, #ff000d, #ff0d00]
     #
     # @param options [Hash]
-    # @option options :results [Symbol] (6) number of results to return
-    # @option options :slices  [Symbol] (30)
+    # @option options :size     [Symbol] (6) number of results to return
+    # @option options :slice_by [Symbol] (30)
     #   the angle in degrees to slice the hue circle per color
-    # @option options :as      [Symbol] (nil) optional format to output colors as strings
+    # @option options :as       [Symbol] (nil) optional format to output colors as strings
     # @return [Array<Color>, Array<String>] depending on presence of `options[:as]`
     def analogous(options = {})
-      results = options[:results] || 6
-      slices = options[:slices] || 30
+      size = options[:size] || 6
+      slices = options[:slice_by] || 30
 
       hsl = @color.hsl
       part = 360 / slices
-      hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360
+      hsl.h = ((hsl.h - (part * size >> 1)) + 720) % 360
 
-      palette = (results - 1).times.reduce([@color]) do |arr, n|
+      palette = (size - 1).times.reduce([@color]) do |arr, n|
         hsl.h = (hsl.h + part) % 360
         arr << Color.new(hsl, @color.format)
       end
@@ -95,21 +95,21 @@ module Chroma
     # Generate a monochromatic palette.
     #
     # @example
-    #   'red'.paint.palette.monochromatic             #=> [red, #2a0000, #550000, maroon, #aa0000, #d40000]
-    #   'red'.paint.palette.monochromatic(as: :hex)   #=> ['#ff0000', '#2a0000', '#550000', '#800000', '#aa0000', '#d40000']
-    #   'red'.paint.palette.monochromatic(results: 3) #=> [red, #550000, #aa0000]
+    #   'red'.paint.palette.monochromatic           #=> [red, #2a0000, #550000, maroon, #aa0000, #d40000]
+    #   'red'.paint.palette.monochromatic(as: :hex) #=> ['#ff0000', '#2a0000', '#550000', '#800000', '#aa0000', '#d40000']
+    #   'red'.paint.palette.monochromatic(size: 3)  #=> [red, #550000, #aa0000]
     #
     # @param options [Hash]
-    # @option options :results [Symbol] (6) number of results to return
-    # @option options :as      [Symbol] (nil) optional format to output colors as strings
+    # @option options :size [Symbol] (6) number of results to return
+    # @option options :as   [Symbol] (nil) optional format to output colors as strings
     # @return [Array<Color>, Array<String>] depending on presence of `options[:as]`
     def monochromatic(options = {})
-      results = options[:results] || 6
+      size = options[:size] || 6
 
       h, s, v = @color.hsv
-      modification = 1.0 / results
+      modification = 1.0 / size
 
-      palette = results.times.map do
+      palette = size.times.map do
         Color.new(ColorModes::Hsv.new(h, s, v), @color.format).tap do
           v = (v + modification) % 1
         end

data/lib/chroma/rgb_generator/from_string.rb

@@ -50,6 +50,8 @@ module Chroma
       def get_generator
         if color = Chroma.hex_from_name(@input)
           format = :name
+        elsif @input == 'transparent'
+          return FromRgbValues.new(:name, 0, 0, 0, 0)
         else
           format = nil
           color = @input

data/lib/chroma/version.rb

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

data/spec/chroma_spec.rb

@@ -0,0 +1,25 @@
+describe Chroma do
+  describe '.hex_from_name' do
+    it 'returns the hex representation for a color name' do
+      Chroma.send(:named_colors_map).each do |name, hex|
+        expect(Chroma.hex_from_name(name)).to eq hex
+      end
+    end
+
+    it 'returns nil for unknown colors names' do
+      expect(Chroma.hex_from_name('foo')).to be_nil
+    end
+  end
+
+  describe '.name_from_hex' do
+    it 'returns a color name for a hex representation' do
+      Chroma.send(:named_colors_map).each do |name, hex|
+        expect(Chroma.name_from_hex(hex)).to be
+      end
+    end
+
+    it 'returns nil for hex values without a corresponding color name' do
+      expect(Chroma.name_from_hex('#123123')).to be_nil
+    end
+  end
+end

data/spec/color/attributes_spec.rb

@@ -0,0 +1,49 @@
+describe Chroma::Color do
+  let(:red)    { 'red'.paint }
+  let(:black)  { 'black'.paint }
+  let(:white)  { 'white'.paint }
+  let(:yellow) { 'yellow'.paint }
+
+  describe '#dark?' do
+    it 'returns true for dark colors' do
+      expect(red).to   be_dark
+      expect(black).to be_dark
+    end
+
+    it 'returns false for light colors' do
+      expect(white).to_not  be_dark
+      expect(yellow).to_not be_dark
+    end
+  end
+
+  describe '#light?' do
+    it 'returns false for dark colors' do
+      expect(red).to_not   be_light
+      expect(black).to_not be_light
+    end
+
+    it 'returns true for light colors' do
+      expect(white).to  be_light
+      expect(yellow).to be_light
+    end
+  end
+
+  describe '#alpha' do
+    it 'returns the correct alpha value' do
+      expect('rgba(255, 0, 0, 0.75)'.paint.alpha).to eq 0.75
+      expect('#80ff0000'.paint.alpha).to             be_within(0.01).of(0.5)
+      expect('transparent'.paint.alpha).to           eq 0
+      expect('hsla(0, 100%, 50%, 0'.paint.alpha).to  eq 0
+      expect(red.alpha).to                           eq 1
+    end
+  end
+
+  describe '#brightness' do
+    it 'returns the correct brightness' do
+      expect(red.brightness).to    eq 76.245
+      expect(black.brightness).to  eq 0
+      expect(white.brightness).to  eq 255
+      expect(yellow.brightness).to eq 225.93
+    end
+  end
+end

data/spec/color/modifiers_spec.rb

@@ -1,9 +1,87 @@
-require 'spec_helper'
-
 describe Chroma::Color do
+  let(:red)    { 'red'.paint }
+  let(:yellow) { 'yellow'.paint }
+
+  describe '#lighten' do
+    context 'with default amount' do
+      it 'generates the correct color' do
+        expect(red.lighten).to eq '#ff3333'.paint
+      end
+    end
+
+    context 'with supplied amount' do
+      it 'generates the correct color' do
+        expect(red.lighten(20)).to eq '#ff6666'.paint
+      end
+    end
+  end
+
+  describe '#brighten' do
+    context 'with default amount' do
+      it 'generates the correct color' do
+        expect(red.brighten).to eq '#ff1a1a'.paint
+      end
+    end
+
+    context 'with supplied amount' do
+      it 'generates the correct color' do
+        expect(red.brighten(20)).to eq '#ff3333'.paint
+      end
+    end
+  end
+
+  describe '#darken' do
+    context 'with default amount' do
+      it 'generates the correct color' do
+        expect(red.darken).to eq '#cc0000'.paint
+      end
+    end
+
+    context 'with supplied amount' do
+      it 'generates the correct color' do
+        expect(red.darken(20)).to eq '#990000'.paint
+      end
+    end
+  end
+
+  describe '#desaturate' do
+    context 'with default amount' do
+      it 'generates the correct color' do
+        expect(red.desaturate).to eq '#f20d0d'.paint
+      end
+    end
+
+    context 'with supplied amount' do
+      it 'generates the correct color' do
+        expect(red.desaturate(20)).to eq '#e61919'.paint
+      end
+    end
+  end
+
+  describe '#saturate' do
+    context 'with default amount' do
+      it 'generates the correct color' do
+        expect('#123'.paint.saturate).to eq '#0e2236'.paint
+      end
+    end
+
+    context 'with supplied amount' do
+      it 'generates the correct color' do
+        expect('#123'.paint.saturate(20)).to eq '#0a223a'.paint
+      end
+    end
+  end
+
+  describe '#grayscale' do
+    it 'generates the correct color' do
+      expect(red.grayscale).to           eq 'gray'.paint
+      expect('green'.paint.grayscale).to eq '#404040'.paint
+    end
+  end
+
   describe '#spin' do
     it 'generates the correct color' do
-      expect('red'.paint.spin(60)).to eq('yellow'.paint)
+      expect(red.spin(60)).to eq yellow
     end
   end
 end

data/spec/color/palette_spec.rb

@@ -96,37 +96,37 @@ describe Chroma::Color, '#palette' do
       end
     end
 
-    context 'with `results` argument' do
+    context 'with `size` argument' do
       it 'returns the analogous palette' do
-        expect(red.palette.analogous(results: 3)).
+        expect(red.palette.analogous(size: 3)).
           to generate_palette %w(#f00 #ff001a #ff1a00)
       end
 
       it 'keeps the same format' do
-        expect(red.palette.analogous(results: 3)).to all have_format :name
+        expect(red.palette.analogous(size: 3)).to all have_format :name
       end
 
       context 'with option :as' do
         it 'outputs the palette as an array of the string format' do
-          expect(red.palette.analogous(results: 3, as: :hex)).
+          expect(red.palette.analogous(size: 3, as: :hex)).
             to eq %w(#ff0000 #ff001a #ff1a00)
         end
       end
     end
 
-    context 'with `results` and `slices` arguments' do
+    context 'with `size` and `slice_by` arguments' do
       it 'returns the analogous palette' do
-        expect(red.palette.analogous(results: 3, slices: 10)).
+        expect(red.palette.analogous(size: 3, slice_by: 10)).
           to generate_palette %w(#f00 #ff004c #ff4d00)
       end
 
       it 'keeps the same format' do
-        expect(red.palette.analogous(results: 3, slices: 10)).to all have_format :name
+        expect(red.palette.analogous(size: 3, slice_by: 10)).to all have_format :name
       end
 
       context 'with option :as' do
         it 'outputs the palette as an array of the string format' do
-          expect(red.palette.analogous(results: 3, slices: 10, as: :hex)).
+          expect(red.palette.analogous(size: 3, slice_by: 10, as: :hex)).
             to eq %w(#ff0000 #ff004c #ff4d00)
         end
       end
@@ -152,19 +152,19 @@ describe Chroma::Color, '#palette' do
       end
     end
 
-    context 'with `results` argument' do
+    context 'with `size` argument' do
       it 'returns the monochromatic palette' do
-        expect(red.palette.monochromatic(results: 3)).
+        expect(red.palette.monochromatic(size: 3)).
           to generate_palette %w(#f00 #500 #a00)
       end
 
       it 'keeps the same format' do
-        expect(red.palette.monochromatic(results: 3)).to all have_format :name
+        expect(red.palette.monochromatic(size: 3)).to all have_format :name
       end
 
       context 'with option :as' do
         it 'outputs the palette as an array of the string format' do
-          expect(red.palette.monochromatic(results: 3, as: :hex)).
+          expect(red.palette.monochromatic(size: 3, as: :hex)).
             to eq %w(#ff0000 #550000 #aa0000)
         end
       end

data/spec/custom_matchers.rb

@@ -11,3 +11,11 @@ RSpec::Matchers.define :have_format do |expected|
     actual.format == expected
   end
 end
+
+RSpec::Matchers.define :be_dark do
+  match { |value| value.dark? }
+end
+
+RSpec::Matchers.define :be_light do
+  match { |value| value.light? }
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chroma
 version: !ruby/object:Gem::Version
-  version: 0.0.1.alpha.3
+  version: 0.0.1
 platform: ruby
 authors:
 - Jeremy Fairbank
@@ -61,6 +61,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - ".yardopts"
 - CHANGELOG.md
 - Gemfile
@@ -97,6 +98,8 @@ files:
 - lib/support/named_colors.yml
 - spec/chroma/define_palette_spec.rb
 - spec/chroma/paint_spec.rb
+- spec/chroma_spec.rb
+- spec/color/attributes_spec.rb
 - spec/color/modifiers_spec.rb
 - spec/color/palette_spec.rb
 - spec/color/serializers_spec.rb
@@ -118,9 +121,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5
@@ -130,6 +133,8 @@ summary: Color manipulation and palette generation.
 test_files:
 - spec/chroma/define_palette_spec.rb
 - spec/chroma/paint_spec.rb
+- spec/chroma_spec.rb
+- spec/color/attributes_spec.rb
 - spec/color/modifiers_spec.rb
 - spec/color/palette_spec.rb
 - spec/color/serializers_spec.rb