rubish 0.0.1

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+begin
+  require 'rcov/rcovtask'
+
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.rcov_opts = ["-T -x '/Library/Ruby/*'"]
+    t.verbose = true
+  end
+rescue LoadError
+  puts "Rcov not available. Install it for rcov-related tasks with: sudo gem install rcov"
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "rubish"
+    s.description = "Ruby Interactive Shell"
+    s.summary = s.description
+    s.email = "hayeah@gmail.com"
+    s.homepage = "http://github.com/hayeah/rubish"
+    s.authors = ["Howard Yeh"]
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["LICENSE"]
+    s.files = FileList["[A-Z]*", "{bin,lib,test}/**/*"]
+  end
+
+rescue LoadError
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Build and install gem"
+task :gem_install =>["gemspec", "build", "install"]
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 0
+:patch: 1
+:major: 0

data/bin/rubish

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/rubish'
+
+Rubish.repl

data/lib/rubish.rb

@@ -0,0 +1,24 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'pp'
+require 'fileutils'
+require 'readline'
+require 'irb/input-method'
+require 'irb/ruby-lex'
+
+require 'rubish/stub'
+require 'rubish/job'
+require 'rubish/job_control'
+require 'rubish/context'
+require 'rubish/repl'
+require 'rubish/workspace'
+require 'rubish/executable'
+require 'rubish/unix_executable'
+require 'rubish/batch_executable'
+require 'rubish/command'
+require 'rubish/command_builder'
+require 'rubish/pipe'
+require 'rubish/streamer'
+require 'rubish/sed'
+require 'rubish/awk'

data/lib/rubish/awk.rb

@@ -0,0 +1,54 @@
+class Rubish::Awk < Rubish::Streamer
+  
+  attr_reader :a # array of fields
+  attr_reader :r # string of current record
+  attr_reader :nf # number of fields for current record
+  
+  def initialize(exe)
+    super(exe)
+    @fs = /\s+/
+    @nf = 0 # number of fields for a record
+    @acts = []
+    @beg_act  = nil
+    @end_act = nil
+  end
+  
+  def rs=(*args)
+    raise "record separator not supported"
+    self
+  end
+
+  def fs(fs)
+    @fs = fs
+    self
+  end
+
+  def nr
+    lineno
+  end
+
+  def stream_begin
+    self.instance_eval(&@beg_act) if @beg_act
+  end
+
+  def init_line
+    @a = line.split(@fs)
+    @nf = @a.length
+    @r = line
+  end
+
+  def stream_end
+    self.instance_eval(&@end_act) if @end_act
+  end
+  
+  def begin(&block)
+    @beg_act = block
+    self
+  end
+
+  def end(&block)
+    @end_act = block
+    self
+  end
+  
+end

data/lib/rubish/batch_executable.rb

@@ -0,0 +1,27 @@
+# wraps all the processing in a context with a job
+# (which encapsulates a thread).
+class Rubish::BatchExecutable < Rubish::Executable
+  
+
+  def initialize(context,&block)
+    @context = context
+    @proc = block
+  end
+  
+  def exec!
+    ctxt = @context.derive(nil,self.i,self.o,self.err)
+    # this block will execute in a thread
+    Rubish::Job::ThreadJob.new {
+      begin
+        ctxt.eval &@proc
+      ensure
+        ctxt.job_control.waitall
+      end
+    }
+  end
+
+  def exec
+    exec!.wait
+  end
+  
+end

data/lib/rubish/command.rb

@@ -0,0 +1,91 @@
+
+class Rubish::Command < Rubish::UnixExecutable
+  
+  attr_reader :cmd, :args
+  attr_reader :quoted # if true, arguments for exec are not shell expanded.
+  def initialize(cmd,args)
+    @quoted = false
+    @args = args
+    @cmd = cmd.to_s
+  end
+  
+  def exec_with(i,o,e)
+    normalize_args!
+    unless pid = Kernel.fork
+      # child
+      system_exec(i,o,e)
+    else
+      return [pid]
+    end
+  end
+
+  # this method should be called after fork
+  def system_exec(i,o,e)
+    begin
+      # dup2 the given i,o,e to stdin,stdout,stderr
+      # close all other file
+      Rubish.set_stdioe(i,o,e)
+      # exec the command
+      if self.quoted
+        # use arguments as is
+        Kernel.exec self.cmd, *args
+      else
+        # want shell expansion of arguments
+        Kernel.exec "#{self.cmd} #{args.join " "}"
+      end
+    rescue
+      # with just want to kill the child
+      # process. When something goes wrong with
+      # exec. No cleanup necessary.
+      #
+      # There's a weird problem with
+      # Process.exit(non_zero) raising SystemExit,
+      # and that exception somehow reaches the
+      # parent process.
+      Process.exit!(1)
+    end
+  end
+
+  def to_s
+    self.inspect
+  end
+
+  def q
+    @quoted = true
+    self
+  end
+
+  def q!
+    @quoted = false
+    self
+  end
+
+  def +(arg)
+    @args << arg
+    self
+  end
+
+  def %(arg)
+    @args = [arg]
+    self
+  end
+
+  def normalize_args!(args=@args)
+    args.map! do |arg|
+      case arg
+      when Symbol
+        "-#{arg.to_s[0..-1]}"
+      when Array
+        # recursively flatten args
+        normalize_args!(arg)
+      when String
+        arg
+      else
+        raise "argument to command should be one of Symbol, String, Array "
+      end
+    end
+    args.flatten!
+    args
+  end
+
+end

data/lib/rubish/command_builder.rb

@@ -0,0 +1,116 @@
+
+class Rubish::Arguments
+  # integeral key doesn't make sense.
+
+  attr_reader :args, :keys
+  def initialize
+    @args = [] # to store the args
+    @keys = {} # to store the position of the key arguments
+  end
+  
+  def to_s
+    @args.flatten.compact!
+    @args.join " "
+  end
+  
+  def [](key)
+    args[keys[key]] if keys.has_key?(key)
+  end
+
+  def <<(obj)
+    args << obj
+  end
+
+  def toggle(key,obj=nil)
+    if self.has_key?(key)
+      # r = args[keys[key]]
+      args[keys[key]] = nil
+      keys.delete(key)
+      return false # kinda weird to return the toggled-off arguments
+    else
+      args << (obj ? [key,obj] : [key])
+      keys[key] = args.length - 1
+      return true
+    end
+  end
+
+  def set(key,val=nil)
+    if self.has_key?(key)
+      self.delete(key)
+    end
+    self.toggle(key,val)
+  end
+
+  def has_key?(key)
+    keys.has_key?(key)
+  end
+
+  def push(key,val)
+    self.concat(key,[val])
+  end
+
+  def concat(key,array)
+    if self.has_key?(key)
+      args[keys[key]].concat array
+    else
+      self.toggle(key,array)
+    end
+  end
+
+  def delete(key)
+    if self.has_key?(key)
+      return args.toggle(key)
+    else
+      nil
+    end
+  end
+  
+
+  def inspect
+    "<#{self.class}: #{self.to_s}>"
+  end
+end
+
+class Rubish::CommandBuilder < Rubish::Command
+  attr_reader :args
+  class << self
+    def inherited(klass)
+      puts "inherited by #{klass}"
+      klass.instance_eval do
+        def as(name)
+          self.instance_eval("def cmd_name; '#{name}'; end")
+        end
+      end
+    end
+  end
+  
+  def initialize
+    @args = Rubish::Arguments.new
+  end
+
+  def set(key,val=nil)
+    args.set(key,val)
+    self
+  end
+
+  def toggle(key,val=nil)
+    args.toggle(key,val)
+    self
+  end
+  
+  def opts(v)
+    case v
+    when Array
+      args << v
+    when Hash
+      v.each do |k,v|
+        args.push(k,v)
+      end
+    end
+    self
+  end
+  
+  def cmd
+    "#{self.class.cmd_name} #{args.to_s}"
+  end
+end

data/lib/rubish/context.rb

@@ -0,0 +1,75 @@
+class Rubish::Context
+
+  class << self
+    def singleton
+      @singleton ||= self.new(Rubish::Workspace.global,
+                              $stdin,$stdout,$stderr)
+    end
+    alias_method :global, :singleton
+    
+    def current
+      Thread.current["rubish.context"] || self.singleton
+    end
+
+    def as_current(context,&block)
+      raise "expects a context" unless context.is_a?(Rubish::Context)
+      begin
+        old_context = Thread.current["rubish.context"]
+        Thread.current["rubish.context"] = context
+        block.call
+      ensure
+        Thread.current["rubish.context"] = old_context
+      end
+    end
+  end
+
+  attr_accessor :i, :o, :err
+  attr_accessor :workspace
+  attr_reader :pwd # working_directory
+  attr_reader :job_control
+  attr_reader :parent
+  
+  # prototype style cloning, but only on select attributes
+  def initialize(workspace,i=nil,o=nil,err=nil)
+    # a cloned context inherits the follow attributes
+    @workspace = workspace
+    @i = i || Rubish::Context.current.i
+    @o = o || Rubish::Context.current.o
+    @err = err || Rubish::Context.current.err
+    # @pwd = Dir.pwd
+
+    # not these
+    @job_control = Rubish::JobControl.new
+    @parent = nil
+  end
+
+  def initialize_copy(from)
+    # note that we use the cloned workspace of the parent's workspace.
+    initialize(from.workspace.derive,
+               from.i, from.o, from.err)
+    @job_control = Rubish::JobControl.new
+  end
+
+  def derive(workspace=nil,i=nil,o=nil,err=nil)
+    parent = self
+    child = parent.clone
+    child.instance_eval {
+      @parent = parent
+      @workspace = workspace if workspace
+      @i = i if i
+      @o = o if o
+      @err = err if err
+    }
+    return child
+  end
+  
+  def eval(string=nil,&block)
+    Rubish::Context.as_current(self) {
+      if string
+        self.workspace.eval(string)
+      else
+        self.workspace.eval(&block)
+      end
+    }
+  end
+end