fancy_irb 0.7.3 → 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2fdffc1b6242172f062ba5594a0ac52d13206a8
+  data.tar.gz: 15bb12b8f67d46fedb9615579faf6d5d4619d855
+SHA512:
+  metadata.gz: a70c8539226521749e6d394f66bfd898921181faa284632bb4e0cd5d7558e97c6395deea7f203f439674394beab43884126fdd1cd0c8fe4b60ec5a324a5d7712
+  data.tar.gz: 49958762080644102e8e0a4f1bf9568bf82527935422b692ebeb62a043e72b633bc03f91e9173f702254414267b811efdbd6fb26d499350eb090a7c1b9eb2cfc

data/CHANGELOG.rdoc

@@ -1,3 +1,14 @@
+== 0.8.0
+* Internals partly refactored
+* Bump paint and unicode-display_width dependencies
+* Drop official support for Ruby 1
+* Don't depend on ansicon specifics for windows (use io/console)
+* Also patch input methods for ARGF
+* Don't try to catch exception when printing to stderr
+* Remove [:colorizer][:output] option
+* Not patching Kernel anymore
+* Only path String if east_asian_width option is used
+
 == 0.7.3
 * Don't colorize stdout by default
 * Deactivate rocket for common system commands

data/{LICENSE → MIT-LICENSE.txt}

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2012 Jan Lelis
+Copyright (c) 2010-2012, 2015 Jan Lelis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,14 +1,9 @@
-FancyIrb patches your IRB to create a smooth output experience.
+= FancyIrb
 
-== Features
-* Use fancy colors! You can colorize the prompts, irb errors, +stderr+ and +stdout+
-* Output evaluation results as Ruby comments (hash rocket)
-* Filter your output value using procs
+* Colorizes prompts, errors, +stderr+ and +stdout+
+* Uses Hash Rockets to display evaluation results
+* Allows you to apply a proc before showing the result
 
-== Motivation
-I really like the {irb_rocket}[https://github.com/genki/irb_rocket] gem, which outputs Ruby results using a hash rocket 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 rubygem is compatible with other great irb gems like {hirb}[https://github.com/cldwalker/hirb], {interactive_editor}[https://github.com/jberkel/interactive_editor], etc.
 
 == Usage
 
@@ -17,40 +12,52 @@ This rubygem is compatible with other great irb gems like {hirb}[https://github.
 
 You can pass an options hash. These are the default values:
 
-  default_options = {
+  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
+    :result_proc     => DEFAULT_RESULT_PROC,       # how to get the output result from IRB
+    :output_procs    => [DEFAULT_COLORIZER_PROC],  # output formatter procs
+    :east_asian_width => false, # set to true if you have double-width characters (slower)
+    :colorize => {              # colors hash. Set to nil to deactivate colors
       :rocket_prompt => [:blue],
       :result_prompt => [:blue],
       :input_prompt  => nil,
-      :irb_errors    => [:red],
+      :irb_errors    => [:red, :clean],
       :stderr        => [:red, :bright],
       :stdout        => nil,
       :input         => nil,
-      :output        => true, # wirb'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
-    :east_asian_width => false, # set to true if you have double-width characters (slower)
   }
 
-=== Rocket mode
 Rocket mode means: Output result as comment if there is enough space left on the terminal line and +stdout+ does not output more than the current terminal height.
 
-=== Wrong display widths?
-When using double-width unicode chars, you should set <tt>:east_asian_width</tt> to <tt>true</tt>. It is deactivated because of performance issues.
+For more information on which colors can be used, see the {paint documentation}[https://github.com/janlelis/paint].
+
+
+== Example configurations
+=== Default
+  FancyIrb.start
+
+=== No colorization
+  FancyIrb.start :colorize => nil
 
-=== Customize colors
-See paint[https://github.com/janlelis/paint]
+=== 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
+                                   }
 
-=== Modify your IRB output
+
+== Advanced: Hook into IRB
 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
 
-  default_result_proc = proc{ |context|
+  DEFAULT_RESULT_PROC = proc{ |context|
     if context.inspect?
       context.last_value.inspect
     else
@@ -58,57 +65,33 @@ You can modify how to get and display the input. The <tt>result_proc</tt> is a p
     end
   }
 
-===== default_colorizer_proc
+=== Default colorizer_proc
 
-  default_colorizer_proc = proc{ |value|
-    FancyIrb.real_lengths[:output] =    value.size
-    if defined?(Wirb) && FancyIrb[:colorize, :output]
+  DEFAULT_COLORIZER_PROC = proc{ |value|
+    if defined?(Wirb)
       Wirb.colorize_result value
     else
-      value 
+      value
     end
   }
 
-== FancyIrb on Windows?
-
-You need ansicon[https://github.com/adoxa/ansicon] and everything will be fine :D
+== Troubleshooting
+=== Windows Support
+You will need ansicon[https://github.com/adoxa/ansicon].
 
-== 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
+=== Wrong display widths?
+When using double-width unicode chars, you should set <tt>:east_asian_width</tt> to <tt>true</tt>. It is not activated by default, because of its performance impact.
 
-== TODO
 === Known bugs
-* 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
+Not all stdin methods are patched properly to work with the rocket: The gems focuses on the often used ones
 
-=== Features, maybe
-* Count string lengths without ansi escape sequences (would be more flexible than remembering)
-* "Always rocket"-mode
 
-== Copyright / Credits
+== TODO
+* Refactor to modern code
+* Just count string lengths without ansi escape sequences (would be more flexible than remembering)
 
-Inspired by the irb_rocket gem from genki.
 
-Copyright (c) 2010-2012 Jan Lelis <http://rbjl.net> released under the MIT license.
+== J-_-L
+Inspired by the irb_rocket gem by genki.
 
-J-_-L
+Copyright (c) 2010-2012, 2015 Jan Lelis <http://janlelis.com> released under the MIT license.

data/Rakefile

@@ -15,7 +15,7 @@ end
 
 desc "Install the gem locally (without docs)"
 task :install => :gem do
-  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version} --no-rdoc --no-ri}
+  sh %{gem install pkg/#{gemspec.name}-#{gemspec.version}.gem --no-rdoc --no-ri --local}
 end
 
 desc "Generate the gemspec"

data/fancy_irb.gemspec

@@ -1,39 +1,35 @@
 # -*- encoding: utf-8 -*-
-require 'rubygems' unless defined? Gem
- 
+
+require File.dirname(__FILE__) + "/lib/fancy_irb/version"
+
 Gem::Specification.new do |s|
   s.name        = "fancy_irb"
-  s.version     = File.read('VERSION').chomp
+  s.version     = FancyIrb::VERSION
   s.authors     = ["Jan Lelis"]
   s.email       = "mail@janlelis.de"
   s.homepage    = "http://github.com/janlelis/fancy_irb"
-  s.summary     = "FancyIrb patches your IRB to create a smooth output experience."
-  s.description = "FancyIrb patches your IRB to create a smooth output experience. You can colorize the prompts, irb errors, stderr and stdout, output your result as #=> (hash rockets) and some other improvements."
-  s.required_rubygems_version = '>= 1.3.6'
-  s.required_ruby_version     = '>= 1.8.7'
-  s.extra_rdoc_files = ["README.rdoc", "LICENSE"]
+  s.summary     = "FancyIrb makes IRB friendly."
+  s.description = "FancyIrb makes IRB # => friendly."
+  s.required_ruby_version = '>= 1.9.3'
   s.license = 'MIT'
-  s.requirements = ['On Windows, you need ansicon: https://github.com/adoxa/ansicon']
-  s.add_dependency('paint', '>= 0.8.1')
-  s.add_dependency('unicode-display_width', ">= 0.1.1")
+  s.requirements = ['Windows: ansicon <https://github.com/adoxa/ansicon>']
+  s.add_dependency 'paint', '>= 0.9.0'
+  s.add_dependency 'unicode-display_width', ">= 0.2.0"
   s.files = [
-    "LICENSE",
+    "MIT-LICENSE.txt",
     "README.rdoc",
     "Rakefile",
-    "VERSION",
     "CHANGELOG.rdoc",
     "fancy_irb.gemspec",
     "lib/fancy_irb.rb",
-    "lib/fancy_irb/irb_ext.rb"
+    "lib/fancy_irb/irb_ext.rb",
+    "lib/fancy_irb/terminal_info.rb",
+    "lib/fancy_irb/implementation.rb",
+    "lib/fancy_irb/size_detector.rb",
+    "lib/fancy_irb/error_capturer.rb",
+    "lib/fancy_irb/core_ext.rb",
+    "lib/fancy_irb/clean_up.rb",
+    "lib/fancy_irb/version.rb",
   ]
-
-  len = s.homepage.size
-  s.post_install_message = \
-   ("       ┌── " + "info ".ljust(len-2,'%')              + "─┐\n" +
-    " J-_-L │ "   + s.homepage                            + " │\n" +
-    "       ├── " + "usage ".ljust(len-2,'%')             + "─┤\n" +
-    "       │ "   + "require 'fancy_irb'".ljust(len,' ')  + " │\n" +
-    "       │ "   + "FancyIrb.start".ljust(len,' ')       + " │\n" +
-    "       └─"   + '─'*len                               + "─┘").gsub('%', '─') # 1.8 workaround
 end
 

data/lib/fancy_irb/clean_up.rb

@@ -0,0 +1 @@
+END{ print Paint::NOTHING }

data/lib/fancy_irb/core_ext.rb

@@ -0,0 +1,12 @@
+# patch streams to track height & apply colors
+FancyIrb.patch_stream $stdout, :stdout
+FancyIrb.patch_stream $stderr, :stderr
+
+# patch some $stdin methods to track height
+FancyIrb.register_height_trackers $stdin, FancyIrb::TRACK_HEIGHT_INPUT_METHODS
+
+# patch some ARGF methods to track height
+FancyIrb.register_height_trackers $<, FancyIrb::TRACK_HEIGHT_INPUT_METHODS
+
+# deactivate rocket for common system commands
+FancyIrb.register_skipped_rockets Object, FancyIrb::SKIP_ROCKET_METHODS

data/lib/fancy_irb/error_capturer.rb

@@ -0,0 +1,18 @@
+require 'stringio'
+
+module FancyIrb
+  class ErrorCapturer
+    def initialize
+      @original_stdout, $stdout = $stdout, StringIO.new
+      @fake_stdout = $stdout
+    end
+
+    def error_string
+      @fake_stdout.string
+    end
+
+    def restore_original_stdout
+      $stdout = @original_stdout
+    end
+  end
+end

data/lib/fancy_irb/implementation.rb

@@ -0,0 +1,168 @@
+module FancyIrb
+  class << self
+    attr_reader :options
+    attr_reader :error_capturer
+    attr_accessor :skip_next_rocket
+
+    def start(user_options = {})
+      set_defaults
+      apply_user_options(user_options)
+      reset_line!
+      extend!
+
+      true
+    end
+
+    # hook into IRB
+    def extend!
+      require 'unicode/display_size' if @options[:east_asian_width]
+      require_relative 'irb_ext'
+      require_relative 'core_ext'
+      require_relative 'clean_up'
+    end
+
+    def set_defaults
+      @skip_next_rocket = false
+      @real_lengths     = { :output => 1, :input_prompt => Float::INFINITY }
+
+      @options = DEFAULT_OPTIONS.dup
+      @options[:colorize] = @options[:colorize].dup if @options[:colorize]
+    end
+
+    def apply_user_options(user_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
+      }
+    end
+
+    def [](key, key2 = nil)
+      if key2
+        @options[key][key2]
+      else
+        @options[key]
+      end
+    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_line!
+      @height_counter = []
+      @indent = false
+    end
+
+    def track_indent!
+      @indent = true
+    end
+
+    def set_input_prompt_size(prompt, irb_scanner)
+      @real_lengths[:input_prompt] =
+        prompt.size + irb_scanner.indent * 2 + ( @indent ? 2 : 0 )
+    end
+
+    def track_height(data)
+      @height_counter << SizeDetector.height_of(data, TerminalInfo.cols)
+    end
+
+    def get_height
+      1 + ( @height_counter == [0] ? 0 : @height_counter.reduce(:+) || 0 )
+    end
+
+    def colorize(string, colorize_key)
+      Paint::NOTHING + Paint[string, *Array(@options[:colorize][colorize_key])]
+    end
+
+    # Note: No reset, relies on next one
+    def append_input_color(string)
+      if input_color = @options[:colorize][:input]
+        string + Paint.color(*Array(input_color))
+      else
+        string
+      end
+    end
+
+    # get_result and pass it into every format_output_proc
+    def get_output_from_irb_context(irb_context)
+      result = @options[:result_proc][irb_context]
+      @real_lengths[:output] = result.size
+      Array(@options[:output_procs]).inject(
+        result
+      ){ |output, output_proc|
+        output_proc[output].to_s
+      }
+    end
+
+    def get_offset_from_irb_scanner(irb_scanner)
+      last_line = irb_scanner.instance_variable_get(:@line).split("\n").last
+      1 + @real_lengths[:input_prompt] + (last_line ? SizeDetector.width_of(last_line) : 0)
+    end
+
+    def get_cols_to_show_from_offset(offset)
+      offset + @options[:rocket_prompt].size + @real_lengths[:output]
+    end
+
+    # TODO testing and improving, e.g. getc does not contain "\n"
+    def register_height_trackers(object, methods_)
+      methods_.each{ |method_|
+        if object.respond_to?(method_)
+          object.send :define_singleton_method, method_ do |*args|
+            res = super(*args)
+            FancyIrb.track_height(res)
+            res
+          end
+        end
+      }
+    end
+
+    def register_skipped_rockets(object_class, methods_)
+      methods_.each{ |method_|
+        object_class.send :define_method, method_ do |*args|
+          FancyIrb.skip_next_rocket = true
+          super(*args)
+        end
+      }
+    end
+
+    def patch_stream(object, stream_name)
+      object.define_singleton_method :write do |data|
+        FancyIrb.track_height data
+        super FancyIrb.colorize(data, stream_name)
+      end
+    end
+
+    def register_error_capturer!
+      @error_capturer = FancyIrb::ErrorCapturer.new
+    end
+
+    def present_and_clear_captured_error!
+      if @error_capturer
+        @error_capturer.restore_original_stdout
+        $stderr.puts colorize(
+          @error_capturer.error_string.chomp,
+          :irb_errors,
+        )
+        @error_capturer = nil
+      end
+    end
+  end
+end

data/lib/fancy_irb/irb_ext.rb

@@ -1,196 +1,62 @@
-if FancyIrb[:east_asian_width]
-  require 'unicode/display_size'
-else
-  class String
-    alias display_size size
-  end
-end
-
 module IRB
   class Irb
-    if FancyIrb.win?
-      TPUT = {
-        :sc   => "\e[s",
-        :rc   => "\e[u",
-        :cuu1 => "\e[1A",
-        :cuf1 => "\e[1C",
-      }
-    else
-      TPUT = {
-        :sc   => `tput sc`,
-        :rc   => `tput rc`,
-        :cuu1 => `tput cuu1`,
-        :cuf1 => `tput cuf1`,
-      }
-    end
-
-    def colorize(string, color)
-      Paint[string, *Array(color)]
-    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 Paint::NOTHING
+      output = FancyIrb.get_output_from_irb_context(@context)
 
-      # try to output in rocket mode (depending on rocket_mode setting)
       if FancyIrb[:rocket_mode] && !FancyIrb.skip_next_rocket
-        # get lengths
-        last_input               = @scanner.instance_variable_get( :@line )
-        last_line_without_prompt = last_input.split("\n").last
-        offset =  + FancyIrb.real_lengths[:input_prompt] + 1
-        if last_line_without_prompt
-          offset += last_line_without_prompt.display_size
-        end
-        screen_length = FancyIrb.current_length
-        screen_lines  = FancyIrb.current_lines
-        output_length = FancyIrb.real_lengths[:output]
-        rocket_length = FancyIrb[:rocket_prompt].size
-        stdout_lines  = FancyIrb.get_height
-
-        # auto rocket mode
-        if  screen_length > offset + rocket_length + output_length &&
-            stdout_lines < screen_lines
-          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
+        offset = FancyIrb.get_offset_from_irb_scanner(@scanner)
+        cols_to_show   = FancyIrb.get_cols_to_show_from_offset(offset)
+        lines_to_show  = FancyIrb.get_height
+
+        if  FancyIrb::TerminalInfo.lines > lines_to_show &&
+            FancyIrb::TerminalInfo.cols  > cols_to_show
+          print \
+            Paint::NOTHING +
+            FancyIrb::TerminalInfo::TPUT[:sc] +                    # save current cursor position
+            FancyIrb::TerminalInfo::TPUT[:cuu1] * lines_to_show +  # move cursor upwards    to the original input line
+            FancyIrb::TerminalInfo::TPUT[:cuf1] * offset +         # move cursor rightwards to the original input offset
+            FancyIrb.colorize(FancyIrb[:rocket_prompt], :rocket_prompt) + # draw rocket prompt
+            output +                                               # draw output
+            FancyIrb::TerminalInfo::TPUT[:rc]                      # return to normal cursor position
           return
         end
       end
-      # normal output mode
       FancyIrb.skip_next_rocket = false
-      puts no_rocket + output
+      puts FancyIrb.colorize(FancyIrb[:result_prompt], :result_prompt) + output
     end
 
     # colorize prompt & input
     alias prompt_non_fancy prompt
     def prompt(*args, &block)
-      print Paint::NOTHING
       prompt = prompt_non_fancy(*args, &block)
 
-      # this is kinda hacky... but that's irb °_°
-      indents = @scanner.indent*2
-      FancyIrb.continue = true if args[0] == IRB.conf[:PROMPT][IRB.conf[:PROMPT_MODE]][:PROMPT_C]
-      indents += 2 if FancyIrb.continue
-      FancyIrb.real_lengths[:input_prompt] = prompt.size + indents
-     
-      colorized_prompt = colorize prompt, FancyIrb[:colorize, :input_prompt]
-      if input_color = FancyIrb[:colorize, :input]
-        colorized_prompt + Paint.color(*Array(input_color)) # NOTE: No reset, relies on next one
-      else
-        colorized_prompt
-      end
+      FancyIrb.track_indent! if args[0] == IRB.conf[:PROMPT][IRB.conf[:PROMPT_MODE]][:PROMPT_C]
+      FancyIrb.set_input_prompt_size(prompt, @scanner)
+
+      FancyIrb.append_input_color(FancyIrb.colorize(prompt, :input_prompt))
     end
 
-    # track height and capture irb errors (part 2)
+    # reset line and capture IRB errors (part 2)
     alias signal_status_non_fancy signal_status
     def signal_status(name, *args, &block)
-      FancyIrb.continue = false
-      FancyIrb.reset_height
+      FancyIrb.reset_line!
       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
+        FancyIrb.present_and_clear_captured_error!
+      end
+    end
+  end
 
   class Context
     alias evaluate_non_fancy evaluate
 
-    # capture irb errors (part 1)
+    # 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
+    rescue Exception
+      FancyIrb.register_error_capturer!
+      raise
     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
-
-# deactivate rocket for common system commands
-%w[system spawn].each{ |m|
-  Object.send(:define_method, m.to_sym, &lambda{ |*args, &block|
-    FancyIrb.skip_next_rocket = true
-    super(*args, &block)
-  })
-}
-
-# 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
-
-END{ print "\e[0m" } # reset colors when exiting
-
-# J-_-L

data/lib/fancy_irb/size_detector.rb

@@ -0,0 +1,20 @@
+module FancyIrb
+  module SizeDetector
+    def self.width_of(data)
+      if FancyIrb[:east_asian_width]
+        data.display_size
+      else
+        data.size
+      end
+    end
+
+    def self.height_of(data, width)
+      data       = Paint.unpaint(data.to_s)
+      lines      = data.count("\n")
+      long_lines = data.split("\n").inject(0){ |sum, line|
+        sum + (width_of(line) / width)
+      }
+      lines + long_lines
+    end
+  end
+end

data/lib/fancy_irb/terminal_info.rb

@@ -0,0 +1,29 @@
+require 'io/console'
+
+module FancyIrb
+  module TerminalInfo
+    def self.lines
+      STDIN.winsize[0]
+    end
+
+    def self.cols
+      STDIN.winsize[1]
+    end
+
+    if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+      TPUT = {
+        :sc   => "\e[s",
+        :rc   => "\e[u",
+        :cuu1 => "\e[1A",
+        :cuf1 => "\e[1C",
+      }
+    else
+      TPUT = {
+        :sc   => `tput sc`,
+        :rc   => `tput rc`,
+        :cuu1 => `tput cuu1`,
+        :cuf1 => `tput cuf1`,
+      }
+    end
+  end
+end

data/lib/fancy_irb/version.rb

@@ -0,0 +1,3 @@
+module FancyIrb
+  VERSION = '0.8.0'.freeze
+end

data/lib/fancy_irb.rb

@@ -1,147 +1,66 @@
+require_relative 'fancy_irb/version'
+
 require 'stringio'
 require 'paint'
 
-module FancyIrb
-  VERSION = File.read( File.dirname(__FILE__) + '/../VERSION' ).chomp
-end
+require_relative 'fancy_irb/terminal_info'
+require_relative 'fancy_irb/size_detector'
+require_relative 'fancy_irb/error_capturer'
+require_relative 'fancy_irb/implementation'
 
-class << FancyIrb
-  # setup instance variable accessors
-  attr_accessor :options
-  def [](key, key2 = nil)
-    if key2
-      @options[key][key2]
+module FancyIrb
+  DEFAULT_RESULT_PROC = proc{ |context|
+    if context.inspect?
+      context.last_value.inspect
     else
-      @options[key]
-    end
-  end
-
-  attr_accessor :original_stdout
-  attr_accessor :capture_irb_errors
-  attr_accessor :real_lengths
-  attr_accessor :continue
-  attr_accessor :stdout_colorful
-  attr_accessor :skip_next_rocket
-
-  def start(user_options = {})
-    # track some irb stuff
-    @height_counter   = []
-    @real_lengths     = { :output => 1, :input_prompt => 9999 } # or whatever
-    @stdout_colorful  = false
-    @continue         = false
-    @skip_next_rocket = 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?(Wirb) && FancyIrb[:colorize, :output]
-        Wirb.colorize_result 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        => [:red, :bright],
-        :stdout        => nil,
-        :input         => nil,
-        :output        => true, # wirb'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
-      :east_asian_width => false, # set to true if you have double-width characters (slower)
-    }
-
-    @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'
-    true
-  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)
-    data       = Paint.unpaint(data.to_s)
-    lines      = data.count("\n")
-    long_lines = data.split("\n").inject(0){ |sum, line|
-      sum + (line.display_size / current_length)
-    }
-    @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( FancyIrb.stdout_colorful ? Paint[data, *Array(color)] : data.to_s )
-  end
-
-  def win?
-    RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-  end
-
-  if FancyIrb.win? 
-    raise LoadError, 'FancyIrb needs ansicon on windows, see https://github.com/adoxa/ansicon' unless ENV['ANSICON']
-    def current_length
-       ENV['ANSICON'][/\((.*)x/, 1].to_i
-    end
-
-    def current_lines
-       ENV['ANSICON'][/\(.*x(.*)\)/, 1].to_i
-    end
-  else
-    def current_length
-     `tput cols`.to_i
+      context.last_value
     end
+  }
 
-    def current_lines
-     `tput lines`.to_i
+  DEFAULT_COLORIZER_PROC = proc{ |value|
+    if defined?(Wirb)
+      Wirb.colorize_result value
+    else
+      value
     end
-  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
+    :result_proc     => DEFAULT_RESULT_PROC,       # how to get the output result from IRB
+    :output_procs    => [DEFAULT_COLORIZER_PROC],  # output formatter procs
+    :east_asian_width => false, # set to true if you have double-width characters (slower)
+    :colorize => {              # colors hash. Set to nil to deactivate colors
+      :rocket_prompt => [:blue],
+      :result_prompt => [:blue],
+      :input_prompt  => nil,
+      :irb_errors    => [:red, :clean],
+      :stderr        => [:red, :bright],
+      :stdout        => nil,
+      :input         => nil,
+     },
+  }
+
+  SKIP_ROCKET_METHODS = %w[
+    system
+    spawn
+  ].map(&:to_sym)
+
+  # TODO: each_byte, each_char, each_codepoint, each, etc
+  TRACK_HEIGHT_INPUT_METHODS = %w[
+    binread
+    read
+    gets
+    getc
+    getbyte
+    readbyte
+    readchar
+    readline
+    readlines
+    readpartial
+    sysread
+  ].map(&:to_sym)
 end
+

metadata

@@ -1,94 +1,87 @@
 --- !ruby/object:Gem::Specification
 name: fancy_irb
 version: !ruby/object:Gem::Version
-  version: 0.7.3
-  prerelease: 
+  version: 0.8.0
 platform: ruby
 authors:
 - Jan Lelis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-30 00:00:00.000000000 Z
+date: 2015-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: paint
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.1
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
   name: unicode-display_width
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.1
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.1
-description: ! 'FancyIrb patches your IRB to create a smooth output experience. You
-  can colorize the prompts, irb errors, stderr and stdout, output your result as #=>
-  (hash rockets) and some other improvements.'
+        version: 0.2.0
+description: 'FancyIrb makes IRB # => friendly.'
 email: mail@janlelis.de
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.rdoc
-- LICENSE
+extra_rdoc_files: []
 files:
-- LICENSE
+- CHANGELOG.rdoc
+- MIT-LICENSE.txt
 - README.rdoc
 - Rakefile
-- VERSION
-- CHANGELOG.rdoc
 - fancy_irb.gemspec
 - lib/fancy_irb.rb
+- lib/fancy_irb/clean_up.rb
+- lib/fancy_irb/core_ext.rb
+- lib/fancy_irb/error_capturer.rb
+- lib/fancy_irb/implementation.rb
 - lib/fancy_irb/irb_ext.rb
+- lib/fancy_irb/size_detector.rb
+- lib/fancy_irb/terminal_info.rb
+- lib/fancy_irb/version.rb
 homepage: http://github.com/janlelis/fancy_irb
 licenses:
 - MIT
-post_install_message: ! "       ┌── info ──────────────────────────────┐\n J-_-L │
-  http://github.com/janlelis/fancy_irb │\n       ├── usage ─────────────────────────────┤\n
-  \      │ require 'fancy_irb'                  │\n       │ FancyIrb.start                       │\n
-  \      └──────────────────────────────────────┘"
+metadata: {}
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 requirements:
-- ! 'On Windows, you need ansicon: https://github.com/adoxa/ansicon'
+- 'Windows: ansicon <https://github.com/adoxa/ansicon>'
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
-summary: FancyIrb patches your IRB to create a smooth output experience.
+specification_version: 4
+summary: FancyIrb makes IRB friendly.
 test_files: []
 has_rdoc: 

data/VERSION

@@ -1 +0,0 @@
-0.7.3