wirb 0.3.2 → 0.4.0

data/lib/wirb/colorizer.rb

@@ -0,0 +1,26 @@
+# Jan:
+#   General philosophical question: Would it be more flexible to have @colorizer point
+#   to an _instance_ of a Colorizer object, rather than a Colorizer class? (And therefore
+#   to have run and color be instance methods of Colorizer, rather than class methods.)
+#   In certain circumstances this could give greater flexibility, for instance to set 
+#   colorizer options...
+
+module Wirb
+  module Colorizer
+    class << self
+      def const_missing(colorizer)
+        path = File.dirname(__FILE__) + '/colorizer/' + colorizer.to_s.downcase
+
+        begin
+          require path
+        rescue LoadError => e
+          raise LoadError, "Could not load colorizer #{colorizer} at #{path}: #{e}"
+        end
+        
+        raise LoadError, "Colorizer definition at #{path} does not appear to define #{self}::#{colorizer}" \
+          unless const_defined?(colorizer)
+        const_get colorizer
+      end
+    end
+  end
+end

data/lib/wirb/colorizer/highline.rb

@@ -0,0 +1,16 @@
+require 'highline'
+
+module Wirb::Colorizer::HighLine
+  @highline = ::HighLine.new
+
+  class << self
+
+    def run(string, *color_args)
+      @highline.color(string, *color_args.flatten)
+    end
+
+    def color(*color_args)
+      @highline.color_code(*color_args.flatten)
+    end
+  end
+end

data/lib/wirb/colorizer/paint.rb

@@ -0,0 +1,11 @@
+require 'paint'
+
+module Wirb::Colorizer::Paint
+  def self.run(string, *color_args)
+    ::Paint[string, *color_args]
+  end
+
+  def self.color(*color_args)
+    ::Paint.color(*color_args)
+  end
+end

data/lib/wirb/{colors.rb → colorizer/wirb0.rb}

@@ -1,4 +1,4 @@
-module Wirb
+module Wirb::Colorizer::Wirb0
   COLORS = {
     :nothing      => '0;0',
 
@@ -42,6 +42,12 @@ module Wirb
     :cyan_background    => '7;36',
     :white_background   => '7;37',
   }
-end
 
-# J-_-L
+  def self.run(string, *color_args)
+    color(*color_args) + string.to_s + color(:nothing)
+  end
+
+  def self.color(*color_args)
+    color_args.first && COLORS[color_args.first.to_sym] ? "\e[#{COLORS[color_args.first.to_sym]}m" : ''
+  end
+end   

data/lib/wirb/colorizer/wirb0_highline.rb

@@ -0,0 +1,73 @@
+# Colorizer for using HighLine colors with Wirb
+#
+# Automatically translates Wirb color to Highline colors: 
+#   HighLineConnector.color(s, :brown_underline) #=> calls HighLine.color(s, :yellow, :underline)
+#
+# You can mix and match using HighLine color names and Wirb color names. Prefix HighLine color names
+# with :highline. For instance:
+#
+#   Wirb.colorizer.run(s, :highline, :yellow) #=> calls HighLine.color(s, :yellow)
+#   Wirb.colorizer.run(s, :yellow)            #=> calls HighLine.color(s, :bold, :yellow) because 
+#                                             #   Wirb uses :yellow to mean bold yellow
+
+require 'highline'
+
+module Wirb::Colorizer::Wirb0_HighLine
+  def self.color(*colors)
+    ::HighLine.color_code(*color_name(*colors))
+  end
+  
+  def self.run(s, *colors)
+    ::HighLine.color(s, *color_name(*colors))
+  end
+  
+
+  def self.color_name(*colors)
+    colors = colors.flatten.compact
+    if colors.first == :highline # In this case, colors already use HighLine's names
+      colors[1..-1]
+    else
+      translated_colors = colors.map do |color|
+        color = color.to_s
+        case color
+        when "nothing"
+          color = "clear"
+        when /light_gray/
+           color = color.sub("light_gray", "white")
+        when /dark_gray/
+           color = color.sub("dark_gray", "light_black")  # Changed to [:bold, :black] below
+        when /yellow/
+          color = color.sub("yellow", "light_yellow")     # Changed to [:bold, :yellow] below
+        when /white/
+           color = color.sub("white", "light_white")      # Changed to [:bold, :white] below
+        when /brown/              
+          color = color.sub("brown", "yellow")
+        when /purple/             
+          color = color.sub("purple", "magenta")
+        end
+        color_set = [color.to_sym]
+        if color_set.first.to_s =~ /^light_(.*)/
+          color_set[0] = $1.to_sym
+          color_set << :bold
+        end
+        case color_set.first.to_s
+        when /(.*)_underline$/
+          color_set[0] = [$1.to_sym]
+          color_set << :underline
+        when /(.*)_background$/
+          color_set[0] = [('on_'+$1).to_sym]
+        end
+        color_set
+      end
+      translated_colors.flatten
+    end
+  end
+ 
+  def color_code(*args)
+    self.class.color_code(*args)
+  end
+  
+  def color(*args)
+    self.class.color(*args)
+  end
+end

data/lib/wirb/colorizer/wirb0_paint.rb

@@ -0,0 +1,71 @@
+require 'paint'
+
+Paint::SHORTCUTS[:wirb] = {
+  :nothing      => Paint::NOTHING,
+
+  # light
+  :black        => Paint.color(:black),
+  :red          => Paint.color(:red),
+  :green        => Paint.color(:green),
+  :brown        => Paint.color(:yellow),
+  :blue         => Paint.color(:blue),
+  :purple       => Paint.color(:magenta),
+  :cyan         => Paint.color(:cyan),
+  :light_gray   => Paint.color(:white),
+  
+  # bold
+  :dark_gray    => Paint.color(:black, :bold),
+  :light_red    => Paint.color(:red, :bold),
+  :light_green  => Paint.color(:green, :bold),
+  :yellow       => Paint.color(:yellow, :bold),
+  :light_blue   => Paint.color(:blue, :bold),
+  :light_purple => Paint.color(:magenta, :bold),
+  :light_cyan   => Paint.color(:cyan, :bold),
+  :white        => Paint.color(:white, :bold),
+
+  # underline
+  :black_underline   => Paint.color(:black, :underline),
+  :red_underline     => Paint.color(:red, :underline),
+  :green_underline   => Paint.color(:green, :underline),
+  :brown_underline   => Paint.color(:yellow, :underline),
+  :blue_underline    => Paint.color(:blue, :underline),
+  :purple_underline  => Paint.color(:magenta, :underline),
+  :cyan_underline    => Paint.color(:cyan, :underline),
+  :white_underline   => Paint.color(:white, :underline),
+
+  # background
+  :black_background   => Paint.color(nil, :black), # first color passed is foreground, second one is background
+  :red_background     => Paint.color(nil, :red),
+  :green_background   => Paint.color(nil, :green),
+  :brown_background   => Paint.color(nil, :yellow),
+  :blue_background    => Paint.color(nil, :blue),
+  :purple_background  => Paint.color(nil, :magenta),
+  :cyan_background    => Paint.color(nil, :cyan),
+  :white_background   => Paint.color(nil, :white),
+}
+
+module Wirb::Colorizer::Wirb0_Paint
+  def self.run(string, *color_args)
+    if color_args.first && color_args.size == 1 && color_args.first.is_a?(Symbol)
+      if color_args.first == :paint # force usage of paint colors
+        Paint[string, *color_args[1..-1]]
+      else
+        Paint::Wirb.send(color_args.first, string)
+      end
+    else
+      Paint[string, *color_args]
+    end
+  end
+
+  def self.color(*color_args)
+    if color_args.first && color_args.size == 1 && color_args.first.is_a?(Symbol)
+      if color_args.first == :paint # force usage of paint colors
+        Paint[string, *color_args[1..-1]]
+      else
+        Paint::Wirb.send(color_args.first)
+      end
+    else
+      Paint.color(*color_args)
+    end
+  end
+end

data/lib/wirb/colorizer/wirble.rb

@@ -0,0 +1,30 @@
+module Wirb::Colorizer::Wirble
+  COLORS = {
+    :nothing      => '0;0',
+    :black        => '0;30',
+    :red          => '0;31',
+    :green        => '0;32',
+    :brown        => '0;33',
+    :blue         => '0;34',
+    :cyan         => '0;36',
+    :purple       => '0;35',
+    :light_gray   => '0;37',
+    :dark_gray    => '1;30',
+    :light_red    => '1;31',
+    :light_green  => '1;32',
+    :yellow       => '1;33',
+    :light_blue   => '1;34',
+    :light_cyan   => '1;36',
+    :light_purple => '1;35',
+    :white        => '1;37',
+  }
+
+
+  def self.run(string, *color_args)
+    color(*color_args) + string.to_s + color(:nothing)
+  end
+
+  def self.color(*color_args)
+    color_args.first && COLORS[color_args.first.to_sym] ? "\e[#{COLORS[color_args.first.to_sym]}m" : ''
+  end
+end   

data/lib/wirb/tokenizer.rb

@@ -438,7 +438,7 @@ class << Wirb
       snapshot = Marshal.dump([@state, @token, llc, lc, c, nc])
     end
   rescue
-     p$!, $!.backtrace[0]
+    p$!, $!.backtrace[0] if $VERBOSE
     pass[:default, str.sub(@passed, '')]
   end
 end

data/lib/wirb/version.rb

@@ -1,3 +1,3 @@
 module Wirb
-  VERSION = '0.3.2'
+  VERSION = '0.4.0'.freeze # Jan: I think the new Colorizer capability warrants a new minor version
 end

data/spec/colorizer_highline_spec.rb

@@ -0,0 +1,23 @@
+begin # only test if highline is available
+require 'highline'
+
+describe Wirb::Colorizer::HighLine do
+  before :each do
+    Wirb.colorizer = Wirb::Colorizer::HighLine
+  end
+  
+  it "creates good color codes based on Highline color symbols" do
+    Wirb.get_color(:reverse, :underline, :magenta).should match_colors(4,7,35)
+  end
+  
+  it "colorizes strings based on Highline color symbols" do
+    Wirb.colorize_string('Dantooine', :blink, :on_red).should match_colored_string('Dantooine', 5,41)
+  end
+  
+  after :each do
+    Wirb.colorizer = nil
+  end
+end
+
+rescue LoadError
+end

data/spec/colorizer_paint_spec.rb

@@ -0,0 +1,33 @@
+begin # only test if paint is available
+require 'paint'
+
+describe Wirb::Colorizer::Paint do
+  before :each do
+    Wirb.colorizer = Wirb::Colorizer::Paint
+  end
+  
+  it "creates good color codes based on Paint color symbols" do
+    Wirb.get_color(:red).should match_colors(31)
+    Wirb.get_color(:red, :bright).should match_colors(1,31)
+    Wirb.get_color(:bright, :red).should match_colors(1,31)
+    Wirb.get_color(:red, :bright, :underline).should match_colors(1,4,31)
+    Wirb.get_color(:red, :blue).should match_colors(31,44)
+    Wirb.get_color(nil, :blue).should match_colors(44)
+    Wirb.get_color([43,86,129]).should match_colors('38;5;'+(16 + 1*36 + 2*6 + 3*1).to_s)
+    Wirb.get_color("medium sea green").should match_colors('38;5;78')
+    Wirb.get_color("#81562b").should match_colors('38;5;' + (16 + 3*36 + 2*6 + 1*1).to_s)
+    Wirb.get_color("#863").should match_colors('38;5;' + (16 + 3*36 + 2*6 + 1*1).to_s)
+    Wirb.get_color(:red, :encircle).should match_colors(52,31)
+  end
+  
+  it "colorizes strings based on Paint color symbols" do
+    Wirb.colorize_string('Dantooine', :red, :bright, :underline).should match_colored_string('Dantooine', 1,4,31)
+  end
+  
+  after :each do
+    Wirb.colorizer = nil
+  end
+end
+
+rescue LoadError
+end

data/spec/colorizer_spec.rb

@@ -0,0 +1,67 @@
+describe "Colorizer interface" do
+  before(:each) { Wirb.colorizer = @colorizer = double() }
+
+  it "invokes Colorizer.color to get color codes" do
+    @colorizer.should_receive(:color).with(:c3po)
+    wirb = Wirb.get_color(:c3po)
+  end
+
+  it "invokes Colorizer.run to colorize strings" do
+    @colorizer.should_receive(:run).with('chewbacca', 'r2d2')
+    wirb = Wirb.colorize_string('chewbacca', 'r2d2')
+  end
+  
+  after(:each) {Wirb.colorizer = nil}
+end
+
+describe "Colorizer loading" do
+  before(:each) {Wirb.colorizer = nil}
+  
+  it "defaults to using the Wirb0 colorizer" do
+    Wirb.colorizer = nil
+    Wirb.instance_variable_get(:@colorizer).should be_nil
+    foo = Wirb.colorizer # Force a colorizer to be loaded
+    Wirb.colorizer.should == Wirb::Colorizer::Wirb0
+  end
+
+  it "attempts to load the appropriate colorizer" do
+    Wirb.colorizer = nil
+    Wirb.instance_variable_get(:@colorizer).should be_nil
+    Wirb::Colorizer.should_receive(:require).
+      with(File.dirname(File.dirname(__FILE__)) + '/lib/wirb/colorizer/notloaded').
+      and_return(true)
+    expect {
+      Wirb.colorizer = Wirb::Colorizer::NotLoaded
+    }.to raise_error(LoadError) # Because the Colorizer doesn't actually exist, wasn't loaded
+                                # and didn't define Wirb::Colorizer::NotLoaded
+  end
+  
+  it "fails if the colorizer is not found" do
+    expect {
+      Wirb.colorizer = Wirb::Colorizer::DoesntExist
+    }.to raise_error(LoadError)
+  end
+  
+  it "fails if the colorizer definition doesn't define the colorizer class" do
+    Wirb::Colorizer.should_receive(:require).
+      with(File.dirname(File.dirname(__FILE__)) + '/lib/wirb/colorizer/badcolorizer').
+      and_return(true)
+    expect {
+      Wirb.colorizer = Wirb::Colorizer::BadColorizer
+    }.to raise_error(LoadError)
+  end
+  
+  it "sets the Colorizer object" do
+    Wirb.colorizer = nil
+    Wirb.instance_variable_get(:@colorizer).should be_nil
+    Wirb.colorizer = Wirb::Colorizer::Wirble
+    Wirb::Colorizer.const_defined?(:Wirble).should be_true
+    Wirb.colorizer.should == Wirb::Colorizer::Wirble
+  end
+  
+  it "doesn't load Colorizers until they are referenced" do
+    # Can't figure out how to test for this, actually
+  end
+  
+  after(:each) {Wirb.colorizer = nil}
+end

data/spec/colorizer_wirb0_highline_spec.rb

@@ -0,0 +1,78 @@
+begin # only test if highline is available
+require 'highline'
+
+describe Wirb::Colorizer::Wirb0_HighLine do
+  before :each do
+    Wirb.colorizer = Wirb::Colorizer::Wirb0_HighLine
+  end
+  
+  it "creates good color codes based on Highline color symbols" do
+    Wirb.get_color(:highline, :reverse, :underline, :magenta).should == "\e[7m\e[4m\e[35m"
+  end
+  
+  it "colorizes strings based on Highline color symbols" do
+    Wirb.colorize_string('Dantooine', :highline, :blink, :on_red).should == "\e[5m\e[41mDantooine\e[0m"
+  end
+  
+  it_behaves_like "a Wirb0 colorizer"
+  
+  context "when using basic color names" do
+    it "understands the differences between HighLine and Wirb0" do
+      Wirb.get_color(:nothing).should match_colors(0)                              # Wirb0 calls this nothing
+      Wirb.get_color(:highline, :clear).should match_colors(0)                     # HighLine calls it clear
+    
+      Wirb.get_color(:brown).should match_colors(0,33)                             # Wirb0 calls this brown
+      Wirb.get_color(:highline, :yellow).should match_colors(0,33)                 # HighLine calls it yellow
+    
+      Wirb.get_color(:purple).should match_colors(0,35)                            # Wirb0 calls this purple
+      Wirb.get_color(:highline, :magenta).should match_colors(0,35)                # HighLine calls it magenta
+    
+      Wirb.get_color(:light_gray).should match_colors(0,37)                        # Wirb0 calls this light_gray
+      Wirb.get_color(:highline, :white).should match_colors(0,37)                  # HighLine calls it white
+    
+      Wirb.get_color(:light_black).should match_colors(1,30)                       # Wirb0 calls this light_black
+      Wirb.get_color(:highline, :bold, :black).should match_colors(1,30)           # HighLine calls it bold black
+    
+      Wirb.get_color(:yellow).should match_colors(1,33)                            # Wirb0 calls this yellow
+      Wirb.get_color(:highline, :bold, :yellow).should match_colors(1,33)          # HighLine calls it bold yellow
+    
+      Wirb.get_color(:white).should match_colors(1,37)                             # Wirb0 calls this white
+      Wirb.get_color(:highline, :bold, :white).should match_colors(1,37)           # HighLine calls it bold white
+    end
+  end
+    
+  context "when using light/bold colors" do
+    it "understands the differences between HighLine and Wirb0" do
+      Wirb.get_color(:light_purple).should match_colors(1,35)                      # Wirb0 says :light_<color>
+      Wirb.get_color(:highline, :magenta, :bold).should match_colors(1,35)         # HighLine says :bold, :<color>
+    end
+  end
+    
+  context "when using underlined colors" do
+    it "understands the differences between HighLine and Wirb0" do
+      Wirb.get_color(:light_gray_underline).should match_colors(4,37)              # Wirb0 says :<color>_underline
+      Wirb.get_color(:highline, :underline, :white).should match_colors(4,37)      # HighLine says :underline, :<color>
+    end
+  end
+
+  context "when using background colors" do
+    it "understands the differences between HighLine and Wirb0" do
+      Wirb.get_color(:brown_background).should match_colors(43)                    # Wirb0 says :<color>_background
+      Wirb.get_color(:highline, :on_yellow).should match_colors(43)                # HighLine says :on_<color>
+    end
+  end
+    
+  context "when encoding strings" do
+    it "understands the differences between HighLine and Wirb0" do
+      Wirb.colorize_string('Alderaan', :purple).should match_colored_string('Alderaan', 35)             # Wirb0 calls this purple
+      Wirb.colorize_string('Alderaan', :highline, :magenta).should match_colored_string('Alderaan', 35) # HighLine calls it magenta
+    end
+  end
+  
+  after :each do
+    Wirb.colorizer = nil
+  end
+end
+
+rescue LoadError
+end