reggieb 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2009 Wyatt M. Greene
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,14 @@
+= Reggie B. -- A Hex/RGB Color Converter
+
+== Description
+
+Reggie B. is a utility for converting colors between rgb and hex format.  It was created
+to support http://www.2rgb.com.
+
+== Examples
+
+  ReggieB.convert "rgb(255, 255, 255)"  =>  "0xffffff"
+  ReggieB.convert "255, 255, 255"       =>  "0xffffff"
+  ReggieB.convert "0xffffff"            =>  [255, 255, 255]
+  ReggieB.convert "#ffffff"             =>  [255, 255, 255]
+  ReggieB.convert "#fff"                =>  [255, 255, 255]

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rubygems'
+ 
+desc 'Default: run unit tests.'
+task :default => :test
+ 
+desc 'Test Reggie B.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+ 
+desc 'Generate documentation for Reggie B.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'Reggie B.'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+gem_spec = Gem::Specification.new do |s|
+  s.name          = "reggieb"
+  s.version       = "0.0.1"
+  s.author        = "Wyatt Greene"
+  s.email         = "techiferous@gmail.com"
+  s.summary       = "A Hex/RGB color converter."
+  s.description   = %Q{
+    Reggie B. converts colors between hex format and rgb format.
+    It is very forgiving in the syntax it allows.
+  }
+  s.require_path  = "lib"
+  s.files         = FileList["lib/**/*.rb", "[A-Z]*", "test/**/*"].to_a
+  s.homepage      = "http://github.com/techiferous/reggieb"
+  s.requirements  << "none"
+  s.has_rdoc      = true
+  s.test_files    = Dir.glob("test/**/*.rb")
+end
+
+Rake::GemPackageTask.new(gem_spec) do |pkg| 
+end

data/lib/reggieb.rb

@@ -0,0 +1,82 @@
+class ReggieB
+
+  # converts rgb colors to hex colors and vice versa.  The input is a string representing
+  # an rgb or hex color.  Many formats are allowed, including:
+  #
+  # - "rgb(255, 255, 255)"
+  # - "rgb(255, 255, 255);"
+  # - "rgb 255, 255, 255 "
+  # - "(255, 255, 255)"
+  # - "255, 255, 255"
+  # - "255 255 255"
+  # - "0xffffff"
+  # - "0xFFFFFF"
+  # - "#ffffff"
+  # - "ffffff"
+  # - "fff"
+  #
+  # In the case only three hex digits are given, the three digits are assumed to expand
+  # into six digits like so:
+  #
+  # - fff => ffffff
+  # - 78e => 7788ee
+  # - 084 => 008844
+  # - ace => aaccee
+  #
+  # The output is either a hex color or an rgb color.  A hex color is represented as a 
+  # string formatted like "0xdddddd" where d represents a hex digit.  An rgb color is
+  # represented as an array of three integers between 0 and 255.
+  #
+  def self.convert(s)
+    s = s.downcase
+    s.gsub!(';', '')
+    if s =~ /^\s*((0x|#|)[0-9,a-f]{6})\s*$/
+      return to_rgb($1)
+    end
+    if s =~ /^\s*(0x|#|)([0-9,a-f])([0-9,a-f])([0-9,a-f])\s*$/
+      s = $2 + $2 + $3 + $3 + $4 + $4
+      return to_rgb(s)
+    end
+    if s =~ /^\D*(\d{1,3})\D+(\d{1,3})\D+(\d{1,3})\D*$/
+      return to_hex($1.to_i, $2.to_i, $3.to_i)
+    end
+    raise ArgumentError.new("Bad color format.")
+  end
+
+  # converts an rgb color to hex.  rgb values must be between 0 and 255.  The output
+  # is a string formatted like "0xdddddd" where d represents a hex digit.
+  #
+  def self.to_hex(r, g, b)
+    unless (0..255).include?(r) && (0..255).include?(g) && (0..255).include?(b)
+      message = "RGB values should be between 0 and 255.  Received #{r}, #{g}, #{b}."
+      raise ArgumentError.new(message)
+    end
+    "0x#{to_hex_byte(r)}#{to_hex_byte(g)}#{to_hex_byte(b)}"
+  end
+  
+  # converts a hex color to rgb.  The hex string should be formatted as "0xdddddd" or
+  # "dddddd" where d represents a hex digit.  An array of three integers is returned
+  # representing red, green, and blue values between 0 and 255.
+  #
+  def self.to_rgb(hex)
+    hex = hex.downcase
+    if hex !~ /0x[0-9,a-f]{6}/ && hex !~ /[0-9,a-f]{6}/
+      raise ArgumentError.new("Hex number should be formatted as 0xdddddd or dddddd.")
+    end
+    last_byte   = hex[-2, 2]
+    middle_byte = hex[-4, 2]
+    first_byte  = hex[-6, 2]
+    return [first_byte.to_i(16), middle_byte.to_i(16), last_byte.to_i(16)]
+  end
+
+  def self.to_hex_byte(digits)
+    hex_string = digits.to_s(16)
+    if hex_string.length == 1
+      "0" + hex_string
+    else
+      hex_string
+    end
+  end
+  private_class_method :to_hex_byte
+
+end

data/test/reggieb_test.rb

@@ -0,0 +1,178 @@
+require 'test/test_helper'
+require 'reggieb'
+
+class ReggieBTest < Test::Unit::TestCase
+
+  def test_simple_rgb_to_hex
+    assert_equal "0xffffff", ReggieB.to_hex(255, 255, 255)
+    assert_equal "0x000000", ReggieB.to_hex(0, 0, 0)
+    assert_equal "0x00000f", ReggieB.to_hex(0, 0, 15)
+    assert_equal "0x001100", ReggieB.to_hex(0, 17, 0)
+    assert_equal "0xa01100", ReggieB.to_hex(160, 17, 0)
+  end
+
+  def test_simple_rgb_to_hex_errors
+    assert_raise ArgumentError do
+      ReggieB.to_hex(255, 256, 255)
+    end
+    assert_raise ArgumentError do
+      ReggieB.to_hex(-10, 10, 10)
+    end
+    assert_raise ArgumentError do
+      ReggieB.to_hex(8, 9, 1000)
+    end
+  end
+
+  def test_simple_hex_to_rgb
+    assert_equal  [255, 255, 255],  ReggieB.to_rgb("0xffffff")
+    assert_equal  [0, 0, 0],        ReggieB.to_rgb("0x000000")
+    assert_equal  [0, 0, 15],       ReggieB.to_rgb("0x00000f")
+    assert_equal  [0, 17, 0],       ReggieB.to_rgb("0x001100")
+    assert_equal  [160, 17, 0],     ReggieB.to_rgb("0xa01100")
+    assert_equal  [0, 17, 0],       ReggieB.to_rgb("001100")
+    assert_equal  [160, 17, 0],     ReggieB.to_rgb("a01100")
+    assert_equal  [160, 17, 0],     ReggieB.to_rgb("A01100")
+    assert_equal  [255, 255, 255],  ReggieB.to_rgb("0xFFFFFF")
+  end
+
+  def test_simple_hex_to_rgb_errors
+    assert_raise ArgumentError do
+      ReggieB.to_rgb("0xfff")
+    end
+    assert_raise ArgumentError do
+      ReggieB.to_rgb("fff")
+    end
+    assert_raise ArgumentError do
+      ReggieB.to_rgb("forks")
+    end
+    assert_raise ArgumentError do
+      ReggieB.to_rgb("0x7897zq")
+    end
+  end
+  
+  def test_six_digit_hex
+    assert_equal  [255, 255, 255],  ReggieB.convert("0xffffff")
+    assert_equal  [0, 0, 0],        ReggieB.convert("0x000000")
+    assert_equal  [0, 0, 15],       ReggieB.convert("0x00000f")
+    assert_equal  [0, 17, 0],       ReggieB.convert("0x001100")
+    assert_equal  [160, 17, 0],     ReggieB.convert("0xa01100")
+    assert_equal  [0, 17, 0],       ReggieB.convert("001100")
+    assert_equal  [160, 17, 0],     ReggieB.convert("a01100")
+    assert_equal  [160, 17, 0],     ReggieB.convert("A01100")
+    assert_equal  [255, 255, 255],  ReggieB.convert("0xFFFFFF")
+  end
+
+  def test_three_digit_hex
+    assert_equal  [255, 255, 255],  ReggieB.convert("0xfff")
+    assert_equal  [0, 0, 0],        ReggieB.convert("0x000")
+    assert_equal  [0, 0, 255],      ReggieB.convert("0x00f")
+    assert_equal  [0, 17, 0],       ReggieB.convert("0x010")
+    assert_equal  [34, 0, 170],     ReggieB.convert("0x20a")
+    assert_equal  [255, 255, 255],  ReggieB.convert("0xFFF")
+    assert_equal  [0, 0, 255],      ReggieB.convert("0x00F")
+    assert_equal  [34, 0, 170],     ReggieB.convert("0x20A")
+    assert_equal  [255, 255, 255],  ReggieB.convert("FFF")
+    assert_equal  [0, 0, 255],      ReggieB.convert("00F")
+    assert_equal  [34, 0, 170],     ReggieB.convert("20A")
+    assert_equal  [255, 255, 255],  ReggieB.convert("fff")
+  end
+
+  def test_wrong_digit_hex
+    assert_raise ArgumentError do
+      ReggieB.convert("0xffff")
+    end
+    assert_raise ArgumentError do
+      ReggieB.convert("0x12345")
+    end
+    assert_raise ArgumentError do
+      ReggieB.convert("0x123456789")
+    end
+    assert_raise ArgumentError do
+      ReggieB.convert("0x1")
+    end
+    assert_raise ArgumentError do
+      ReggieB.convert("0x")
+    end
+  end
+
+  def test_hex_prefixes
+    assert_equal  [255, 255, 255],  ReggieB.convert("0xffffff")
+    assert_equal  [0, 170, 0],      ReggieB.convert("0x0a0")
+    assert_equal  [0, 0, 11],       ReggieB.convert("0x00000B")
+    assert_equal  [255, 255, 255],  ReggieB.convert("ffffff")
+    assert_equal  [0, 170, 0],      ReggieB.convert("0a0")
+    assert_equal  [0, 0, 11],       ReggieB.convert("00000B")
+    assert_equal  [255, 255, 255],  ReggieB.convert("#ffffff")
+    assert_equal  [0, 170, 0],      ReggieB.convert("#0a0")
+    assert_equal  [0, 0, 11],       ReggieB.convert("#00000B")
+  end
+
+  def test_whitespace
+    assert_equal  [255, 255, 255],  ReggieB.convert(" 0xffffff ")
+    assert_equal  [0, 170, 0],      ReggieB.convert("    0x0a0    ")
+    assert_equal  [0, 0, 11],       ReggieB.convert("0x00000B  ")
+    assert_equal  [255, 255, 255],  ReggieB.convert(" ffffff")
+    assert_equal  [0, 170, 0],      ReggieB.convert("\t0a0")
+    assert_equal  [0, 0, 11],       ReggieB.convert("\n00000B\t")
+    assert_equal  [255, 255, 255],  ReggieB.convert("               #ffffff")
+    assert_equal  [0, 170, 0],      ReggieB.convert("#0a0\n")
+    assert_equal  [0, 0, 11],       ReggieB.convert(" #00000B ")
+  end
+
+  def test_bad_hex_digits
+    assert_raise ArgumentError do
+      ReggieB.convert("0xbcq")
+    end
+    assert_raise ArgumentError do
+      ReggieB.convert("ffg")
+    end
+    assert_raise ArgumentError do
+      ReggieB.convert("0x0967uf")
+    end
+  end
+  
+  def test_semicolons
+    assert_equal  [255, 255, 255],  ReggieB.convert("0xffffff;")
+    assert_equal  [0, 170, 0],      ReggieB.convert("    0x0a0;")
+    assert_equal  [0, 0, 11],       ReggieB.convert("0x00000B;  ")
+    assert_equal  [255, 255, 255],  ReggieB.convert(" ffffff;")
+    assert_equal  [0, 170, 0],      ReggieB.convert("\t0a0    ;")
+    assert_equal  [0, 0, 11],       ReggieB.convert("\n00000B\t;")
+    assert_equal  [255, 255, 255],  ReggieB.convert("               #ffffff;")
+    assert_equal  [0, 170, 0],      ReggieB.convert("#0a0;")
+    assert_equal  [0, 0, 11],       ReggieB.convert("#00000B;")
+  end
+
+  def test_simple_rgb
+    assert_equal "0xffffff", ReggieB.convert("255, 255, 255")
+    assert_equal "0x000000", ReggieB.convert("0, 0, 0")
+    assert_equal "0x00000f", ReggieB.convert("0, 0, 15")
+    assert_equal "0x001100", ReggieB.convert("0, 17, 0")
+    assert_equal "0xa01100", ReggieB.convert("160, 17, 0")
+  end
+
+  def test_rgb_whitespace
+    assert_equal "0xffffff", ReggieB.convert("255,255,255")
+    assert_equal "0x000000", ReggieB.convert("       0, 0, 0        ")
+    assert_equal "0x00000f", ReggieB.convert("0\t0\t15")
+    assert_equal "0x001100", ReggieB.convert("\t0        17,0")
+    assert_equal "0xa01100", ReggieB.convert("  160, 17, 0  ")
+  end
+
+  def test_rgb_semicolons
+    assert_equal "0xffffff", ReggieB.convert("255,255,255;")
+    assert_equal "0x000000", ReggieB.convert("       0, 0, 0;        ")
+    assert_equal "0x00000f", ReggieB.convert("0\t0\t15;")
+    assert_equal "0x001100", ReggieB.convert("\t0        17,0;")
+    assert_equal "0xa01100", ReggieB.convert("  160, 17, 0  ;")
+  end
+
+  def test_rgb_delimeters
+    assert_equal "0xffffff", ReggieB.convert("255-255-255")
+    assert_equal "0x000000", ReggieB.convert("0 0 0")
+    assert_equal "0x00000f", ReggieB.convert("0   0   15")
+    assert_equal "0x001100", ReggieB.convert("rgb(0, 17, 0)")
+    assert_equal "0xa01100", ReggieB.convert("rgb(160, 17, 0);")
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require 'rubygems'
+require 'redgreen'

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: reggieb
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Wyatt Greene
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-27 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: "\n    Reggie B. converts colors between hex format and rgb format.\n    It is very forgiving in the syntax it allows.\n  "
+email: techiferous@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/reggieb.rb
+- LICENSE
+- Rakefile
+- README
+- test/reggieb_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/techiferous/reggieb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- none
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Hex/RGB color converter.
+test_files: 
+- test/reggieb_test.rb
+- test/test_helper.rb