larrytheliquid-Cry 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Larry Diehl
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,84 @@
+= Cry
+ 
+A CommonLisp CLOS-like parse tree library for Ruby... read (and write) it and weep.
+
+For example, you could create a parse tree like so:
+ 
+  parse_tree = Cry::ParseTree.new(:+, 1, 3)
+  
+... then evaluate it:
+
+	parse_tree.evaluate #	=> 4
+ 
+... You can also create and evaluate more complex parse trees:
+
+	Cry::ParseTree.new( :+, Cry::ParseTree.new( :+, 1, Cry::ParseTree.new(:*, 2, 2) ), Cry::ParseTree.new(:+, 1, 3) ).evaluate # => 9
+	
+== Lineage
+
+Cry::ParseTree just inherits from Array, so you can use all of Array's convenient methods for manipulating your ParseTrees too.
+ 
+== Parameter order
+
+The first parameter is the method as a String or Symbol, this never changes.
+	
+The second parameter is the object that the method will be called on. This can either be a normal object, or an unevaluated Cry::ParseTree for delayed recursive evaluation.
+	
+Any subsequent parameters can either be normal objects, or Cry::ParseTrees, and will be passed as arguments to the method call.
+ 
+== Usage
+ 
+  require 'cry'
+
+	Cry::ParseTree.new(:*, Cry::ParseTree.new(:+, 1, 3), 23).evaluate # => 92
+ 
+This is similar to the following Lisp:
+ 
+	(* (+ 1 3) 23) # => 92
+	
+Take note that ParseTree's second parameter is always your object (be it a class or not).
+
+The method specified will be called on the object, similar to CLOS.
+	
+To distinguish Cry::ParseTree objects from Arrays when using inspect, they are denoted by parentheses:
+
+  Cry::ParseTree.new(:<<, [1], 2).inspect # => "(:<<, [1], 2)"
+
+
+Realize that you have access to all of Ruby, so you can do crazy things like this:
+
+	Cry::ParseTree.new(:instance_variable_set, self, '@parse_tree', 'Cry::ParseTree.new(:*, Cry::ParseTree.new(:+, 1, 3), 23).evaluate').evaluate
+	Cry::ParseTree.new(:eval, Kernel, @parse_tree).evaluate # => 92
+	
+== Manipulation
+
+The nice thing is that the parse trees are lazily evaluated. This means you can change them around before evaluations. 
+
+  parse_tree = Cry::ParseTree.new(:+, 1, 3)
+  
+  parse_tree.node_method # => :+
+  parse_tree.node_object # => 1
+  parse_tree.node_arguments # => [3]
+  
+  parse_tree.node_method = :*
+  parse_tree.node_object = 2
+  parse_tree.node_arguments = [4]
+  
+  parse_tree.evaluate # => 8
+
+Also note that evaluate is not a destructive method.
+
+  parse_tree.evaluate # => 8
+  parse_tree.node_object = 3
+  parse_tree.evaluate # => 12
+	
+== Blocks
+	
+To use methods that accept a block, just use a Proc for your last argument:
+
+  Cry::ParseTree.new(:inject, [1, 2, 3], 0, lambda{|sum, i| sum + i }).evaluate # => 6
+	
+== Author
+
+Author:: Larry Diehl (larrytheliquid)
+Website:: http://larrytheliquid.com

data/Rakefile

@@ -0,0 +1,30 @@
+require 'spec/rake/spectask'
+require 'spec/translator'
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', "\"spec/spec.opts\""]
+  t.spec_files = FileList['spec/parse_tree/public/**/*_spec.rb', 'spec/parse_tree/private/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run the specs under spec/parse_tree"
+  Spec::Rake::SpecTask.new(:parse_tree) do |t|
+    t.spec_opts = ['--options', "\"spec/spec.opts\""]
+    t.spec_files = FileList['spec/parse_tree/public/**/*_spec.rb', 'spec/parse_tree/private/**/*_spec.rb']
+  end
+  
+  namespace :parse_tree do |t|
+    desc "Run the specs under spec/parse_tree/public"
+    Spec::Rake::SpecTask.new(:public) do |t|
+      t.spec_opts = ['--options', "\"spec/spec.opts\""]
+      t.spec_files = FileList['spec/parse_tree/public/**/*_spec.rb']
+    end
+    
+    desc "Run the specs under spec/parse_tree/private"
+    Spec::Rake::SpecTask.new(:private) do |t|
+      t.spec_opts = ['--options', "\"spec/spec.opts\""]
+      t.spec_files = FileList['spec/parse_tree/private/**/*_spec.rb']
+    end
+  end
+end

data/cry.rb

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), "lib", "parse_tree")
+
+module Cry end

data/lib/parse_tree.rb

@@ -0,0 +1,60 @@
+module Cry
+  class ParseTree < Array
+    def initialize(*args)
+      super args.to_ary
+    end
+  
+    def evaluate
+      evaluated_node_object = evaluate_node(node_object)
+      raw_send_arguments = node_arguments.map{|argument| evaluate_node(argument) }.insert(0, node_method)
+      evaluated_node_object.send *raw_send_arguments
+    rescue ArgumentError => original_error
+      begin
+        standard_send_arguments = raw_send_arguments
+        block_send_argument = raw_send_arguments.pop
+        evaluated_node_object.send *standard_send_arguments, &block_send_argument
+      rescue Exception
+        raise original_error
+      end
+    end
+  
+    def node_method
+      self.first.to_sym unless empty?
+    end
+  
+    def node_method=(node_method)
+      self[0] = node_method.to_sym
+    end
+  
+    def node_object
+      self[1] unless size < 2
+    end
+  
+    def node_object=(node_object)
+      self[1] = node_object
+    end
+  
+    def node_arguments
+      size >= 2 ? self[2..size].to_a : Array.new
+    end
+  
+    def node_arguments=(node_arguments)
+      self[2..size] = node_arguments
+    end
+  
+    def height
+      (node_method ? 1 : 0) + self[1..size].to_a.map{|node| node.is_a?(ParseTree) ? node.height : 1 }.max.to_i
+    end
+  
+    def inspect
+      super.sub(/^\[/, "(").sub(/\]$/, ")")
+    end
+    alias_method :to_s, :inspect
+  
+  private
+  
+    def evaluate_node(node)
+      node.is_a?(ParseTree) ? (node.node_method ? node.evaluate : nil) : node if node
+    end
+  end
+end

data/spec/parse_tree/private/evaluate_node_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "cry")
+
+describe Cry::ParseTree, "#evaluate_node" do
+  before(:each) do
+    @parse_tree = Cry::ParseTree.new
+  end
+  
+  it "should be nil if the node is nil" do
+    @parse_tree.send(:evaluate_node, nil).should be_nil
+  end
+  
+  it "should be nil if the node is an uninitialized Cry::ParseTree" do
+    @parse_tree.send(:evaluate_node, Cry::ParseTree.new).should be_nil
+  end
+  
+  it "should be the evaluated node if the everything is a terminal" do
+    @parse_tree.send(:evaluate_node, Cry::ParseTree.new(:+, 1, 2)).should == 3
+  end
+  
+  it "should be the recursively evaluated node if something is a Cry::ParseTree" do
+    @parse_tree.send(:evaluate_node, Cry::ParseTree.new(:+, Cry::ParseTree.new(:+, 1, 2), 2)).should == 5
+  end
+end

data/spec/parse_tree/public/evaluate_spec.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "cry")
+
+describe Cry::ParseTree, "#evaluate, with terminal object and parameters" do
+  it "should be able to evaluate an expression for a simple parse tree" do
+    parse_tree = Cry::ParseTree.new(:to_s, 1)            
+    parse_tree.evaluate.should == "1"
+  end
+  
+  it "should be able to evaluate an expression for a complex parse tree" do
+    parse_tree = Cry::ParseTree.new(:new, Array, 2, 1)            
+    parse_tree.evaluate.should == [1, 1]
+  end
+end
+
+describe Cry::ParseTree, "#evaluate, with terminal object, and Cry::ParseTree parameters" do
+  it "should be able to evaluate an expression for a simple parse tree" do
+    parse_tree = Cry::ParseTree.new( :+, 1, Cry::ParseTree.new(:*, 2, 2) )            
+    parse_tree.evaluate.should == 5
+  end
+  
+  it "should be able to evaluate an expression for a complex parse tree" do
+    parse_tree = Cry::ParseTree.new( :+, 2, Cry::ParseTree.new( :+, 1, Cry::ParseTree.new(:*, 2, 2) ) )                
+    parse_tree.evaluate.should == 7
+  end
+end
+
+describe Cry::ParseTree, "#evaluate, with terminal parameters, and Cry::ParseTree object" do
+  it "should be able to evaluate an expression for a simple parse tree" do
+    parse_tree = Cry::ParseTree.new( :+, Cry::ParseTree.new(:*, 2, 2), 1 )            
+    parse_tree.evaluate.should == 5
+  end
+  
+  it "should be able to evaluate an expression for a complex parse tree" do
+    parse_tree = Cry::ParseTree.new( :+, Cry::ParseTree.new( :+, 1, Cry::ParseTree.new(:*, 2, 2) ), 2 )                
+    parse_tree.evaluate.should == 7
+  end
+end
+
+describe Cry::ParseTree, "#evaluate, for complex mixed parameters" do
+  it "should be able to evaluate" do
+    parse_tree = Cry::ParseTree.new( 
+      :+, Cry::ParseTree.new(:+, 1, 2), 
+        Cry::ParseTree.new(:+, Cry::ParseTree.new(:+, 1, 2), 
+          Cry::ParseTree.new(:*, Cry::ParseTree.new(:+, 1, 2), 
+            Cry::ParseTree.new(:+, 1, 2) ) )
+    )           
+    parse_tree.evaluate.should == 15
+  end
+  
+  it "should work with Arrays" do
+    parse_tree = Cry::ParseTree.new( :+, [1, 2], Cry::ParseTree.new(:new, Array, 1, 3) )
+    parse_tree.evaluate.should == [1, 2, 3]
+  end
+  
+  it "should work with lambdas" do
+    Cry::ParseTree.new(:call, lambda{|from, backwards_greeting| Cry::ParseTree.new(:+, Cry::ParseTree.new(:join, Cry::ParseTree.new(:reverse, backwards_greeting), " "), from).evaluate }, " from lisp", ["world", "hello"]).evaluate.should == "hello world from lisp"
+  end
+  
+  it "should work with block parameters as lambdas" do
+    Cry::ParseTree.new(:inject, [1, 2, 3], 0, lambda{|sum, i| sum + i }).evaluate.should == 6
+  end
+  
+  it "should raise the original error if the block parameters as lambda attempt failes" do
+    lambda { Cry::ParseTree.new(:inject, [1, 2, 3], 0, "not a Proc").evaluate }.should raise_error(ArgumentError)
+  end
+  
+  it "should be able to create new classes" do
+    Cry::ParseTree.new(:instance_variable_set, self, '@klass', Class.new ).evaluate
+    @klass.should be_kind_of(Class)
+  end
+  
+  it "should work with the main 'self' runtime" do    
+    Cry::ParseTree.new(:instance_variable_set, self, '@parse_tree', 'Cry::ParseTree.new(:*, Cry::ParseTree.new(:+, 1, 3), 23).evaluate' ).evaluate
+    Cry::ParseTree.new(:eval, Kernel, @parse_tree).evaluate.should == 92
+  end
+end

data/spec/parse_tree/public/height_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "cry")
+
+describe Cry::ParseTree, "#height" do
+  it "should be 0 for an uninitialized Cry::ParseTree" do
+    Cry::ParseTree.new.height.should == 0
+  end
+  
+  it "should be 1 for a Cry::ParseTree with only a method" do
+    Cry::ParseTree.new(:to_s).height.should == 1
+  end
+  
+  it "should be 2 for a Cry::ParseTree with a method and an object" do
+    Cry::ParseTree.new(:to_s, 1).height.should == 2
+  end
+  
+  it "should work with nil" do
+    Cry::ParseTree.new(:to_s, nil).height.should == 2
+  end    
+  
+  it "should compute height for a simple Cry::ParseTree with one parameter" do
+    parse_tree = Cry::ParseTree.new(:+, 1, 2)
+    parse_tree.height.should == 2
+  end
+  
+  it "should compute height for a simple Cry::ParseTree with multiple parameters" do
+    parse_tree = Cry::ParseTree.new(:new, Array, 2, 1)
+    parse_tree.height.should == 2
+  end
+  
+  it "should compute height for a simple nested Cry::ParseTree with a heavier left side" do
+    parse_tree = Cry::ParseTree.new( :+, Cry::ParseTree.new(:*, 2, 2), 1 )            
+    parse_tree.height.should == 3
+  end
+  
+  it "should compute height for a simple nested Cry::ParseTree with a heavier right side" do
+    parse_tree = Cry::ParseTree.new( :+, 1, Cry::ParseTree.new(:*, 2, 2) )            
+    parse_tree.height.should == 3
+  end
+  
+  it "should compute height for a complex nested Cry::ParseTree with a heavier left side" do
+    parse_tree = Cry::ParseTree.new( :+, Cry::ParseTree.new(:*, 2, Cry::ParseTree.new(:*, 2, 2)), Cry::ParseTree.new(:*, 2, 2) )            
+    parse_tree.height.should == 4
+  end
+  
+  it "should compute height for a complex nested Cry::ParseTree with a heavier right side" do
+    parse_tree = Cry::ParseTree.new( :+, Cry::ParseTree.new(:*, 2, 2), Cry::ParseTree.new(:*, Cry::ParseTree.new(:*, 2, 2), 2) )            
+    parse_tree.height.should == 4
+  end
+  
+  it "should compute height for a very complex nested Cry::ParseTree" do
+    parse_tree = Cry::ParseTree.new( 
+      :+, Cry::ParseTree.new(:+, 1, Cry::ParseTree.new(:+, 1, 2) ), 
+        Cry::ParseTree.new(:+, Cry::ParseTree.new(:+, 1, 2), 
+          Cry::ParseTree.new(:*, Cry::ParseTree.new(:+, 1, 2), 
+            Cry::ParseTree.new(:+, 
+              Cry::ParseTree.new(:+, 1, 
+                Cry::ParseTree.new(:+, 1, 2)), 2) ) )
+    )
+    parse_tree.height.should == 7
+  end
+  
+  it "should compute height for a non-binary tree" do
+    parse_tree = Cry::ParseTree.new(
+      :foobar, Object, 1, 2, Cry::ParseTree.new(:+, 
+        Cry::ParseTree.new(:+, 1, 2), Cry::ParseTree.new(:+, 1, 
+          Cry::ParseTree.new(:+, 1, 2))), 4)
+          
+    parse_tree.height.should == 5
+  end
+end

data/spec/parse_tree/public/inspect_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "cry")
+
+describe Cry::ParseTree, "#inspect, distinguishing itself from Array#inspect" do
+  it "should use parantheses instead of brackets" do
+    p = Cry::ParseTree.new(:+, 1, 2)
+    p.inspect.should == "(:+, 1, 2)"
+  end
+  
+  it "should work with Arrays" do
+    p = Cry::ParseTree.new(:+, 1, [2, 3])
+    p.inspect.should == "(:+, 1, [2, 3])"
+  end
+  
+  it "should work with nested Cry::ParseTrees" do
+    p = Cry::ParseTree.new(:+, 1, Cry::ParseTree.new(:+, 2, 3))
+    p.inspect.should == "(:+, 1, (:+, 2, 3))"
+  end
+end

data/spec/parse_tree/public/new_spec.rb

@@ -0,0 +1,7 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "cry")
+
+describe Cry::ParseTree, ".new" do
+  it "should be a kind of Array" do
+    Cry::ParseTree.new.should be_kind_of(Array)
+  end
+end

data/spec/parse_tree/public/node_arguments_spec.rb

@@ -0,0 +1,93 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "cry")
+
+describe Cry::ParseTree, "#node_arguments" do
+  it "should be empty if the list is empty" do
+    Cry::ParseTree.new.node_arguments.should be_empty
+  end
+  
+  it "should be emtpy if the list has one element" do
+    Cry::ParseTree.new(:self).node_arguments.should be_empty
+  end
+  
+  it "should be empty if the list has two elements" do
+    Cry::ParseTree.new(:to_s, 1).node_arguments.should be_empty
+  end
+  
+  it "should return an Array" do
+    Cry::ParseTree.new(:+, 1, 2).node_arguments.class.should == Array
+  end
+  
+  it "should return the single element remainder if the list has more than two elements, and its elements only have terminals" do
+    Cry::ParseTree.new(:+, 1, 2).node_arguments.should == [2]
+  end
+  
+  it "should return the multiple element remainder if the list has more than two elements, and its elements only have terminals" do
+    Cry::ParseTree.new(:new, Array, 2, 1).node_arguments.should == [2, 1]
+  end
+  
+  it "should return the remainder of the elements if the list has more than two elements, and its elements have Cry::ParseTrees" do
+    Cry::ParseTree.new(:new, Array, 2, Cry::ParseTree.new(:+, 1, 2)).node_arguments.should == [2, [:+, 1, 2]]
+  end
+end
+
+describe Cry::ParseTree, "#node_arguments=" do
+  it "should be able to set on a new Cry::ParseTree" do
+    parse_tree = Cry::ParseTree.new
+    parse_tree.node_arguments = [1]
+    parse_tree.node_arguments.should == [1]
+  end
+  
+  it "should be able to set when node_arguments is emtpy" do
+    parse_tree = Cry::ParseTree.new(:+, 1)
+    parse_tree.node_arguments = [2]
+    parse_tree.node_arguments.should == [2]
+  end
+  
+  it "should be able to set with a single object" do
+    parse_tree = Cry::ParseTree.new(:+, 1, 2)
+    parse_tree.node_arguments = 5
+    parse_tree.node_arguments.should == [5]
+  end
+  
+  it "should be able to set with a single element Array" do
+    parse_tree = Cry::ParseTree.new(:+, 1, 2)
+    parse_tree.node_arguments = [5]
+    parse_tree.node_arguments.should == [5]
+  end
+  
+  it "should be able to set with a multiple element Array" do
+    parse_tree = Cry::ParseTree.new(:new, Array)
+    parse_tree.node_arguments = [2, 1]
+    parse_tree.node_arguments.should == [2, 1]
+  end
+  
+  it "should be able to set when node_object is already set" do
+    parse_tree = Cry::ParseTree.new(:+, 1, 2)
+    parse_tree.node_arguments = [4]
+    parse_tree.node_arguments.should == [4]
+  end
+  
+  it "should be able to set with a Cry::ParseTree" do
+    parse_tree = Cry::ParseTree.new(:+, 1, 2)
+    parse_tree.node_arguments = Cry::ParseTree.new
+    parse_tree.node_arguments.should == Cry::ParseTree.new
+  end
+  
+  it "should be able to set with a Cry::ParseTree in an Array" do
+    parse_tree = Cry::ParseTree.new(:+, 1, 2)
+    parse_tree.node_arguments = [Cry::ParseTree.new]
+    parse_tree.node_arguments.should == [Cry::ParseTree.new]
+  end
+  
+  it "should be able to overwrite current arguments with a new Array, when more arguments are added" do
+    parse_tree = Cry::ParseTree.new(:foobar, Object, 1, 2)
+    parse_tree.node_arguments = [3, 4, 5]
+    parse_tree.node_arguments.should == [3, 4, 5]
+  end
+  
+  it "should be able to overwrite current arguments with a new Array, when less arguments are added" do
+    parse_tree = Cry::ParseTree.new(:foobar, Object, 1, 2, 3)
+    parse_tree.node_arguments = [4, 5]
+    parse_tree.node_arguments.should == [4, 5]
+  end
+end

data/spec/parse_tree/public/node_method_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "cry")
+
+describe Cry::ParseTree, "#node_method" do
+  it "should be nil if the list is empty" do
+    Cry::ParseTree.new.node_method.should be_nil
+  end
+  
+  it "should be the first element as a symbol if the list has one element" do
+    Cry::ParseTree.new("self").node_method.should == :self
+  end
+  
+  it "should be the first element as a symbol if the list has more than one element" do
+    Cry::ParseTree.new(:+, 1, 2).node_method.should == :+
+  end
+end
+
+describe Cry::ParseTree, "#node_method=" do
+  it "should be able to set on a new Cry::ParseTree" do
+    parse_tree = Cry::ParseTree.new
+    parse_tree.node_method = :+
+    parse_tree.node_method.should == :+
+  end
+  
+  it "should be able to set when node_method is nil" do
+    parse_tree = Cry::ParseTree.new(nil, 1, 2)
+    parse_tree.node_method = :+
+    parse_tree.node_method.should == :+
+  end
+  
+  it "should be able to set when node_method is already set" do
+    parse_tree = Cry::ParseTree.new(:+, 1, 2)
+    parse_tree.node_method = :*
+    parse_tree.node_method.should == :*
+  end
+end

data/spec/parse_tree/public/node_object_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), "..", "..", "..", "cry")
+
+describe Cry::ParseTree, "#node_object" do
+  it "should be nil if the list is empty" do
+    Cry::ParseTree.new.node_object.should be_nil
+  end
+  
+  it "should be nil if the list has one element" do
+    Cry::ParseTree.new(:self).node_object.should be_nil
+  end
+  
+  it "should be the second element if the list has more than one element, and it is a terminal" do
+    Cry::ParseTree.new(:+, 1, 2).node_object.should == 1
+  end
+  
+  it "should be the second element if the list has more than one element, and it is a Cry::ParseTree" do
+    Cry::ParseTree.new(:+, Cry::ParseTree.new(:+, 1, 2), 2).node_object.should == [:+, 1, 2]
+  end
+end
+
+describe Cry::ParseTree, "#node_object=" do
+  it "should be able to set on a new Cry::ParseTree" do
+    parse_tree = Cry::ParseTree.new
+    parse_tree.node_object = 1
+    parse_tree.node_object.should == 1
+  end
+  
+  it "should be able to set when node_object is nil" do
+    parse_tree = Cry::ParseTree.new(:+, nil, 2)
+    parse_tree.node_object = 1
+    parse_tree.node_object.should == 1
+  end
+  
+  it "should be able to set when node_object is already set" do
+    parse_tree = Cry::ParseTree.new(:+, 1, 2)
+    parse_tree.node_object = 4
+    parse_tree.node_object.should == 4
+  end
+  
+  it "should be able to set with a Cry::ParseTree" do
+    parse_tree = Cry::ParseTree.new(:+, nil, 2)
+    parse_tree.node_object = Cry::ParseTree.new
+    parse_tree.node_object.should == Cry::ParseTree.new
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: larrytheliquid-Cry
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Larry Diehl (larrytheliquid)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-04 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A CommonLisp CLOS-like ParseTree in Ruby... read (and write) it and weep.
+email: larrytheliquid@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- Rakefile
+- cry.rb
+- lib/parse_tree.rb
+- MIT-LICENSE
+- spec/parse_tree/public/evaluate_spec.rb
+- spec/parse_tree/public/height_spec.rb
+- spec/parse_tree/public/inspect_spec.rb
+- spec/parse_tree/public/new_spec.rb
+- spec/parse_tree/public/node_arguments_spec.rb
+- spec/parse_tree/public/node_method_spec.rb
+- spec/parse_tree/public/node_object_spec.rb
+- spec/parse_tree/private/evaluate_node_spec.rb
+- spec/spec.opts
+has_rdoc: true
+homepage: http://github.com/larrytheliquid/cry/tree/master
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+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: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: A lazily evaluated and easy to use Ruby parse tree.
+test_files: 
+- spec/parse_tree/public/evaluate_spec.rb
+- spec/parse_tree/public/height_spec.rb
+- spec/parse_tree/public/inspect_spec.rb
+- spec/parse_tree/public/new_spec.rb
+- spec/parse_tree/public/node_arguments_spec.rb
+- spec/parse_tree/public/node_method_spec.rb
+- spec/parse_tree/public/node_object_spec.rb
+- spec/parse_tree/private/evaluate_node_spec.rb
+- spec/spec.opts