chitin 1.0.1 → 1.0.2

data/ANNOUNCEMENT

@@ -3,58 +3,64 @@ chitin
 by Ari Brown
 http://bitbucket.org/seydar/chitin
 
-Hai everybahdy
+% gem install chitin  # for bash
 
-Let's talk about the shell you're using real quick. It's most likely bash. Or
-at least it's bash-esque. There are a few hipsters among us who are using fish
-or zsh or whatever. A few of the older persuasion are into csh and tcsh.
-But that's not the point. The point is you're on a Ruby mailing list but you're
-not using a Ruby shell. It's time to upgrade. It's time to upgrade your shell
-to Chitin. I hope you all get the joke. I made it myself. The joke and the shell.
+Hai everybahdy
 
 == So what IS Chitin?
 
 * Chitin is a Ruby interpreter
 * Turned into a shell.
 
-Everything you type is Ruby -- remember that. So let's look at it in action:
-
-  ari: ~/src/chitin % 4 + 5
-   => 9
-
-Boom. "Show me more!" Ok, but only because you asked so nicely:
-
-  ari: ~/src/chitin % ls
-  ANNOUNCEMENT  README    TODO    bin   chitin-1.0.gem  chitin.gemspec
-  chitinrc      lib       sample.txt
-  ari: ~/src/chitin % hg.stat | wc | proc {|i| i.read.size } > '/tmp/test.out'
-  ari: ~/src/chitin %
-
-Holy Batman! Yeah, waddap, git on mah level. I don't even know why you'd want
-to run that last command, but thar ya go.
-
-It's supposed to replace your current shell. Now OBVIOUSLY, you're not going
-to replace the entirety of the bash infrastructure that exists in computing and
-has existed for like 40 years since the dinosaurs first walked the Earth, but
-it's a start. It's just supposed to be for personal use.
+I hope you all get the joke. I made it myself. The joke and the shell.
+
+Everything you type is Ruby -- remember that. So let's look at it in action.
+Remember that the tab completion makes typing quotes painless. Plus you don't
+even need closing quotes if they're the final character in a line:
+
+  % hg.commit :m => 'fixed issues with procs in pipes...
+  % hg.push
+  pushing to https://seydar:***@bitbucket.org/seydar/chitin
+  ...
+  remote: bb/acl: seydar is allowed. accepted payload.
+  % cat("ANNOUNCEMENT") | pbcopy
+  % ll
+  total 136
+  -rw-r--r--  1 ari  staff   1.7K Nov 25 14:43 ANNOUNCEMENT
+  ...
+  -rw-r--r--  1 ari  staff   7.7K Nov 24 20:44 sample.txt
+  % rm "chitin-1.0.1.gem"
+  % gem.build "chitin.gemspec"
+    Successfully built RubyGem
+    Name: chitin
+    Version: 1.0.1
+    File: chitin-1.0.1.gem
+  % vim "ANNOUNCEMENT"
+  % ll | grep('gem')
+  -rw-r--r--  1 ari  staff    24K Nov 25 14:49 chitin-1.0.1.gem
+  -rw-r--r--  1 ari  staff   883B Nov 21 14:43 chitin.gemspec
+  % ll | split("\n").map {|l| l.size }
+   => [9, 57, 51, 49, 48, 61, 59, 53, 48, 55]
 
 == Why use it?
 
 Because it's written in Ruby and supadupes easy to modify. Also:
 
-  * No need to use closing quotes. If you need a final quote in a line, don't
-    sweat it. Chitin will take care of that.
-  * Syntax highlighting while you type (thanks to Coolline!)
-  * You can do simple arithmatic on the command line without having to switch
-    interfaces (this was the original itch I had to scratch).
   * The power of Ruby in a shell
   * The command utility of a shell in Ruby
-  * No underlying shell usage
+  * Text processing is SO. MUCH. EASIER.
   * A much more programmatic shell
   * Prevents against accidental `rm -rf /usr /local/bin` like that one thing
     we all saw on Reddit.
+  * Syntax highlighting while you type (thanks to Coolline!)
+  * You can do simple arithmetic on the command line without having to switch
+    interfaces (this was the original itch I had to scratch).
+  * No underlying shell usage
+  * Sweet tab completion
+  * No need to use closing quotes. If you need a final quote in a line, don't
+    sweat it. Chitin will take care of that.
+  * You can set key bindings to arbitrary keys
   * Makes for a great Christmas present
-  * Text processing is SO. MUCH. EASIER.
   * Great library for calling executable files from your own program without
     shelling your soul or shelling out.
 

data/TODO

@@ -1,32 +1,21 @@
 FUTURE:
-*   add STDERR support
-*   fix it so that self.err isn't alone in the whole `if self.err` bit.
 *   set local variables in config, have them appear in shell
 *   getting the menu to NOT have leading quotes
 *   remove/edit history
     -> important for removing passwords if accidentally typed
 *   improve library usage of executables
-*   output silencing
-    -> learn to fake being an IO
-    -> shit won't work until then
-*   get consistent on what methods needs #[] and what methods don't
+
+QUIRKS:
+*   menu doesn't erase itself sometimes
+    -> cat and tabcomplete a file that is empty. output is correct but confusing
 
 FAILURES:
-*   cursor display issues with the menu
-    -> it places the cursor at the location of the cursor on the input line
-       except the cursor is actually placed on the final line of the menu
-       (the input line is several lines above it)
-*   get coolline to play well with missing newlines before it
-    -> right now it preserves junk on the line up until the first character is
-       typed. once the user types something, the line is made pristine.
-    -> see if you can replace reset_line with something like
-       reset_what_was_written, deleting the prompt and the visible portion of
-       the line
 
 Questions:
 *   Why do you have to do @line = '' in Coolline in order to not affect the
     history? History calls el.dup which creates a new object. It shouldn't
     matter if I do @line.clear on the original.
-*   Are there any ANSI codes for deleting part of a line? Yes. Duh. But what
-    are they?
+
+RELEASE
+*   failures
 

data/chitin.gemspec

@@ -25,7 +25,7 @@ DESC
   # specify any dependencies here; for example:
   # s.add_development_dependency "rspec"
   s.add_runtime_dependency "wirble"
-  s.add_runtime_dependency "coolline"
+  s.add_runtime_dependency "coolline", ">= 0.4.0"
   s.add_runtime_dependency "coderay"
 end
 

data/lib/chitin/commands/builtins.rb

@@ -96,18 +96,8 @@ module Chitin
     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
+        "#{ENV['USER']}: #{short_pwd} % "
       end
     end
     include Prompts

data/lib/chitin/commands/executable.rb

@@ -1,5 +1,7 @@
 module Chitin
   class Executable
+    __sweep__ :[]
+
     include Runnable
   
     def initialize(path, *args)
@@ -54,6 +56,10 @@ module Chitin
       @args += arr.map {|a| a.to_s }
       self # need to return this so that the shell can just run it
     end
+
+    def returning
+      :io
+    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.

data/lib/chitin/commands/pipe.rb

@@ -100,11 +100,7 @@ module Chitin
     end
   
     def returning
-      if [StringMethod, Proc].include?(@parts.last[:class])
-        :ruby
-      else
-        :io
-      end
+      parts.last[:returning]
     end
   
   end

data/lib/chitin/commands/ruby.rb

@@ -1,5 +1,7 @@
 module Chitin
   class StringMethod
+    __sweep__ :[]
+
     include Runnable
   
     attr_reader :chains
@@ -18,6 +20,7 @@ module Chitin
     end
 
     def method_missing(*arr, &block)
+      puts caller[0]
       latest  = [*arr]
       latest << block if block
       @chains << latest
@@ -29,7 +32,7 @@ module Chitin
     def result
       val = self[:in].read
       @chains.each do |arr|
-        val = if arr.last.is_a? Proc
+        val = if Proc === arr.last
                 val.send *arr[0..-2], &arr[-1]
               else
                 val.send *arr
@@ -53,6 +56,8 @@ module Chitin
       reset
   
       @pid = child
+
+      self
     end
   
     # like #run, except instead of writing the output
@@ -67,13 +72,18 @@ module Chitin
     end
   
     def wait
-      Process.wait @pid
+      @pid && Process.wait(@pid)
     end
   
     def reset
       self.in, self.out, self.err = nil
     end
+
+    def returning
+      :ruby
+    end
   
+    # fix this. What if someone passes an executable as an argument?
     def to_s
       @chains.map do |arr|
         "#{arr[0]}(#{arr[1..-1].map {|a| a.is_a?(Proc) ? "&block" : a.inspect }.join ', '})"
@@ -86,67 +96,69 @@ module Chitin
   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
+# 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.
+#   #
+#   # Maybe I shouldn't even offer this as a feature.
+#   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

@@ -15,7 +15,22 @@ module Chitin
   
       self
     end
+
+    def >>(io)
+      case io
+      when IO, File
+        self[:set_err, io]
+      when String, FileObject
+        f = File.open io, 'w'
+        self[:set_err, f]
+        f.close
+      else
+        raise "Unknown piping type: #{io.class}"
+      end
   
+      self
+    end
+
     # access private methods
     def [](*args)
       if method(args.first)
@@ -25,13 +40,20 @@ module Chitin
                                 "`#{args.first}' for #{self}:#{self.class}")
       end
     end
-  
+
+    def bg!; @bg = true; self; end
+    def bg?; @bg; end
+
     private
 
     attr_accessor :bg
     attr_accessor :in
     attr_accessor :out
     attr_accessor :err
+
+    def returning
+      raise "Not Yet Implemented"
+    end
   
     # Generally the same as +run+, except for the ruby commands
     # they return real ruby that can be given back to the user.

data/lib/chitin/core_ext/class.rb

@@ -0,0 +1,9 @@
+class Class
+  def __sweep__(*save)
+    instance_methods.each do |meth|
+      next if save.include? meth
+      private meth
+    end
+  end
+end
+

data/lib/chitin/core_ext/coolline.rb

@@ -70,7 +70,7 @@ class Coolline
 
     @should_exit = false
 
-    #reset_line
+    reset_line
     print @prompt
 
     @history.index = @history.size - 1
@@ -98,6 +98,7 @@ class Coolline
 
     @history.save_line
 
+    @menu.erase
     @line
   end
 end

data/lib/chitin/file.rb

@@ -1,6 +1,9 @@
 module Chitin
   class FSObject
+    include Enumerable
+
     attr_accessor :path
+    attr_accessor :search
   
     # The choice to not have File.expand_path here is explicitly done.
     # Relativity is up to the user.
@@ -8,6 +11,7 @@ module Chitin
     # and over again on lists of files.
     def initialize(path, opts={})
       @path = path
+      @search = proc { path }
       @unknown = opts[:unknown]
     end
 
@@ -15,6 +19,37 @@ module Chitin
       @unknown
     end
 
+    def files
+      return @files if @files
+      files = Dir[search.call]
+      @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 each(&block)
+      files.values.each &block
+    end
+
+    def to_a
+      files.values
+    end
+
+    def size
+      files.size
+    end
+
     def lstat
       File.lstat @path
     end
@@ -42,7 +77,7 @@ module Chitin
         block.call f
       end
     end
-  
+ 
     def delete
       File.safe_unlink @path
     end
@@ -71,49 +106,27 @@ module Chitin
   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
+    def initialize(path, opts={})
+      super
+      @search = proc { File.join self.path, '*' }
     end
-  
+
     def down
-      self.path = File.join path, '**'
+      @path = File.join path, '**'
+      @files = nil
       self
     end
 
     # Get a specific level down
     def level(n=1)
-      n.times { self.path = File.join path, '*' }
+      n.times { @path = File.join self.path, '*' }
+      @files = nil
       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
+      File.rm_rf path
     end
 
     def inspect
@@ -124,40 +137,17 @@ module Chitin
       false
     end
   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, :<<
+module Kernel
+  def D(path); Chitin::Directory.new path; end
+  def F(path); Chitin::FileObject.new path; end
+  def S(path); Chitin::Symlink.new path; end
 
-    def >(executable)
-      executable[:in=, self]
-      executable
-    end
+  alias_method :d, :D
+  alias_method :f, :F
+  alias_method :s, :S
 
-    def close
-      true
-    end
-  end
+  NULLIN = NULLOUT = NULLERR = File.open File::NULL
 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/session.rb

@@ -80,6 +80,20 @@ module Chitin
     # THIS METHOD WILL POSSIBLY RETURN NIL!!!!!
     # So it can return a string or nil. Remember that, folks.
     def read
+      # find out the column (1-indexed) that will next be printed
+      # if it's NOT 1, then something was printed, and we want to insert
+      # a newline
+      a = nil
+      STDIN.raw do
+        print "\e[6n"
+        a = STDIN.gets 'R'
+      end
+
+      if a.chomp('R').split(';').last != '1'
+        puts
+        puts "(no trailing newline)"
+      end
+
       inp = @editor.readline @sandbox.prompt
   
   
@@ -97,21 +111,32 @@ module Chitin
       @sandbox.evaluate val
     end
   
-    def shell_command?(res)
-      res.is_a?(Executable) || (res.is_a?(Pipe) && res[:returning] != :ruby)
+    def returning_ruby?(res)
+      # 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).
+      return true unless Runnable === res
+
+      res[:returning] == :ruby &&
+        (res[:out] == nil ||
+        res[:out].stat == STDOUT.stat)
+    end
+
+    def all_not_ruby?(res)
+      if Array === res
+         !res.empty? && res.map {|r| not returning_ruby? r }.all?
+      else
+        not returning_ruby? res
+      end
     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)
+      if all_not_ruby? res
+        res = [res] unless Array === res
   
         res.each do |res|
           # set up the inputs and outputs
@@ -125,30 +150,19 @@ module Chitin
   
       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
+        if Pipe === res || StringMethod === 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]
-  
-          # 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
+
+          val = res[:raw_run]
+        else
+          val = res
         end
   
+        txt = @config.post_processing[:color].call val.inspect
+        puts " => #{txt}"
       end
   
       # Run all the post_processing stuff

data/lib/chitin/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chitin
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-25 00:00:00.000000000 Z
+date: 2012-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: wirble
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: coderay
   requirement: !ruby/object:Gem::Requirement
@@ -84,6 +84,7 @@ files:
 - lib/chitin/commands/pipe.rb
 - lib/chitin/commands/ruby.rb
 - lib/chitin/commands/runnable.rb
+- lib/chitin/core_ext/class.rb
 - lib/chitin/core_ext/coolline.rb
 - lib/chitin/core_ext/io.rb
 - lib/chitin/core_ext/object.rb