rink 1.0.0

data/lib/rink/delegation.rb

@@ -0,0 +1,139 @@
+module Rink
+  # Blatantly ripped from ActiveSupport and pasted here to avoid the extra dependency.
+  # Only applied to objects internal to Rink.
+  module Delegation
+    # Provides a delegate class method to easily expose contained objects' methods
+    # as your own. Pass one or more methods (specified as symbols or strings)
+    # and the name of the target object as the final <tt>:to</tt> option (also a symbol
+    # or string).  At least one method and the <tt>:to</tt> option are required.
+    #
+    # Delegation is particularly useful with Active Record associations:
+    #
+    #   class Greeter < ActiveRecord::Base
+    #     def hello()   "hello"   end
+    #     def goodbye() "goodbye" end
+    #   end
+    #
+    #   class Foo < ActiveRecord::Base
+    #     belongs_to :greeter
+    #     delegate :hello, :to => :greeter
+    #   end
+    #
+    #   Foo.new.hello   # => "hello"
+    #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+    #
+    # Multiple delegates to the same target are allowed:
+    #
+    #   class Foo < ActiveRecord::Base
+    #     belongs_to :greeter
+    #     delegate :hello, :goodbye, :to => :greeter
+    #   end
+    #
+    #   Foo.new.goodbye # => "goodbye"
+    #
+    # Methods can be delegated to instance variables, class variables, or constants
+    # by providing them as a symbols:
+    #
+    #   class Foo
+    #     CONSTANT_ARRAY = [0,1,2,3]
+    #     @@class_array  = [4,5,6,7]
+    #     
+    #     def initialize
+    #       @instance_array = [8,9,10,11]
+    #     end
+    #     delegate :sum, :to => :CONSTANT_ARRAY
+    #     delegate :min, :to => :@@class_array
+    #     delegate :max, :to => :@instance_array
+    #   end
+    #
+    #   Foo.new.sum # => 6
+    #   Foo.new.min # => 4
+    #   Foo.new.max # => 11
+    #
+    # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+    # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+    # delegated to.
+    #
+    #   Person = Struct.new(:name, :address)
+    #
+    #   class Invoice < Struct.new(:client)
+    #     delegate :name, :address, :to => :client, :prefix => true
+    #   end
+    #
+    #   john_doe = Person.new("John Doe", "Vimmersvej 13")
+    #   invoice = Invoice.new(john_doe)
+    #   invoice.client_name    # => "John Doe"
+    #   invoice.client_address # => "Vimmersvej 13"
+    #
+    # It is also possible to supply a custom prefix.
+    #
+    #   class Invoice < Struct.new(:client)
+    #     delegate :name, :address, :to => :client, :prefix => :customer
+    #   end
+    #
+    #   invoice = Invoice.new(john_doe)
+    #   invoice.customer_name    # => "John Doe"
+    #   invoice.customer_address # => "Vimmersvej 13"
+    #
+    # If the object to which you delegate can be nil, you may want to use the
+    # :allow_nil option. In that case, it returns nil instead of raising a
+    # NoMethodError exception:
+    #
+    #  class Foo
+    #    attr_accessor :bar
+    #    def initialize(bar = nil)
+    #      @bar = bar
+    #    end
+    #    delegate :zoo, :to => :bar
+    #  end
+    #
+    #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+    #
+    #  class Foo
+    #    attr_accessor :bar
+    #    def initialize(bar = nil)
+    #      @bar = bar
+    #    end
+    #    delegate :zoo, :to => :bar, :allow_nil => true
+    #  end
+    #
+    #  Foo.new.zoo   # returns nil
+    #
+    def delegate(*methods)
+      options = methods.pop
+      unless options.is_a?(Hash) && to = options[:to]
+        raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+      end
+
+      if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+        raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+      end
+
+      prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
+
+      file, line = caller.first.split(':', 2)
+      line = line.to_i
+
+      methods.each do |method|
+        on_nil =
+          if options[:allow_nil]
+            'return'
+          else
+            %(raise "#{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+          end
+
+        module_eval(<<-EOS, file, line)
+          def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
+            #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
+          rescue NoMethodError                                # rescue NoMethodError
+            if #{to}.nil?                                     #   if client.nil?
+              #{on_nil}
+            else                                              #   else
+              raise                                           #     raise
+            end                                               #   end
+          end                                                 # end
+        EOS
+      end
+    end
+  end
+end

data/lib/rink/input_method/base.rb

@@ -0,0 +1,41 @@
+module Rink
+  module InputMethod
+    class Base
+      STDIN_FILE_NAME = "(line)"
+  
+      def initialize(prompt = " > ", file = STDIN_FILE_NAME)
+        @prompt = prompt
+        @output = nil
+        @filename = file
+      end
+  
+      attr_reader :filename
+      attr_accessor :prompt
+      attr_accessor :output
+      
+      def input
+        raise NotImplementedError, "input"
+      end
+      
+      def print(*args)
+        @output.print(*args) if @output
+      end
+      
+      def puts(*args)
+        @output.puts(*args) if @output
+      end
+      
+      def write(*args)
+        @output.write(*args) if @output
+      end
+  
+      def gets
+        raise NotImplementedError, "gets"
+      end
+  
+      def readable_after_eof?
+        false
+      end
+    end
+  end
+end

data/lib/rink/input_method/file.rb

@@ -0,0 +1,24 @@
+module Rink
+  module InputMethod
+    class File < Rink::InputMethod::Base
+      def initialize(file)
+        super
+        @io = file
+        @line_num = 0
+        @lines = []
+      end
+
+      def eof?
+        @io.eof?
+      end
+
+      def gets
+        print @prompt
+        line = @lines[@line_num += 1] = @io.gets
+        line += "\n" unless !line || line =~ /\n/
+        print(line)
+        line
+      end
+    end
+  end
+end

data/lib/rink/input_method/io.rb

@@ -0,0 +1,34 @@
+module Rink
+  module InputMethod
+    class IO < Rink::InputMethod::Base
+      attr_accessor :input
+      
+      def initialize(input = $stdin)
+        super()
+        @input = input
+        @line_num = 0
+        @lines = []
+      end
+      
+      def gets
+        print @prompt
+        line = @lines[@line_num += 1] = input.gets
+        line += "\n" unless !line || line =~ /\n/
+        print line if line
+        line
+      end
+      
+      def eof?
+        input.eof?
+      end
+      
+      def readable_after_eof?
+        true
+      end
+      
+      def [](line_number)
+        @lines[line_number]
+      end
+    end
+  end
+end

data/lib/rink/input_method/readline.rb

@@ -0,0 +1,49 @@
+begin
+  require 'readline'
+  
+  module Rink
+    module InputMethod
+      class Readline < Rink::InputMethod::Base
+        attr_accessor :completion_append_character, :completion_proc, :prompt
+        
+        def initialize(completion_proc = proc { |line| [] })
+          super()
+          
+          @completion_append_character = nil
+          @completion_proc = completion_proc
+          @line_num = 0
+          @lines = []
+          @eof = false
+        end
+        
+        def gets
+          # in case they were changed. Do we need this here?
+          ::Readline.completion_append_character = completion_append_character 
+          ::Readline.completion_proc = completion_proc
+          
+          if line = ::Readline.readline(@prompt, false)
+            ::Readline::HISTORY.push(line) if !line.empty?
+            @lines[@line_num += 1] = line + "\n"
+          else
+            @eof = true
+            line
+          end
+        end
+        
+        def eof?
+          @eof
+        end
+        
+        def readable_after_eof?
+          true
+        end
+        
+        def [](line_num)
+          @line[num]
+        end
+      end
+    end
+  end
+rescue LoadError
+  # Fail silently. Rink will fall back to an IO input type with STDIN.
+end

data/lib/rink/io_methods.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "input_method/base"))
+require File.expand_path(File.join(File.dirname(__FILE__), "input_method/readline"))
+require File.expand_path(File.join(File.dirname(__FILE__), "input_method/io"))
+require File.expand_path(File.join(File.dirname(__FILE__), "input_method/file"))
+require File.expand_path(File.join(File.dirname(__FILE__), "output_method/base"))
+require File.expand_path(File.join(File.dirname(__FILE__), "output_method/io"))
+require 'stringio'
+
+module Rink
+  module IOMethods
+    def setup_input_method(input)
+      @input = case input
+        when Rink::InputMethod::Base
+          input
+        when STDIN
+          defined?(Rink::InputMethod::Readline) ? Rink::InputMethod::Readline.new : Rink::InputMethod::IO.new
+        when File
+          Rink::InputMethod::File.new(input)
+        when String
+          Rink::InputMethod::IO.new(StringIO.new(input))
+        when ::IO, StringIO
+          Rink::InputMethod::IO.new(input)
+        #when nil
+        #  nil
+        else raise ArgumentError, "Unexpected input type: #{input.class}"
+      end
+    end
+    
+    def setup_output_method(output)
+      @output = case output
+        when Rink::OutputMethod::Base
+          output
+        when STDOUT, STDERR, ::IO, StringIO then
+          Rink::OutputMethod::IO.new(output)
+        when String
+          Rink::OutputMethod::IO.new(StringIO.new(output))
+        when nil then
+          nil
+        else
+          raise ArgumentError, "Unexpected ouptut type: #{output.class}"
+      end
+    end
+  end
+end

data/lib/rink/lexer.rb

@@ -0,0 +1,58 @@
+require 'irb/ruby-lex'
+
+module Rink
+  class Lexer < ::RubyLex
+    extend Rink::Delegation
+    attr_accessor :output
+    delegate :print, :puts, :write, :p, :to => :output
+    
+    def initialize(output = nil)
+      @output = output
+      super()
+    end
+    
+    # RubyLex prompts unconditionally once the prompt is first set (not very reset-friendly), so we need to fix that.
+    def set_prompt(p = nil, &block)
+      if p.nil? && !block_given?
+        @prompt = nil # this will go back to NOT prompting
+      else
+        super
+      end
+    end
+    # overriding this method because we don't want to prompt
+#      def each_top_level_statement
+#    initialize_input
+#    catch(:TERM_INPUT) do
+#      loop do
+#	begin
+#	  @continue = false
+#	  prompt
+#	  unless l = lex
+#	    throw :TERM_INPUT if @line == ''
+#	  else
+#	    #p l
+#	    @line.concat l
+#	    if @ltype or @continue or @indent > 0
+#	      next
+#	    end
+#	  end
+#	  if @line != "\n"
+#	    yield @line, @exp_line_no
+#	  end
+#	  break unless l
+#	  @line = ''
+#	  @exp_line_no = @line_no
+#
+#	  @indent = 0
+#	  @indent_stack = []
+#	  prompt
+#	rescue TerminateLineInput
+#	  initialize_input
+#	  prompt
+#	  get_readed
+#	end
+#      end
+#    end
+#  end
+  end
+end

data/lib/rink/line_processor/base.rb

@@ -0,0 +1,23 @@
+module Rink
+  module LineProcessor
+    # The Line Processor takes partial lines and performs operations on them. This is usually triggered by some special
+    # character or combination of characters, such as TAB, ARROW UP, ARROW DOWN, and so forth.
+    #
+    class Base
+      attr_reader :source
+      
+      def initialize(source = nil)
+        @source = source
+      end
+      
+      # Autocomplete is usually triggered by a TAB character and generally involves looking at the beginning of a line
+      # and finding the command the user is most likely trying to type. This saves typing for the user and creates a more
+      # intuitive interface.
+      #
+      # This method returns either a single String or an array of Strings.
+      def autocomplete(line, namespace)
+        raise NotImplementedError, "autocomplete"
+      end
+    end
+  end
+end

data/lib/rink/line_processor/pure_ruby.rb

@@ -0,0 +1,180 @@
+module Rink
+  module LineProcessor
+    # Performs autocompletion based on method names of objects used. This algorithm is identical to that of IRB.
+    class PureRuby < Rink::LineProcessor::Base
+      OPERATORS = ["%", "&", "*", "**", "+",  "-",  "/", "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>",
+                   "[]", "[]=", "^"
+      ] unless defined?(OPERATORS)
+      
+      RESERVED_WORDS = [ "BEGIN", "END", "alias", "and", "begin", "break", "case", "class", "def", "defined", "do",
+                         "else", "elsif", "end", "ensure", "false", "for", "if", "in", "module", "next", "nil", "not",
+                         "or", "redo", "rescue", "retry", "return", "self", "super", "then", "true", "undef", "unless",
+                         "until", "when", "while", "yield"
+      ] unless defined?(RESERVED_WORDS)
+      
+      def autocomplete_for_regexp(receiver, message)
+        candidates = Regexp.instance_methods(true)
+        select_message(receiver, message, candidates)
+      end
+      
+      def autocomplete_for_array(receiver, message)
+        candidates = Array.instance_methods(true)
+        select_message(receiver, message, candidates)
+      end
+      
+      def autocomplete_for_proc_or_hash(receiver, message)
+        candidates = Proc.instance_methods(true) | Hash.instance_methods(true)
+        select_message(receiver, message, candidates)
+      end
+      
+      def autocomplete_for_symbol(sym)
+        if Symbol.respond_to?(:all_symbols)
+          candidates = Symbol.all_symbols.collect{|s| ":" + s.id2name}
+          candidates.grep(/^#{sym}/)
+        else
+          []
+        end
+      end
+      
+      def autocomplete_for_absolute_constant_or_class_methods(receiver)
+        candidates = Object.constants
+        candidates.grep(/^#{receiver}/).collect{|e| "::" + e}
+      end
+      
+      def autocomplete_for_constant_or_class_methods(receiver, message)
+        begin
+          candidates = eval("#{receiver}.constants | #{receiver}.methods", bind)
+        rescue Exception
+          candidates = []
+        end
+        candidates.grep(/^#{message}/).collect{|e| receiver + "::" + e}
+      end
+      
+      def autocomplete_for_symbol_method(receiver, message)
+        candidates = Symbol.instance_methods(true)
+        select_message(receiver, message, candidates)
+      end
+      
+      def autocomplete_for_numeric(receiver, message)
+        begin
+          candidates = eval(receiver, bind).methods
+        rescue Exception
+          candidates = []
+        end
+        select_message(receiver, message, candidates)
+      end
+      
+      def autocomplete_for_hex_numeric(receiver, message)
+        begin
+          candidates = eval(receiver, bind).methods
+        rescue Exception
+          candidates = []
+        end
+        select_message(receiver, message, candidates)
+      end
+      
+      def autocomplete_for_global_variable(obj)
+        global_variables.grep(Regexp.new(obj))
+      end
+      
+      def autocomplete_for_variable(receiver, message)
+        gv = eval("global_variables", bind)
+        lv = eval("local_variables", bind)
+        cv = eval("self.class.constants", bind)
+        
+        if (gv | lv | cv).include?(receiver)
+          # foo.func and foo is local var.
+          candidates = eval("#{receiver}.methods", bind)
+        elsif /^[A-Z]/ =~ receiver and /\./ !~ receiver
+          # Foo::Bar.func
+          begin
+            candidates = eval("#{receiver}.methods", bind)
+          rescue Exception
+            candidates = []
+          end
+        else
+          # func1.func2
+          candidates = []
+          ObjectSpace.each_object(Module){|m|
+            begin
+              name = m.name
+            rescue Exception
+              name = ""
+            end
+            next if name != "IRB::Context" and 
+              /^(IRB|SLex|RubyLex|RubyToken)/ =~ name
+            candidates.concat m.instance_methods(false)
+          }
+          candidates.sort!
+          candidates.uniq!
+        end
+        select_message(receiver, message, candidates)
+      end
+      
+      def autocomplete_for_string(message)
+        receiver = ""
+        candidates = String.instance_methods(true)
+        select_message(receiver, message, candidates)
+      end
+      
+      def autocomplete(line, namespace)
+        # Borrowed from irb/completion.rb
+        case line
+          when /^(\/[^\/]*\/)\.([^.]*)$/
+            autocomplete_for_regexp($1, Regexp.quote($2))
+            
+          when /^([^\]]*\])\.([^.]*)$/
+            autocomplete_for_array($1, Regexp.quote($2))
+
+          when /^([^\}]*\})\.([^.]*)$/
+            autocomplete_for_proc_or_hash($1, Regexp.quote($2))
+	
+          when /^(:[^:.]*)$/
+            autocomplete_for_symbol($1)
+
+          when /^::([A-Z][^:\.\(]*)$/
+            autocomplete_for_absolute_constant_or_class_methods($1)
+
+          when /^(((::)?[A-Z][^:.\(]*)+)::?([^:.]*)$/
+            autocomplete_for_constant_or_class_methods($1, Regexp.quote($4))
+
+          when /^(:[^:.]+)\.([^.]*)$/
+            autocomplete_for_symbol_method($1, Regexp.quote($2))
+
+          when /^(-?(0[dbo])?[0-9_]+(\.[0-9_]+)?([eE]-?[0-9]+)?)\.([^.]*)$/
+            autocomplete_for_numeric($1, Regexp.quote($5))
+
+          when /^(-?0x[0-9a-fA-F_]+)\.([^.]*)$/
+            autocomplete_for_hex_numeric($1, Regexp.quote($2))
+          
+          when /^(\$[^.]*)$/
+            autocomplete_for_global_variable(Regexp.quote($1))
+            
+    #      when /^(\$?(\.?[^.]+)+)\.([^.]*)$/
+          when /^((\.?[^.]+)+)\.([^.]*)$/
+            autocomplete_for_variable($1, Regexp.quote($3))
+
+          when /^\.([^.]*)$/
+            # unknown(maybe String)
+            autocomplete_for_string(Regexp.quote($1))
+          else
+            candidates = eval("methods | private_methods | local_variables | self.class.constants", namespace.send(:binding))
+            (candidates|RESERVED_WORDS).grep(/^#{Regexp.quote(line)}/)
+        end
+      end
+      
+      private
+      def select_message(receiver, message, candidates)
+        candidates.grep(/^#{message}/).collect do |e|
+          case e
+            when /^[a-zA-Z_]/
+              receiver + "." + e
+            when /^[0-9]/
+            when *OPERATORS
+              #receiver + " " + e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rink/output_method/base.rb

@@ -0,0 +1,31 @@
+module Rink
+  module OutputMethod
+    class Base
+      attr_writer :silenced
+      
+      def output
+        raise NotImplementedError, "output"
+      end
+      
+      def initialize(silenced = false)
+        @silenced = silenced
+      end
+      
+      def write(*args)
+        print(*args)
+      end
+      
+      def puts(*args)
+        print args.join("\n"), "\n"
+      end
+      
+      def print(*args)
+        raise NotImplementedError, "print" unless silenced?
+      end
+      
+      def silenced?
+        @silenced
+      end
+    end
+  end
+end

data/lib/rink/output_method/io.rb

@@ -0,0 +1,22 @@
+module Rink
+  module OutputMethod
+    class IO < Rink::OutputMethod::Base
+      attr_accessor :io
+      
+      def initialize(io)
+        super()
+        @io = io
+      end
+      
+      def output
+        @io
+      end
+      
+      def print(*args)
+        return if silenced?
+        args = args.flatten.join
+        @io.print(*args)
+      end
+    end
+  end
+end

data/lib/rink.rb

@@ -0,0 +1,12 @@
+#require 'sc-ansi'
+
+require File.expand_path(File.join(File.dirname(__FILE__), "rink/delegation"))
+require File.expand_path(File.join(File.dirname(__FILE__), "rink/lexer"))
+require File.expand_path(File.join(File.dirname(__FILE__), 'rink/io_methods'))
+require File.expand_path(File.join(File.dirname(__FILE__), "rink/line_processor/base"))
+require File.expand_path(File.join(File.dirname(__FILE__), "rink/line_processor/pure_ruby"))
+require File.expand_path(File.join(File.dirname(__FILE__), "rink/console"))
+
+module Rink
+
+end