walnut 0.0.1 → 0.1.0

data/Gemfile

@@ -4,6 +4,7 @@
 
 source 'https://rubygems.org'
 
-gemspec :development_group => :dev
+gem "rake", :group => [:test]
+gem "bacon", :group => [:test]
 
 # vim: set ts=4 sts=2 sw=2 et:

data/README.md

@@ -1,10 +1,13 @@
 walnut
 ======
 
-A gem for Ruby 1.9 which provides a simple, highly customizable shell.
+[![Build Status](https://travis-ci.org/noxgirl/walnut.png?branch=master)](https://travis-ci.org/noxgirl/walnut)
+
+_The crunchy shell building framework!_
 
 + [Homepage](http://git.io/walnutrb)
 + [Documentation](http://rdoc.info/github/noxgirl/walnut/)
++ [RubyGems](https://rubygems.org/gems/walnut)
 
 **_Please see_** the licensing terms in LICENSE.md. walnut is free, open-source
 software distributed under the permissive terms of the **MIT license**.

data/Rakefile

@@ -2,6 +2,45 @@
 # All rights reserved.
 # Distributed under the terms of the MIT license (see LICENSE.md).
 
-require 'bundler/gem_tasks'
+task :default => [:testing]
+task :gem     => [:default, :make_gem, :release_gem]
+
+# Turn off echoing
+verbose false
+
+desc 'Test the application.'
+task :testing do 
+  inc   = "-i lib"
+  tests = [ File.join(%w[ spec *spec.rb ]) ]
+  
+  tests.each do |t|
+    sh "bacon #{inc} #{t}"
+  end
+end
+
+desc 'Create a gem from the gemspec.'
+task :make_gem do
+  sh "gem build #{Dir["*.gemspec"].first}"
+end
+
+desc 'Install the gem.'
+task :install => :make_gem do
+  sh "gem install #{Dir["*.gem"].last}"
+end
+
+desc 'Push this release to RubyGems.'
+task :release_gem => :make_gem do
+  sh "gem push #{Dir["*.gem"].last}"
+end
+
+desc 'Run a sample'
+task :sample, :name do |t, args|
+  args.with_defaults(:name => nil)
+  if args[:name].nil?
+    puts Dir["sample/*.rb"].map {|x| x.chomp(".rb").sub(/sample\//, '').prepend "- " }
+  else
+    sh "ruby -I lib/ sample/#{args[:name]}.rb"
+  end
+end
 
 # vim: set ts=4 sts=2 sw=2 et:

data/docs/interfaces/Input.md

@@ -6,19 +6,19 @@ Synopsis
 
 Input drivers require elements which any IO object would generally mandate. 
 
-The essential ability to read, to write, and to test for an end of input.
+The essential ability to read, and to test for an end of input.
 
 Methods
 -------
 
 A basic input driver will require the following as a bare minimum:
 
-- read(size)         -- Read (size) number of characters from the input.
-- write(\*strings)   -- Write to the input.
+- read()             -- An alias for gets.
 - eof?()             -- Check for a closed stream.
-- puts(\*strings)    -- Write with appended newlines.
 - gets()             -- Read one line from the source.
 - close()            -- Close the stream.
 
 Driver Implementations
 ----------------------
+
+- Walnut::Input::Readline

data/docs/interfaces/Output.md

@@ -0,0 +1,19 @@
+Interface for Walnut Input Drivers
+==================================
+
+Synopsis
+--------
+
+The essential ability to write is the only requirement for an Output object.
+
+Methods
+-------
+
+A basic input driver will require the following as a bare minimum:
+
+- write(string)      -- Write (string) to the output stream.
+- puts(string)       -- Write (string) to the output stream with an appended newline character.
+
+Driver Implementations
+----------------------
+

data/lib/walnut.rb

@@ -4,6 +4,21 @@
 
 require 'walnut/version'
 require 'walnut/configuration'
+require 'walnut/events'
 require 'walnut/shell'
 
+module Walnut
+  def self.configure
+    yield Walnut.config if block_given?
+  end
+end
+
+# Set the default configuration
+Walnut.configure do |c|
+  c.input = Walnut::Configuration.new
+  c.input.prompt = ">> "
+  c.input.history = []
+  
+  c.output = Walnut::Configuration.new
+end
 # vim: set ts=4 sts=2 sw=2 et:

data/lib/walnut/{config.rb → configuration.rb}

@@ -1,12 +1,35 @@
 # Copyright (c) 2013, Autumn Perrault, Matthew Carey
 # All rights reserved.
 # Distributed under the terms of the MIT license (see LICENSE.md).
+require "ostruct"
 
 module Walnut
 
   # Dummy class to give a namespace to the configuration object.
   class Configuration < OpenStruct
     # Let's just do this to ensure that this has its own class
+
+    # Convenience for accessing keys
+    #
+    # @param [#to_s] key The key you are accessing
+    #
+    # @return [Object] The value of the key.
+    #
+    def [](key)
+      send(key.to_s)
+    end
+
+    # Convenience method to set keys
+    #
+    # @param [#to_s] key The key you will be assigning the value to.
+    # @param [Object] value The new value to assign to the key.
+    #
+    # @return [Object] The value you passed to assign to the key.
+    #
+    def []=(key, value)
+      send(key.to_s << "=", value)
+    end
+
   end
   
   # Make a globally accessible configuration that general configuration will go
@@ -25,6 +48,14 @@ module Walnut
     @walnut_global_configuration||=Configuration.new
   end
 
+  def self.[](key)
+    self.config.send(key)
+  end
+
+  def self.[]=(key, value)
+    self.config.send(key.to_s << "=", value)
+  end
+
 end
 
 # vim: set ts=4 sts=2 sw=2 et:

data/lib/walnut/events.rb

@@ -0,0 +1,85 @@
+# Copyright (c) 2013, Autumn Perrault, Matthew Carey
+# All rights reserved.
+# Distributed under the terms of the MIT license (see LICENSE.md).
+
+module Walnut
+
+  # Setup events in Walnut as {Walnut.ev}.
+  def self.ev
+   @walnut_events ||= Walnut::Events.new 
+  end
+
+  # The simple yet fundamental events system of walnut.
+  #
+  # @author noxgirl
+  #
+  # @!attribute [r] events
+  #   @return [Hash{String => Array<Array(Symbol, Proc)>}] The list of events.
+  #
+  # @!attribute [r] threads
+  #   @return [Hash{String => Array<Thread>}] A list of threads.
+  class Events
+
+    attr_reader :events, :threads
+    
+    # Produce a new events system.
+    def initialize
+      @events  = Hash.new
+    end
+
+    # Await an event, and upon its occurrence, execute a block of code. It
+    # cannot get much simpler than such.
+    #
+    # @param [Symbol] event The event for which to wait.
+    # @param [Symbol] hook The identity of this hook.
+    #
+    # @yield [...] The arguments which will be yielded to the block vary by
+    #   event. Consult with the {file:docs/Events.md events specification}.
+    def nut_catch(event, hook, &prc)
+      
+      # Create a collection in the events hash for this event if one does not
+      # already exist.
+      @events[event]  ||= []
+
+      # Append this hook.
+      @events[event] << [hook, prc]
+
+    end
+    
+    # Execute an event, and call all the blocks of code which are hooked onto it,
+    # if any, passing to each the provided arguments.
+    #
+    # @param [Symbol] event The event which to execute.
+    # @param [Array<>] args The arguments which to pass to each block. (splat)
+    def nut_throw(event, *args)
+      
+      # If a collection for this event exists, iterate through it.
+      if @events.include? event
+        
+        @events[event].each do |hook|
+            hook[1].call(*args)
+        end
+
+      end # if @events.include? event
+          
+    end
+
+    # Delete a hook from an event.
+    #
+    # @param [Symbol] event The event for which this hook is waiting.
+    # @param [Symbol] hook The hook.
+    def nut_smash(event, hook)
+      if @events.include? event
+        @events[event].each do |h| # iterate through the hooks
+          if h[0] == hook
+            @events[event].delete([h[0], h[1]]) and next
+          end
+        end
+      end # if @events.include? event
+    end
+
+  end # class Events
+
+end # module Walnut
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/walnut/input/readline.rb

@@ -0,0 +1,49 @@
+begin
+  require "readline"
+rescue LoadError
+end
+
+module Walnut
+
+  module Input
+    
+    # Readline input plugin
+    #
+    # Must implement #read, #gets, and #eof?
+    class Readline
+      
+      attr_reader :input_object
+
+      def initialize(parent)
+        @walnut       = parent
+        @input_object = ::Readline
+      end
+      
+      # Read a line from input
+      #
+      # @return [String,NilClass] A line read from the input, or nil if the user canceled the input with \C-d
+      #
+      # @note The instance variable @eof is set to nil when EOF has been reached, see #eof?
+      #
+      def gets
+        @eof = @input_object.readline(@walnut[:input].prompt||Walnut[:input].prompt, @walnut[:input].history||[])
+      end
+      
+      # Check if an EOF has been reached
+      #
+      # @return [TrueClass,FalseClass] 
+      def eof?
+        (@eof.nil?) ? true : false
+      end
+
+      alias read gets
+
+      def close
+        @eof = nil
+      end
+
+    end
+  
+  end
+
+end

data/lib/walnut/output/standard.rb

@@ -0,0 +1,47 @@
+# Copyright (c) 2013, Autumn Perrault, Matthew Carey
+# All rights reserved.
+# Distributed under the terms of the MIT license (see LICENSE.md).
+
+module Walnut
+  
+  module Output
+    
+    class Standard
+
+      # @note #output defaults to $stdout
+      attr_accessor :output
+
+      # Initialize an object
+      #
+      # @param [Walnut::Shell] parent The parent of this object.
+      #
+      def initialize(parent)
+        @walnut = parent
+        @output = $stdout
+      end
+
+      # Write a string to the output
+      #
+      # @param [#to_s] string The string that will be written to the output stream.
+      #
+      # @return [Numeric] The number of characters written to the stream.
+      def write(string)
+        @output.write(string.to_s)
+        string.to_s.length
+      end
+
+      # Write a string with a newline to the output.
+      #
+      # @see {Walnut::Output::Standard#write}
+      #
+      def puts(string)
+        write(string + "\n")
+      end
+
+    end
+  
+  end
+
+end
+
+# vim: set ts=4 sts=2 sw=2 et:

data/lib/walnut/shell.rb

@@ -8,16 +8,85 @@ module Walnut
   class Shell
 
     # Constructor.
-    def initialize
+    def initialize(&block)
+      # Set the default config to the global.
+      @config = Walnut.config.dup
+      
+      # Start with the global hooks.
+      events = Walnut.ev.dup
+      define_singleton_method(:ev) { events }
+
+      instance_exec(@config, &block) if block_given?
+      
     end
 
+
     # Configure the shell.
     def configure
 
-      yield Walnut.config if block_given?
+      yield @config if block_given?
+
+    end
+
+    # A shortcut to the configuration
+    #
+    # @param [#to_s] key The configuration key you are looking for
+    #
+    # @return [Object] The object that the configuration key points to
+    #
+    def [](key)
+      @config.send(key.to_s)
+    end
 
+    # A shortcut to assign configuration values.
+    #
+    # @param [#to_s] key The key you are looking up in the configuration.
+    # @param [Object] value The new value for the key in the configuration.
+    #
+    # @return [Object] The value passed to be assigned.
+    #
+    def []=(key,value)
+      @config.send(key.to_s << "=", value)
     end
 
+    # Begin a session, crack being a cutesy way to allude to the name of the project.
+    #
+    # @param [IO] input This object should at least implement the interface for Input.
+    # @param [IO] output This object should at least implement the interface for Output.
+    # 
+    # @return [Walnut::Shell] Return self.
+    #
+    def crack(input=@config[:input].interface, output=@config[:output].interface)
+      
+      if input  then @config[:input].interface  = input  end
+      if output then @config[:output].interface = output end
+
+      input  ||= Walnut[:input].interface
+      output ||= Walnut[:output].interface
+      ev.nut_throw :cracking
+      loop do
+        ev.nut_throw :before_read
+        text = input.gets
+        
+        if input.eof?
+          ev.nut_throw :eof, self
+
+          # This has to be unset in a hook to recover from the EOF
+          break if input.eof?
+        end
+        
+        ev.nut_throw :after_read, text
+        
+        ev.nut_throw :before_parse, text 
+        ast = nil #Parse -- ast == Abstract Syntax Tree. This is basically dependant on how the parser handles it.
+                  #      -- There is no definite interface for this because of the vast differences in parsers/lexers.
+        ev.nut_throw :after_parse, ast
+      end
+
+      # Cute after session hook name.
+      Walnut.ev.nut_throw :scrambled
+    end
+    
   end # class Shell
 
 end # module Walnut

data/lib/walnut/version.rb

@@ -3,7 +3,7 @@
 # Distributed under the terms of the MIT license (see LICENSE.md).
 
 module Walnut
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end
 
 # vim: set ts=4 sts=2 sw=2 et:

data/sample/echo.rb

@@ -0,0 +1,28 @@
+require "walnut"
+require "walnut/input/readline"
+require "walnut/output/standard"
+
+shell = Walnut::Shell.new do |conf|
+  conf.input.prompt     = "echo> "
+  conf.input.interface  = Walnut::Input::Readline.new(self)
+
+  conf.output.interface = Walnut::Output::Standard.new(self)
+
+end
+
+shell.ev.nut_catch(:cracking, :banner) do
+  shell[:output].interface.write <<EOF
+  Welcome to Walnut's first example `echo'! To exit the echoing session, press Ctrl-d or whatever your system
+  recognizes as "END OF INPUT".
+EOF
+end
+
+shell.ev.nut_catch(:after_read, :echo) do |string|
+  shell[:output].interface.puts string
+end
+
+shell.ev.nut_catch(:after_read, :add_history) do |string|
+  shell[:input].history << string
+end
+
+shell.crack

data/sample/repl.rb

@@ -0,0 +1,63 @@
+require "walnut"
+require "walnut/input/readline"
+require "walnut/output/standard"
+require "coderay"
+require "pp"
+
+shell = Walnut::Shell.new do |conf|
+  conf.input.interface = Walnut::Input::Readline.new(self)
+
+  conf.repl = Walnut::Configuration.new
+  conf.repl.depth  = 0
+  conf.repl.lineno = 0
+  conf.repl.valid  = false
+  conf.repl.buffer = ""
+
+  conf.output.interface = Walnut::Output::Standard.new(self)
+end
+
+shell.ev.nut_catch(:before_read, :prompt_line_no) do
+  if shell[:repl].depth == 0
+    shell[:input].prompt = "[%i] (walnut)> " % shell[:repl].lineno
+  else
+    shell[:input].prompt = "[%i] (walnut) *#{"  "*shell[:repl].depth}#{" "}" % shell[:repl].lineno
+  end
+end
+
+shell.ev.nut_catch(:after_read, :push_to_buffer) do |text|
+  shell[:repl].buffer << text + "\n"
+end
+
+shell.ev.nut_catch(:after_read, :push_to_history) do |text|
+  shell[:input].history << text
+end
+
+shell.ev.nut_catch(:after_read, :validate_code) do |text|
+  begin
+    catch :valid do
+      eval "BEGIN { throw :valid }\n#{shell[:repl].buffer}"
+    end
+    shell[:repl].valid = true
+  rescue SyntaxError
+    shell[:repl].valid = false
+  end
+end
+
+shell.ev.nut_catch(:after_read, :transform_line) do |text|
+  shell[:output].interface.write("\e[s\e[A#{shell[:input].prompt}#{CodeRay.scan(text, :ruby).term}\e8")
+end
+  
+shell.ev.nut_catch(:after_read, :evaluate) do |text|
+  if shell[:repl].valid
+    shell[:output].interface.write("=> #{CodeRay.scan((eval shell[:repl].buffer, TOPLEVEL_BINDING).pretty_inspect, :ruby).term}".concat("\n").sub(/\n+$/, "\n"))
+    shell[:repl].valid = false
+    shell[:repl].buffer = ""
+  end
+end
+
+shell.ev.nut_catch(:after_read, :increase_line) do |text|
+  if shell[:repl].buffer == ""
+    shell[:repl].lineno += 1
+  end
+end
+shell.crack

data/spec/events_spec.rb

@@ -0,0 +1,55 @@
+# Copyright (c) 2013, Autumn Perrault, Matthew Carey
+# All rights reserved.
+# Distributed under the terms of the MIT license (see LICENSE.md).
+require(File.expand_path('../helper.rb', __FILE__))
+
+require 'walnut'
+
+describe 'Walnut::Events' do
+
+  @events = Walnut::Events.new
+
+  it 'should create a hook with #nut_catch' do
+    @events.nut_catch(:foo, :fooness) { nil }.should.not.equal nil
+  end
+
+  it 'should execute an event with #nut_throw' do
+    @fail = true
+    @events.nut_catch(:rawr, :nyan) { @fail = false }
+    @events.nut_throw(:rawr)
+    sleep 0.1
+    @fail.should.not.be.true
+  end
+
+  it 'should destroy a hook with #nut_smash' do
+    @succeed = true
+    @events.nut_catch(:meow, :moo) { @succeed = false }
+    @events.nut_smash(:meow, :moo)
+    @events.nut_throw(:meow)
+    @succeed.should.be.true
+  end
+
+  it 'should separate events based on how and where they were added' do
+    @result1 = ""
+    @result2 = false
+    @result3 = false
+    
+    Walnut.ev.nut_catch(:im_a, :global_gnu) { @result1 << "gnu" }
+    
+    shell1 = Walnut::Shell.new
+    shell2 = Walnut::Shell.new
+    
+    shell1.ev.nut_catch(:gnu, :local_gnu) { @result2 = :open_source }
+    shell2.ev.nut_catch(:gnu, :local_gnu) { @result3 = :not_unix }
+    
+    [shell1, shell2 ].each do |s| 
+      [:gnu, :im_a].each {|n| s.ev.nut_throw(n) }
+    end
+
+    @result1.should == "gnugnu"
+    @result2.should == :open_source
+    @result3.should == :not_unix
+  end
+end
+
+# vim: set ts=4 sts=2 sw=2 et:

data/spec/helper.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2013, Autumn Perrault, Matthew Carey
+# All rights reserved.
+# Distributed under the terms of the MIT license (see LICENSE.md).
+
+require 'bacon'
+
+# vim: set ts=4 sts=2 sw=2 et:

data/spec/input_spec.rb

@@ -0,0 +1,46 @@
+$:.unshift File.join [File.expand_path(File.dirname __FILE__), "../lib"]
+
+require "walnut"
+require "walnut/input/readline"
+require "stringio"
+require "tempfile"
+
+INPUT_STRING = "Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo\n"
+
+describe "Walnut Readline Input" do
+  
+  @walnut = Walnut::Shell.new
+  @walnut.configure do |c|
+    c.input = Walnut::Configuration.new
+    c.input.prompt = ">>> "
+  end
+
+  before do
+    File.open(".walnut_test.txt", "w") {|f| f.write INPUT_STRING }
+    @input  = Walnut::Input::Readline.new(@walnut)
+    @input.input_object.input = File.open(".walnut_test.txt", "r")
+    @input.input_object.output = File.open(".walnut_output.txt", "w+")
+  end
+
+  it "implements the read and gets function in the same manner" do
+    @input.gets.should == INPUT_STRING.chomp
+  end
+
+  it "should output a prompt based on the provided configuration" do
+   @input.gets
+    File.read(".walnut_output.txt").should == (@walnut[:input].prompt + INPUT_STRING)
+  end
+
+  it "should use the default prompt if there is no instance value for a prompt" do
+    @walnut[:input].prompt = false
+    @input.gets 
+    File.read(".walnut_output.txt").should == (Walnut[:input].prompt + INPUT_STRING)
+  end
+
+  after do
+    @input.input_object.input = STDIN
+    @input.input_object.output = STDOUT
+    File.unlink(".walnut_test.txt", ".walnut_output.txt")
+  end
+
+end

data/spec/output_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+$:.unshift File.expand_path(File.dirname __FILE__) << "../lib"
+
+require "walnut"
+require "walnut/output/standard"
+
+describe "Walnut Output Standard plugin" do
+
+  @output = Walnut::Output::Standard.new(Walnut::Shell.new)
+
+  it "writes to the stream based on the object in #output" do
+    string1, string2 = "", ""
+    string_io1, string_io2 = StringIO.new(string1), StringIO.new(string2)
+    
+    # Set up a StringIO to recieve
+    @output.output = string_io1
+    @output.puts "I'm a gnu!"
+
+    # Set up a different StringIO to recieve
+    @output.output = string_io2
+    @output.puts "Soy un ñu!"
+
+    # If everything worked, the strings should be in their respective objects.
+    string1.should == "I'm a gnu!\n"
+    string2.should == "Soy un ñu!\n"
+  end
+
+  it "tells you how many characters you write to the stream" do
+    string1 = "PNEUMONOULTRAMICROSCOPICSILICOVOLCANOCONIOSIS"
+    string2 = "HEPATICOCHOLANGIOCHOLECYSTENTEROSTOMIES"
+
+    string_io = StringIO.new("")
+
+    @output.output = string_io
+
+    @output.write(string1).should == string1.length
+    @output.puts(string2).should == (string2.length+1)
+  end
+
+end

data/walnut.gemspec

@@ -15,11 +15,11 @@ Gem::Specification.new do |gem|
   
   gem.authors       = ['Autumn Perrault', 'Matthew Carey']
   gem.email         = ['xoeverlux@gmail.com', 'matthew.b.carey@gmail.com']
-  gem.summary       = 'A simple shell for Ruby 1.9.'
+  gem.summary       = 'The crunchy shell building framework.'
   gem.description   = 'A simple, highly customizable shell for Ruby 1.9.'
   gem.homepage      = 'http://git.io/walnutrb'
 
-  files             = `git ls-files`.split($/); files.delete('.template.rb')
+  files             = `git ls-files`.split($/); %w{.template.rb .travis.yml .gitignore}.each {|x| files.delete(x) }
   gem.files         = files
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ['lib']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: walnut
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-04 00:00:00.000000000 Z
+date: 2013-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bacon
@@ -42,10 +42,20 @@ files:
 - README.md
 - Rakefile
 - docs/interfaces/Input.md
+- docs/interfaces/Output.md
 - lib/walnut.rb
-- lib/walnut/config.rb
+- lib/walnut/configuration.rb
+- lib/walnut/events.rb
+- lib/walnut/input/readline.rb
+- lib/walnut/output/standard.rb
 - lib/walnut/shell.rb
 - lib/walnut/version.rb
+- sample/echo.rb
+- sample/repl.rb
+- spec/events_spec.rb
+- spec/helper.rb
+- spec/input_spec.rb
+- spec/output_spec.rb
 - walnut.gemspec
 homepage: http://git.io/walnutrb
 licenses: []
@@ -70,6 +80,10 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: A simple shell for Ruby 1.9.
-test_files: []
+summary: The crunchy shell building framework.
+test_files:
+- spec/events_spec.rb
+- spec/helper.rb
+- spec/input_spec.rb
+- spec/output_spec.rb
 has_rdoc: