davidrichards-sirb 0.6.14

data/lib/sirb/lib_loader.rb

@@ -0,0 +1,45 @@
+class LibLoader
+  class << self
+    def libs
+      @libs ||= {}
+    end
+  
+    def add_lib(name, &block)
+      name = name.to_s
+      block ||= lambda{require name}
+      self.libs[name] = self.safe_require(&block)
+    end
+    
+    def all_libs
+      self.libs.keys.sort
+    end
+    
+    def libs_loaded
+      self.libs.map {|k, v| k if v }.compact
+    end
+    
+    def failed_libs
+      self.libs.map {|k, v| k unless v }.compact
+    end
+    
+    def safe_require(&block)
+      begin
+        block.call
+        # If the lib is already loaded, it may return false, but it's available.
+        # If there's a problem with this, you should require the lib in a block
+        # and raise an exception if it fails. 
+        true
+        # If the laod returns false, then 
+      rescue Exception => e # Very important
+        false
+      end
+    end
+    
+    def to_s
+      return nil if self.failed_libs.empty?
+      "Libs loaded:\n\t" + (self.libs_loaded.empty? ? "None" : self.libs_loaded.join(", ")) + 
+      "\nLibs NOT loaded:\n\t" + (self.failed_libs.empty? ? "None" : self.failed_libs.join(", "))
+    end
+  end
+  
+end

data/lib/sirb/runner.rb

@@ -0,0 +1,274 @@
+# So, this is interesting.  It's a class to store operations from blocks,
+# and run them. 
+
+# Persistent Store from Standard Library
+require 'pstore'
+
+module Sirb #:nodoc:
+  
+  class Runner
+    class << self
+      
+      # Storing everything in local .pstore for now.  Uses the home directory,when possible.
+      def pstore
+        File.mkdir_p(dirname)
+        @@pstore ||= PStore.new(filename)
+      end
+      protected :pstore
+      
+      def dirname
+        @@dirname ||= File.expand_path(File.join(ENV['HOME'], '.sirb'))
+      end
+      protected :dirname
+      
+      def filename
+        @@filename ||= File.join(dirname, "proc.pstore")
+      end
+      protected :filename
+      
+      # Needs a lambda, instead of a block, because we're serializing this and
+      # the code I use to serialize this needs to be able to find the string
+      # that created this code. 
+      def add_command(name, l, description=nil)
+        coerce name
+        pstore.transaction { pstore[@name] = new(name.to_s, l, description) }
+      end
+      
+      def remove_command(name)
+        coerce name
+        pstore.transaction { pstore.delete(@name) }
+      end
+      
+      # Very harsh, but necessary if you have an unknown issue with a stored block.
+      def reset_commands
+        puts "Are you sure you want to remove all commands?(yN)\nThis will delete the contents of #{filename}"
+        result = gets.strip
+        return false unless result == 'y'
+        `rm -rf #{filename}`
+        puts "Successfully reset all commands."
+      end
+      
+      def commands
+        pstore.transaction { pstore.roots }
+      end
+      
+      def commands_as_commands
+        commands.map {|cmd| find(cmd)}
+      end
+      protected :commands_as_commands
+    
+      def find(name)
+        return nil unless name
+        coerce name
+        begin
+          pstore.transaction { pstore[@name] }
+        rescue Exception => e
+          # Don't know a good way to look in the pstore for something that doesn't
+          # exist 
+          nil
+        end
+      end
+      
+      def methodize(name)
+        eval stringify_proc(name)
+      end
+      
+      def stringify_proc(name)
+        cmd = find(name)
+        cmd_name = cmd.name
+        matched = cmd.block_source.match(/^(\|.+\|)(.+)$/)
+        cmd_params = matched ? matched[1] : ''
+        cmd_body = matched ? matched[2] : nil
+        cmd_body ||= cmd.block_source
+        cmd_body.lstrip!
+        "def #{cmd_name}(#{cmd_params})\n#{cmd_body}"
+      end
+      
+      def run(name, *data)
+        coerce name
+        raise ArgumentError, "Unknown command: #{name}" unless self.find(@name)
+        self.find(@name).run(*data)
+      end
+      
+      def coerce(name)
+        @name = name.to_sym
+      end
+      protected :coerce
+      
+      def sirb_help(command=nil)
+        return puts(command_help(command)) if command
+        puts(sirb_description, all_commands_description, '')
+      end
+      
+      def sirb_description
+        
+        result = left_justify %{
+          This is Irb, with some extra libraries and commands loaded.
+          You have loaded the following libraries:
+        }
+        result += tab_indent( LibLoader.libs_loaded.join("\n") )
+        result += "\n\n"
+        
+        if not LibLoader.failed_libs.empty?
+          result += "The following libraries are not available on your system at this time:\n"
+          result += tab_indent( LibLoader.failed_libs.join("\n") )
+          result += "\n\n"
+        end
+                
+        result
+      end
+
+      def all_commands_description
+        result = ''
+        
+        if commands.empty?
+          result += "You have not stored any custom commands at this time.\n\n"
+        else
+          result += "You have setup the following commands:\n\n"
+          result += commands_as_commands.map{ |cmd| cmd.command_help }.join("\n")
+          result += "\n\n"
+        end
+        
+        result += "You can store a command like this:\n"
+        result += tab_indent(%{
+          set :command_name, lambda{|list params| command }, "Optional description"
+        })
+
+        result
+        
+      end
+      protected :all_commands_description
+      
+      def command_help(command)
+        cmd = find(command)
+        cmd ? cmd.command_help : "Could not find the command: #{command}"
+      end
+      protected :command_help
+      
+      # Probably need to setup some decorators here instead...
+      def tab_indent(str)
+        return "" unless str
+        str.strip.split("\n").map {|line| "\t#{line.strip}" }.join("\n")
+      end
+      
+      def left_justify(str)
+        return "" unless str
+        str.split("\n").map {|line| line.lstrip }.join("\n")
+      end
+      
+    end
+
+    attr_reader :name, :description
+    # Needs a lambda, instead of a block, because we're serializing this and
+    # the code I use to serialize this needs to be able to find the string
+    # that created this code. 
+    def initialize(name, l, description=nil)
+      @name, @block, @description = name, l, description
+    end
+  
+    # Kind of loose: allows me to use reduce, map, or just call a stored
+    # command.  This may just seem to work, but we'll see. 
+    def run(*data)
+      case @block.arity 
+      when 2
+        # Same as reduce
+        data.inject &@block
+      when 1
+        # Same as map
+        data.map &@block
+      when -1
+        # Same as call
+        @block.call
+      else
+        # Probably not going to work.
+        data.inject &@block
+      end
+    end
+    
+    def command_help
+      result = (self.description and not self.description.empty?) ? formatted_description : empty_description
+      result  + source_description
+    end
+    
+    def arity_desc
+      case @block.arity
+      when -1
+        "takes 0 arguments"
+      when 1
+        "takes 1 argument, returns an array"
+      when 2
+        "takes 2 arguments, returns a single value--reduce function"
+      else
+        "takes #{@block.arity} arguments"
+      end
+    end
+    protected :arity_desc
+
+    def block_source
+      @block.source
+    end
+    
+    def name_line
+      "* #{self.name} (#{arity_desc})\n"
+    end
+    protected :name_line
+    
+    def source_description
+      "\n\tSource: #{block_source}"
+    end
+    
+    def empty_description
+      "#{name_line}\tThere is no other information available for the #{self.name.to_s} command."
+    end
+    protected :empty_description
+    
+    def formatted_description
+      name_line + 
+      Runner.tab_indent(self.description)
+    end
+    protected :formatted_description
+    
+  end  
+  
+  # These should be available in the console generally
+  module CommandLineMethods
+    
+    def store_command(name, l, description=nil)
+      cmd = Runner.add_command(name, l, description)
+      cmd.name.to_s + " added"
+    end
+    alias set store_command
+    
+    
+    # May want to move this to delegate (standard library)
+    # http://www.ruby-doc.org/stdlib/libdoc/delegate/rdoc/index.html
+    def method_missing(sym, *args, &block)
+      # base, extension = breakdown_method(sym)
+      # if Runner.find(base) and extension == 'methodize'
+      #   Runner.methodize(base)
+      # elsif Runner.find(base) and extension == 'to_s'
+      #   require 'rubygems'
+      #   require 'ruby-debug'
+      #   debugger
+      #   Runner.stringify_proc(base)
+      if Runner.find(sym)
+        Runner.run(sym, *args)
+      # elsif Runner.respond_to?(sym)
+      elsif Runner.respond_to?(sym)
+        Runner.send(sym, *args, &block)
+      else
+        super
+      end
+    end
+    
+    # Doesn't work.
+    def breakdown_method(sym)
+      s = sym.to_s
+      r = /^(.+)\.(.+)$/
+      md = s.match r
+      md ? [md[1].to_sym, md[2]] : [nil,nil]
+    end
+    protected :breakdown_method
+  end
+  
+end 

data/lib/sirb/sproc/proc.rb

@@ -0,0 +1,5 @@
+class Proc
+  def to_sproc
+    Sproc.new(&self)
+  end
+end

data/lib/sirb/sproc/proc_source.rb

@@ -0,0 +1,130 @@
+require 'stringio'
+require 'irb/ruby-lex'
+
+# Tell the ruby interpreter to load code lines of required files
+# into this filename -> lines Hash. This behaviour seems to be
+# very undocumented and therefore shouldn't really be relied on.
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+module ProcSource
+  def get_lines(filename, start_line = 0)
+    case filename
+      # special "(irb)" descriptor?
+      when "(irb)"
+        IRB.conf[:MAIN_CONTEXT].io.line(start_line .. -1)
+      # special "(eval...)" descriptor?
+      when /^\(eval.+\)$/
+        EVAL_LINES__[filename][start_line .. -1]
+      # regular file
+      else
+        # Ruby already parsed this file? (see disclaimer above)
+        if lines = SCRIPT_LINES__[filename]
+          lines[(start_line - 1) .. -1]
+        # If the file exists we're going to try reading it in
+        elsif File.exist?(filename)
+          begin
+            File.readlines(filename)[(start_line - 1) .. -1]
+          rescue
+            nil
+          end
+        end
+    end
+  end
+
+  def handle(proc)
+    filename, line = proc.source_descriptor
+    lines = get_lines(filename, line) || []
+
+    lexer = RubyLex.new
+    lexer.set_input(StringIO.new(lines.join))
+
+    state = :before_constructor
+    nesting_level = 1
+    start_token, end_token = nil, nil
+    found = false
+    while token = lexer.token
+      # we've not yet found any proc-constructor -- we'll try to find one.
+      if [:before_constructor, :check_more].include?(state)
+        # checking more and newline? -> done
+        if token.is_a?(RubyToken::TkNL) and state == :check_more
+          state = :done
+          break
+        end
+        # token is Proc?
+        if token.is_a?(RubyToken::TkCONSTANT) and
+           token.instance_variable_get(:@name) == "Proc"
+          # method call?
+          if lexer.token.is_a?(RubyToken::TkDOT)
+            method = lexer.token
+            # constructor?
+            if method.is_a?(RubyToken::TkIDENTIFIER) and
+               method.instance_variable_get(:@name) == "new"
+              unless state == :check_more
+                # okay, code will follow soon.
+                state = :before_code
+              else
+                # multiple procs on one line
+                return
+              end
+            end
+          end
+        # token is lambda or proc call?
+        elsif token.is_a?(RubyToken::TkIDENTIFIER) and
+              %w{proc lambda}.include?(token.instance_variable_get(:@name))
+          unless state == :check_more
+            # okay, code will follow soon.
+            state = :before_code
+          else
+            # multiple procs on one line
+            return
+          end
+        end
+
+      # we're waiting for the code start to appear.
+      elsif state == :before_code
+        if token.is_a?(RubyToken::TkfLBRACE) or token.is_a?(RubyToken::TkDO)
+          # found the code start, update state and remember current token
+          state = :in_code
+          start_token = token
+        end
+
+      # okay, we're inside code
+      elsif state == :in_code
+        if token.is_a?(RubyToken::TkRBRACE) or token.is_a?(RubyToken::TkEND)
+          nesting_level -= 1
+          if nesting_level == 0
+            # we're done!
+            end_token = token
+            # parse another time to check if there are multiple procs on one line
+            # we can't handle that case correctly so we return no source code at all
+            state = :check_more
+          end
+        elsif token.is_a?(RubyToken::TkfLBRACE) or token.is_a?(RubyToken::TkDO) or
+              token.is_a?(RubyToken::TkBEGIN) or token.is_a?(RubyToken::TkCASE) or
+              token.is_a?(RubyToken::TkCLASS) or token.is_a?(RubyToken::TkDEF) or
+              token.is_a?(RubyToken::TkFOR) or token.is_a?(RubyToken::TkIF) or
+              token.is_a?(RubyToken::TkMODULE) or token.is_a?(RubyToken::TkUNLESS) or
+              token.is_a?(RubyToken::TkUNTIL) or token.is_a?(RubyToken::TkWHILE) or
+              token.is_a?(RubyToken::TklBEGIN)
+          nesting_level += 1
+        end
+      end
+    end
+
+    if start_token and end_token
+      start_line, end_line = start_token.line_no - 1, end_token.line_no - 1 
+      source = lines[start_line .. end_line]
+      start_offset = start_token.char_no
+      start_offset += 1 if start_token.is_a?(RubyToken::TkDO)
+      end_offset = -(source.last.length - end_token.char_no)
+      source.first.slice!(0 .. start_offset)
+      source.last.slice!(end_offset .. -1)
+
+      # Can't use .strip because newline at end of code might be important
+      # (Stuff would break when somebody does proc { ... #foo\n})
+      proc.source = source.join.gsub(/^ | $/, "")
+    end
+  end
+
+  module_function :handle, :get_lines
+end

data/lib/sirb/sproc/sproc.rb

@@ -0,0 +1,79 @@
+class Sproc < Proc
+
+  class << self
+    # An alternate constructor for the class, to allow string input.
+    def build(arg=nil, &block)
+      block_given? ? infer_sproc(block) : infer_sproc(arg)
+    end
+  
+    def infer_sproc(arg)
+      case arg
+      when Proc
+        Proc.new(&arg)
+      when String
+        Sproc.from_string(arg)
+      else
+        raise ArgumentError, "Don't know how to create a sproc from #{arg.inspect}"
+      end
+    end
+    protected :infer_sproc
+  end
+  
+  def source_descriptor
+    if md = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+)>$/.match(old_inspect)
+      filename, line = md.captures
+      return filename, line.to_i
+    end
+  end
+
+  attr_accessor :source
+  def source
+    ProcSource.handle(self) unless @source
+    @source
+  end
+
+  alias :old_inspect :inspect
+  def inspect
+    if source
+      "sproc {#{source}}"
+    else
+      old_inspect
+    end
+  end
+
+  def ==(other)
+    if self.source and other.source
+      self.source == other.source
+    else
+      self.object_id == other.object_id
+    end
+  end
+
+  def _dump(depth = 0)
+    if source
+      source
+    else
+      raise(TypeError, "Can't serialize Proc with unknown source code.")
+    end
+  end
+
+  def to_yaml(*args)
+    self.source # force @source to be set
+    super.sub("object:Proc", "sproc")
+  end
+
+  def self.allocate; from_string ""; end
+
+  def self.from_string(string)
+    result = eval("Sproc.new {#{string}}")
+    result.source = string
+    return result
+  end
+
+  def self._load(code)
+    self.from_string(code)
+  end
+
+  def self.marshal_load; end
+  def marshal_load; end
+end

data/lib/sirb/sproc/usage_notes.txt

@@ -0,0 +1,25 @@
+if __FILE__ == $0 then
+  require "pstore"
+
+  code = lambda { puts "Hello World!" }
+
+  File.open("proc.marshalled", "w") { |file| Marshal.dump(code, file) }
+  code = File.open("proc.marshalled") { |file| Marshal.load(file) }
+
+  code.call
+
+  store = PStore.new("proc.pstore")
+  store.transaction do
+    store["proc"] = code
+  end
+  store.transaction do
+    code = store["proc"]
+  end
+
+  code.call
+
+  File.open("proc.yaml", "w") { |file| YAML.dump(code, file) }
+  code = File.open("proc.yaml") { |file| YAML.load(file) }
+
+  code.call
+end

data/lib/sirb/sproc.rb

@@ -0,0 +1,29 @@
+# This is an adaptation from Florian Groß's submission to Ruby Quiz #38.
+# http://rubyquiz.com/quiz38.html
+# 
+# I needed a serializable Proc, I don't care about the closure of
+# the proc.  I just need to be able to store procs between Sirb sessions.  
+# I'm using these procs with explicitly-passed context anyway, so they
+# are meant to be portable functions. 
+
+# Loads everything in Sproc, want to break this up, make it more useful
+# and understandable. 
+Dir.glob("#{File.dirname(__FILE__)}/sproc/*.rb").each { |file| require file }
+
+require 'yaml'
+YAML.add_ruby_type(/^proc/) do |type, val|
+  Proc.from_string(val["source"])
+end
+
+EVAL_LINES__ = Hash.new
+
+alias :old_eval :eval
+def eval(code, *args)
+  context, descriptor, start_line, *more = *args
+  descriptor ||= "(eval#{code.hash})"
+  start_line ||= 0
+  lines ||= code.grep(/.*/)
+  EVAL_LINES__[descriptor] ||= Array.new
+  EVAL_LINES__[descriptor][start_line, lines.length] = lines
+  old_eval(code, context, descriptor, start_line, *more)
+end

data/lib/sirb/thread_support.rb

@@ -0,0 +1,20 @@
+module Sirb #:nodoc:
+  
+  # This adds some concurrency and distributed processing to your programs.
+  # It follows loosely the interface offered by Erlang though the implementation
+  # is different:
+  # * spawn
+  # * send
+  # * receive
+  # * link
+  # * system_process
+  # * spawn_link
+  # * disconnect_node
+  # * monitor_node
+  # * node
+  # * nodes
+  # * is_alive
+  module ThreadSupport
+    
+  end
+end

data/lib/sirb/unbound_method.rb

@@ -0,0 +1,5 @@
+# Also from The Ruby Programming Language.
+class UnboundMethod
+  # Allow [] as an alternative to bind.  
+  alias [] bind
+end

data/lib/sirb.rb

@@ -0,0 +1,52 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
+
+module Sirb
+end
+
+require 'sirb/lib_loader'
+
+Dir.glob("#{File.dirname(__FILE__)}/overrides/*.rb").each { |file| require file }
+
+require 'rubygems'
+LibLoader.add_lib('rubygems')
+LibLoader.add_lib('mathn')
+LibLoader.add_lib('bigdecimal') {
+  require 'bigdecimal'
+  require 'bigdecimal/math'
+}
+LibLoader.add_lib('set')
+LibLoader.add_lib('matrix')
+LibLoader.add_lib('narray')
+LibLoader.add_lib('rnum')
+LibLoader.add_lib('rgl') { 
+  require 'rgl/dot'
+  require 'rgl/adjacency'
+  require 'rgl/traversal'
+  require 'rgl/topsort'
+}
+LibLoader.add_lib('tenacious_g')
+LibLoader.add_lib('rbtree')
+LibLoader.add_lib('statisticus')
+
+
+LibLoader.add_lib('general statistics') {
+  require 'sirb/general_statistics'
+  include Sirb::GeneralStatistics
+}
+
+LibLoader.add_lib('enumerable statistics') {
+  require 'sirb/enumerable_statistics'
+  class Array
+    include Sirb::EnumerableStatistics
+  end
+  # TODO: Add other enumerables, adapt for Matrices, Vectors, graphs, the whole thing.
+
+  require 'sirb/inter_enumerable_statistics'
+  include Sirb::InterEnumerableStatistics
+  
+  require 'sirb/functional'
+  require 'sirb/unbound_method'
+  
+}
+
+puts LibLoader.to_s if LibLoader.to_s

data/lib/stored_procedures.rb

@@ -0,0 +1,10 @@
+# Called after sirb.rb, when we want to have stored procedures.  Sproc/
+# Proc is pretty draconian, so I want to pull this out for now until
+# more tests have been done. Probably we'll never want the command runner
+# if Sirb is being used as a library, instead of as a real Irb instance.
+
+LibLoader.add_lib('command runner') {
+  require 'sirb/sproc'
+  require 'sirb/runner'
+  include Sirb::CommandLineMethods
+}

data/spec/lib/overrides/array_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), "/../../spec_helper")
+
+describe Array do
+  it "should allow multiple paramaters for include?" do
+    [1,2,3].include?(1,2).should eql(true)
+  end
+end