rish 0.1

data/bin/rish

@@ -0,0 +1,79 @@
+#!/usr/bin/env/ruby
+# -*- ruby -*-
+
+# Copyright (c) 2010 by Mikio L. Braun
+# rish is distributed under a BSD-style license. See COPYING
+
+require 'rish/shell'
+require 'rish/autoreload'
+
+def banner
+  puts <<EOS
+    
+                    rish - Ruby Interactive Shell
+
+               an autoreloading interactive shell with
+             interactive help, shell-outs and profiling.
+
+                      written by Mikio L. Braun
+
+         Type 'exit' or hit Ctrl-D on an empty line to exit.
+              Type '@h' to get help on built-in commands
+
+EOS
+end
+
+def usage
+  puts <<EOS
+Usage: rish [options] files_to_require.rb ...
+
+Options:
+  -a dir     : load all *.rb files in dir/ on startup
+  -w dir     : watch all *.rb files in dir/ for changes
+  -I dir     : add dir/ to load-path
+  --irb      : use IRB as shell (default)
+  --rish     : user rish's own shell
+  -h, --help : show help (this)
+EOS
+end
+
+# 
+# Main
+#
+
+banner
+
+type = :irb
+
+until ARGV.empty?
+  cmd = ARGV.shift
+  case cmd
+  when '-I'
+    dir = ARGV.shift
+    $: << dir
+  when '-a'
+    dir = ARGV.shift
+    puts "Loading all ruby files in #{dir}/"
+    Dir.glob("#{dir}/**/*.rb").each {|fn| require fn}
+  when '-w'
+    dir = ARGV.shift
+    Rish::Autoreload.watch_directory dir
+  when '-h', '--help'
+    usage
+    exit
+  when '-e'
+    cmd = ARGV.shift
+    puts eval(cmd)
+    exit
+  when '--irb'
+    type = :irb
+  when '--rish'
+    type = :rish
+  else
+    require cmd
+  end
+end
+
+Rish::Autoreload.check_directories
+
+shell = Rish.shell(type)

data/lib/rish/autoreload.rb

@@ -0,0 +1,123 @@
+# Copyright (c) 2010 by Mikio L. Braun
+# rish is distributed under a BSD-style license. See COPYING
+
+require 'pp'
+require 'set'
+
+module Rish
+  # This module tracks loaded files and their timestamps and allows to reload
+  # files which have changed automatically by calling reload.
+  #
+  # There is nothing magically happening here. Basically, you can
+  # reload a file by removing it from $" (the list of all loaded
+  # files) and require'ing it again.
+  module Autoreload
+
+    # stores the normalized filenames and their File.mtime timestamps
+    @timestamps = Hash.new
+    @notfound = Set.new
+    @verbose = false
+    @watched_dirs = []
+
+    # Set verbosity flag. Setting this to true will report each file
+    # that has been reloaded.
+    def self.verbose=(flag)
+      @verbose = flag
+    end
+    
+    # Find the full path to a file.
+    def self.locate(file)
+      return nil if @notfound.include? file
+      $:.each do |dir|
+        fullpath = File.join(dir, file)
+        if File.exists? fullpath
+          return fullpath
+        elsif File.exists?(fullpath + '.rb')
+          return fullpath + '.rb'
+        elsif File.exists?(fullpath + '.so')
+          return fullpath + '.so'
+        end
+      end
+      # puts "[JML::AutoReload] File #{file} not found!"
+      @notfound.add file
+      return nil
+    end
+    
+    # Store the time stamp of a file.
+    def self.timestamp(file)
+      path = locate(file)
+      if path
+        file = normalize(path, file)
+        @timestamps[file] = File.mtime(path)
+      end
+    end
+    
+    # Put the extension on a filename.
+    def self.normalize(path, file)
+      if File.extname(file) == ""
+        return file + File.extname(path)
+      else
+        return file
+      end
+    end
+    
+    # Show all stored files and their timestamp.
+    def self.dump
+      pp @timestamps
+    end
+    
+    # Reload a file. With force=true, file is reloaded in
+    # any case.
+    def self.reload(file, force=false)
+      path = locate(file)
+      file = normalize(path, file)
+      
+      if force or (path and File.mtime(path) > @timestamps[file])
+        puts "[JML::AutoReload] reloading #{file}" if @verbose
+        
+        # delete file from list of loaded modules, and reload
+        $".delete file
+        require file
+        return true
+      else
+        return false
+      end
+    end
+    
+    # Reload all files which were required.
+    def self.reload_all(force=false)
+      @timestamps.each_key do |file|
+        self.reload(file, force)
+      end
+      check_directories
+    end
+    
+    # Add directories to be watched.
+    def self.watch_directory(dir)
+      @watched_dirs << dir
+    end
+    
+    # Reload any new files in the watched directories.
+    def self.check_directories
+      @watched_dirs.each do |dir|
+        Dir.glob("#{dir}/**/*.rb").each do |fn| 
+          if @timestamps.include? fn
+            reload(fn)
+          else
+            require(fn)
+          end
+        end
+      end
+    end
+  end
+end
+
+# Overwrite 'require' to register the time stamps instead.
+module Kernel # :nodoc:
+  alias old_require require
+  
+  def require(file)
+    Rish::Autoreload.timestamp(file)
+    old_require(file)
+  end
+end

data/lib/rish/commands.rb

@@ -0,0 +1,28 @@
+# Copyright (c) 2010 by Mikio L. Braun
+# rish is distributed under a BSD-style license. See COPYING
+
+module Rish
+  # Collects commands which are available trough extensions.
+  module Commands
+    module_function
+    
+    # Show help for a command, or just the builtin commands.
+    def help(word=nil)
+      if word
+        puts %x{qri #{word}}
+      else
+        puts <<EOS
+Rish builtin-commands
+
+@p <expr>  profile expression (requires --debug on JRuby)
+?<expr>    show help for command expr (doesn't work so well on IRB :( )
+@h         show this help
+!<cmd>     Run cmd in a shell
+!<cmd> &   Run cmd in background 
+!&<cmd>    Same as above (version for IRB which doesn't like an "&" 
+           as last element on line)
+EOS
+      end
+    end
+  end
+end

data/lib/rish/hook.rb

@@ -0,0 +1,63 @@
+# Copyright (c) 2010 by Mikio L. Braun
+# rish is distributed under a BSD-style license. See COPYING
+
+require 'profiler'
+require 'rish/autoreload'
+require 'rish/commands'
+
+module Rish
+  # The main Hook class.
+  #
+  # This adds the main functionality realized through before
+  # and after hooks.
+  #
+  # If you want to add further capabilities, here is the place to do
+  # so.
+  class Hook
+    @profile = false
+    
+    # Called with each input line.
+    #
+    # If a special command is recognized, the input line is changed
+    # accordingly. For example, "!ls" becomes "%x{ls}"
+    def before(line)
+      Autoreload::reload_all
+      if line[0] == ?!
+        if line[1] == ?&
+          line = line[2..-1] + "&"
+        end
+        if line[-1] == ?&
+          "Thread.new { %x{#{line[1...-1]}} };"
+        else
+          "%x{#{line[1..-1]}}"
+        end
+      elsif line[0] == ?? and line.size > 2
+        "Rish::Commands.help \"#{line[1..-1]}\""
+      elsif line[0] == ?@
+        if line[1] == ?p
+          Profiler__::start_profile
+          @profile = true
+          line = line[2..-1]
+        elsif line[1] == ?h
+          'Rish::Commands.help'
+        else
+          line
+        end
+      else
+        line
+      end
+    end
+
+    # Called on the result of an evaluation.
+    #
+    # Used here mainly to clean up after the profiler.
+    def after(result)
+      if @profile
+        Profiler__::stop_profile
+        Profiler__::print_profile($stdout)
+        @profile = false
+      end
+      result
+    end
+  end  
+end

data/lib/rish/interactive.rb

@@ -0,0 +1,188 @@
+# Copyright (c) 2010 by Mikio L. Braun
+# rish is distributed under a BSD-style license. See COPYING
+
+require 'readline'
+require 'pp'
+
+module Rish
+  # Rish's own interactive mode.
+  #
+  # Similar to IRB, but much smaller. The advantage it has is that it
+  # doesn't look for line continuations and works better with rish's
+  # built-in commands (well, is this a feature or a bug?)
+  #
+  # Also, if the line ends in ";", the result is not plotted, just as in 
+  # matlab.
+  class Interactive
+    # Start an interactive shell.
+    def run
+      read_history
+
+      #binding = Workspace.new.binding
+      binding = Object::TOPLEVEL_BINDING
+
+      Readline.completion_proc = proc do |s|
+        if /([a-zA-Z_]+)(::|\.)([^.]*)/ =~ s
+          prefix = $1
+          sep = $2
+          s = $3
+          
+          candidates = get_candidates(binding, prefix + sep)
+        else
+          prefix = ''
+          sep = ''
+
+          candidates = get_candidates(binding)
+        end
+
+        candidates = candidates.select {|m| starts_with(m, s)}
+        candidates.map! {|c| prefix + sep + c}
+      end
+      
+      thread = Thread.current
+
+      state = :input
+
+      trap('SIGINT') do
+        case state
+        when :input
+          puts "Exiting..."
+          thread.raise Interrupt
+          exit
+        when :calc
+          thread.raise Interrupt
+        end
+      end
+
+      lineno = 0
+      s = 'okay'
+      while s
+        lineno += 1
+        state = :input
+        s = Readline.readline("interactive:#{lineno}> ", true)
+        #print "interactive:#{lineno}> "
+        #s = gets.chomp
+        break if (s.nil? or s == 'exit' or s == 'quit')
+        begin
+          s = @hook.before(s) if @hook
+          state = :calc
+          result = eval(s, binding, 'interactive', lineno)
+          state = :input
+          result = @hook.after(result) if @hook
+          if s[-1] != ?;
+            print_result(result)
+            $ans = result
+          end
+        rescue SyntaxError => e
+          puts "SyntaxError: #{e}"
+        rescue StandardError, ScriptError => e
+          puts "#{e.class}: #{e.to_s[0..1000]}"
+          print_backtrace e.backtrace
+        rescue SignalException => e
+          puts "Caught #{e.class}"
+          print_backtrace e.backtrace
+        end
+      end
+
+      write_history
+      exit
+    end
+
+    # Add a hook which is called before and after each line.
+    #
+    # The hook object as to have a +before+ and +after+ method.
+    # The +before+ method is called with the input line
+    # and has to return it or a changed version. Likewise,
+    # the +after+ method gets the result of the evaluation and
+    # has to return the value or a changed version.
+    def hook=(h)
+      @hook = h
+    end
+
+    #######
+    private
+    #######
+
+    def history_file
+      File.join(ENV['HOME'], '.rish_history')
+    end
+
+    def print_result(result)
+      puts result.inspect unless result.nil?
+    end
+
+    def read_history
+      begin
+        open(history_file, 'r').each do |l|
+          Readline::HISTORY << l.chomp
+        end
+      rescue Errno::ENOENT
+        # do nothing
+      end
+    end
+
+    def write_history
+      open(history_file, 'w') do |f|
+        Readline::HISTORY.each {|l| f.puts l }
+      end
+    end
+
+    # For cleanin up JRuby's stack traces.
+    BACKTRACE_HIDE = [ 'sun/', 'java/', 'org/jruby', 'interactive', ':', __FILE__ ]
+
+    def print_backtrace(bt)
+      bt.each do |t|
+        unless BACKTRACE_HIDE.inject(false) do |flag,h|
+            flag ||= starts_with(t, h)
+          end
+          puts "     #{t}"
+        end
+      end
+    end
+
+    def starts_with(long, short)
+      long[0...short.length] == short
+    end
+
+    def get_candidates(binding, where='')
+      candidates = []
+      %w(methods constants local_variables).each do |m|
+        begin
+          candidates += eval(where + m, binding)
+        rescue
+        end
+      end
+
+      if where == ''
+        eval('self.class.ancestors', binding).each do |an|
+          %w(methods constants).each do |m|
+            begin
+              candidates += an.send(m)
+            rescue
+            end
+          end
+        end
+      end
+
+      return candidates.sort.uniq
+    end
+  end
+end
+
+if __FILE__ == $0
+  include M
+
+  puts "Interactive with a before and after hook"
+  class MyInteractive < Interactive # :nodoc:
+    def process_line(line)
+      puts "This line is great: #{line}"
+      line
+    end
+
+    def process_result(result)
+      print " => "
+      result
+    end
+  end
+  MyInteractive.new.run
+end

data/lib/rish/irb.rb

@@ -0,0 +1,104 @@
+# Copyright (c) 2010 by Mikio L. Braun
+# rish is distributed under a BSD-style license. See COPYING
+
+require 'irb'
+
+module IRB
+  # Start a rish-shell.
+  #
+  # This code is basically the same as IRB.start with the
+  # irb object replaced by our own version.
+  def IRB.rish_start(ap_path=nil, hook=nil)
+    $0 = File::basename(ap_path, ".rb") if ap_path
+    
+    IRB.setup(ap_path)
+    
+    if @CONF[:SCRIPT]
+      irb = Rish::Irb::RishIrb.new(nil, @CONF[:SCRIPT])
+    else
+      irb = Rish::Irb::RishIrb.new
+    end
+
+    irb.hook = hook
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+    
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+#    print "\n"
+  end
+end
+
+module Rish
+  # Rish's irb extensions.
+  #
+  # This module defines two classes derived from IRB::Irb and
+  # IRB::Context which basically add after and before hooks
+  # to the evaluation to implement automatic reloading and
+  # profiling.
+  module Irb
+    # Our version of IRB::Irb which uses a RishContext.
+    class RishIrb < IRB::Irb
+      # Create new object.
+      #
+      # Overwrites @context to RishContext.
+      def initialize(workspace = nil, input_method = nil, output_method = nil)
+        super(workspace, input_method, output_method)
+        @context = RishContext.new(self, workspace, input_method, output_method)
+      end
+      
+      # Add a hook in the context object.
+      def hook=(h)
+        @context.hook = h
+      end
+    end
+    
+    # Our version of IRB::Context which adds before and after hooks
+    # to evaluate.
+    class RishContext < IRB::Context
+      # Create new context object.
+
+      def initialize(irb, workspace = nil, input_method = nil, output_method = nil)
+        super(irb, workspace, input_method, output_method)
+      end
+      
+      # Add a hook.
+      def hook=(h)
+        @hook = h
+      end
+
+      # Overwritten version of evaluate which calls the +before+ and
+      # +after+ methods of the hook, if present. +before+ gets the
+      # input line and may return a changed version, +after+ gets the
+      # result and may return a changed version.
+      def evaluate(line, line_no)
+        line = @hook.before(line) if @hook
+        val = super(line, line_no)
+        val = @hook.after(val) if @hook
+        val
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  class RishHook # :nodoc:
+    def before(line)
+      puts "Before"
+      line
+    end
+    
+    def after(val)
+      puts "After"
+      val
+    end
+  end
+  
+  IRB.rish_start(nil, RishHook.new)
+end

data/lib/rish/shell.rb

@@ -0,0 +1,28 @@
+# Copyright (c) 2010 by Mikio L. Braun
+# rish is distributed under a BSD-style license. See COPYING
+
+require 'profiler'
+
+require 'rish/hook'
+require 'rish/irb'
+require 'rish/interactive'
+
+# The Rish main module.
+#
+# Call Rish.shell to start a shell.
+module Rish
+  module_function
+
+  # Start a new Rish shell. Supported types are :irb and :rish.
+  def shell(type=:irb)
+    hook = Hook.new
+    case type
+    when :irb
+      IRB.rish_start(nil, hook)
+    when :rish
+      i = Interactive.new
+      i.hook = hook
+      i.run
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: rish
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 1
+  version: "0.1"
+platform: ruby
+authors: 
+  - Mikio L. Braun
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-14 00:00:00 +02:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: fastri
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 0
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+description: |
+  An interactive Ruby shell with auto-reloading, shell-outs, profiling,
+  and integrated help.
+
+email: mikiobraun@gmail.com
+executables: 
+  - rish
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - bin/rish
+  - lib/rish/commands.rb
+  - lib/rish/autoreload.rb
+  - lib/rish/irb.rb
+  - lib/rish/hook.rb
+  - lib/rish/interactive.rb
+  - lib/rish/shell.rb
+has_rdoc: true
+homepage: http://github.com/mikiobraun/rish
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Ruby interactive shell
+test_files: []
+