bus-scheme 0.6

data/COPYING

@@ -0,0 +1,25 @@
+Copyright (c) 2007, Phil Hagelberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+* Neither the name of Phil Hagelberg nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Manifest.txt

@@ -0,0 +1,14 @@
+COPYING
+Manifest.txt
+README.txt
+Rakefile
+bin/bus
+lib/array_extensions.rb
+lib/bus_scheme.rb
+lib/eval.rb
+lib/object_extensions.rb
+lib/parser.rb
+test/foo.scm
+test/test_eval.rb
+test/test_helper.rb
+test/test_parser.rb

data/README.txt

@@ -0,0 +1,63 @@
+Bus Scheme
+    by Phil Hagelberg (c) 2007
+    http://bus-scheme.rubyforge.org
+
+== Description
+
+Bus Scheme is a Scheme written in Ruby, but implemented on the bus!
+Every programmer must implement Scheme as a rite of passage; this is
+mine. Note that all the implementation of Bus Scheme must be written
+while on a bus. Documentation, tests, and administrivia may be
+accomplished elsewhere, but all actual implementation code is strictly
+bus-driven. Patches are welcome as long as they were written while
+riding a bus. (If your daily commute does not involve a bus but you
+want to submit a patch, we may be able to work something out regarding
+code written on trains, ferries, or perhaps even carpool lanes.) Bus
+Scheme is primarily a toy; using it for anything serious is (right
+now) ill-advised.
+
+Bus Scheme aims for general Scheme usefulness optimized for learning
+and fun. It's not targeting R5RS or anything like that.
+
+== Install
+
+* sudo gem install bus-scheme
+
+For the source:
+
+* git clone git://git.caboo.se/bus_scheme.git
+
+== Usage
+
+$ bus # drop into a repl
+
+$ bus -e "(do some stuff)"
+
+$ bus foo.scm # load a file -- todo
+
+== Todo
+
+Bus Scheme is currently missing huge pieces of functionality:
+
+* lexical scoping
+* closures
+* loading files
+* eval input from command line, stdin
+* parse cons cells
+* parse character literals
+* numeric tower?
+
+Failing tests for most of these are already included (commented out,
+mostly) in the relevant test files.
+
+== Requirements
+
+Bus Scheme should run on (at least) Ruby 1.8, Ruby 1.9, and Rubinius.
+
+== Bonus Fact
+
+I haven't actually used a real Scheme yet. Everything I know about it
+I've gathered from reading The Little Schemer, watching the Structure
+and Interpretation of Computer Programs videos, and reading lots about
+Common Lisp and Emacs Lisp. If there are huge gaping flaws in the
+implementation, this is likely to be why.

data/Rakefile

@@ -0,0 +1,25 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/bus_scheme.rb'
+require 'rake/testtask'
+
+Hoe.new('bus-scheme', BusScheme::VERSION) do |p|
+  p.rubyforge_name = 'bus-scheme'
+  p.author = 'Phil Hagelberg'
+  p.email = 'technomancy@gmail.com'
+  p.summary = 'Bus Scheme is a Scheme in Ruby, imlemented on the bus.'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.remote_rdoc_dir = ''
+end
+
+task :stats do
+  require 'code_statistics'
+  CodeStatistics.new(['lib'], ['Unit tests', 'test']).to_s
+end
+
+task :flog do
+  system "flog lib/*rb"
+end

data/bin/bus

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
+
+require 'bus_scheme'
+
+if ARGV.empty?
+  BusScheme.repl
+elsif ARGV.first == '-e' and ARGV.length == 2
+  puts BusScheme.eval_string(ARGV[1])
+elsif ARGV.length == 1 and File.exist?(ARGV.first) # must be a file
+  puts BusScheme.load(ARGV.first)
+else
+  puts "Bus Scheme: a scheme interpreter written on the bus.
+Usage: bus [file | -e \"form\"]
+  Invoking with no arguments enters a REPL
+  With one argument it loads that as a file
+  -e : evals a single form"
+  exit 1
+end

data/lib/array_extensions.rb

@@ -0,0 +1,19 @@
+class Array
+  # Lisp-style list access
+  def rest
+    self[1 .. -1]
+  end
+
+  alias_method :car, :first
+  alias_method :cdr, :rest
+
+  # Treat the array as a lambda and call it with given args
+  def call(*args)
+    BusScheme::eval_lambda(self, args)
+  end
+
+  # Simple predicate for convenience
+  def lambda?
+    first == :lambda
+  end
+end

data/lib/bus_scheme.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'readline'
+  require 'yaml'
+rescue LoadError
+end
+
+$LOAD_PATH << File.dirname(__FILE__)
+require 'object_extensions'
+require 'array_extensions'
+require 'parser'
+require 'eval'
+
+module BusScheme
+  class ParseError < StandardError; end
+  class EvalError < StandardError; end
+  class ArgumentError < StandardError; end
+
+  VERSION = "0.6"
+
+  PRIMITIVES = {
+    '#t'.intern => true, # :'#t' screws up emacs' ruby parser
+    '#f'.intern => false,
+
+    :+ => lambda { |*args| args.inject(0) { |sum, i| sum + i } },
+    :- => lambda { |x, y| x - y },
+    '/'.intern => lambda { |x, y| x / y },
+    :* => lambda { |*args| args.inject(1) { |product, i| product * i } },
+
+    :> => lambda { |x, y| x > y },
+    :< => lambda { |x, y| x < y },
+
+    :intern => lambda { |x| x.intern },
+    :concat => lambda { |x, y| x + y },
+    :substring => lambda { |x, from, to| x[from .. to] },
+
+    :exit => lambda { exit }, :quit => lambda { exit },
+  }
+
+  SPECIAL_FORMS = {
+    :quote => lambda { |arg| arg },
+    :if => lambda { |condition, yes, *no| eval_form(condition) ? eval_form(yes) : eval_form([:begin] + no) },
+    :begin => lambda { |*args| args.map{ |arg| eval_form(arg) }.last },
+    :set! => lambda { },
+    :lambda => lambda { |args, *form| [:lambda, args] + form },
+    :define => lambda { |sym, definition| BusScheme[sym] = eval_form(definition); sym },
+  }
+
+  SYMBOL_TABLE = {}.merge(PRIMITIVES).merge(SPECIAL_FORMS)
+  SCOPES = [SYMBOL_TABLE]
+  PROMPT = '> '
+
+  # symbol existence predicate
+  def self.in_scope?(symbol)
+    SCOPES.last.has_key?(symbol) or SCOPES.first.has_key?(symbol)
+  end
+
+  # symbol lookup
+  def self.[](symbol)
+    SCOPES.last[symbol] or SCOPES.first[symbol]
+  end
+
+  # symbol assignment to value
+  def self.[]=(symbol, value)
+    SCOPES.last[symbol] = value
+  end
+
+  # remove symbols from all scopes
+  def self.clear_symbols(*symbols)
+    SCOPES.map{ |scope| symbols.map{ |sym| scope.delete sym } }
+  end
+
+  # symbol special form predicate
+  def self.special_form?(symbol)
+    SPECIAL_FORMS.has_key?(symbol)
+  end
+
+  # Read-Eval-Print-Loop
+  def self.repl
+    loop do
+      begin
+        puts BusScheme.eval_string(Readline.readline(PROMPT))
+      rescue Interrupt
+        puts 'Type "(quit)" to leave Bus Scheme.'
+      end
+    end
+  end
+end

data/lib/eval.rb

@@ -0,0 +1,51 @@
+module BusScheme
+  class << self
+    # Parse a string, then eval the result
+    def eval_string(string)
+      eval_form(parse(string))
+    end
+
+    # Eval a form passed in as an array
+    def eval_form(form)
+      if form == []
+        nil
+      elsif form.is_a? Array
+        apply(form.first, *form.rest)
+      elsif form.is_a? Symbol
+        raise "Undefined symbol: #{form}" unless in_scope?(form)
+        BusScheme[form]
+      else
+        form
+      end
+    end
+
+    # Call a function with given args
+    def apply(function, *args)
+      args.map!{ |arg| eval_form(arg) } unless special_form?(function)
+
+      # refactor me
+      if function.is_a?(Array) and function.lambda?
+        function.call(*args)
+      else
+        raise "Undefined symbol: #{function}" unless in_scope?(function)
+        BusScheme[function].call(*args)
+      end
+    end
+
+    # All the super lambda magic happens (or fails to happen) here
+    def eval_lambda(lambda, args)
+      raise BusScheme::EvalError unless lambda.shift == :lambda
+
+      arg_list = lambda.shift
+      raise BusScheme::ArgumentError if !arg_list.is_a?(Array) or arg_list.length != args.length
+
+      SCOPES << {} # new scope
+      until arg_list.empty?
+        BusScheme[arg_list.shift] = args.shift
+      end
+
+      # using affect as a non-return-value-affecting callback
+      BusScheme[:begin].call(*lambda).affect { SCOPES.pop }
+    end
+  end
+end

data/lib/object_extensions.rb

@@ -0,0 +1,8 @@
+class Object
+  # Return self after evaling block
+  # see http://www.ruby-forum.com/topic/131340
+  def affect
+    yield self
+    return self
+  end
+end

data/lib/parser.rb

@@ -0,0 +1,69 @@
+module BusScheme
+  class << self
+    # Turn an input string into an S-expression
+    def parse(input)
+      parse_tokens tokenize(normalize_whitespace(input))
+    end
+
+    # Turn a list of tokens into a properly-nested S-expression
+    def parse_tokens(tokens)
+      token = tokens.shift
+      if token == :'('
+        parse_list(tokens)
+      else
+        raise BusScheme::ParseError unless tokens.empty?
+        token # atom
+      end
+    end
+
+    # Nest a list from a 1-dimensional list of tokens
+    def parse_list(tokens)
+      [].affect do |list|
+        while element = tokens.shift and element != :')'
+          if element == :'('
+            list << parse_list(tokens)
+          else
+            list << element
+          end
+        end
+      end
+    end
+
+    # Split an input string into lexically valid tokens
+    def tokenize(input)
+      [].affect do |tokens|
+        while token = pop_token(input)
+          tokens << token
+        end
+      end
+    end
+
+    # Take a token off the input string and return it
+    def pop_token(input)
+      token = case input
+              when /^ +/ # whitespace
+                input[0 ... 1] = ''
+                return pop_token(input)
+              when /^\(/ # open paren
+                :'('
+              when /^\)/ # closing paren
+                :')'
+              when /^(\d+)/ # positive integer
+                Regexp.last_match[1].to_i
+              when /^"(.*?)"/ # string
+                Regexp.last_match[1]
+              when /^([^ \)]+)/ # symbol
+                Regexp.last_match[1].intern
+              end
+      # compensate for quotation marks
+      length = token.is_a?(String) ? token.length + 2 : token.to_s.length
+      input[0 .. length - 1] = ''
+      return token
+    end
+
+    # Treat all whitespace in a string as spaces
+    def normalize_whitespace(string)
+      string && string.gsub(/\t/, ' ').gsub(/\n/, ' ').gsub(/ +/, ' ')
+    end
+  end
+end

data/test/foo.scm

@@ -0,0 +1 @@
+(define foo 3)

data/test/test_eval.rb

@@ -0,0 +1,158 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'test_helper'
+
+class BusSchemeEvalTest < Test::Unit::TestCase
+  def test_eval_empty_list
+    assert_evals_to nil, []
+  end
+
+  def test_eval_number
+    assert_evals_to 2, 2
+  end
+
+  def test_eval_symbol
+    eval "(define hi 13)"
+    assert_evals_to 13, :hi
+  end
+
+  def test_eval_string
+    assert_evals_to "hi", "\"hi\""
+  end
+
+  def test_eval_function_call
+    assert_evals_to 2, [:+, 1, 1]
+  end
+
+  def test_many_args_for_arithmetic
+    assert_evals_to 4, [:+, 1, 1, 1, 1]
+    assert_evals_to 2, [:*, 1, 2, 1, 1]
+  end
+
+  def test_arithmetic
+    assert_evals_to 2, [:'-', 4, 2]
+    assert_evals_to 2, [:'/', 4, 2]
+    assert_evals_to 2, [:'*', 1, 2]
+  end
+
+  def test_define
+    BusScheme.clear_symbols :foo
+    eval("(define foo 5)")
+    assert_equal 5, BusScheme[:foo]
+    eval("(define foo (quote (5 5 5))")
+    assert_evals_to [5, 5, 5], :foo
+  end
+
+  def test_define_returns_defined_term
+    assert_evals_to :foo, "(define foo 2)"
+    # can't use the eval convenience testing method since it assumes strings are unparsed
+    assert_equal 2, eval("foo")
+  end
+
+  def test_string_primitives
+    assert_evals_to :hi, [:intern, 'hi']
+    assert_evals_to 'helloworld', [:concat, 'hello', 'world']
+    assert_evals_to 'lo', [:substring, 'hello', 3, -1]
+  end
+
+  def test_booleans
+    assert_evals_to false, '#f'
+    assert_evals_to true, '#t'
+  end
+
+  def test_eval_quote
+    assert_evals_to [:'+', 2, 2], [:quote, [:'+', 2, 2]]
+  end
+
+  def test_quote
+    assert_evals_to :hi, [:quote, :hi]
+  end
+
+  def test_nested_arithmetic
+    assert_evals_to 6, [:+, 1, [:+, 1, [:*, 2, 2]]]
+  end
+
+  def test_blows_up_with_undefined_symbol
+    assert_raises(RuntimeError) { eval("undefined-symbol") }
+  end
+
+  def test_variable_substitution
+    eval "(define foo 7)"
+    assert_evals_to 7, :foo
+    assert_evals_to 21, [:*, 3, :foo]
+  end
+
+  def test_if
+    assert_evals_to 7, [:if, '#f'.intern, 3, 7]
+    assert_evals_to 3, [:if, [:>, 8, 2], 3, 7]
+  end
+
+  def test_begin
+    eval([:begin,
+          [:define, :foo, 779],
+          9])
+    assert_equal 779, BusScheme[:foo]
+  end
+
+  def test_set!
+    # i dunno... what does set! do? how's it different from define?
+  end
+
+  def test_simple_lambda
+    assert_equal [:lambda, [], [:+, 1, 1]], eval("(lambda () (+ 1 1))")
+    eval("(define foo (lambda () (+ 1 1)))")
+    assert_equal :lambda, BusScheme[:foo].first
+    assert_evals_to 2, [:foo]
+  end
+
+  def test_lambda_with_arg
+    eval("(define foo (lambda (x) (+ x 1)))")
+    assert_evals_to 2, [:foo, 1]
+  end
+
+  def test_eval_literal_lambda
+    assert_evals_to 4, "((lambda (x) (* x x)) 2)"
+  end
+
+  def test_lambda_with_incorrect_arity
+    eval("(define foo (lambda (x) (+ x 1)))")
+    assert_raises(BusScheme::ArgumentError) { assert_evals_to 2, [:foo, 1, 3] }
+  end
+
+  def test_lambda_args_dont_stay_in_scope
+    BusScheme.clear_symbols(:x, :foo)
+    eval("(define foo (lambda (x) (+ x 1)))")
+    assert !BusScheme.in_scope?(:x)
+    assert_evals_to 2, [:foo, 1]
+    assert !BusScheme.in_scope?(:x)
+  end
+
+  #   def test_lexical_scoping
+  #     assert_raises(BusScheme::EvalError) do
+  #       eval "???"
+  #     end
+  #   end
+
+  #   def test_lambda_closures
+  #     eval "(define foo (lambda (x) ((lambda (y) (+ x y)) (* x 2))))"
+  #     assert_evals_to 3, [:foo, 1]
+  #   end
+
+  #   def test_load_file
+  #     eval "(load \"#{File.dirname(__FILE__)}/foo.scm\")"
+  #     assert_evals_to 3, :foo
+  #   end
+
+  private
+
+  def eval(form) # convenience method that accepts string or form
+    if form.is_a?(String)
+      BusScheme.eval_string(form)
+    else
+      BusScheme.eval_form(form)
+    end
+  end
+
+  def assert_evals_to(expected, form)
+    assert_equal expected, eval(form)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+begin
+  require 'rubygems'
+  gem 'miniunit'
+rescue LoadError
+  puts "Proceeding with standard test/unit instead of miniunit."
+end
+
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib/'
+require 'test/unit'
+require 'bus_scheme'

data/test/test_parser.rb

@@ -0,0 +1,122 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'test_helper'
+
+class BusSchemeParserTest < Test::Unit::TestCase
+  def test_pop_token
+    string = "(+ 2 2)"
+    assert_equal :'(', BusScheme.pop_token(string)
+
+    assert_equal :'+', BusScheme.pop_token(string)
+    assert_equal 2, BusScheme.pop_token(string)
+    assert_equal 2, BusScheme.pop_token(string)
+    assert_equal :")", BusScheme.pop_token(string)
+
+    string = "\"two\")"
+    assert_equal "two", BusScheme.pop_token(string)
+    assert_equal ")", string
+  end
+
+  def test_tokenize
+    assert_equal [:'(', :'+', 2, 2, :')'], BusScheme.tokenize("(+ 2 2)")
+    assert_equal [:'(', :'+', 2, :'(', :'+', 22, 2, :')', :')'], BusScheme.tokenize("(+ 2 (+ 22 2))")
+    assert_equal [:'(', :plus, 2, 2, :')'], BusScheme.tokenize('(plus 2 2)')
+  end
+
+  def test_parse_numbers
+    assert_parses_to "99", 99
+  end
+
+  def test_parses_strings
+    assert_parses_to "\"hello world\"", "hello world"
+  end
+
+  def test_parses_two_strings
+    assert_parses_to "(concat \"hello\" \"world\")", [:concat, "hello", "world"]
+  end
+
+  def test_parse_list_of_numbers
+    assert_parses_to "(2 2)", [2, 2]
+  end
+
+  def test_parse_list_of_atoms
+    assert_parses_to "(+ 2 2)", [:+, 2, 2]
+  end
+
+  def test_parse_list_of_atoms_with_string
+    assert_parses_to "(+ 2 \"two\")", [:+, 2, "two"]
+  end
+
+  def test_parse_list_of_nested_sexprs
+    assert_parses_to "(+ 2 (+ 2))", [:+, 2, [:+, 2]]
+  end
+
+  def test_parse_list_of_deeply_nested_sexprs
+    assert_parses_to "(+ 2 (+ 2 (+ 2 2)))", [:+, 2, [:+, 2, [:+, 2, 2]]]
+  end
+
+  def test_parse_two_consecutive_parens_simple
+    assert_parses_to "(let ((foo 2)))", [:let, [[:foo, 2]]]
+  end
+
+  def test_parse_two_consecutive_parens
+    assert_parses_to "(let ((foo 2)) (+ foo 2))", [:let, [[:foo, 2]], [:+, :foo, 2]]
+  end
+
+  def test_whitespace_indifferent
+    assert_parses_equal "(+ 2 2)", "(+ 2  \n \t    2)"
+  end
+
+  #   def test_parses_dotted_cons
+  #     assert_parses_to "(22 . 11)", [:cons, 22, 11]
+  #     assert_parses_to "((+ 2 2) . 11)", [:cons, [:+, 2, 2], 11]
+  #   end
+
+  #   def test_floats
+  #     assert_parses_to "44.9", 44.9
+  #     assert_parses_to "0.22", 0.22
+  #     assert_parses_to ".22", 0.22
+  #     assert_parses_to "2.220", 2.22
+  #   end
+
+  #   def test_negative_numbers
+  #     assert_parses_to "-1", -1
+  #     assert_parses_to "-0", 0
+  #     assert_parses_to "-02", -2
+  #   end
+
+  #   def test_negative_floats
+  #     assert_parses_to "-0.22", -0.22
+  #     assert_parses_to "-.22", -0.22
+  #     assert_parses_to "-0.10", -0.1
+  #   end
+
+  #   def test_character_literals
+  #     assert_parses_to "?e", "e"
+  #     assert_parses_to "?A", "A"
+  #     # what else?
+  #   end
+
+  def test_parse_random_elisp_form_from_my_dot_emacs
+    lisp = "(let ((system-specific-config
+         (concat \"~/.emacs.d/\"
+                 (shell-command-to-string \"hostname\"))))
+    (if (file-exists-p system-specific-config)
+        (load system-specific-config)))"
+    assert_parses_to(lisp,
+                     [:let, [[:'system-specific-config',
+                              [:concat, "~/.emacs.d/",
+                               [:'shell-command-to-string', "hostname"]]]],
+                      [:if, [:'file-exists-p', :'system-specific-config'],
+                       [:load, :'system-specific-config']]])
+  end
+
+  private
+
+  def assert_parses_to(actual_string, expected)
+    assert_equal expected, BusScheme.parse(actual_string)
+  end
+
+  def assert_parses_equal(one, two)
+    assert_equal BusScheme.parse(one), BusScheme.parse(two)
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: bus-scheme
+version: !ruby/object:Gem::Version 
+  version: "0.6"
+platform: ""
+authors: 
+- Phil Hagelberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2007-12-17 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: 
+description: Bus Scheme is a Scheme written in Ruby, but implemented on the bus! Every programmer must implement Scheme as a rite of passage; this is mine. Note that all the implementation of Bus Scheme must be written while on a bus. Documentation, tests, and administrivia may be accomplished elsewhere, but all actual implementation code is strictly bus-driven. Patches are welcome as long as they were written while riding a bus. (If your daily commute does not involve a bus but you want to submit a patch, we may be able to work something out regarding code written on trains, ferries, or perhaps even carpool lanes.) Bus Scheme is primarily a toy; using it for anything serious is (right now) ill-advised.  Bus Scheme aims for general Scheme usefulness optimized for learning and fun. It's not targeting R5RS or anything like that.  == Install  * sudo gem install bus-scheme
+email: technomancy@gmail.com
+executables: 
+- bus
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- README.txt
+files: 
+- COPYING
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/bus
+- lib/array_extensions.rb
+- lib/bus_scheme.rb
+- lib/eval.rb
+- lib/object_extensions.rb
+- lib/parser.rb
+- test/foo.scm
+- test/test_eval.rb
+- test/test_helper.rb
+- test/test_parser.rb
+has_rdoc: true
+homepage: "    by Phil Hagelberg (c) 2007"
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: bus-scheme
+rubygems_version: 0.9.5
+signing_key: 
+specification_version: 2
+summary: Bus Scheme is a Scheme in Ruby, imlemented on the bus.
+test_files: 
+- test/test_parser.rb
+- test/test_helper.rb
+- test/test_eval.rb