chitin 1.0.1

data/lib/chitin/commands/builtins.rb

@@ -0,0 +1,224 @@
+# Things are contained in modules or functions so that they play well with
+# code folding.
+
+require 'etc'
+ENV['USER'] ||= Etc.getlogin
+ENV['HOME'] ||= Etc.getpwent(ENV['USER']).dir
+
+module Chitin
+  module Builtins
+    extend self
+
+    # interface to Coolline
+    def bind(key, &action)
+      cool = defined?(SESSION) ? SESSION : Coolline
+      cool.bind(key, &action)
+    end
+
+    def completion_proc(&block)
+      @completion_proc = block
+    end
+  
+    def pre_processing
+      @pre_processing ||= {:default => []}
+    end
+  
+    def pre_process(label=:default, &block)
+      if label == :default
+        pre_processing[label] << block
+      else
+        pre_processing[label] = block
+      end
+    end
+  
+    def post_processing
+      @post_processing ||= {:default => []}
+      @post_processing.default = Proc.new {|*args| args.size > 1 ? args : args.first }
+      @post_processing
+    end
+  
+    def post_process(label=:default, &block)
+      if label == :default
+        post_processing[label] << block
+      else
+        post_processing[label] = block
+      end
+    end
+
+    # L for Lambda. Creates a proc as a RubyMethod
+    def L(&block)
+      StringMethod.new :bottle, &block
+    end
+
+    # Place the last argument on the line
+    # This is a total hack. It would need proper parsing to accomodate for
+    # strings with spaces in them.
+    bind "\e." do |c|
+      # Make it a proper string, first
+      last_line = proper_string c.history[-2]
+      last_arg = shellsplit_keep_quotes(c.history[-2]).last
+      c.line << last_arg
+      c.pos = c.line.length # go one beyond the last character position
+    end
+
+    # Quote the word around or before the cursor.
+    # Useful for when you finish typing something and think "damn i'd like this
+    # in quotes"
+    bind ?\C-q do |c|
+      if beg = c.word_beginning_before(c.pos) and last = c.word_end_before(c.pos) and
+         not (["'", '"'].include?(c.line[beg..last][0, 1]) &&
+              ["'", '"'].include?(c.line[beg..last][-1, 1]))
+        c.line[beg..last] = '"' + c.line[beg..last] + '"'
+        c.pos = last + 3 # 2 for the quotes and 1 for the cursor
+      end
+    end
+
+    # Clear the line, don't add it to history
+    bind ?\C-g do |c|
+      c.line.clear
+      c.pos = 0
+    end
+
+    # Clear the line, add it to history
+    bind ?\C-d do |c|
+      # Save the current line
+      c.history[-1] = c.line if c.history.size != 0
+      c.history.index = c.history.size
+      c.history.save_line
+
+      # And prep the new one
+      c.instance_variable_set :@line, ""
+      c.pos = 0
+      c.history.index = c.history.size - 1
+      c.history << c.line
+    end
+  
+    module Prompts
+      # The standard prompt. Must return a string. Override this to provide
+      # a custom prompt.
+      def big_prompt
+        "+-#{'-' * ENV['USER'].length}--#{'-' * short_pwd.length}-+\n" +
+        "| #{ENV['USER']}: #{short_pwd} |\n" +
+        "+-#{'-' * ENV['USER'].length}--#{'-' * short_pwd.length}-+ "
+      end
+  
+      def small_prompt
+        "#{ENV['USER']}: #{short_pwd} % "
+      end
+  
+      def prompt
+        big_prompt
+      end
+    end
+    include Prompts
+  
+    # I'm putting these in their own module so that you can compress them easily
+    # using code folding. Sinatra-style, baby.
+    module Aliases
+      # Basic helper commands for shell usability
+      def cd(path=ENV['HOME']); Dir.chdir path; pwd; end
+      def pwd; Dir.pwd; end
+      def short_pwd
+        home = ENV['HOME']
+        pwd.start_with?(home) ? pwd.sub(home, '~') : pwd
+      end
+      def ll(*a); ls '-hGl', *a; end
+      def la(*a); ls '-haGl', *a; end
+      def exeunt; puts 'Fare thee well...'; exit 0; end
+      def x; exeunt; end
+      def c; clear; end
+  
+      def gem(*a); raw_exec("gem", *a); end
+      def all; D('.'); end
+    end
+    include Aliases
+    
+    # Fixnum math is now floating-point math
+    class ::Fixnum
+      alias_method :old_div, :/
+      
+      def /(other)
+        self.to_f / other.to_f
+      end
+    end
+  
+    module ExecutableBinaries
+      # Executable files
+      # Do them lazily because otherwise we could have a SHITTONNE of methods lying
+      # around in the objectspace
+      COMMANDS = {}
+      PRIORITY_METHODS = []
+      def path_for_exec(name)
+        # poor man's caching
+        return COMMANDS[name] if COMMANDS[name]
+      
+        ENV['PATH'].split(':').each do |p|
+          if File.exist? File.join(p, name.to_s)
+            COMMANDS[name] = File.join(p, name.to_s)
+            return COMMANDS[name]
+          end
+        end
+      
+        false
+      end
+      
+      def method_missing(name, *args, &block)
+        if PRIORITY_METHODS.include? name
+          return StringMethod.new(name, *args, &block)
+        end
+  
+        if path_for_exec(name)
+          return Executable.new(path_for_exec(name), *args)
+        end
+  
+        if "".public_methods(false).include? name
+          return StringMethod.new(name, *args, &block)
+        end
+      
+        # If we made it this far, there is no executable to be had. Super it up.
+        super
+      end
+  
+      def raw_exec(path, *args)
+        Executable.new path, *args
+      end
+      alias_method :here, :raw_exec
+    end
+    include ExecutableBinaries
+  
+    pre_process do |val|
+      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
+      #
+      # option: make it ask for confirmation first
+      # settable in chitinrc, perjaps?
+      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
+    
+    # You can use error classes as a name and if the error comes up,
+    # block of code will be run.
+    # 
+    # post_process SyntaxError do |e, val|
+    #   # sample
+    # end
+    
+    post_process :color do |val|
+      Wirble::Colorize.colorize val
+    end
+  end 
+end
+

data/lib/chitin/commands/executable.rb

@@ -0,0 +1,139 @@
+module Chitin
+  class Executable
+    include Runnable
+  
+    def initialize(path, *args)
+      @path = path
+      @args = process_args(args)
+    end
+  
+    def |(other)
+      Pipe.new self, other
+    end
+    alias_method :<=>, :|
+  
+    # EVERYTHING will be sent to the command. ERRTHANG!!!!
+    def method_missing(name, *arr, &blk)
+      setup name.to_s, *process_args(arr)
+      self
+    end
+
+    private
+
+    attr_accessor :args
+    attr_accessor :path
+    attr_accessor :pid
+  
+    def process_args(args)
+      processed = args.map do |arg|
+        if arg.is_a? Hash
+          arg.map do |k, v|
+            if k.is_a? Symbol
+              ["#{k.to_s.size > 1 ? '--' : '-'}#{k}", v.to_s]
+            else
+              [k.to_s, v.to_s]
+            end
+          end
+        else
+          arg.to_s
+        end
+      end
+  
+      processed.flatten
+    end
+
+    def args
+      @args ||= []
+    end
+
+    # prep the executable to run with the arguments +subc+ and +args+
+    def setup(subc, *arr)
+      # we have to use +@args+ here because otherwise we'd have to use the +=
+      # method which would trigger an explosion of +method_missing+
+      @args += [subc.to_s]
+      @args += arr.map {|a| a.to_s }
+      self # need to return this so that the shell can just run it
+    end
+  
+    # TODO fix it so that self.err isn't alone in the whole `if self.err`
+    # bit. figure out a good way to make it default or something. i dunno.
+    # just do it.
+    def run
+      child = fork do
+        # Like the comments in +open_pipes+, the user writes to +@in+.
+        # Then our executable now will read from +@in+. OH HEY NO WAY
+        # since executables normally read from STDIN, we can link them.
+        IO.open(0).reopen self[:in] # STDIN to the program comes from 
+        IO.open(1).reopen self[:out]
+        IO.open(2).reopen self[:err] if self[:err]
+  
+        self[:in].close  # These can be closed
+        self[:out].close # because there is already an opening
+        self[:err].close if self[:err] # via IO 0, 1, and 2.
+        # And it is important that they be closed, otherwise
+        # we'll have a hanging pipe that will hold everything up.
+        # In the future, we'll use `close_all` to make it simple.
+  
+        exec path, *args
+      end
+  
+      close_all
+  
+      reset
+      @pid = child
+    end
+  
+    def wait
+      Process.wait @pid
+    rescue Interrupt => e
+      Process.kill "HUP", @pid
+    end
+  
+    def reset
+      @opened = false
+      self.in, self.out, self.err = nil
+    end
+  
+    def each_line
+      proc do |inp|
+        # since out is only open for writing (since it is supposed to be used
+        # by the process itself, like with puts and print), we need to make our
+        # OWN pipe
+        r, w = IO.pipe
+        inp > self > w
+        run # since we let it run in the background, we're not gonna call +#wait+
+  
+        # lil bits at a time
+        while (chunk = r.gets)
+          yield chunk
+        end
+  
+        self
+      end
+    end
+
+    def inspect
+      "#<Chitin::Executable @path=#{@path.inspect} @args=#{@args.inspect}>"
+    end
+
+    def to_s
+      arr = args.map do |arg|
+        if arg.is_a? Hash
+          arg.map do |k, v|
+            if k.is_a? Symbol
+              ["#{k.to_s.size > 1 ? '--' : '-'}#{k}", v.to_s]
+            else
+              [k.to_s, v.to_s]
+            end
+          end
+        else
+          arg.to_s
+        end
+      end
+  
+      [path, *arr.flatten].join ' '
+    end
+  
+  end
+end
+

data/lib/chitin/commands/pipe.rb

@@ -0,0 +1,112 @@
+module Chitin
+  class Pipe
+    include Runnable
+  
+    attr_accessor :parts
+    attr_accessor :pids
+  
+    def initialize(*parts)
+      @parts = parts
+  
+      link_all
+    end
+  
+    # link everything together
+    def link_all
+      # move from left to right through the list
+      # link the left one to the right one
+      parts[1..-1].inject parts.first do |left, right|
+        link left, right
+        # return this, and shift the whole process one to the right
+        right
+      end
+    end
+  
+    def link(left, right)
+      # The pipe that we use to connect the dots
+      r, w = IO.pipe
+  
+      # since left will want to write to STDOUT, we have to give it
+      # something else it can write to.
+      left > w
+
+      # same thing for right, but with reading
+      r > right
+  
+      # right will try to read from r until w is closed.
+      # when w is closed, right will finish processing.
+      # if we don't close this, right will never return
+      w.close
+      r.close # and we close r so that we don't have any open useless handles
+    end
+  
+    # Like raw_run, but meant to be used in chaining.
+    def run
+      parts.each {|part| part[:run] }
+      reset
+  
+      self
+    end
+  
+    # Run them all but let the last run return its value
+    def raw_run
+      parts[0..-2].each {|part| part[:run] }
+      result = parts.last[:raw_run]
+      reset
+  
+      result
+    end
+
+    def wait
+      parts.each {|part| part[:wait] }
+  
+      self
+    end
+  
+    def reset
+      parts.map {|part| part[:reset] }
+      link_all # we have to refresh the pipes connecting everything
+  
+      self
+    end
+  
+    def |(other)
+      raise "#{other.class} needs to include Runnable" unless Runnable === other
+  
+      link parts.last, other
+      parts << other
+  
+      self
+    end
+    alias_method :<=>, :|
+  
+    def in
+      @parts.first[:in]
+    end
+    def in=(other); @parts.first[:set_in, other]; end
+  
+    def out
+      @parts.last[:out]
+    end
+    def out=(other); @parts.last[:set_out, other]; end
+  
+    def err
+      @parts.last[:err]
+    end
+    def err=(other); @parts.last[:set_err, other]; end
+  
+    def to_s
+      "#{self.in} > #{parts.map {|p| p[:to_s] }.join ' | '} > #{self.out}"
+    end
+  
+    def returning
+      if [StringMethod, Proc].include?(@parts.last[:class])
+        :ruby
+      else
+        :io
+      end
+    end
+  
+  end
+end
+

data/lib/chitin/commands/ruby.rb

@@ -0,0 +1,152 @@
+module Chitin
+  class StringMethod
+    include Runnable
+  
+    attr_reader :chains
+    attr_reader :pid
+  
+    def initialize(*arr, &block)
+      raise "Need at least a method name" unless [String, Symbol].include? arr.first.class
+      @chains = []
+      latest  = [*arr]
+      latest << block if block
+      @chains << latest
+    end
+  
+    def |(other)
+      Pipe.new self, other
+    end
+
+    def method_missing(*arr, &block)
+      latest  = [*arr]
+      latest << block if block
+      @chains << latest
+      self # chainable
+    end
+
+    private
+
+    def result
+      val = self[:in].read
+      @chains.each do |arr|
+        val = if arr.last.is_a? Proc
+                val.send *arr[0..-2], &arr[-1]
+              else
+                val.send *arr
+              end
+      end
+  
+      val
+    end
+  
+    # this is runs the method on the input
+    # and then writes the output to self.out
+    # used in piping
+    def run
+      child = fork do
+        self[:out].write result
+  
+        close_all
+      end
+  
+      close_all
+      reset
+  
+      @pid = child
+    end
+  
+    # like #run, except instead of writing the output
+    # we simply return it
+    # used when a StringMethod is the LAST item in a pipe
+    def raw_run
+      res = result
+      close_all
+      reset
+  
+      res
+    end
+  
+    def wait
+      Process.wait @pid
+    end
+  
+    def reset
+      self.in, self.out, self.err = nil
+    end
+  
+    def to_s
+      @chains.map do |arr|
+        "#{arr[0]}(#{arr[1..-1].map {|a| a.is_a?(Proc) ? "&block" : a.inspect }.join ', '})"
+      end.join '.'
+    end
+  
+    def inspect
+      "#<StringMethod #{to_s}>"
+    end
+  end
+end
+
+class Proc
+  # So let's quick chat about what including Runnable to a proc means.
+  # It means that it can be chained with pipes.
+  # It also means that you can run private methods with #[].
+  # The important thing isn't that you can run private methods. You could
+  # do that since the beginning of time.
+  # The take-away is that it OVERRIDES #[]. In the words of Joe Biden,
+  # this is a big fucking deal.
+  #
+  # whatdo.jpg
+  #
+  # This means that you cannot, in the environment of Chitin, use
+  # Proc#[] for anything other than accessing private methods. This
+  # means it does not play well with others. This is what we in the biz
+  # call bad.
+  undef_method :[]
+  include Chitin::Runnable
+
+  # # 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
+
+  def |(other)
+    Pipe.new self, other
+  end
+
+  private
+
+  def run
+    child = fork do
+      self.out.puts call(self.in)
+
+      close_all
+    end
+
+    close_all
+    reset
+
+    @pid = child
+  end
+
+  def raw_run
+    val = call self.in
+    
+    close_all
+    reset
+    val
+  end
+
+  def wait
+    Process.wait @pid
+  end
+
+  def reset
+    self.in, self.out, self.err = nil
+  end
+end
+

data/lib/chitin/commands/runnable.rb

@@ -0,0 +1,84 @@
+module Chitin
+  module Runnable
+
+    def >(io)
+      case io
+      when IO, File
+        self[:set_out, io]
+      when String, FileObject
+        f = File.open io, 'w'
+        self[:set_out, f]
+        f.close
+      else
+        raise "Unknown piping type: #{io.class}"
+      end
+  
+      self
+    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
+  
+    private
+
+    attr_accessor :bg
+    attr_accessor :in
+    attr_accessor :out
+    attr_accessor :err
+  
+    # Generally the same as +run+, except for the ruby commands
+    # they return real ruby that can be given back to the user.
+    def raw_run
+      run
+    end
+  
+    def set_in(other)
+      unless self[:in]
+        r, w = IO.pipe
+        w.close
+        self[:in=, r]
+      end
+      self[:in].reopen other
+    end
+  
+    def set_out(other)
+      unless self[:out]
+        r, w = IO.pipe
+        r.close
+        self[:out=, w]
+      end
+      self[:out].reopen other
+    end
+  
+    def set_err(other)
+      unless self[:err]
+        r, w = IO.pipe
+        r.close
+        self[:err=, w]
+      end
+      self[:err].reopen other
+    end
+  
+    # code smell...
+    def close_all
+      self[:in]  && self[:in].close
+      self[:out] && self[:out].close
+      self[:err] && self[:err].close
+    end
+  
+    # Methods to be done by those including this:
+    # wait
+    # reset
+    # run
+    # |(other) though this is easily done with a Pipe.new(self, other)
+  
+  end
+end
+