piggly-nsd 2.3.3

data/spec/examples/grammar/tokens/literal_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+ 
+    describe "literals" do
+      it "can be a cast call on a string" do
+        node = parse(:tLiteral, "cast('100.00' as numeric(10, 2))")
+        node = parse(:tLiteral, "cast( '100.00' as numeric (10, 2) )")
+      end
+
+      it "can be a cast call on a number" do
+        node = parse(:tLiteral, "cast(100.00 as character varying(8))")
+        node = parse(:tLiteral, "cast( 100.00 as character varying (8) )")
+      end
+
+      it "can be a ::cast on a string" do
+        node = parse(:tLiteral, "'100'::int")
+        node = parse(:tLiteral, "'100' :: int")
+      end
+
+      it "can be a ::cast on a number" do
+        node = parse(:tLiteral, '100 :: varchar')
+        node = parse(:tLiteral, '100::varchar')
+      end
+    end
+
+  end
+end

data/spec/examples/grammar/tokens/lval_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+
+    describe "l-values" do
+      it "can be a simple identifier" do
+        parse(:lValue, 'id').should be_a(Parser::Nodes::Assignable)
+      end
+
+      it "can be an attribute accessor" do
+        parse(:lValue, 'record.id').should be_a(Parser::Nodes::Assignable)
+        parse(:lValue, 'public.dataset.id').should be_a(Parser::Nodes::Assignable)
+      end
+
+      it "can use quoted attributes" do
+        parse(:lValue, 'record."ID"').should be_a(Parser::Nodes::Assignable)
+        parse(:lValue, '"schema name"."table name"."column name"').should be_a(Parser::Nodes::Assignable)
+      end
+      
+      it "can be an array accessor" do
+        parse(:lValue, 'names[0]').should be_a(Parser::Nodes::Assignable)
+        parse(:lValue, 'names[1000]').should be_a(Parser::Nodes::Assignable)
+      end
+
+      it "can contain comments in array accessors" do
+        node = parse(:lValue, 'names[3 /* comment */]')
+        node.should be_a(Parser::Nodes::Assignable)
+        node.count{|e| e.comment? }.should == 1
+        
+        node = parse(:lValue, "names[9 -- comment \n]")
+        node.should be_a(Parser::Nodes::Assignable)
+        node.count{|e| e.comment? }.should == 1
+      end
+
+      it "can be an array accessed by another l-value" do
+        parse(:lValue, 'names[face.id]').should be_a(Parser::Nodes::Assignable)
+      end
+
+      it "can be a nested array access"
+        # names[faces[0].id].id doesn't work because it requires context-sensitivity [faces[0]
+      
+      it "can be a multi-dimensional array access" do
+        parse(:lValue, 'data[10][2][0]').should be_a(Parser::Nodes::Assignable)
+      end
+    end
+
+  end
+end

data/spec/examples/grammar/tokens/number_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+ 
+    describe "numbers" do
+      it "can be an integer in binary notation" do
+        node = parse(:tNumber, "B'0'")
+      end
+
+      it "can be an integer in hexadecimal notation" do
+        node = parse(:tNumber, "X'F'")
+      end
+
+      it "can be an integer in decimal notation" do
+        node = parse(:tNumber, '11223344556677889900')
+      end
+
+      it "can be a real number in decimial notation" do
+        node = parse(:tNumber, '3.2267')
+      end
+
+      it "can be a real number in scientific notation" do
+        node = parse(:tNumber, '1.3e3')
+      end
+
+      it "can be an integer in scientific notation" do
+        node = parse(:tNumber, '5e4')
+      end
+    end
+
+  end
+end

data/spec/examples/grammar/tokens/sqlkeywords_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Piggly
+
+  describe Parser, "statements" do
+    include GrammarHelper
+
+      describe "SQL keywords" do
+        it "parse successfully" do
+          GrammarHelper::SQLWORDS.test_each do |k|
+            parse(:sqlKeyword, k).source_text.should == k
+          end
+        end
+
+        it "cannot have trailing characters" do
+          GrammarHelper::SQLWORDS.each do |k|
+            expect{ parse(:sqlKeyword, "#{k}abc") }.to raise_error(Piggly::Parser::Failure)
+          end
+        end
+
+        it "cannot have preceeding characters" do
+          GrammarHelper::SQLWORDS.each do |k|
+            expect{ parse(:sqlKeyword, "#{k}abc") }.to raise_error(Piggly::Parser::Failure)
+          end
+        end
+
+        it "are terminated by symbols" do
+          GrammarHelper::SQLWORDS.test_each do |k|
+            node, rest = parse_some(:sqlKeyword, "#{k}+")
+            node.source_text.should == k
+            rest.should == '+'
+          end
+        end
+
+        it "are terminated by spaces" do
+          GrammarHelper::SQLWORDS.test_each do |k|
+            node, rest = parse_some(:sqlKeyword, "#{k} ")
+            node.source_text.should == k
+            rest.should == ' '
+          end
+        end
+      end
+
+  end
+end

data/spec/examples/grammar/tokens/string_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+  
+    describe "strings" do
+      it "can be enclosed within single quotes" do
+        ["''", "'abc'", "'abc xyz'"].test_each do |s|
+          parse(:tString, s).should be_string
+        end
+      end
+
+      it "cannot be nested within single quotes" do
+        node, rest = parse_some(:tString, "'abc 'xyz' tuv'")
+        node.should be_string
+        rest.should == "xyz' tuv'"
+
+        node, rest = parse_some(:tString, "'can't'")
+        node.should be_string
+        rest.should == "t'"
+      end
+
+      it "can contain escaped single quotes" do
+        ["''''", "'can''t'", "'abc '' xyz'"].test_each do |s|
+          parse(:tString, s).should be_string
+        end
+      end
+      
+      it "can be enclosed with $$ tags" do
+        ["$$$$", "$$ abc $$", "$T$ abc $T$", "$tt$ abc $tt$"].test_each do |s|
+          parse(:tString, s).should be_string
+        end
+      end
+
+      it "must have matching start and end $$ tags"
+
+      it "can be nested within $$ tags"
+
+      it "can embed $$ strings within single-quoted strings" do
+        ["'ab $$ xyz $$ cd'", "'a $b$ c $b$ d'"].test_each do |s|
+          parse(:tString, s).should be_string
+        end
+      end
+
+      it "can embed single-quote strings within $$ strings" do
+        ["$$ 'abc' $$", "$ABC$ 'ab''cd' $ABC$"].test_each do |s|
+          parse(:tString, s).should be_string
+        end
+      end
+    end
+
+  end
+end

data/spec/examples/grammar/tokens/whitespace_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module Piggly
+  describe Parser, "tokens" do
+    include GrammarHelper
+
+    describe "white space" do
+      it "includes spaces" do
+        node, rest = parse_some(:tSpace, "    ")
+        rest.should == ''
+        node.source_text.should == "    "
+      end
+
+      it "includes tabs" do
+        node, rest = parse_some(:tSpace, "\t\t")
+        rest.should == ''
+        node.source_text.should == "\t\t"
+      end
+
+      it "includes line feeds" do
+        node, rest = parse_some(:tSpace, "\f\f")
+        rest.should == ''
+        node.source_text.should == "\f\f"
+      end
+
+      it "includes line breaks" do
+        node, rest = parse_some(:tSpace, "\n\n")
+        rest.should == ''
+        node.source_text.should == "\n\n"
+      end
+
+      it "includes carriage returns" do
+        node, rest = parse_some(:tSpace, "\r\r")
+        rest.should == ''
+        node.source_text.should == "\r\r"
+      end
+    end
+
+  end
+end

data/spec/examples/installer_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Piggly
+
+describe Installer do
+
+  before do
+    @config     = Config.new
+    @connection = double('connection')
+    @installer  = Installer.new(@config, @connection)
+  end
+
+  describe "trace" do
+    it "compiles, executes, and profiles the procedure" do
+      untraced  = 'create or replace function x(char)'
+      traced    = 'create or replace function f(int)'
+
+      result   = {:tags => double, :code => traced}
+      profile  = double('profile')
+
+      compiler = double('compiler', :compile => result)
+      expect(Compiler::TraceCompiler).to receive(:new).
+        and_return(compiler)
+
+      procedure = double('procedure', :oid => 'oid', :source => untraced)
+      expect(procedure).to receive(:definition).
+        with(traced).and_return(traced)
+
+      expect(@connection).to receive(:exec).
+        with(traced)
+
+      expect(profile).to receive(:add).
+        with(procedure, result[:tags], result)
+
+      @installer.trace(procedure, profile)
+    end
+  end
+
+  describe "untrace" do
+    it "executes the original definition" do
+      untraced  = 'create or replace function x(char)'
+      procedure = double(:oid => 'oid', :source => untraced)
+
+      expect(procedure).to receive(:definition).
+        and_return(untraced)
+
+      expect(@connection).to receive(:exec).
+        with(untraced)
+
+      @installer.untrace(procedure)
+    end
+  end
+
+  describe "install_trace_support"
+  describe "uninstall_trace_support"
+
+end
+
+end

data/spec/examples/parser/nodes_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Piggly
+
+  # load support code
+  Parser.parser
+
+  describe NodeClass do
+    describe "source_text"
+    describe "named?"
+
+    context "untagged node" do
+      describe "tagged?"
+      describe "tag_id"
+      describe "tag"
+    end
+
+    context "tagged node" do
+      describe "tagged?"
+      describe "tag_id"
+      describe "tag"
+    end
+  end
+
+  describe Parser::Nodes::Expression do
+    describe "tag" do
+      context "untagged node" do
+        context "named :cond" do
+          context "with parent.while?"
+          context "with parent.loop?"
+          context "with parent.branch?"
+          context "with some other type of parent"
+        end
+
+        context "not named :cond" do
+        end
+      end
+    end
+  end
+
+  describe Parser::Nodes::Sql do
+    describe "tag" do
+      context "untagged node" do
+        context "named :cond" do
+          context "with parent.for?"
+          context "with some other parent"
+        end
+
+        context "not named :cond"
+      end
+    end
+  end
+
+  describe Parser::Nodes::TKeyword do
+    describe "tag" do
+      context "untagged node" do
+        context "named :cond" do
+          context "with parent.loop?"
+          context "with some other parent"
+        end
+
+        context "not named :cond"
+      end
+    end
+  end
+
+  describe Parser::Nodes::Terminal do
+  end
+
+  describe Parser::Nodes::NotImplemented do
+  end
+
+end

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,118 @@
+require 'spec_helper'
+
+module Piggly
+
+describe Parser do
+  
+  describe "parse" do
+    it "returns a thunk" do
+      tree = nil
+
+      expect do
+        tree = Parser.parse('input')
+      end.not_to raise_error
+
+      expect(tree.thunk?).to be_truthy
+    end
+
+    context "when the thunk is evaluated" do
+      before do
+        @parser = double('PigglyParser')
+        allow(Parser).to receive(:parser).and_return(@parser)
+      end
+
+      it "downcases input string before parsing" do
+        input = 'SOURCE CODE'
+
+        allow(@parser).to receive(:failure_reason)
+        expect(@parser).to 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'
+
+          expect(@parser).to receive(:parse).
+            and_return(nil)
+          expect(@parser).to receive(:failure_reason).
+            and_return(reason)
+
+          expect do
+            Parser.parse('SOURCE CODE').force!
+          end.to raise_error(Parser::Failure, reason)
+        end
+      end
+
+      context "when parser succeeds" do
+        it "returns parser's result" do
+          input = 'SOURCE CODE'
+          tree  = double('NodeClass', :message => 'result')
+
+          expect(@parser).to receive(:parse).
+            and_return(tree)
+
+          expect(Parser.parse('SOURCE CODE').message).to eq(tree.message)
+        end
+      end
+
+    end
+  end
+
+  describe "parser" do
+
+    context "when the grammar is older than the generated parser" do
+      before do
+        allow(Util::File).to receive(:stale?).and_return(false)
+      end
+
+      it "does not regenerate the parser" do
+        expect(Treetop::Compiler::GrammarCompiler).not_to receive(:new)
+      # expect(Parser).to receive(:require).
+      #   with(Parser.parser_path)
+
+        Parser.parser
+      end
+
+      it "returns an instance of PigglyParser" do
+        expect(Parser.parser).to be_a(PigglyParser)
+      end
+    end
+
+    context "when the generated parser is older than the grammar" do
+      before do
+        # Reset the cached parser
+        Piggly::Parser.instance_variable_set(:@parser, nil)
+        allow(Util::File).to receive(:stale?).and_return(true)
+      end
+
+      it "regenerates the parser and loads it" do
+        compiler = double('GrammarCompiler')
+        expect(compiler).to receive(:compile).
+          with(Parser.grammar_path, Parser.parser_path)
+
+        expect(Treetop::Compiler::GrammarCompiler).to receive(:new).
+          and_return(compiler)
+
+        expect(Piggly::Parser).to receive(:load).
+          with(Parser.parser_path).and_call_original
+
+        result = Parser.parser
+        expect(result).to be_a(PigglyParser)
+      end
+
+      it "returns an instance of PigglyParser" do
+        expect(Parser.parser).to 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 = double('config', :trace_prefix => 'PIGGLY')
+      @stderr = double('stderr').as_null_object
+      @callback = @profile.notice_processor(@config, @stderr)
+    end
+
+    it "returns a function" do
+      expect(@callback).to 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"
+          expect(@profile).to 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"
+          expect(@profile).to 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!"
+        expect(@stderr).to receive(:puts).with("unknown trace: #{message}")
+        @callback.call(message)
+      end
+    end
+  end
+
+  describe "add" do
+    before do
+      @first  = double('first tag',  :id => 'first')
+      @second = double('second tag', :id => 'second')
+      @third  = double('third tag',  :id => 'third')
+      @cache  = double('Compiler::Cacheable::CacheDirectory')
+
+      @procedure = Dumper::SkeletonProcedure.allocate
+      allow(@procedure).to receive(:oid).and_return('oid')
+    end
+
+    context "without cache parameter" do
+      it "indexes each tag by id" do
+        @profile.add(@procedure, [@first, @second, @third])
+        expect(@profile[@first.id]).to eq(@first)
+        expect(@profile[@second.id]).to eq(@second)
+        expect(@profile[@third.id]).to eq(@third)
+      end
+
+      it "indexes each tag by procedure" do
+        @profile.add(@procedure, [@first, @second, @third])
+        expect(@profile[@procedure]).to eq([@first, @second, @third])
+      end
+    end
+
+    context "with cache parameter" do
+      it "indexes each tag by id" do
+        @profile.add(@procedure, [@first, @second, @third], @cache)
+        expect(@profile[@first.id]).to eq(@first)
+        expect(@profile[@second.id]).to eq(@second)
+        expect(@profile[@third.id]).to eq(@third)
+      end
+
+      it "indexes each tag by procedure" do
+        @profile.add(@procedure, [@first, @second, @third])
+        expect(@profile[@procedure]).to eq([@first, @second, @third])
+      end
+    end
+  end
+
+  describe "ping" do
+    context "when tag isn't in the profile" do
+      it "raises an exception" do
+        expect do
+          @profile.ping('0123456789abcdef')
+        end.to raise_error('No tag with id 0123456789abcdef')
+      end
+    end
+
+    context "when tag is in the profile" do
+      before do
+        @tag = double('tag', :id => '0123456789abcdef')
+        procedure = double('procedure', :oid => nil)
+        @profile.add(procedure, [@tag])
+      end
+
+      it "calls ping on the corresponding tag" do
+        expect(@tag).to 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  = double('first tag',  :id => 'first')
+      @second = double('second tag', :id => 'second')
+      @third  = double('third tag',  :id => 'third')
+      procedure = double('procedure', :oid => nil)
+
+      @profile.add(procedure, [@first, @second, @third])
+    end
+
+    it "calls clear on each tag" do
+      expect(@first).to receive(:clear)
+      expect(@second).to receive(:clear)
+      expect(@third).to 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'