piggly 1.2.1 → 2.0.0

data/spec/examples/parser/traversal_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+module Piggly
+
+  describe Parser::Traversal do
+    describe "fold"
+    describe "reduce"
+    describe "count"
+    describe "find"
+    describe "select"
+    describe "flatten"
+  end
+
+end

data/spec/examples/parser_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+module Piggly
+
+describe Parser do
+  
+  describe "parse" do
+    it "returns a thunk" do
+      tree = nil
+
+      lambda do
+        tree = Parser.parse('input')
+      end.should_not raise_error
+
+      tree.thunk?.should be_true
+    end
+
+    context "when the thunk is evaluated" do
+      before do
+        @parser = mock('PigglyParser')
+        Parser.stub(:parser).and_return(@parser)
+      end
+
+      it "downcases input string before parsing" do
+        input = 'SOURCE CODE'
+
+        @parser.stub(:failure_reason)
+        @parser.should_receive(:parse).
+          with(input.downcase)
+
+        begin
+          Parser.parse(input).force!
+        rescue Parser::Failure
+          # don't care
+        end
+      end
+
+      context "when parser fails" do
+        it "raises Parser::Failure" do
+          input  = 'SOURCE CODE'
+          reason = 'expecting someone else'
+
+          @parser.should_receive(:parse).
+            and_return(nil)
+          @parser.should_receive(:failure_reason).
+            and_return(reason)
+
+          lambda do
+            Parser.parse('SOURCE CODE').force!
+          end.should raise_error(Parser::Failure, reason)
+        end
+      end
+
+      context "when parser succeeds" do
+        it "returns parser's result" do
+          input = 'SOURCE CODE'
+          tree  = mock('NodeClass', :message => 'result')
+
+          @parser.should_receive(:parse).
+            and_return(tree)
+
+          Parser.parse('SOURCE CODE').message.should == tree.message
+        end
+      end
+
+    end
+  end
+
+  describe "parser" do
+
+    context "when the grammar is older than the generated parser" do
+      before do
+        Util::File.stub(:stale?).and_return(false)
+      end
+
+      it "does not regenerate the parser" do
+        Treetop::Compiler::GrammarCompiler.should_not_receive(:new)
+      # Parser.should_receive(:require).
+      #   with(Parser.parser_path)
+
+        Parser.parser
+      end
+
+      it "returns an instance of PigglyParser" do
+        Parser.parser.should be_a(PigglyParser)
+      end
+    end
+
+    context "when the generated parser is older than the grammar" do
+      before do
+        Util::File.stub(:stale?).and_return(true)
+      end
+
+      it "regenerates the parser and loads it" do
+        compiler = mock('GrammarCompiler')
+        compiler.should_receive(:compile).
+          with(Parser.grammar_path, Parser.parser_path)
+
+        Treetop::Compiler::GrammarCompiler.should_receive(:new).
+          and_return(compiler)
+
+        Parser.should_receive(:load).
+          with(Parser.parser_path)
+
+        Parser.parser
+      end
+
+      it "returns an instance of PigglyParser" do
+        Parser.parser.should be_a(PigglyParser)
+      end
+    end
+  end
+end
+
+end

data/spec/examples/profile_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+module Piggly
+
+describe Profile do
+
+  before do
+    @profile = Profile.new
+  end
+
+  describe "notice_processor" do
+    before do
+      @config = mock('config', :trace_prefix => 'PIGGLY')
+      @stderr = mock('stderr').as_null_object
+      @callback = @profile.notice_processor(@config, @stderr)
+    end
+
+    it "returns a function" do
+      @callback.should be_a(Proc)
+    end
+
+    context "when message matches PATTERN" do
+      context "with no optional value" do
+        it "pings the corresponding tag" do
+          message = "WARNING:  #{@config.trace_prefix} 0123456789abcdef"
+          @profile.should_receive(:ping).
+            with('0123456789abcdef', nil)
+
+          @callback.call(message)
+        end
+      end
+
+      context "with an optional value" do
+        it "pings the corresponding tag" do
+          message = "WARNING:  #{@config.trace_prefix} 0123456789abcdef X"
+          @profile.should_receive(:ping).
+            with('0123456789abcdef', 'X')
+
+          @callback.call(message)
+        end
+      end
+    end
+
+    context "when message doesn't match PATTERN" do
+      it "prints the message to stderr" do
+        message = "WARNING:  Parameter was NULL and I don't like it!"
+        @stderr.should_receive(:puts).with(message)
+        @callback.call(message)
+      end
+    end
+  end
+
+  describe "add" do
+    before do
+      @first  = mock('first tag',  :id => 'first')
+      @second = mock('second tag', :id => 'second')
+      @third  = mock('third tag',  :id => 'third')
+      @cache  = mock('Compiler::Cacheable::CacheDirectory')
+
+      @procedure = Dumper::SkeletonProcedure.allocate
+      @procedure.stub(:oid).and_return('oid')
+    end
+
+    context "without cache parameter" do
+      it "indexes each tag by id" do
+        @profile.add(@procedure, [@first, @second, @third])
+        @profile[@first.id].should == @first
+        @profile[@second.id].should == @second
+        @profile[@third.id].should == @third
+      end
+
+      it "indexes each tag by procedure" do
+        @profile.add(@procedure, [@first, @second, @third])
+        @profile[@procedure].should == [@first, @second, @third]
+      end
+    end
+
+    context "with cache parameter" do
+      it "indexes each tag by id" do
+        @profile.add(@procedure, [@first, @second, @third], @cache)
+        @profile[@first.id].should == @first
+        @profile[@second.id].should == @second
+        @profile[@third.id].should == @third
+      end
+
+      it "indexes each tag by procedure" do
+        @profile.add(@procedure, [@first, @second, @third])
+        @profile[@procedure].should == [@first, @second, @third]
+      end
+    end
+  end
+
+  describe "ping" do
+    context "when tag isn't in the profile" do
+      it "raises an exception" do
+        lambda do
+          @profile.ping('0123456789abcdef')
+        end.should raise_error('No tag with id 0123456789abcdef')
+      end
+    end
+
+    context "when tag is in the profile" do
+      before do
+        @tag = mock('tag', :id => '0123456789abcdef')
+        procedure = mock('procedure', :oid => nil)
+        @profile.add(procedure, [@tag])
+      end
+
+      it "calls ping on the corresponding tag" do
+        @tag.should_receive(:ping).with('X')
+        @profile.ping(@tag.id, 'X')
+      end
+    end
+  end
+
+  describe "summary" do
+    context "when given a procedure" do
+    end
+
+    context "when not given a procedure" do
+    end
+  end
+
+  describe "clear" do
+    before do
+      @first  = mock('first tag',  :id => 'first')
+      @second = mock('second tag', :id => 'second')
+      @third  = mock('third tag',  :id => 'third')
+      procedure = mock('procedure', :oid => nil)
+
+      @profile.add(procedure, [@first, @second, @third])
+    end
+
+    it "calls clear on each tag" do
+      @first.should_receive(:clear)
+      @second.should_receive(:clear)
+      @third.should_receive(:clear)
+      @profile.clear
+    end
+  end
+
+  describe "store" do
+  end
+
+  describe "empty?" do
+  end
+
+  describe "difference" do
+  end
+
+end
+
+end

data/spec/examples/reporter/html_spec.rb

@@ -0,0 +1 @@
+require 'spec_helper'

data/spec/{compiler → examples}/tags_spec.rb

@@ -1,28 +1,28 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'spec_helper'
 
 module Piggly
 
-describe Tag do
+describe Tags::AbstractTag do
 end
 
-describe EvaluationTag do
+describe Tags::EvaluationTag do
 end
 
-describe BlockTag do
+describe Tags::BlockTag do
 end
 
-describe UnconditionalBranchTag do
+describe Tags::UnconditionalBranchTag do
 end
 
-describe LoopConditionTag do
+describe Tags::ConditionalLoopTag do
 end
 
-describe ForCollectionTag do
+describe Tags::UnconditionalLoopTag do
   before do
-    @tag = ForCollectionTag.new('for-loop')
+    @tag = Tags::UnconditionalLoopTag.new('for-loop')
   end
 
-  it "detects state 00 (0b0000)" do
+  it "starts with state 00 (0b0000)" do
     # - terminates normally
     # - pass through
     # - iterate only once
@@ -279,7 +279,7 @@ describe ForCollectionTag do
 
 end
 
-describe BranchConditionTag do
+describe Tags::ConditionalBranchTag do
 end
 
 end

data/spec/examples/util/cacheable_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Piggly
+
+=begin
+  describe Util::Cacheable do
+
+    class ExampleClass;           include Piggly::Util::Cacheable; end
+    class ExampleCacheClass;      include Piggly::Util::Cacheable; end
+    class PigglyExampleClassHTML; include Piggly::Util::Cacheable; end
+    class PigglyExampleHTMLClass; include Piggly::Util::Cacheable; end
+    class HTMLPiggly;             include Piggly::Util::Cacheable; end
+    class ExampleRedefined
+      include Piggly::Util::Cacheable
+      def self.cache_path(file)
+        'redefined'
+      end
+    end
+
+    before do
+      Config.stub(:cache_root).and_return('/')
+    end
+
+    it "installs class methods" do
+      ExampleClass.should respond_to(:cache_path)
+    end
+    
+    it "uses class name as cache subdirectory" do
+      FileUtils.should_receive(:makedirs).at_least(:once)
+
+      ExampleClass.cache_path('a.ext').should           =~ %r(/Example/a.ext$)
+      ExampleCacheClass.cache_path('a.ext').should      =~ %r(/ExampleCache/a.ext$)
+      PigglyExampleClassHTML.cache_path('a.ext').should =~ %r(/PigglyExampleClassHTML/a.ext$)
+      PigglyExampleHTMLClass.cache_path('a.ext').should =~ %r(/PigglyExampleHTML/a.ext$)
+      HTMLPiggly.cache_path('a.ext').should             =~ %r(/HTML/a.ext$)
+      ExampleRedefined.cache_path('a.ext').should       == 'redefined'
+    end
+  end
+=end
+
+end

data/spec/examples/util/enumerable_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module Piggly::Util
+
+  describe Enumerable do
+    before do
+      @hash  = {:a => '%', :b => '#'}
+      @array = %w(a b c d)
+      @range = 'w'..'z'
+      @empty = []
+    end
+
+    describe "count" do
+      it "should default to `size' when no block is given" do
+        Enumerable.count(@hash).should == 2
+      end
+
+      it "should count items that satisfied block" do
+        Enumerable.count(@hash){ true }.should == @hash.size
+        Enumerable.count(@array){ false }.should == 0
+        Enumerable.count(@empty){ true }.should == @empty.size
+        Enumerable.count(@range){|c| c < 'z' }.should == 3
+      end
+    end
+
+    describe "sum" do
+      it "should append when no block is given" do
+        Enumerable.sum(@range).should == 'wxyz'
+        Enumerable.sum(@array).should == 'abcd'
+        Enumerable.sum(@empty).should == 0
+      end
+
+      it "should use block return value" do
+        Enumerable.sum(@range){ 100 }.should == 400
+        Enumerable.sum(@empty){ 100 }.should == 0
+      end
+    end
+
+    describe "group_by" do
+      it "should return a Hash" do
+        Enumerable.group_by(@array){ nil }.should be_a(Hash)
+      end
+
+      it "should collect elements into subcollections" do
+        Enumerable.group_by(@array){ :a }.should == { :a => @array }
+        Enumerable.group_by(@array){|x| x <= 'b'}.should == { true => %w(a b), false => %w(c d) }
+        Enumerable.group_by(@range){|x| x.to_i }.should == { 0 => %w(w x y z) }
+        Enumerable.group_by(@empty){ false }.should == {}
+      end
+    end
+
+    describe "index_by" do
+      it "should return a Hash" do
+        Enumerable.index_by(@array){ nil }.should be_a(Hash)
+      end
+
+      it "should collect only one element per group" do
+        Enumerable.index_by(@array){ nil }.should == { nil => 'd' }
+        Enumerable.index_by(@range){|x| x }.should == { 'w' => 'w', 'x' => 'x', 'y' => 'y', 'z' => 'z' }
+      end
+    end
+  end
+
+end