chitin 1.0.1

data/ANNOUNCEMENT

@@ -0,0 +1,67 @@
+chitin
+========================
+by Ari Brown
+http://bitbucket.org/seydar/chitin
+
+Hai everybahdy
+
+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.
+
+== 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.
+
+== 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
+  * A much more programmatic shell
+  * Prevents against accidental `rm -rf /usr /local/bin` like that one thing
+    we all saw on Reddit.
+  * 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.
+
+Anyways, I really like it and find it useful. I much prefer it over Bash. I
+encourage you all to take a quick look at the README and maybe try it out
+yourselves.
+
+- Ari/seydar
+ari@aribrown.com
+

data/README

@@ -0,0 +1,414 @@
+== Quick Intro
+
+Rules of the road:
+
+  * Everything you enter is pure Ruby. When you type, you are typing pure Ruby.
+  * When in doubt of what something is: use #inspect by doing command[:inspect]
+  * #[] allows you to run methods of Executables, Pipes, and StringMethods
+    without accidentally running them.
+
+Sample commands and shizzle:
+
+  ari: ~/src/chitin % ls
+  ari: ~/src/chitin % 5 + 4
+  ari: ~/src/chitin % ll = ls -:al
+  ari: ~/src/chitin % hg.stat
+  ari: ~/src/chitin % hg.stat | wc | L {|i| i.size }
+  ari: ~/src/chitin % hg.stat | wc | L {|i| i.size } > '/tmp/test.out'
+  ari: ~/src/chitin % 44 - 2
+  ari: ~/src/chitin % _ + 5
+  ari: ~/src/chitin % wget "http://bigbad.evils.in
+  ari: ~/src/chitin % _ # run the same command again
+
+Look! Thanks to Mon_Ouie, it even has syntax highlighting on the line as you
+type! Hooray! Thank you, monsieur!
+
+For the most part, you can just use chitin as you would bash or any other
+shell.
+
+Why should you use Chitin?
+
+  * You can do simple arithmatic on the command line without having to switch
+    interfaces.
+  * The power of Ruby in a shell
+  * The command utility of a shell in Ruby
+  * No underlying shell usage
+  * 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
+  * 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.
+
+== The Library
+
+Buckle up, kids:
+
+  include Chitin
+
+Real simply, here's how you create a reference to a file with Chitin:
+
+  f = FileObject.new "/bin/ls"
+  f = F "/bin/ls"
+
+and a directory:
+
+  d = Directory.new "/bin"
+  d = D "/bin"
+
+Which is sweet and all, but you kinda need read and write priveleges in order
+to read and write to it. And if you're writing to /bin/ls, you're a bad person.
+
+So we can make it an executable really easily:
+
+  f = Executable.new "/bin/ls"
+
+By default, it reads and writes from and to, respectively, empty pipes.
+So to make it work in a standard manner, we need to set it up to use STDIN,
+STDOUT, and STDERR.
+
+  f.in.reopen  STDIN  # f.in is the input to f
+  f.out.reopen STDOUT # f.out is the output of f
+  f.err.reopen STDERR # f.err is the error of f
+
+We can easily run this:
+
+  f.run
+
+SWEET!
+
+A more complicated example of "cat /tmp/cool | wc -l":
+
+  f = Executable.new "/bin/cat", "/tmp/cool"
+  g = Executable.new "/bin/wc", "-l"
+
+Now we link them together (something like f | g)
+
+  g.in.reopen f.out
+
+And make the overall input and output visible to us
+
+  f.in.reopen  STDIN
+  g.out.reopen STDOUT
+
+and run them
+
+  f.run # since these are asynchronous
+  g.run # this seems like an ok thing to do
+
+That's a lot of work, though. Luckily, we can simplify it all:
+
+  STDIN > f | g > STDOUT
+
+What's that? You have another function called h?
+
+  h = Executable.new "/bin/cat"
+  pipe = STDIN > f | g | h > STDOUT
+
+And then you can run the pipe simply:
+
+  pipe.run
+
+Easy peasy, right? But what if you want to run the exact same command again?
+No worries:
+
+  pipe.run
+
+It automatically resets itself internally after being run.
+
+You can even use ruby code:
+
+  STDIN > f | gsub(/asdf/, "LAWL") > STDOUT
+
+And you can chain it simply:
+
+  STDIN > f | gsub(/asdf/, "LAWL").chomp > STDOUT
+
+You can even set up a pipe to return a random ruby object of your choice:
+
+  STDIN > f | split.size > STDOUT
+
+Although you have to run it with `pipe.raw_run`.
+
+If you have your own method and you want to take the result of something as an
+input, you can use a special proc to make it happen:
+
+  STDIN > f | L {|i| my_method(i) } > STDOUT
+
+And let's say that you want it all into a file. No problemo, broski.
+
+  STDIN > f | L {|i| my_method(i) } > '/tmp/lolwut'
+
+Dis ish goes both ways:
+
+  '/tmp/my_input' > f | L {|i| my_method(i) } > '/tmp/lolwut'
+
+SILENCE ALLLLLLLLLLLLLLLLLLLL
+
+  NULLIN > f | L {|i| my_method(i) } > NULLOUT > NULLERR
+
+Git on mah level, son.
+
+== The Shell
+
+Chitin is such named because it is the material that comprises the exoskeleton
+shells of insects. Yes, I know insects suck, but chitin is a pretty cool word,
+especially when you learn that it's pronounced chitin and not chitin.
+
+By default, chitin gives you a funky prompt that's big like yo mamma. The
+reason the default prompt is so AWESOME is so that it doesn't look identical
+to my bash prompt (leading me to get confused) but still provides useful
+information. Before we continue our tutorial, let's change that. Add the
+following bit of code to ~/.chitinrc
+
+  def prompt
+    "#{ENV['USER']}: #{short_pwd} % "
+  end
+
+1337. Well done! You've been promoted to tenderfoot. I'm proud of you.
+
+So now let's get going with this thang. Try out some random math equation:
+
+  ari: ~/src/chitin % 4 + 5
+   => 9
+  ari: ~/src/chitin % (1 + 3 + 4  +65 + 7 +345) / 23
+   => 18.4782608695652
+
+NB: integer division is off by default because it sucks and always has sucked.
+If I'm cranking out some quick maths, I don't want to deal with the fact that
+3/4 = 0. NIQUE LA POLICE WOOT WOOT!!!!!
+
+So ladida, you're doing some math, this could be IRB with a few changes.
+HOLY BATMAN! LOOK AT THAT SHIZNIZZLE YOU JUST DID!!! Oh, you mean this bit?
+
+  ari: ~/src/chitin % ls
+  NOTES   README  TODO    bin     lib
+
+Yeah, that's right. We just ran a command. And guess what? We didn't have to
+start a shell underneath to get it to work! We also didn't use any system
+calls because that would be hell to get right for every system. Though it
+might be neat for a future version. Note to self...
+
+But that's not all! Let's make ruby do some heavy lifting for us:
+
+  ari: ~/src/chitin % ls | L {|s| s.split }
+   => ["NOTES", "README", "TODO", "bin", "lib"]
+
+Chyeah son, it even returned us a ruby object.
+
+What Chitin as a shell does is it automatically does the STDIN > ... > STDOUT
+boilerplate that you saw in the first section. It also automagically runs your
+pipe, calling #run in the general case and #raw_run if it's supposed to return
+ruby.
+
+To earn your second class rank, you need to do a few things. First, you must
+demonstrate proficiency with the bowline knot and clove hitch. These are just
+good life skillz. Second, you must solve a problem for "your friend Jimmy".
+
+Jimmmy has a pokemon folder on his computer that he doesn't want his dad to see.
+Unfortunately, Jimmy doesn't know about cryptography and wants to give you
+(hah, as if you and Jimmy aren't the same person) a task to solve with Chitin.
+Help him hide his pokemon folder from his dad who likes to cd and ls around!
+
+  ari: ~/src/chitin % ls
+  NOTES   POKEMON    README  TODO    bin     lib
+  ari: ~/src/chitin % ls | L {|s| a = s.gsub /pokemon/i, "digimon"} | cat
+  NOTES
+  digimon
+  README
+  TODO
+  bin
+  lib
+  ari: ~/src/chitin % def ls; raw_command('/bin/ls') | L {|s| s.gsub /pokemon/i, "digimon" } | cat; end
+   => nil
+  ari: ~/src/chitin % ls
+  NOTES
+  digimon
+  README
+  TODO
+  bin
+  lib
+
+Save that in you ~/.chitinrc and your dad won't find out about your pokemon
+collection.
+
+Congratulations! You are now a second class scout!
+
+Alright, hotshot. Let's see if you've got what it takes to be first class.
+Your boss rolls into your office and asks to speak with you. You know it
+couldn't be about your porn collection because you fixed that in attaining
+second class; now he just thinks you're a nerd for having a 40GB digimon
+collection. So bossman rolls in and says "Yo dawg, delete every file and folder
+in a directory." Naturally, he decides not to open up a GUI and do that himself
+using the wonders of modern technology (the mouse). You look that cat dead in
+the eye and say "YES SIR LET'S DO DIS THANG!"
+
+  ari: ~/src/chitin % Dir['pokemon/*'].each {|f| rm f }
+
+But since I'm a sick bastard, I showed you code that DOES NOT WORK. Before I
+get into why it doesn't work, lemme show you code that DOES work, first:
+
+  ari: ~/src/chitin % Dir['pokemon/*'].map {|f| rm f}
+
+The difference here is that we used #map instead of #each. Why?
+
+#each is a function that returns self after running the block. Since an
+executable is just a Ruby object that is only run when told to, those blocks
+will never run the code you want. In order to run the code, we use #map to
+return the executables we want to run in an array. Chitin knows that whenever
+it sees an array of executables, its job is to execute them.
+
+But let's get back to the original problem, which was removing a buttload of
+files:
+
+  ari: ~/src/chitin % rm *Dir['pokemon/*']
+
+The built-in Ruby * (glob) operator enables us to do batch functions as an
+afterthought. It is like `rm "file1", "file2", ...`.
+
+Sweet deal brah, you're a second class scout. To become a first class scout,
+you need to install something. Luckily, Rosy the Nosy Neighbor from down the
+street (guess who just watch "Trapped in the Closet" -- all fucking 23 videos)
+wants you to install this C program that she wrote so she can monitor your
+keystrokes. Here comes you to the rescue! OH MAN that rhymed. Time to give
+up 'gramming and move to lyrical wordsmithing.
+
+First, you gotsta download the codez:
+
+  ari: ~/src/chitin % wget "http://supersecret.com/rosys_stuff.tar.gz
+
+Simple enough, you're just running the `wget` command. Now, unzip it to remove
+it from its archived format. Use tab completion to make your life simpler! Or
+not...
+
+  ari: ~/src/chitin % tar.zxf "rosys_stuff.tar.gz"
+
+Easy there, cowboy. You have no idea what Rosy the Asshole just sent you.
+Let's try it again except THIS time, use the "v" flag for "tar".
+
+  ari: ~/src/chitin % rm -:rf, "rosys_stuff
+  ari: ~/src/chitin % tar.zxvf "rosys_stuff.tar.gz"
+
+So here we learned a few things about Chitin and how it plays well with 40
+fucking years of bash-style syntax and history. Most obviously, -:rf takes
+a symbol and translates it into '-rf'. These three are all equal:
+
+  -:rf == -'rf' == '-rf'
+
+You want two dashes? Sweet deal brah.
+
+  --:rf == --'rf == -'-rf' == '--rf'
+
+Next in the commands, we use tar. But we don't just run tar. We run tar.zxvf.
+tar refers to the command itself, and then calling any methods on it send the
+method name directly to the executable. Thus, 'tar.zxvf' becomes 'tar zxvf'. We
+do this here because tar does NOT want any dashes.
+
+So back to the installation process:
+
+  ari: ~/src/chitin % here 'configure', :prefix => '/Users/ari/local'
+  ari: ~/src/chitin % make & make.install
+
+`here` is the method we use to refer to an executable file relative to the
+current directory. We're using hash notation in configure to automatically
+prepend two dashes to 'prefix' ('--prefix'); the whole line is translated
+as "./configure --prefix /Users/ari/local". We're also using the #& operator
+to do each command only if the previous one succeeds.
+
+In lieu of using `here`, which can understandably get a little tedious, we
+can do two other things:
+
+  ari: ~/src/chitin % raw_exec 'configure', :prefix => '/Users/ari/local
+
+And if you didn't want to include any arguments:
+
+  ari: ~/src/chitin % '.'/'configure'
+
+For the second one using String#/, it can't take any arguments because
+otherwise it wouldn't be valid Ruby. I'm still trying to figure out a better
+way to make use of it.
+
+So now that we have this all, let's try archiving it all up again.
+
+  ari: ~/src/chitin % tar.zcf 'compiled.tar.gz' => 'rosys_stuff'
+
+Much better.
+
+== Color Guard: Working with Flags
+
+Here's a quick synopsis of flag equivalencies from bash-style flags to Chitin.
+The first on the left is the bash, and everything else is Chitin:
+
+  -h          == -:h == -'h' == '-h'
+  -f file     == :f => file
+  -help       == -:help ==  -'help' == '-help'
+  --d         == --:h == --'h' == '--h'
+  --pref file == :pref => file
+
+You should be able to get the idea after that. The important things to note
+are how hashes are treated. If the key is one character long, it gets one dash.
+If the key is two or more characters long, it gets two dashes. This makes
+dealing with Java programs really fucking annoying.
+
+== String Methods
+
+One of the points of using Ruby in a shell is that you can use Ruby. For
+instance:
+
+  ari: ~/src/chitin % ll | split("\n")
+
+However, what if there's an executable on your path entitled "split"? Then
+the executable would be the one to be run. However, I really, really, really
+want to use a few String methods such as #gsub and #split regardless of whether
+there is an executable named as such. So, there's the Kernel::string_method
+function that takes a string method and makes it a PRIORITY method. This means
+that the Ruby method will take precedence over any executables found.
+
+The string methods which take precedence over executables are:
+
+  gsub
+  split
+  size
+  pack
+  unpack
+
+== Globbing: Globins and Hobglobins
+
+Globbing is simple in Chitin: there is none. However, that's ok because
+globbing is a really really cheap hack. So here's what Chitin offers in its
+stead:
+
+  ari: ~/src/chitin % D('.').map {|f| echo f } # D stands for Directory
+  ari: ~/src/chitin % all.map {|f| echo f }    # all is an alias to D('.')
+  ari: ~/src/chitin % echo *all                # Ruby's natural glob!
+
+Now, all and D('.') will only get the files and directories in the current
+directory. What if you wanted to see just how far the rabbit hole went?
+
+  ari: ~/src/chitin % all.down.map {|f| echo f }
+  ari: ~/src/chitin % echo *all.down
+
+#down will go from the directory it's called on allllll the way down to
+Davey Jones' locker.
+
+== Kewl Features
+
+Did you know?
+
+  * A FULL RUBY INTERPRETER!
+  * Tab completion that respects spaces in strings!
+  * Bashes' ESC-. to place the last argument!
+  * Syntax highlighting as you type!
+  * ^q quotes the word just behind your cursor
+  * I think this train might ACTUALLY get to Chicago on time!
+
+== Bugs
+
+Coolline deletes and reprints the line with every character you type. This is
+great! We like this because it means we get syntax highlighting as we type.
+We don't like this, however, because it means that if a program prints output
+without a trailing newline, the last line of the output will be cut off by
+chitin as soon as you start typing :(
+

data/TODO

@@ -0,0 +1,32 @@
+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
+
+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?
+

data/bin/chitin

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+# fuck, this isn't my method. i don't know where i got it. please don't hate me!
+def follow_link(file)
+  file = File.expand_path(file)
+  while File.symlink?(file)
+    file = File.expand_path(File.readlink(file), File.dirname(file))
+  end
+  file
+end
+
+require File.join(File.dirname(follow_link(__FILE__)), "..", "lib", "chitin")
+
+FileUtils
+if ARGV[0]
+  rc = ARGV[0]
+else
+  FileUtils.touch File.expand_path('~/.chitinrc')
+  rc = File.expand_path('~/.chitinrc')
+end
+
+Chitin::Builtins.class_eval File.read(rc)
+
+SESSION = Chitin::Session.new Chitin::Builtins
+SESSION.start
+

data/chitin.gemspec

@@ -0,0 +1,31 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "chitin/version"
+
+Gem::Specification.new do |s|
+  # Metadata
+  s.name        = "chitin"
+  s.version     = Chitin::VERSION
+  s.authors     = ["Ari Brown"]
+  s.email       = ["ari@aribrown.com"]
+  s.homepage    = "http://bitbucket.org/seydar/chitin"
+  s.summary     = %q{A shell! In Ruby!}
+  s.description = <<DESC
+The point of Chitin is that you should be able to use Ruby in your shell. Bash
+is too old. Time for the new wave of shell environments.
+DESC
+
+  s.rubyforge_project = "chitin"
+
+  # Manifest
+  s.files         = `hg manifest`.split("\n")
+  s.executables   = ["chitin"]
+  s.require_paths = ["lib"]
+
+  # Dependencies
+  # 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 "coderay"
+end
+

data/chitinrc

@@ -0,0 +1,86 @@
+###########################
+# Place this in ~/.chitinrc
+# This is mine. Feel free to screw with this as you please.
+# - Ari Brown
+###########################
+include Math
+
+module Aliases
+  def src; cd "#{ENV['HOME']}/src"; end
+  def school; cd "/Users/ari/School/Fall '11/"; end
+  def idea; vim '/Users/ari/src/IDEAS'; end
+  def ideas; less '/Users/ari/src/IDEAS'; end
+  def vpython(*args)
+    Executable.new '/Library/Frameworks/Python.framework/Versions/2.7/bin/python', *args
+  end
+  def fixit; vim '/Users/ari/.chitinrc'; end
+  def ouvrez(*args)
+    Executable.new '/usr/bin/open', *args
+  end
+end
+include Aliases
+
+def normal_prompt
+  "#{ENV['USER'].cyan}: #{short_pwd.yellow} (... "
+end
+
+def prompt
+  normal_prompt
+end
+
+def relax
+  def prompt
+    normal_prompt
+  end
+end
+
+def focus(string)
+  @todo = string
+  def prompt
+    @todo = @todo.to_s
+    "[ #{@todo.red} #{'-' * (`tput cols`.to_i - 4 - @todo.red.size)}]\n" +
+    "[ #{short_pwd.light_cyan} ] "
+  end
+end
+
+pre_process do |val|
+  val = val.strip == '.'  ? 'exit' : val
+  val = val.strip == '..' ? 'cd ".."' : val
+end
+
+# Sample usage of pre_process and post_process.
+# This is taken from the lib/chitin/commands/builtins.rb
+#
+# pre_process do |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
+