wirb 1.0.3 → 2.0.0

data/README.rdoc

@@ -1,79 +0,0 @@
-== Wirb Interactive Ruby {<img src="https://travis-ci.org/janlelis/wirb.png" />}[https://travis-ci.org/janlelis/wirb]
-
-*Wirb* colorizes your inspected Ruby objects. It is based on Wirble[http://pablotron.org/software/wirble/], but only provides and improves result highlighting. It also provides a colorization engine abstraction layer and offers flexible schemas using yaml. Wirb is part of the {irbtools suite}[https://github.com/janlelis/irbtools].
-
-Supported Rubies: 2.1, 2.0, 1.9, 1.8, jruby, rubinius
-
-== Install
-
-Install the gem with:
-
-  gem install wirb
-
-== Usage
-
-Add to your <tt>~/.irbrc</tt>
-
-  require 'wirb'
-  Wirb.start
-
-== Features
-
-* Syntax highlighting for Ruby objects
-* Does not change the inspect method
-* Support for generic objects, especially sets and enumerators and nesting more generic objects
-* Funny looking test suite
-* Can be used without irb
-* Limited stdlib/gem objects support (e.g. Set, Gem::Requirement)
-* Usable with any supported terminal colors engine
-* Color schemas in yaml files
-
-== wp
-You can colorize any object with <tt>wp</tt> (wavy_print):
-  require 'wirb/wp'
-  wp some_object
-
-== Colors
-
-To only tweak some colors, take a look at the <tt>Wirb.schema</tt> hash. To use a custom schema, inspect the yaml files in the <tt>data/wirb/</tt> directory. You can create your own schema and load it using <tt>Wirb.load_schema(path_to_yaml_file)</tt>. Alternatively, you can use one of the bundled ones by passing a symbol instead of a path.
-
-=== Colorizer
-
-Wirb supports multiple colorization engines. Available engines can be found in <tt>lib/wirb/colorizer/*</tt>. Some of them require external gems as dependencies (e.g. HighLine). The current default engine is <em>Paint</em>. You can change the colorizer using:
-
-  Wirb.load_colorizer :Paint # or :HighLine or whatever
-
-Be careful, though! You also need to select a color schema that supports your colorizer (Schemas define supported colorizers using the <tt>:colorizer</tt> key). Load a schema with:
-
-  Wirb.load_schema! :classic_paint # make sure your colorizer is paint
-
-You can automatically use the first colorizer of the schema by using the non-exclamation mark version:
-
-  Wirb.load_schema :classic_paint # will fail if paint is not installed
-
-Color schemas wanted! You've got a good looking alternative color schema? Please fork and add it to <tt>data/wirb/*</tt> :)
-
-Colorizers wanted! Your favorite terminal colors gem is not supported yet? Please fork and add it to <tt>lib/wirb/colorizer/*</tt> :D
-
-=== Bundled schemas
-
-The following schemas are bundled (load with <tt>Wirb.load_schema :name</tt> and make sure the used colorizer is available).
-
-* <tt>:classic_paint</tt> (paint implementation of default)
-* <tt>:colorless</tt> (only uses :bright, :underline and :inverse effect)
-* <tt>:classic_wirb0</tt> (default implemented with wirb0)
-
-== Also see
-
-* Configure views for specific objects: hirb[https://github.com/cldwalker/hirb]
-* Wirb is part of: irbtools[https://github.com/janlelis/irbtools]
-* ripl is an irb alternative, syntax highlighting plugin (uses wirb by default): ripl-color_result[https://github.com/janlelis/ripl-color_result]
-* Advanced terminal color gems: Paint[https://github.com/janlelis/paint], HighLine[https://github.com/JEG2/highline]
-
-== Credits
-
-Copyright (c) 2011-2014 Jan Lelis <http://janlelis.de>, see COPYING for details.
-
-Influenced by code from and thanks to: Copyright (C) 2006-2009 Paul Duncan <pabs@pablotron.org>
-
-Contributions[https://github.com/janlelis/wirb/contributors] by and thanks to: {Richard LeBer}[https://github.com/rleber]

data/data/wirb/classic_wirb0.yml

@@ -1,72 +0,0 @@
-colorizer:
-- Wirb0
-- Wirb0_Paint
-- Wirb0_HighLine
-
-# container
-open_hash:   light_green
-close_hash:  light_green
-open_array:  light_green
-close_array: light_green
-open_set:    green
-close_set:   green
-
-# delimiter
-comma:  green
-refers: green
-
-# class
-class:           light_green
-class_separator: green
-object_class:    light_green
-
-# object
-open_object:               green
-object_description_prefix: green
-object_description:        brown
-object_address_prefix:     brown_underline
-object_address:            brown_underline
-object_line_prefix:        brown_underline
-object_line:               brown_underline
-object_line_number:        brown_underline
-object_variable_prefix:    light_purple
-object_variable:           light_purple
-close_object:              green
-
-# symbol
-symbol_prefix:       yellow
-symbol:              yellow
-open_symbol_string:  brown
-symbol_string:       yellow
-close_symbol_string: brown
-
-# string
-open_string:  light_gray
-string:       purple
-close_string: light_gray
-
-# regexp
-open_regexp:  light_blue
-regexp:       purple
-close_regexp: light_blue
-regexp_flags: light_red
-
-# number
-number: cyan
-special_number: cyan
-range:  red
-open_rational:      light_cyan
-rational_separator: light_cyan
-close_rational:     light_cyan
-open_complex:       cyan
-close_complex:      cyan
-
-# misc
-#default:
-#keyword:
-time:    purple
-nil:     light_red
-false:   red
-true:    green
-gem_requirement_condition: cyan
-gem_requirement_version:   light_cyan

data/lib/wirb/colorizer.rb

@@ -1,26 +0,0 @@
-# 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

@@ -1,16 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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/colorizer/wirb0.rb

@@ -1,53 +0,0 @@
-module Wirb::Colorizer::Wirb0
-  COLORS = {
-    :nothing      => '0;0',
-
-    # light
-    :black        => '0;30',
-    :red          => '0;31',
-    :green        => '0;32',
-    :brown        => '0;33',
-    :blue         => '0;34',
-    :purple       => '0;35',
-    :cyan         => '0;36',
-    :light_gray   => '0;37',
-    
-    # bold
-    :dark_gray    => '1;30',
-    :light_red    => '1;31',
-    :light_green  => '1;32',
-    :yellow       => '1;33',
-    :light_blue   => '1;34',
-    :light_purple => '1;35',
-    :light_cyan   => '1;36',
-    :white        => '1;37',
-
-    # underline
-    :black_underline   => '4;30',
-    :red_underline     => '4;31',
-    :green_underline   => '4;32',
-    :brown_underline   => '4;33',
-    :blue_underline    => '4;34',
-    :purple_underline  => '4;35',
-    :cyan_underline    => '4;36',
-    :white_underline   => '4;37',
-
-    # background
-    :black_background   => '7;30',
-    :red_background     => '7;31',
-    :green_background   => '7;32',
-    :brown_background   => '7;33',
-    :blue_background    => '7;34',
-    :purple_background  => '7;35',
-    :cyan_background    => '7;36',
-    :white_background   => '7;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/colorizer/wirb0_highline.rb

@@ -1,73 +0,0 @@
-# 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

@@ -1,71 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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