wirb 0.2.0

data/CHANGELOG.rdoc

@@ -0,0 +1,2 @@
+== 0.2.0
+* Initial release.

data/COPYING

@@ -0,0 +1,21 @@
+Copyright (C) 2011 Jan Lelis <mail@janlelis.de>
+Copyright (C) 2006-2009 Paul Duncan <pabs@pablotron.org>
+ 
+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 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 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.rdoc

@@ -0,0 +1,52 @@
+== Wavy Interactive Ruby
+*Wirb* colorizes your inspected Ruby objects. It is based on Wirble[http://pablotron.org/software/wirble/], but only provides result highlighting.
+
+It fixes some displaying bugs and extends the original tokenizer.
+
+== Install
+Install the gem with:
+
+  gem install wirb
+
+== Usage
+Add to your <tt>~/.irbrc</tt>
+
+  require 'rubygems' unless defined? Gem
+  require 'wirb'
+  Wirb.start
+
+== Improvements and fixed Wirble bugs
+* Basic support for regexes (Wirble displayed them as keywords)
+* Support for generic objects, especially sets and enumerators
+* Fixes some symbol bugs (e.g. :+, :*, ...)
+* Does not change the inspect value (e.g. ranges with 4 instead of 3 dots)
+* Comes with tests
+* Can be used without irb
+
+== Customize
+The color schema can be changed with:
+
+  Wirb.schema = { :comma => :purple, ... }
+
+Wirb color schemas are (almost) compatible with those from the original Wirble, but there are many extensions. Take a look at wirb/schema.rb or </tt>Wirb.schema</tt> for a list of available token descriptions. See wirb/colors.rb or <tt>Wirb::COLORS</tt> for the available colors.
+
+Color schemas wanted! You've got a good looking alternative color schema? Please post it on the wiki[https://github.com/janlelis/wirb/wiki/schemas], it may be bundled with a next version ;)
+
+== wp
+You can colorize any object with <tt>wp</tt> (wavy_print):
+  require 'wirb/wp'
+  wp some_object
+  wp some_object, :light_red
+
+== Also see
+* hirb[https://github.com/cldwalker/hirb]
+* irbtools[https://github.com/janlelis/irbtools]
+* ripl-color_result[https://github.com/janlelis/ripl-color_result]
+
+== Credits
+Copyright (c) 2011 Jan Lelis <http://rbjl.net>, see COPYING for details.
+
+Contains code from (and thanks to)
+* Copyright (C) 2006-2009 Paul Duncan <pabs@pablotron.org>
+
+J-_-L

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'fileutils'
+require "rspec/core/rake_task"
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = [
+    # '--color',
+    '-r ' + File.expand_path( File.join( 'spec', 'spec_helper') ),
+  ]
+end
+
+def gemspec
+  @gemspec ||= eval(File.read('wirb.gemspec'), binding, 'wirb.gemspec')
+end
+
+desc "Build the gem"
+task :gem => :gemspec do
+  sh "gem build wirb.gemspec"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+end
+
+desc "Install the gem locally"
+task :install => :gem do
+  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version} --no-rdoc --no-ri}
+end
+
+desc "Generate the gemspec"
+task :generate do
+  puts gemspec.to_ruby
+end
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+Rake::RDocTask.new do |rdoc|
+  require File.expand_path( File.join( 'lib',  'wirb') )
+
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "Wirb #{Wirb::VERSION}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/wirb.rb

@@ -0,0 +1,45 @@
+module Wirb
+  VERSION = '0.2.0'
+end
+
+require File.dirname(__FILE__) + '/wirb/colors'
+require File.dirname(__FILE__) + '/wirb/schema'
+require File.dirname(__FILE__) + '/wirb/tokenizer'
+
+class << Wirb
+  attr_accessor :schema
+
+  # Return the escape code for a given color
+  def get_color(key)
+    if key.is_a? String
+      color = key
+    elsif Wirb::COLORS.key?(key)
+      color = Wirb::COLORS[key]
+    end
+
+    color ? "\033[#{ color }m" : ''
+  end
+
+  # Colorize a string
+  def colorize_string(string, color)
+    get_color(color) + string.to_s + get_color(:nothing)
+  end
+
+  # Colorize a result string
+  def colorize_result(str, custom_schema = schema)
+    tokenize(str).map{ |kind, token|
+      colorize_string token, custom_schema[kind]
+    }.join
+  end
+
+  # Colorize results in irb/ripl (or whatever might be supported in future)
+  def start
+    require File.dirname(__FILE__) + '/wirb/irb'
+  rescue LoadError
+    warn "Couldn't activate Wirb for #{which}"
+  end
+  alias activate start
+  alias enable start
+end
+
+# J-_-L

data/lib/wirb/colors.rb

@@ -0,0 +1,47 @@
+module Wirb
+  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',
+  }
+end
+
+# J-_-L

data/lib/wirb/irb.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../wirb' unless defined? Wirb
+
+class IRB::Irb
+  alias :output_value_without_wirb :output_value
+
+  def output_value
+    if @context.inspect?
+      printf @context.return_format, ::Wirb.colorize_result( @context.last_value.inspect )
+    else
+      printf @context.return_format, @context.last_value
+    end
+  end
+end

data/lib/wirb/schema.rb

@@ -0,0 +1,68 @@
+module Wirb
+  @schema = { # you can also use escape codes directly, e.g. "4;31"
+
+    # container
+    :open_hash        => :light_green,
+    :close_hash       => :light_green,
+    :open_array       => :light_green,
+    :close_array      => :light_green,
+
+    :open_set         => :green,
+    :close_set        => :green,
+    :open_enumerator  => :green,
+    :close_enumerator => :green,
+
+    # delimiter colors
+    :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_addr_prefix        => :brown_underline,
+    :object_addr               => :brown_underline,
+    :object_line_prefix        => :brown_underline,
+    :object_line               => :brown_underline,
+    :object_line_number        => :brown_underline,
+    :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       => :dark_gray,
+    :close_string => :light_gray,
+
+    # regexp
+    :open_regexp  => :light_blue,
+    :regexp       => :dark_gray,
+    :close_regexp => :light_blue,
+    :regexp_flags => :light_red,
+
+    # number
+    :number => :cyan,
+    :range  => :red,
+    :open_rational      => :light_cyan,
+    :rational_separator => :light_cyan,
+    :close_rational     => :light_cyan,
+
+    # misc
+    :keyword => nil, # rename to default?
+    :nil     => :light_red,
+    :false   => :red,
+    :true    => :green,
+  }
+end
+
+# J-_-L

data/lib/wirb/tokenizer.rb

@@ -0,0 +1,307 @@
+class << Wirb
+  # This is an extended version of the original wirble tokenizer.
+  # Almost everyone would say that 300 lines long case statements need refactoring, but
+  # ...sometimes it just doesn't matter ;)
+  def tokenize(str)
+    raise ArgumentError, 'Tokenizer needs an inspect-string' unless str.is_a? String
+    return enum_for(:tokenize, str) unless block_given?
+
+    chars = str.split(//)
+
+    @state, @token, i = [], '', 0
+
+    # helpers
+    pass_custom_state = lambda{ |kind, *options|
+      yield kind, @token  unless @token.empty?
+      @state.pop          if     options.include?(:remove)
+      @token  = ''        unless options.include?(:keep_token)
+      @repeat = true      if     options.include?(:repeat)
+    }
+
+    pass_state  = lambda{ |*options| pass_custom_state[ @state[-1], *options ] }
+
+    pass        = lambda{ |kind, string| yield kind, string }
+    
+    set_state   = lambda{ |state| @state[-1] = state }
+
+    get_state   = lambda{ |state| @state[-1] == state }
+
+    get_previous_state =
+                  lambda{ |state| @state[-2] == state }
+
+    push_state  = lambda{ |state, *options|
+      @state << state
+      @repeat = true if options.include? :repeat
+    }
+
+    pop_state   = lambda{ |*options|
+      @state.pop
+      @repeat = true if options.include? :repeat
+    }
+
+    # action!
+    while i <= chars.size
+      @repeat = false
+      llc, lc, c, nc = lc, c, chars[i], chars[i+1]
+
+      # warn "char = #{c}  state = #{@state*':'}"
+
+      case @state[-1]
+      when nil, :hash, :array, :enumerator, :set # "default" state
+        case c
+        when ':'      then push_state[:symbol]
+        when '"'      then push_state[:string]
+        when '/'      then push_state[:regexp]
+        when '#'      then push_state[:object]
+        when /[A-Z]/  then push_state[:class,    :repeat]
+        when /[a-z]/  then push_state[:keyword,  :repeat]
+        when /[0-9-]/ then push_state[:number,   :repeat]
+        when '('      then push_state[:rational, :repeat]
+        when '.'      then push_state[:range, :repeat]
+        when /\s/     then pass[:whitespace, c]
+        when ','      then pass[:comma, ',']
+        when '>'      then pass[:refers, '=>'] if lc == '='
+ 
+        when '{'
+          if get_state[:set]
+            pass[:open_set, '{'];  push_state[nil]
+          else
+            pass[:open_hash, '{']; push_state[:hash]
+          end
+
+        when '['
+          if get_state[:enumerator]
+            pass[:open_enumerator, '[']; push_state[nil]
+          else
+            pass[:open_array, '['];      push_state[:array]
+          end
+          
+        when ']'
+          if get_state[:array]
+            pass[:close_array, ']'];       pop_state[]
+          elsif get_previous_state[:enumerator]
+            pass[:close_enumerator, ']'];  pop_state[]
+            set_state[:object_description]
+          end
+
+        when '}'
+          if get_state[:hash]
+            pass[:close_hash, '}'];  pop_state[]
+          elsif get_previous_state[:set]
+            pass[:close_set, '}'];   pop_state[]
+            set_state[:object_description]
+          end
+
+        # else
+        #   warn "ignoring char #{c.inspect}" if @debug
+        end
+
+      when :class
+        case c
+        when /[a-z0-9_]/i
+          @token << c
+        else
+          if c ==':' && nc == ':'
+            pass_state[]
+            pass[:class_separator, '::']
+          elsif !(c == ':' && lc == ':')
+            pass_state[:remove, :repeat]
+          end
+        end
+
+      when :symbol
+        case c
+        when /"/
+          pass[:symbol_prefix, ':']
+          set_state[:symbol_string]
+          @token = ''
+        when /[^"., }\])=]/
+          @token << c
+        else
+          if  ( c == '=' && !(nc == '>' && lc != '<' ) ) ||
+              ( c == ']' && lc == '[' )
+            @token << c
+          else
+            pass[:symbol_prefix, ':']
+            pass_state[:remove, :repeat]
+          end
+        end
+
+      when :symbol_string
+        if c == '"' && lc != '\\'
+          pass[:open_symbol_string, '"']
+          pass_state[:remove]
+          pop_state[]
+          pass[:close_symbol_string, '"']
+        else
+          @token << c
+        end
+
+      when :string
+        if c == '"' && lc != '\\'
+          pass[:open_string, '"']
+          pass_state[:remove]
+          pass[:close_string, '"']
+        else
+          @token << c
+        end
+
+      when :regexp
+        if c == '/' && lc != '\\'
+          pass[:open_regexp, '/']
+          pass_state[:remove]
+          pass[:close_regexp, '/']
+          push_state[:regexp_flags]
+        else
+          @token << c
+        end
+
+      when :regexp_flags
+        if c =~ /[a-z]/i #*%w[m i x o n e u s]
+          @token << c
+        else
+          pass_state[:remove, :repeat]
+        end
+
+      when :keyword
+        if c =~ /[a-z0-9_]/i
+          @token << c
+          pass_custom_state[@token.to_sym, :remove] if %w[nil false true].include?(@token)
+        else
+          pass_state[:remove, :repeat]
+        end
+
+      when :number
+        if c =~ /[0-9e+.-]/ && !(c == '.' && nc == '.')
+          @token << c
+        else
+          pass_state[:remove, :repeat]
+        end
+
+      when :range
+        if c == '.'
+          @token << c
+        else
+          pass_state[:remove, :repeat]
+        end
+
+      when :rational
+        case c
+        when '('
+          pass[:open_rational, '(']
+        when /[0-9e-]/
+          push_state[:number, :repeat]
+        when '/', ','
+          pass[:rational_separator, c]
+        when ' '
+          pass[:whitespace, c]
+        when ')'
+          pass[:close_rational, ')']
+          pop_state[]
+        end
+
+      when :object
+        case c
+        when '<'
+          pass[:open_object, '#<']
+          push_state[:object_class]
+          open_brackets = 0
+        when '>'
+          pass[:close_object, '>']
+          pop_state[]; @token = ''
+        end
+
+      when :object_class
+        case c
+        when /[a-z0-9_]/i
+          @token << c
+        when '>'
+          pass_state[:remove, :repeat]
+        else
+          if c == ':' && nc == ':'
+            pass_state[]
+            pass[:class_separator, '::']
+          elsif !(c == ':' && lc == ':')
+            pass_state[:keep_token]
+            pass[:object_description_prefix, c]
+            if %w[set].include? @token = @token.downcase
+              set_state[@token.to_sym]
+            else
+              set_state[:object_description]
+            end
+            @token = ''
+          end
+        end
+
+      when :object_description
+        case c
+        when '>', nil
+          if open_brackets == 0
+            pass_state[:remove, :repeat]
+          else
+            open_brackets -= 1
+            @token << c
+          end
+        when '<'
+          open_brackets += 1
+          @token << c
+        when '['
+          pass_state[:repeat]
+          set_state[:enumerator]
+        when '"'
+          pass_state[]
+          push_state[:string]
+        when /[0-9]/
+          if c == '0' && nc == 'x'
+            pass_state[:repeat]
+            push_state[:object_addr]
+          else
+            # push_state[:number, :repeat]
+            @token << c
+          end
+        else
+          @token << c
+        end
+
+      when :object_addr
+        if c =~ /[x0-9a-f]/
+          @token << c
+        else
+          if c == '@'
+            pass_state[:remove]
+            push_state[:object_line]
+            pass[:object_line_prefix, '@']
+          else
+            pass_state[:remove, :repeat]
+          end
+        end
+
+       when :object_line
+        if c == ':' && nc =~ /[0-9]/
+          @token << ':'
+          pass_state[:remove]
+          push_state[:object_line_number]
+        else
+          @token << c
+        end
+
+      when :object_line_number
+        if c =~ /[0-9]/
+          @token << c
+        else
+          pass_state[:remove, :repeat]
+        end
+      
+      # else
+      #   raise "unknown state #{@state[-1]} #{@state.inspect}"
+      end
+
+      # TODO infinite recursion detection and catch errors?
+
+      # next round :)
+      i += 1 unless @repeat
+    end
+  end
+end
+
+# J-_-L

data/lib/wirb/wp.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../wirb' unless defined? Wirb
+
+module Kernel
+  private
+
+  def wp(object, color = nil)
+    if color
+      puts Wirb.colorize_string object.inspect, color
+    else
+      puts Wirb.colorize_result object.inspect
+    end
+  end
+end

data/wirb.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems' unless defined? Gem
+require File.dirname(__FILE__) + "/lib/wirb"
+ 
+Gem::Specification.new do |s|
+  s.name        = "wirb"
+  s.version     = Wirb::VERSION
+  s.authors     = ["Jan Lelis"]
+  s.email       = "mail@janlelis.de"
+  s.homepage    = "http://github.com/janlelis/wirb"
+  s.summary     = "Colorizes your irb results."
+  s.description =  "Colorizes your irb results. It's based on Wirble but only provides result highlighting. Just call Wirb.start and enjoy the colors ;)."
+  s.required_rubygems_version = '>= 1.3.6'
+  s.required_ruby_version     = '>= 1.8.7'
+  s.files = Dir.glob(%w[{lib,test}/**/*.rb bin/* [A-Z]*.{txt,rdoc} ext/**/*.{rb,c} **/deps.rip]) + %w{Rakefile wirb.gemspec}
+  s.extra_rdoc_files = ["README.rdoc", "COPYING"]
+  s.license = 'MIT'
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: wirb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
+platform: ruby
+authors: 
+- Jan Lelis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-27 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Colorizes your irb results. It's based on Wirble but only provides result highlighting. Just call Wirb.start and enjoy the colors ;).
+email: mail@janlelis.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- COPYING
+files: 
+- lib/wirb.rb
+- lib/wirb/schema.rb
+- lib/wirb/tokenizer.rb
+- lib/wirb/wp.rb
+- lib/wirb/colors.rb
+- lib/wirb/irb.rb
+- README.rdoc
+- CHANGELOG.rdoc
+- Rakefile
+- wirb.gemspec
+- COPYING
+has_rdoc: true
+homepage: http://github.com/janlelis/wirb
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Colorizes your irb results.
+test_files: []
+