aniero-treehouse 0.0.2

data/spec/integration/assignments_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+require Treehouse.path(%w(spec grammars assignments))
+
+describe AssignmentsLanguage::Grammar do
+
+  it "has nodes defined" do
+    consts = AssignmentsLanguage::Grammar.constants
+    consts.should include("Assignments")
+    consts.should include("Assignment")
+    consts.should include("BlankLine")
+  end
+
+end
+
+describe AssignmentsLanguage::Parser, ".parse" do
+
+  before(:each) do
+    @input = File.read(Treehouse.path(%w(spec fixtures assignments.txt)))
+  end
+
+  it "parses a file and returns a Treehouse AST" do
+    AssignmentsLanguage::Parser.parse(@input).should be_a_kind_of(Treehouse::Node)
+  end
+
+end
+
+describe AssignmentsLanguage do
+  it "has a string visitor defined" do
+    AssignmentsLanguage.const_get("StringVisitor").ancestors.should include(Treehouse::Visitor)
+  end
+end
+
+describe AssignmentsLanguage::StringVisitor do
+  before(:each) do
+    @input = File.read(Treehouse.path(%w(spec fixtures assignments.txt)))
+    @ast = AssignmentsLanguage::Parser.parse(@input)
+  end
+
+  describe "#visit" do
+    it "traverses the AST and collects the values" do
+      AssignmentsLanguage::StringVisitor.visit(@ast).should == "foo = bar\nbaz = blech\nno = way\n"
+    end
+  end
+end

data/spec/integration/dot_xen_spec.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+require Treehouse.path(%w(spec grammars dot_xen))
+
+describe DotXen::Parser, ".parse" do
+  before(:each) do
+    data = File.read(Treehouse.path(%w(spec fixtures ey00-s00348.xen)))
+    @ast = DotXen::Parser.parse(data)
+  end
+  it "returns an AST" do
+    @ast.should_not be_nil
+  end
+
+  describe "with a parsed AST" do
+    it "has a comment" do
+      @ast.should have(1).comments
+    end
+
+    it "has 3 disks" do
+      @ast.should have(3).disks
+    end
+
+    it "has vars" do
+      @ast.should have_at_least(5).vars
+    end
+
+  end
+
+end
+
+describe DotXen::HashVisitor do
+  before(:all) do
+    data = File.read(Treehouse.path(%w(spec fixtures ey00-s00348.xen)))
+    @ast = DotXen::Parser.parse(data)
+  end
+
+  describe ".visit" do
+    it "returns a hash representation of the AST" do
+      DotXen::HashVisitor.visit(@ast).should == {
+        :comments => ["  -*- mode: python; -*-"],
+        :disks => [
+          "phy:/dev/ey00-data4/root-s00348,sda1,w",
+          "phy:/dev/ey00-data4/swap-s00348,sda2,w",
+          "phy:/dev/ey00-data4/gfs-00218,sdb1,w!"
+        ],
+        :vars => {
+          "name" => "ey00-s00348",
+          "kernel" => "/boot/vmlinuz-2.6.18-xenU",
+          "memory" => 712,
+          "cpu_cap" => 100,
+          "vcpus" => 1,
+          "root" => "/dev/sda1 ro",
+          "maxmem" => 4096,
+          "vif" => ["bridge=xenbr0"]
+        }
+      }
+    end
+  end
+end
+
+describe DotXen::StringVisitor do
+  before(:all) do
+    data = File.read(Treehouse.path(%w(spec fixtures ey00-s00348.xen)))
+    @ast = DotXen::Parser.parse(data)
+  end
+  describe ".visit" do
+    it "returns a string representation of the AST" do
+          DotXen::StringVisitor.visit(@ast).should == <<-EOS
+#   -*- mode: python; -*-
+kernel = '/boot/vmlinuz-2.6.18-xenU'
+memory = 712
+maxmem = 4096
+name = 'ey00-s00348'
+vif = [ 'bridge=xenbr0' ]
+root = "/dev/sda1 ro"
+vcpus = 1
+cpu_cap = 100
+disk = [
+  "phy:/dev/ey00-data4/root-s00348,sda1,w",
+  "phy:/dev/ey00-data4/swap-s00348,sda2,w",
+  "phy:/dev/ey00-data4/gfs-00218,sdb1,w!"
+]
+      EOS
+    end
+  end
+end

data/spec/integration/magic_spec.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), %w[.. spec_helper])
+
+require Treehouse.path(%w(spec grammars magic))
+
+describe MagicAssignments::Parser do
+  describe ".parse" do
+    before(:each) do
+      @input = File.read(Treehouse.path(%w(spec fixtures assignments.txt)))
+      @result = MagicAssignments::Parser.parse(@input)
+    end
+
+    it "returns an AST" do
+      @result.should be_an_instance_of(MagicAssignments::AST::Assignments)
+    end
+
+    it "has the right number of nodes" do
+      @result.should have(7).assignments
+    end
+
+    it "has an assignment with correct values" do
+      @result.assignments.first.should be_an_instance_of(MagicAssignments::AST::Assignment)
+      @result.assignments.first.lhs.value.should == "foo"
+      @result.assignments.first.rhs.value.should == "bar"
+    end
+
+  end
+end
+
+describe MagicAssignments::HashVisitor do
+  describe ".visit" do
+    it "returns a hash representation of the assignments" do
+      ast = MagicAssignments::Parser.parse(File.read(Treehouse.path(%w(spec fixtures assignments.txt))))
+      MagicAssignments::HashVisitor.visit(ast).should == {
+        "foo" => "bar",
+        "baz" => "blech",
+        "no" => "way"
+      }
+    end
+  end
+end

data/spec/node_creator_spec.rb

@@ -0,0 +1,47 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Treehouse::NodeCreator do
+
+  before(:all) do
+    SomeNode = Class.new(Treehouse::Node)
+  end
+  after(:all) do
+    Object.send(:remove_const, "SomeNode")
+  end
+
+  describe "#initialize" do
+
+    it "takes a class as an argument" do
+      nc = Treehouse::NodeCreator.new(SomeNode)
+    end
+  end
+
+  describe "#new" do
+    before(:each) do
+      @nc = Treehouse::NodeCreator.new(SomeNode)
+    end
+
+    it "takes parameters as if it were a treetop syntax node" do
+      @nc.new("what", 0..3)
+    end
+
+    it "returns a treetop syntax node" do
+      node = @nc.new("what", 0..3)
+      node.should be_an_instance_of(Treetop::Runtime::SyntaxNode)
+    end
+
+    it "defines a build method on the syntax node" do
+      node = @nc.new("what", 0..3)
+      node.methods.should include("build")
+    end
+
+    it "creates an instance of the defined class when build is called on the resulting syntax node" do
+      node = @nc.new("what", 0..3)
+      mock_node = mock("node")
+      SomeNode.should_receive(:new).with(node).and_return(mock_node)
+      node.build.should == mock_node
+    end
+
+  end
+
+end

data/spec/node_definition_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Treehouse::NodeDefinition do
+  module TestNodes
+    include Treehouse::NodeDefinition
+  end
+
+  it "adds a node method when included" do
+    TestNodes.methods.should include("node")
+  end
+
+  it "adds a create_node method when included" do
+    TestNodes.methods.should include("create_node")
+  end
+
+  describe ".node" do
+    before(:each) do
+      TestNodes.class_eval { node :foo, :bar, :baz }
+    end
+    after(:each) do
+      TestNodes.send(:remove_const, "Foo")
+    end
+
+    it "defines a class" do
+      TestNodes.constants.should include("Foo")
+      TestNodes::Foo.ancestors.should include(Treehouse::Node)
+    end
+
+    it "defines a class with an attribute for each of the provided arguments" do
+      TestNodes::Foo.instance_methods.should include("bar")
+      TestNodes::Foo.instance_methods.should include("baz")
+    end
+
+  end
+
+  describe ".create_node" do
+    before(:all) do
+      TestNodes.class_eval { node :foo_node }
+    end
+    after(:all) do
+      TestNodes.send(:remove_const, "FooNode")
+    end
+
+    it "takes a node name as an argument" do
+      TestNodes.create_node(:foo_node)
+    end
+
+    it "returns an instance of NodeCreator" do
+      TestNodes.create_node(:foo_node).should be_an_instance_of(Treehouse::NodeCreator)
+    end
+
+    it "instantiates the node creator with the class corresponding to the node name" do
+      obj = Object.new
+      Treehouse::NodeCreator.should_receive(:new).with(TestNodes::FooNode).and_return(obj)
+      TestNodes.create_node(:foo_node).should == obj
+    end
+
+  end
+
+end

data/spec/node_spec.rb

@@ -0,0 +1,131 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Treehouse::Node do
+
+  describe ".create" do
+    it "returns a class that inherits from Treehouse::Node" do
+      klass = Treehouse::Node.create
+      klass.should be_an_instance_of(Class)
+      klass.ancestors.should include(Treehouse::Node)
+    end
+
+    describe "with attribute names" do
+      before(:each) do
+        @node = Treehouse::Node.create(:foo, :bar)
+      end
+
+      it "creates a class with the given attributes" do
+        n = @node.new(:foo => 1, :bar => 2)
+        n.foo.should == 1
+        n.bar.should == 2
+      end
+
+      it "creates attributes with a default of raising an exception if not initialized" do
+        n = @node.new(:foo => 1) # no :bar
+        n.foo.should == 1
+        lambda { n.bar }.should raise_error(RuntimeError, "no value given for bar")
+      end
+
+    end
+
+    describe "with an attribute hash" do
+      before(:each) do
+        @node = Treehouse::Node.create(:lhs => :left_value, :rhs => :right_value)
+      end
+
+      it "creates a class with attributes matching the hash keys" do
+        @node.attributes.sort.should == ["lhs", "rhs"]
+      end
+
+      it "creates attributes with a default of raising an exception if not set" do
+        n = @node.new
+        lambda { n.lhs }.should raise_error(RuntimeError, "no value given for lhs")
+      end
+
+      it "returns a class with an attribute mapping" do
+        @node.attribute_mapping.should == {"lhs" => :left_value, "rhs" => :right_value}
+      end
+
+    end
+
+    describe "with a mix of named attributes and hash attributes" do
+      before(:each) do
+        @node = Treehouse::Node.create(:one, :two, :three => :value)
+      end
+
+      it "creates a class with attributes matching the named attributes and hash keys" do
+        @node.attributes.should == %w(one two three)
+      end
+
+      it "updates the attribute mapping" do
+        @node.attribute_mapping.should == {"three" => :value}
+      end
+
+    end
+
+  end
+
+  describe ".new" do
+    before(:each) do
+      @node = Treehouse::Node.create(:child, :value => :data)
+    end
+
+    describe "with empty args" do
+      it "initializes a node without touching the attributes" do
+        n = @node.new
+        lambda { n.child }.should raise_error(RuntimeError)
+      end
+    end
+
+    describe "with a hash" do
+      it "initializes each of the attributes to the given value" do
+        n = @node.new(:child => 1, :value => 2)
+        n.child.should == 1
+        n.value.should == 2
+      end
+    end
+
+    describe "with an instance of Treetop::Runtime::SyntaxNode" do
+      before(:each) do
+        @child = mock_syntax_node :build => "child value"
+        @top = mock_syntax_node :child => @child, :data => "data"
+      end
+
+      it "sets the named values by calling build on the named child node" do
+        @top.should_receive(:child).and_return(@child)
+        @child.should_receive(:build).and_return("child value")
+        n = @node.new(@top)
+        n.child.should == "child value"
+      end
+
+      it "calls the specified method directly for hash values" do
+        @top.should_receive(:data).and_return do
+          puts "called from #{caller.detect {|c| c !~ /rspec/}}"
+          "foo"
+        end
+        n = @node.new(@top)
+        n.value.should == "foo"
+      end
+
+      it "calls build on each element of a referenced node value if that value is an array" do
+        @top.should_receive(:child).and_return([@child, @child])
+        @child.should_receive(:build).exactly(2).times.and_return("one", "two")
+        n = @node.new(@top)
+        n.child.should == %w(one two)
+      end
+
+      it "only calls build on elements of an array if they respond to that method" do
+        @top.should_receive(:child).and_return([@child, "blah"])
+        @node.new(@top).child.should == ["child value", "blah"]
+      end
+
+      it "yields the syntax node instance if a mapped attribute is a lambda" do
+        @node = Treehouse::Node.create(:value => lambda { |x| @x = x })
+        @node.new(@top)
+        @x.should == @top
+      end
+
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib treehouse]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+
+  # borrowed from rspec_on_rails' mock_model
+  def mock_syntax_node(stubs={})
+    m = mock "mock syntax node", stubs
+    m.send(:__mock_proxy).instance_eval do
+      def @target.is_a?(other)
+        Treetop::Runtime::SyntaxNode.ancestors.include?(other)
+      end
+      def @target.kind_of?(other)
+        Treetop::Runtime::SyntaxNode.ancestors.include?(other)
+      end
+      def @target.instance_of?(other)
+        other == Treetop::Runtime::SyntaxNode
+      end
+      def @target.class
+        Treetop::Runtime::SyntaxNode
+      end
+    end
+    yield m if block_given?
+    m
+  end
+
+end