fancy_irb 0.6.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.swp
+*~
+doc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Jan Lelis
+
+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,114 @@
+FancyIrb patches your IRB to create a smooth output experience.
+
+== Features
+* Use fancy colors! You can colorize the prompts, irb errors, +stderr+ and +stdout+
+* Output results as Ruby comment
+* Enhance your output value, using procs
+
+== Motivation
+I really like the {irb_rocket}[https://github.com/genki/irb_rocket] gem, which outputs the evaluation result as comment and colorizes errors. Unfortunately, the implementation leads to bugs, because it tries to run the whole command before printing anything to +stdout+. For this reason, I've rewritten (and extended) it.
+
+This plugin is compatible with other great gems like {hirb}[https://github.com/cldwalker/hirb], {interactive_editor}[https://github.com/jberkel/interactive_editor], etc.
+
+== Usage
+
+  require 'fancy_irb'
+  FancyIrb.start
+
+You can pass an options hash. These are the default values:
+
+  default_options = {
+    :rocket_mode     => true,   # activate or deactivate #=> rocket output
+    :rocket_prompt   => '#=> ', # prompt to use for the rocket
+    :result_prompt   => '=> ',  # prompt to use for normal output
+    :colorize => {              # colors hash. Set to nil to deactivate colorizing
+      :rocket_prompt => :blue,
+      :result_prompt => :blue,
+      :input_prompt  => nil,
+      :irb_errors    => :red,
+      :stderr        => :light_red,
+      :stdout        => :dark_gray,
+      :input         => nil,
+      :output        => true, # wirble's output colorization
+     },
+    :result_proc     => default_result_proc,       # how to get the output result (see below)
+    :output_procs    => [default_colorizer_proc],  # you can modify/enhance/log your output
+  }
+
+=== Rocket mode
+
+Rocket mode means: Output result as comment if there is enough space left on the terminal line.
+
+=== Available colors
+  >> Wirble::Colorize::Color::COLORS.keys
+  => [:light_purple, :yellow, :light_gray, :white, :black, :dark_gray, :red, :green, :light_green, :brown, :light_blue, :light_red, :cyan, :blue, :light_cyan, :purple, :nothing]
+
+=== Modify your output
+
+You can modify how to get and display the input. The <tt>result_proc</tt> is a proc which takes the irb context object and should return the value. You can change it with <tt>FancyIrb.set_result_proc do (your code) end</tt>. After that, each proc in <tt>output_procs</tt> gets triggered. They take the value and can return a modified one. You can use the <tt>FancyIrb.add_output_proc</tt> method for adding new output filter procs.
+
+===== default_result_proc
+
+  default_result_proc = proc{ |context|
+    if context.inspect?
+      context.last_value.inspect
+    else
+      context.last_value
+    end
+  }
+
+===== default_colorizer_proc
+
+  default_colorizer_proc = proc{ |value|
+    FancyIrb.real_lengths[:output] =    value.size
+    if defined?(Wirble) && FancyIrb[:colorize, :output]
+      Wirble::Colorize.colorize value
+    else
+      value 
+    end
+  }
+
+== Example configurations
+
+=== Default
+  FancyIrb.start
+
+=== No colorization
+  FancyIrb.start :colorize => nil
+
+=== Use awesome_print for inspecting
+  require 'ap'
+  FancyIrb.start :rocket_mode   => false,
+                 :colorize      => { :output => false,
+                                     :result_prompt => :yellow },
+                 :result_proc   => proc{ |context|
+                                    context.last_value.awesome_inspect
+                                   }
+
+=== Smileyfy output
+  FancyIrb.start
+  FancyIrb.add_output_proc do |value|
+    value + ' :)'
+  end
+
+== TODO
+=== Known bugs
+* If stdout of the current command scrolls, the rocket is displayed not higher than the first terminal line
+* Something is wrong with input-newline when colorizing input
+* Not all input methods are patched properly (to work with the rocket) --> focusing on the often used ones
+
+=== Features, maybe
+* Count string lengths without ansi escape sequences (would be more flexible than remembering)
+* "Always rocket"-mode
+* Allow custom ansi escape strings
+* Refactor some code duplications
+
+Feel free to fix a bug or implement a todo ;)
+
+== Copyright / Credits
+
+Inspired by the irb_rocket gem from genki.
+
+Copyright (c) 2010 Jan Lelis, http://rbjl.net, released under the MIT license.
+
+J-_-L

data/Rakefile

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fancy_irb"
+    gem.summary = %q{FancyIrb patches your IRB to create a smooth output experience.}
+    gem.description = %q{FancyIrb patches your IRB to create a smooth output experience.
+* Use fancy colors! You can colorize the prompts, irb errors, +stderr+ and +stdout+
+* Output results as Ruby comment #=> (rocket)
+* Enhance your output value, using procs}
+    gem.email = "mail@janlelis.de"
+    gem.homepage = "http://github.com/janlelis/fancy_irb"
+    gem.authors = ["Jan Lelis"]
+    gem.add_dependency 'wirble'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION').chomp : ""
+
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "FancyIrb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.6.0

data/fancy_irb.gemspec

@@ -0,0 +1,51 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fancy_irb}
+  s.version = "0.6.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jan Lelis"]
+  s.date = %q{2010-11-10}
+  s.description = %q{FancyIrb patches your IRB to create a smooth output experience.
+* Use fancy colors! You can colorize the prompts, irb errors, +stderr+ and +stdout+
+* Output results as Ruby comment #=> (rocket)
+* Enhance your output value, using procs}
+  s.email = %q{mail@janlelis.de}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README",
+     "Rakefile",
+     "VERSION",
+     "fancy_irb.gemspec",
+     "lib/fancy_irb.rb",
+     "lib/fancy_irb/irb_ext.rb"
+  ]
+  s.homepage = %q{http://github.com/janlelis/fancy_irb}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{FancyIrb patches your IRB to create a smooth output experience.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<wirble>, [">= 0"])
+    else
+      s.add_dependency(%q<wirble>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<wirble>, [">= 0"])
+  end
+end
+

data/lib/fancy_irb/irb_ext.rb

@@ -0,0 +1,163 @@
+module IRB
+  class Irb
+    def colorize(string, color)
+      if defined?(Wirble) && color && color_string = Wirble::Colorize::Color.escape( color.to_sym )
+        color_string + string.to_s + Wirble::Colorize::Color.escape( :nothing )
+      else
+      #  if defined? Wirble
+      #    Wirble::Colorize::Color.escape( :nothing ) + string.to_s
+      #  else
+          string.to_s
+      #  end
+      end
+    end
+
+    def output_value
+      # prepare prompts
+      rocket    = colorize FancyIrb[:rocket_prompt], FancyIrb[:colorize, :rocket_prompt]
+      no_rocket = colorize FancyIrb[:result_prompt], FancyIrb[:colorize, :result_prompt]
+      
+      # get_result and pass it into every format_output_proc
+      result = FancyIrb[:result_proc][ @context ]
+
+      output = Array( FancyIrb[:output_procs] ).
+        inject( result.to_s ){ |output, formatter|
+          formatter[ output ].to_s
+        }
+
+      # reset color
+      print Wirble::Colorize::Color.escape( :nothing ) 
+
+      # try to output in rocket mode (depending on rocket_mode setting)
+      if FancyIrb[:rocket_mode]
+        # get lengths
+        last_input               = @scanner.instance_variable_get( :@line )
+        last_line_without_prompt = last_input.split("\n").last
+        offset = last_line_without_prompt.size + FancyIrb.real_lengths[:input_prompt] + 1
+        screen_length = `tput cols`.to_i
+        output_length = FancyIrb.real_lengths[:output]
+        rocket_length = FancyIrb[:rocket_prompt].size
+        stdout_lines  = FancyIrb.get_height
+
+        # auto rocket mode
+        if FancyIrb[:rocket_mode] && screen_length > offset + rocket_length + output_length
+          print `tput sc` +                # save current cursor position
+                `tput cuu1`*stdout_lines + # move cursor upwards    to the original input line
+                `tput cuf1`*offset +       # move cursor rightwards to the original input offset
+                rocket +                   # draw rocket prompt
+                output +                   # draw output
+                `tput rc`                  # return to normal cursor position
+          return
+        end
+      end
+      # normal output mode
+      puts no_rocket + output
+    end
+
+    # colorize prompt & input
+    alias prompt_non_fancy prompt
+    def prompt(*args, &block)
+      print Wirble::Colorize::Color.escape(:nothing)
+
+      prompt = prompt_non_fancy(*args, &block)
+      FancyIrb.real_lengths[:input_prompt] = prompt.size
+      colorized_prompt = colorize prompt, FancyIrb[:colorize, :input_prompt]
+      if input_color = FancyIrb[:colorize, :input]
+        colorized_prompt + Wirble::Colorize::Color.escape( input_color )  # NOTE: No reset, relies on next one
+                                                                          # TODO buggy
+      else
+        colorized_prompt
+      end
+    end
+
+    # track height and capture irb errors (part 2)
+    alias signal_status_non_fancy signal_status
+    def signal_status(name, *args, &block)
+      FancyIrb.reset_height
+      signal_status_non_fancy(name, *args, &block)
+    ensure
+      if name == :IN_EVAL
+        if FancyIrb.capture_irb_errors
+          errors = FancyIrb.capture_irb_errors.string
+          
+          $stdout = FancyIrb.original_stdout
+          FancyIrb.capture_irb_errors = nil
+          FancyIrb.original_stdout    = nil
+          
+          unless errors.empty?
+            warn colorize( errors.chomp, FancyIrb[:colorize, :irb_errors] )
+          end
+        end
+      end#if
+    end#def
+  end#class
+
+  class Context
+    alias evaluate_non_fancy evaluate
+
+    # capture irb errors (part 1)
+    def evaluate(*args)
+      FancyIrb.stdout_colorful = true
+      evaluate_non_fancy(*args)
+      FancyIrb.stdout_colorful = false
+    rescue Exception => err
+      FancyIrb.stdout_colorful    = false
+      FancyIrb.capture_irb_errors = StringIO.new
+      FancyIrb.original_stdout, $stdout = $stdout, FancyIrb.capture_irb_errors
+      raise err
+    end
+  end
+end
+
+# hook into streams to count lines and colorize
+class << $stdout
+  alias write_non_fancy write
+  def write(data)
+    FancyIrb.track_height data
+    FancyIrb.write_stream $stdout, data, FancyIrb[:colorize, :stdout]
+  end
+end
+
+class << $stderr
+  alias write_non_fancy write
+  def write(data)
+    FancyIrb.track_height data
+    FancyIrb.write_stream $stderr, data, FancyIrb[:colorize, :stderr]
+  rescue Exception # catch fancy_irb errors
+    write_non_fancy data
+  end
+end
+
+
+# patch some input methods to track height
+alias gets_non_fancy gets
+def gets(*args)
+  res = gets_non_fancy *args
+  FancyIrb.track_height res
+  res
+end
+
+# TODO testing and improving, e.g. getc does not contain "\n"
+class << $stdin
+  stdin_hooks = %w[binread read gets getc getbyte readbyte readchar readline readlines readpartial sysread]
+  # TODO: each_byte, each_char, each_codepoint, each
+
+  stdin_hooks.each{ |m|
+    msym   = m.to_sym
+    malias = (m+'_non_fancy').to_sym
+
+    if $stdin.respond_to? msym
+      alias_method malias, msym
+      define_method msym do |*args|
+        res = send malias, *args
+        FancyIrb.track_height res
+        res
+      end
+    end
+  }
+end
+
+# reset everything (e.g. colors) when exiting
+END{
+  print `tput sgr0`
+}

data/lib/fancy_irb.rb

@@ -0,0 +1,123 @@
+require 'stringio'
+require 'wirble'
+
+module FancyIrb
+  VERSION = ( File.read File.expand_path( '../VERSION', File.dirname(__FILE__)) ).chomp
+end
+
+class << FancyIrb
+  # setup instance variable accessors
+  attr_reader :options
+  def [](key, key2 = nil)
+    if key2
+      @options[key][key2]
+    else
+      @options[key]
+    end
+  end
+
+  attr_accessor :original_stdout
+  attr_accessor :capture_irb_errors
+  attr_accessor :real_lengths
+  attr_accessor :stdout_colorful
+
+  def start(user_options = {})
+    # track some irb stuff
+    @height_counter = []
+    @real_lengths = { :output => 1, :input_prompt => 9999 } # or whatever
+    @stdout_colorful = false
+
+    # set defaults and parse user options
+    default_result_proc = proc{ |context|
+      if context.inspect?
+        context.last_value.inspect
+      else
+        context.last_value
+      end
+    }
+
+    default_colorizer_proc = proc{ |value|
+      FancyIrb.real_lengths[:output] =    value.size
+      if defined?(Wirble) && FancyIrb[:colorize, :output]
+        Wirble::Colorize.colorize value
+      else
+        value 
+      end
+    }
+
+    default_options = {
+      :rocket_mode     => true,   # activate or deactivate #=> rocket output
+      :rocket_prompt   => '#=> ', # prompt to use for the rocket
+      :result_prompt   => '=> ',  # prompt to use for normal output
+      :colorize => {              # colors hash. Set to nil to deactivate colorizing
+        :rocket_prompt => :blue,
+        :result_prompt => :blue,
+        :input_prompt  => nil,
+        :irb_errors    => :red,
+        :stderr        => :light_red,
+        :stdout        => :dark_gray,
+        :input         => nil,
+        :output        => true, # wirble's output colorization
+       },
+      :result_proc     => default_result_proc,       # how to get the output result
+      :output_procs    => [default_colorizer_proc],  # you can modify/enhance/log your output
+    }
+
+    @options = default_options
+
+    default_options.each{ |key, value|
+      # (ugly) 1 level deep merge, maybe refactor
+      if key == :colorize
+        if user_options.has_key?(:colorize) && user_options[:colorize].nil?
+          @options[:colorize] = {}
+        else
+          value.each{ |key2, _|
+            if user_options[key] && user_options[key].has_key?(key2)
+              @options[:colorize][key2] = user_options[key][key2]
+            end
+          }
+        end
+      else
+        @options[key] = user_options.has_key?(key) ? user_options[key] : default_options[key]
+      end
+    }
+
+    # hook code into IRB
+    require 'fancy_irb/irb_ext'
+
+    "Enjoy your FancyIrb :)"
+  end
+
+  def add_output_proc(prepend = false, &proc)
+    action = prepend ? :unshift : :push
+    @options[:output_procs].send action, proc
+  end
+
+  def set_result_proc(&proc)
+    @options[:result_proc] = proc
+  end
+
+  def reset_height
+    @height_counter = []
+  end
+
+  def track_height(data)
+    lines      = data.to_s.count("\n")
+    long_lines = data.to_s.split("\n").inject(0){ |sum, line| line.size / `tput cols`.to_i }
+    @height_counter << lines + long_lines
+  end
+
+  def get_height
+    1 + ( @height_counter == [0] ? 0 : @height_counter.reduce(:+) || 0 )
+  end
+
+  def write_stream(stream, data, color = nil)
+    stream.write_non_fancy(
+      if defined?(Wirble) && FancyIrb.stdout_colorful && color
+        Wirble::Colorize::Color.escape( color ) + data.to_s + Wirble::Colorize::Color.escape(:nothing)
+      else
+        data.to_s
+      end
+    )
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: fancy_irb
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 6
+  - 0
+  version: 0.6.0
+platform: ruby
+authors: 
+- Jan Lelis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-10 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: wirble
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: |-
+  FancyIrb patches your IRB to create a smooth output experience.
+  * Use fancy colors! You can colorize the prompts, irb errors, +stderr+ and +stdout+
+  * Output results as Ruby comment #=> (rocket)
+  * Enhance your output value, using procs
+email: mail@janlelis.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+files: 
+- .gitignore
+- LICENSE
+- README
+- Rakefile
+- VERSION
+- fancy_irb.gemspec
+- lib/fancy_irb.rb
+- lib/fancy_irb/irb_ext.rb
+has_rdoc: true
+homepage: http://github.com/janlelis/fancy_irb
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: FancyIrb patches your IRB to create a smooth output experience.
+test_files: []
+