chitin 1.0.1

data/lib/chitin/core_ext/coolline.rb

@@ -0,0 +1,104 @@
+require 'coolline'
+
+class Coolline
+  def bind(key, &action)
+    @handlers.unshift Handler.new(key, &action)
+  end
+
+  # This is to deal wtih adding closing quotes on completions.
+  # It assumes that the completion proc will automatically place
+  # a leading quote on the line.
+  def complete
+    return if word_boundary? line[pos - 1]
+
+    completions = @completion_proc.call(self)
+
+    if completions.empty?
+      menu.string = ""
+    elsif completions.size == 1
+      menu.string = ""
+      word = completions.first
+
+      # don't close quotes on directories
+      if word[-1, 1] != '/'
+        word += word[0, 1] # because there's a quote from when we expand the options
+      end
+
+      self.completed_word = word
+    else
+      menu.list = completions
+      self.completed_word = common_beginning(completions)
+    end
+  end
+
+  alias_method :old_word_beginning_before, :word_beginning_before
+
+  # This is to make word completion complete entire unquoted strings.
+  # Very useful since Ruby doesn't have space escapes like in Bash.
+  def word_beginning_before(pos)
+    # if the line is an uncompleted string, make it the whole string
+    # else, do the normal shit
+    if incomplete_string line[0..pos]
+      point = line[0..pos].reverse.index incomplete_string(line[0..pos])
+      line[0..pos].size - point - 1
+    else
+      old_word_beginning_before(pos)
+    end
+  end
+
+  # This is to comment out `reset_line`.
+  # Now why would we do that, you ask?
+  # Because otherwise it overwrites the entire line when printing the prompt.
+  # And what's wrong with that?
+  # This is undesirable behavior if the previous program run prints output
+  # that does NOT have a trailing newline.
+  # This was the source of a "bug" for a few days now.
+  #
+  # NB: This preserves any input on the line for ONLY the initial printing of
+  # the prompt. After that, the render call in the #getch loop will overwrite
+  # it. This needs some work, obviously.
+  def readline(prompt = ">> ")
+    @prompt = prompt
+
+    @history.delete_empty
+
+    @line        = ""
+    @pos         = 0
+    @accumulator = nil
+
+    @history_moved = false
+
+    @should_exit = false
+
+    #reset_line
+    print @prompt
+
+    @history.index = @history.size - 1
+    @history << @line
+
+    until (char = @input.getch) == "\r"
+      @menu.erase
+
+      handle(char)
+      return if @should_exit
+
+      if @history_moved
+        @history_moved = false
+      end
+
+      render
+    end
+
+    @menu.erase
+
+    print "\n"
+
+    @history[-1] = @line if @history.size != 0
+    @history.index = @history.size
+
+    @history.save_line
+
+    @line
+  end
+end
+

data/lib/chitin/core_ext/io.rb

@@ -0,0 +1,7 @@
+class IO
+  def >(executable)
+    executable[:set_in, self]
+    executable
+  end
+end
+

data/lib/chitin/core_ext/object.rb

@@ -0,0 +1,21 @@
+class Object
+
+  # it does NOT return self, but rather the value of block.
+  # if no block is given, it returns nil
+  def bottle # since it's not tap
+    if block_given?
+      yield self
+    end
+  end
+
+  # access private methods
+  def [](*args)
+    if method(args.first)
+      method(args.first).call *args[1..-1]
+    else
+      raise NoMethodError.new("undefined method" +
+                              "`#{args.first}' for #{self}:#{self.class}")
+    end
+  end
+end
+

data/lib/chitin/core_ext/string.rb

@@ -0,0 +1,35 @@
+require 'wirble'
+
+class String
+  def -@
+    "-#{self}"
+  end
+
+  def nothing     ; Wirble::Colorize.colorize_string self, :nothing     ; end
+  def black       ; Wirble::Colorize.colorize_string self, :black       ; end
+  def red         ; Wirble::Colorize.colorize_string self, :red         ; end
+  def green       ; Wirble::Colorize.colorize_string self, :green       ; end
+  def brown       ; Wirble::Colorize.colorize_string self, :brown       ; end
+  def blue        ; Wirble::Colorize.colorize_string self, :blue        ; end
+  def cyan        ; Wirble::Colorize.colorize_string self, :cyan        ; end
+  def purple      ; Wirble::Colorize.colorize_string self, :purple      ; end
+  def light_gray  ; Wirble::Colorize.colorize_string self, :light_gray  ; end
+  def dark_gray   ; Wirble::Colorize.colorize_string self, :dark_gray   ; end
+  def light_red   ; Wirble::Colorize.colorize_string self, :light_red   ; end
+  def light_green ; Wirble::Colorize.colorize_string self, :light_green ; end
+  def yellow      ; Wirble::Colorize.colorize_string self, :yellow      ; end
+  def light_blue  ; Wirble::Colorize.colorize_string self, :light_blue  ; end
+  def light_cyan  ; Wirble::Colorize.colorize_string self, :light_cyan  ; end
+  def light_purple; Wirble::Colorize.colorize_string self, :light_purple; end
+  def white       ; Wirble::Colorize.colorize_string self, :white       ; end
+
+  def map_lines(&block)
+    split("\n").map(&block)
+  end
+
+  # Make an executable out of File.join(self, other)
+  def /(other)
+    Chitin::Executable.new File.join(self, other.to_s)
+  end
+end
+

data/lib/chitin/core_ext/symbol.rb

@@ -0,0 +1,6 @@
+class Symbol
+  def -@
+    "-#{self}"
+  end
+end
+

data/lib/chitin/file.rb

@@ -0,0 +1,163 @@
+module Chitin
+  class FSObject
+    attr_accessor :path
+  
+    # The choice to not have File.expand_path here is explicitly done.
+    # Relativity is up to the user.
+    # Also it got really annoying seeing the same prefix over and over
+    # and over again on lists of files.
+    def initialize(path, opts={})
+      @path = path
+      @unknown = opts[:unknown]
+    end
+
+    def unknown_type?
+      @unknown
+    end
+
+    def lstat
+      File.lstat @path
+    end
+  
+    def to_s
+      path
+    end
+  end
+
+  class FileObject < FSObject
+    def readable?(force=false)
+      @readable = force ? File.readable(path) : @readable
+    end
+  
+    def writeable?(force=false)
+      @writeable = force ? File.writeable?(path) : @writeable
+    end
+  
+    def exists?
+      File.exists? path
+    end
+  
+    def open(permissions, &block)
+      File.open path, permissions do |f|
+        block.call f
+      end
+    end
+  
+    def delete
+      File.safe_unlink @path
+    end
+  
+    def executable?(force=false)
+      @executable = force ? File.executable?(path) : @executable
+    end
+  
+    def inspect
+      "#<Chitin::FileObject #{path.inspect}>"
+    end
+
+    def symlink?
+      false
+    end
+  end
+
+  class Symlink < FileObject
+    def symlink?
+      true
+    end
+
+    def inspect
+      "#<Chitin::Symlink #{path}>"
+    end
+  end
+
+  class Directory < FSObject
+    include Enumerable
+
+    def files
+      return @files if @files
+      files = Dir[File.join(path, '*')]
+      @files = files.inject({}) do |h, f|
+        f = f[2..-1] if f.start_with? './'
+        h[f] = if File.directory? f
+                 D f
+               elsif File.file? f
+                 F f
+               elsif File.symlink? f
+                 S f
+               else
+                 FSObject.new f, :unknown => true
+               end
+  
+        h
+      end
+    end
+  
+    def down
+      self.path = File.join path, '**'
+      self
+    end
+
+    # Get a specific level down
+    def level(n=1)
+      n.times { self.path = File.join path, '*' }
+      self
+    end
+
+    def each(&block)
+      files.values.each &block
+    end
+
+    def to_a
+      files.values
+    end
+  
+    def delete
+      # this is probably unwise...
+      File.rm_rf @path
+    end
+
+    def inspect
+      "#<Chitin::Directory #{path.inspect}>"
+    end
+
+    def symlink?
+      false
+    end
+  end
+
+  # Consumes all input.
+  # Gives no output.
+  # Takes no prisoners.
+  # Used for NULLIN, NULLOUT, and NULLERR.
+  class Abyss
+    def eof?
+      true
+    end
+
+    def read
+      ""
+    end
+    alias_method :readline, :read
+
+    def <<(*args)
+    end
+    alias_method :write, :<<
+    alias_method :puts, :<<
+
+    def >(executable)
+      executable[:in=, self]
+      executable
+    end
+
+    def close
+      true
+    end
+  end
+end
+  
+def D(path); Chitin::Directory.new path; end
+def F(path); Chitin::FileObject.new path; end
+def S(path); Chitin::Symlink.new path; end
+
+NULLIN = NULLOUT = NULLERR = Chitin::Abyss.new
+

data/lib/chitin/sandbox.rb

@@ -0,0 +1,18 @@
+module Chitin
+  class Sandbox
+    def initialize
+      @binding = binding
+      @previous = nil
+    end
+  
+    def inspect
+      "(sandbox)"
+    end
+  
+    def evaluate(code)
+      @previous = eval code, @binding
+      eval "_ = @previous", @binding
+    end
+  end
+end
+

data/lib/chitin/session.rb

@@ -0,0 +1,167 @@
+require 'coderay'
+
+module Chitin
+  class Session
+    attr_accessor :sandbox
+    attr_accessor :out
+  
+    attr_reader :config
+    attr_reader :editor
+  
+    def initialize(config=nil)
+      @config  = config
+      @out     = STDOUT
+      @sandbox = Sandbox.new # give it its own private space to work
+      (class << @sandbox; self; end).send :include, @config # include the config and builtins
+
+      @editor  = Coolline.new do |c|
+        # Remove the default of '-' and add support for strings
+        # starting after parentheses.
+        c.word_boundaries = [' ', "\t", "(", ")"]
+        c.history_file    = File.join ENV['HOME'], '.chitin_history'
+
+        # Make sure we don't kill the shell accidentally when we're trying to
+        # kill a file. That's what the default does, so we're overriding that
+        # here.
+        c.bind(?\C-c) {}
+
+        c.transform_proc = proc do
+          CodeRay.scan(c.line, :ruby).term
+        end
+  
+        c.completion_proc = Proc.new do
+          line = c.completed_word
+  
+          # expand ~ to homedir
+          if line.start_with? '~'
+            line = ENV['HOME'] + line[1..-1]
+          end
+  
+          # if there's a quote, remove it. we'll add it back in later, but it ruins
+          # searching so we need it removed for now.
+          unquoted_line = ['"', '\''].include?(line[0, 1]) ? line[1..-1] : line
+  
+          Dir[unquoted_line + '*'].map do |w|
+            slash_it = File.directory?(w) and line[-1] != '/' and w[-1] != '/'
+  
+            "\"#{w}#{slash_it ? '/' : ''}"
+          end
+        end
+      end
+
+      if @sandbox.completion_proc
+        @editor.completion_proc = @sandbox.completion_proc
+      end
+    end
+  
+    # Read
+    # Evaluate
+    # Print (display)
+    # Loop
+    def start
+      while (val = read)
+        next if val.empty?
+  
+        begin
+          res = evaluate val
+          display res unless val.lstrip[0, 1] == '#'
+        rescue StandardError, ScriptError, Interrupt => e
+          @config.post_processing[e.class].call e, val
+  
+          print e.backtrace.first, ': '
+          puts "#{e.message} (#{e.class})"
+          e.backtrace[1..-1].each {|l| puts "\t#{l}" }
+          nil
+        end
+  
+      end
+    end
+  
+    # THIS METHOD WILL POSSIBLY RETURN NIL!!!!!
+    # So it can return a string or nil. Remember that, folks.
+    def read
+      inp = @editor.readline @sandbox.prompt
+  
+  
+      inp ? inp.chomp : nil # return nil so that the while loop in #start can end
+    end
+  
+    # we need to save the frame or something i think. could use fibers
+    # to make the whole thing a generator so that original frame would be saved.
+    # why did i write those lines. that makes no sense.
+    # AH now i remember. we need to save a frame and use that frame as a sandbox.
+    def evaluate(val)
+      val.strip!
+      @config.pre_processing[:default].each {|p| val = p.call val }
+  
+      @sandbox.evaluate val
+    end
+  
+    def shell_command?(res)
+      res.is_a?(Executable) || (res.is_a?(Pipe) && res[:returning] != :ruby)
+    end
+  
+    def display(res)
+      # The reason that this is here instead of in #evaluate is that
+      # pipes could, in fact, have NO display output, but that isn't for
+      # #evaluate to decide; rather, it is for #display
+      #
+      # Only pipes and executables are standalone. StringMethods need to be
+      # chained, and proc is also a general Ruby type, so we don't want to
+      # automatically call it.
+      if shell_command?(res) || (res.is_a?(Array) && !res.empty? && res.map {|r| shell_command? r }.all?)
+  
+        res = [res] unless res.is_a?(Array)
+  
+        res.each do |res|
+          # set up the inputs and outputs
+          res[:set_in,  STDIN]  unless res[:in]
+          res[:set_out, STDOUT] unless res[:out]
+          res[:set_err, STDOUT] unless res[:err]
+  
+          res[:run]
+          res[:wait] unless res[:bg]
+        end
+  
+      else # else it's a standard ruby type (or a pipe returning as such)
+  
+        unless res.is_a? Pipe
+          # RUBY values pass through here
+          txt = @config.post_processing[:color].call res.inspect
+          puts " => #{txt}"
+        else
+          # set up the inputs and outputs
+          res[:set_in,  STDIN]  unless res[:in]
+          res[:set_out, STDOUT] unless res[:out]
+          res[:set_err, STDOUT] unless res[:err]
+  
+          # We have to use #stat here because reopened pipes retain the file
+          # descriptor of the original pipe. Example:
+          #   r, w = IO.pipe; r.reopen STDIN; r == STDIN # => false
+          # Thus, we have to use #stat (or, more lamely, #inspect).
+          if res[:out].stat == STDOUT.stat
+            val = res[:raw_run]
+            txt = @config.post_processing[:color].call val.inspect
+            puts " => #{txt}"
+          else
+            res[:run]
+            res[:wait] unless res[:bg]
+          end
+        end
+  
+      end
+  
+      # Run all the post_processing stuff
+      # Not sure where I should really put this or what arguments it should have
+      @config.post_processing[:default].each {|b| b.call }
+    end
+  
+    def puts(*args)
+      @out.puts *args
+    end
+  
+    def print(*args)
+      @out.print *args
+    end
+  end
+end

data/lib/chitin/support.rb

@@ -0,0 +1,51 @@
+def proper_string(val)
+  # if there is an unclosed string, close it and run it again.
+  # smart compilers are bad... but this ain't a compiler
+  if (e = syntax_error_for(val)) &&
+     e.message =~ /unterminated string meets end of file/
+
+    if syntax_error_for(val + '\'')
+      unless syntax_error_for(val + '"')
+        val << '"'
+      end
+    else
+      val << '\''
+    end
+
+  end
+
+  val
+end
+
+# Is this an incomplete string?
+# If so, return the string character that it uses.
+# Else return false.
+def incomplete_string(string)
+  return '"' unless syntax_error_for(string + '"')
+  return "'" unless syntax_error_for(string + '\'')
+  return false
+end
+
+# If the code is syntactically correct, return nil.
+# Else, return the error.
+def syntax_error_for(code) 
+  eval "return nil\n#{code}" 
+rescue SyntaxError => e
+  e
+end 
+
+def shellsplit_keep_quotes(line)
+  words = []
+  field = ''
+  line.scan(/\G\s*(?>([^\s\\\'\"]+)|('[^\']*')|("(?:[^\"\\]|\\.)*")|(\\.?)|(\S))(\s|\z)?/m) do
+    |word, sq, dq, esc, garbage, sep|
+    raise ArgumentError, "Unmatched double quote: #{line.inspect}" if garbage
+    field << (word || sq || (dq || esc).gsub(/\\(.)/, '\\1'))
+    if sep
+      words << field
+      field = ''
+    end
+  end
+  words
+end
+

data/lib/chitin/tools/replay.rb

@@ -0,0 +1,45 @@
+require 'stringio'
+
+# The hard part is to not confuse interface with implementation. Tough because
+# this relies almost entirely on the interface.
+# Possibly reopen STDOUT so that it writes to two, instead of just redefining
+# puts/print?
+class Replay
+  attr_reader :path
+  attr_reader :session
+
+  def initialize(path, session)
+    @path = path
+    @session = session
+  end
+
+  def start!
+    session.out = MultiIO.new STDOUT, StringIO.new
+  end
+
+  def end!
+    multi = session.out
+    session.out = STDOUT
+    stringio = multi.ios[1]
+    @text = stringio.read
+  end
+
+  def to_s
+    @text
+  end
+
+end
+
+module Builtins
+  
+  def record(path="replay.#{DateTime.now.to_s}")
+    @__record__ = Replay.new path, SESSION
+    @__record__.start!
+  end
+
+  def stop
+    @__record__.end!
+    @__record__
+  end
+end
+

data/lib/chitin/tools/string_methods.rb

@@ -0,0 +1,10 @@
+def string_method(name)
+  Chitin::Builtins::PRIORITY_METHODS << name.to_sym
+end
+
+string_method :gsub
+string_method :split
+string_method :size
+string_method :pack
+string_method :unpack
+

data/lib/chitin/version.rb

@@ -0,0 +1,4 @@
+module Chitin
+  VERSION = '1.0.1'
+end
+

data/lib/chitin.rb

@@ -0,0 +1,26 @@
+def need(file)
+  require(File.dirname(File.expand_path(__FILE__)) + '/' + file)
+end
+
+need 'chitin/version'
+need 'chitin/support'
+need 'chitin/file'
+
+Dir[File.dirname(File.expand_path(__FILE__)) + '/chitin/core_ext/*'].each do |f|
+  require f
+end
+
+need 'chitin/commands/runnable'
+Dir[File.dirname(File.expand_path(__FILE__)) + '/chitin/commands/*'].each do |f|
+  require f
+end
+
+need 'chitin/tools/string_methods'
+
+need 'chitin/sandbox'
+need 'chitin/session'
+
+require 'date'
+require 'fileutils'
+require 'pp'
+