piggly-nsd 2.3.3

data/spec/issues/032_spec.rb

@@ -0,0 +1,98 @@
+require "spec_helper"
+
+module Piggly
+  describe "github issue #32" do
+
+    # note: both -r always subtracts and -s always adds
+    # from left-to-right.
+    #
+    # if the first filter is -s, then the set starts empty
+    # and -s adds to it.
+    #
+    # if the first filter is -r, then the set starts with
+    # all procedures and -r removes from it.
+
+    def result(args)
+      index = double("index", :procedures => [
+                double("public.a", :name => "public.a"),
+                double("public.b", :name => "public.b"),
+                double("public.c", :name => "public.c"),
+                double("public.d", :name => "public.d")])
+      config = Command::Trace.configure(args.dup)
+      result = Command::Trace.filter(config, index)
+      result.map(&:name).sort
+    end
+    
+    context "with one -s argument" do
+      let(:args) { %w(-s public.c) }
+
+      it "selects matching procs" do
+        result(args).should == ["public.c"]
+      end
+    end
+
+    context "with -s regular expression" do
+      let(:args) { %w(-s /public.[bcd]/) }
+
+      it "selects matching procs" do
+        result(args).should == [
+          "public.b",
+          "public.c",
+          "public.d"]
+      end
+    end
+
+    context "with two -s arguments" do
+      let(:args) { %w(-s public.b -s public.d) }
+
+      it "adds matching procs" do
+        result(args).should == [
+          "public.b",
+          "public.d"]
+      end
+    end
+
+    context "with one -r argument" do
+      let(:args) { %w(-r public.c) }
+
+      it "rejects matching procs" do
+        result(args).should == [
+          "public.a",
+          "public.b",
+          "public.d"]
+      end
+    end
+
+    context "with two -r arguments" do
+      let(:args) { %w(-r public.b -r public.d) }
+
+      it "subtracts rejected procs" do
+        result(args).should == [
+          "public.a",
+          "public.c"]
+      end
+    end
+
+    context "with -s then -r" do
+      let(:args) { %w(-s /\.[abc]/ -r public.b -r public.d) }
+
+      it "-r removes from -s matches" do
+        result(args).should == [
+          "public.a",
+          "public.c"]
+      end
+    end
+
+    context "with -r then -s" do
+      let(:args) { %w(-r /\.[bc]/ -s public.b -s public.a) }
+
+      it "-s adds to -r non-matches" do
+        result(args).should == [
+          "public.a",
+          "public.b",
+          "public.d"]
+      end
+    end
+
+  end
+end

data/spec/issues/036_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+module Piggly
+  describe "github issue #32" do
+    include GrammarHelper
+
+    it "can parse a GET DIAGNOSTICS statement" do
+      node = parse(:statement, "GET DIAGNOSTICS v_cnt = ROw_COUNT;")
+      node.should be_statement
+    end
+
+	it "can parse a procedure with GET DIAGNOSTICS" do
+      body = <<-SQL
+      DECLARE
+        v_cnt INTEGER;
+      BEGIN
+        INSERT INTO foo.foo_table(bar, barbar_fl, foofoo_fl, bazbaz_ts)
+          SELECT
+            a.zoorzoor_id,
+            b.zap_fl,
+            b.zip_fl,
+            current_timestamp
+          FROM unnest(p_baz) a
+            INNER JOIN foo.zimzam b
+              ON a.zoor_id = b.zoor_id
+        ON CONFLICT (bar)
+          DO UPDATE SET barbar_fl= excluded.barbar_fl, foofoo_fl= excluded.foofoo_fl, last_updt_ts=current_timestamp;
+        GET DIAGNOSTICS v_cnt = ROW_COUNT;
+        RAISE NOTICE Updated % bar stuffs', v_cnt;
+        RETURN v_cnt;
+      END;
+      SQL
+
+      node = parse(:start, body.strip.downcase)
+      node.count{|e| e.sql? }.should == 1
+      node.count{|e| Parser::Nodes::Raise === e }.should == 1
+      node.count{|e| Parser::Nodes::Return === e }.should == 1
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,312 @@
+require "rspec"
+require "ostruct"
+require File.expand_path("#{File.dirname(__FILE__)}/../lib/piggly")
+
+# RSpec 3 configuration
+RSpec.configure do |config|
+  # Enable both should and expect syntax during transition
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    expectations.syntax = [:should, :expect]
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+    mocks.syntax = [:should, :expect]
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end
+
+# load runtime dependencies
+Piggly::Parser.parser
+
+module Piggly
+  module GrammarHelper
+
+    COMMENTS = ["abc defghi", "abc -- abc", "quote's", "a 'str'"]
+
+    SQLWORDS = %w[select insert update delete drop alter commit set start]
+
+    KEYWORDS = %w[as := = alias begin by constant continue
+                  cursor debug declare diagnostics else elsif elseif
+                  end exception execute exit for from get if
+                  in info insert into is log loop not notice
+                  null or raise rename result_oid return
+                  reverse row_count scroll strict then to type warning
+                  when while]
+
+    def parse(root, input)
+      string = input.downcase
+      parser = Parser.parser
+      parser.root = root
+      parser.consume_all_input = true
+      parser.parse(string) or raise Parser::Failure, parser.failure_reason
+    ensure
+      string.replace input
+    end
+
+    def parse_some(root, input)
+      string = input.downcase
+      parser = Parser.parser
+      parser.root = root
+      parser.consume_all_input = false
+      node = parser.parse(string)
+      raise Parser::Failure, parser.failure_reason unless node
+      return node, input[parser.index..-1]
+    ensure
+      string.replace input
+    end
+  end
+
+  # mock NodeClass
+  class N < OpenStruct
+    # Constructs a terminal
+    def self.terminal(text, hash = {})
+      new({:text_value => text,
+           :terminal?  => true}.update(hash))
+    end
+
+    def self.keyword(text)
+      terminal(text)
+    end
+
+    # Create a tSpace node
+    def self.space(text = ' ')
+      terminal(text)
+    end
+
+    # Constructs an inline tComment
+    def self.inline_comment(text)
+      terminal("/* #{text} */",
+               :content  => text,
+               :elements => ['/*', " #{text} ", '*/'])
+    end
+
+    # Constructs a rest-of-the-line comment
+    def self.line_comment(text)
+      terminal("-- #{text}\n",
+               :content  => text,
+               :elements => ['--', " #{text}", "\n"])
+    end
+
+    # Constructs a stubNode
+    def self.stub
+      terminal("")
+    end
+
+    # Constructs an expressionUntil-type node
+    def self.expr(code)
+      Node.new :head => ' ',
+               :expr => code,
+               :tail => ' ',
+               :elements => [:head, :expr, :tail]
+    end
+
+    # Constructs a sequence (of statements usually)
+    def self.sequence(*elements)
+      Node.new :elements  => elements
+    end
+
+    # Constructs BEGIN/END block or ELSE block
+    def self.block(declare, statements)
+      Node.new :bodySpace => ' ',
+               :bodyStub  => stub,
+               :body      => sequence(*statements),
+               :elements  => [keyword('begin'), :bodySpace, :bodyStub, :body, keyword('end'), terminal(';')]
+    end
+    
+    # Construct a CASE with a match expression
+    def self.case(expression, *whens)
+      Node.new :expr     => expr(expression),
+               :cases    => whens,
+               :elements => [keyword('case'), space, :expr, :cases, keyword('end'), space, keyword('case'), terminal(';')]
+    end
+
+    # Construct a CASE with no match expression
+    def self.cond(*whens)
+      Node.new :cases    => whens,
+               :elements => [keyword('case'), space, :cases, keyword('end'), space, keyword('case'), terminal(';')]
+    end
+
+    # Constructs a WHEN branch for a CASE with a match expression
+    def self.casewhen(pattern, *statements)
+      Node.new :condSpace => space,
+               :cond      => expr(pattern),
+               :bodySpace => space,
+               :body      => sequence(*statements),
+               :elements  => [keyword('when'), :condSpace, :cond, keyword('then'), :bodySpace, :bodyStub, :body]
+    end
+
+    # Constructs a WHEN branch for a CASE with no match expression
+    def self.condwhen(expression, *statements)
+      Node.new :condSpace => space,
+               :condStub  => stub,
+               :cond      => expr(expression),
+               :bodySpace => space,
+               :body      => sequence(*statements),
+               :elements  => [keyword('when'), :condSpace, :condStub, :cond, keyword('then'), :bodySpace, :bodyStub, :body]
+    end
+
+    # Constructs an IF or ELSIF
+    def self.if(cond, body, other)
+      Node.new :condSpace => nil,
+               :condStub  => stub,
+               :cond      => expr(cond),
+               :bodySpace => ' ',
+               :bodyStub  => stub,
+               :body      => body,
+               :else      => other,
+               :elements  => [keyword('if'), :condSpace, :condStub, :cond, keyword('then'), :bodySpace, :body, :else, keyword('end'), space, keyword('if'), terminal(';')]
+    end
+
+    # Constructs an unconditional LOOP
+    def self.loop(*statements)
+      Node.new :bodySpace => space,
+               :bodyStub  => stub,
+               :body      => sequence(*statements),
+               :doneStub  => stub,
+               :elements  => [keyword('loop'), :bodySpace, :bodyStub, :body, :doneStub, keyword('end'), space, keyword('loop'), terminal(';'), :exitStub]
+    end
+
+    # Constructs a WHILE loop
+    def self.while(condition, *statements)
+      Node.new :condSpace => space,
+               :condStub  => stub,
+               :cond      => expr(condition),
+               :bodySpace => space,
+               :bodyStub  => stub,
+               :body      => sequence(*statements),
+               :exitStub  => stub,
+               :elements  => [keyword('while'), :condSpace, :condStub, :cond, keyword('loop'), :bodySpace, :bodyStub, :body, keyword('end'), space, keyword('loop'), terminal(';')]
+    end
+
+    # Constructs a FOR loop
+    def self.for(idents, iterator, *statements)
+      Node.new :condSpace => space,
+               :cond      => expr(iterator),
+               :bodySpace => space,
+               :bodyStub  => stub,
+               :body      => sequence(*statements),
+               :doneStub  => stub,
+               :exitStub  => stub,
+               :elements  => [keyword('for'), space, idents, keyword('in'), :condSpace, :cond, keyword('loop'), :bodySpace, :bodyStub, :body, :doneStub, keyword('end'), space, keyword('loop'), terminal(';'), :exitStub]
+    end
+
+    # Constructs an EXIT statement
+    def self.exit(condition = nil)
+      if condition
+        Node.new :body      => keyword('exit'),
+                 :condSpace => space,
+                 :condStub  => stub,
+                 :cond      => expr(condition),
+                 :elements  => [:body, space, keyword('when'), :condSpace, :condStub, :cond, terminal(';')]
+      else
+        Node.new :bodyStub  => stub,
+                 :body      => keyword('exit'),
+                 :elements  => [:bodyStub, :body, ';']
+      end
+    end
+
+    # Constructs a CONTINUE statement
+    def self.continue(condition = nil)
+      if condition
+        Node.new :body      => keyword('continue'),
+                 :condSpace => space,
+                 :condStub  => stub,
+                 :cond      => expr(condition),
+                 :elements  => [:body, space, keyword('when'), :condSpace, :condStub, :cond, terminal(';')]
+      else
+        Node.new :bodyStub  => stub,
+                 :body      => keyword('exit'),
+                 :elements  => [:bodyStub, :body, ';']
+      end
+    end
+
+    # Constructs a RETURN statement
+    def self.return(value)
+      Node.new :bodyStub => stubNode,
+               :body     => sequence(keyword('return'), expr(value)),
+               :elements => [:bodyStub, :body]
+    end
+
+    # Constructs a RAISE statement
+    def self.raise(level, message)
+      if level == 'exception'
+        Node.new :bodyStub => stubNode,
+                 :body     => sequence(keyword('raise'), space, keyword('exception'), space, expr(message), terminal(';')),
+                 :elements => [:bodyStub, :body]
+      else
+        Node.new :elements => [keyword('raise'), space, keyword(level), space, expr(message), terminal(';')]
+      end
+    end
+
+    class Node < N
+      def initialize(hash)
+        if elements = hash[:elements]
+          elements.map!{|e| e.is_a?(Symbol) ? hash.fetch(e) : e }
+        end
+
+        super(hash)
+      end
+
+      def text_value
+        @text_value ||= elements.inject('') do |string, e|
+          string << e.text_value
+        end
+      end
+    end
+
+    def initialize(hash)
+      super({:parent      => nil,
+             :terminal?   => false,
+             :expression? => false,
+             :branch?     => false,
+             :block?      => false,
+             :stub?       => false,
+             :loop?       => false,
+             :for?        => false,
+             :while?      => false,
+             :style       => nil,
+             :sourceText  => nil }.update(hash))
+
+      elements.each{|c| c.parent = self } if elements
+    end
+
+    # Recursively compute the byte-offsets within the source text
+    def interval(start=0)
+      @start ||= start
+      @stop  ||= if terminal?
+                   @start + text_value.size
+                 else
+                   # recursively compute intervals
+                   elements.inject(@start) do |prev, e|
+                     e.interval(prev).end
+                   end
+                 end
+      @start...@stop
+    end
+
+    def source_text
+      @source_text || text_value
+    end
+
+    def tap
+      yield self
+      self
+    end
+  end
+end
+
+module Enumerable
+  def test_each
+    each do |o|
+      begin
+        yield o
+      rescue
+        $!.message << "; while evaluating #{o}"
+        raise
+      end
+    end
+  end
+end

data/spec/spec_suite.rb

@@ -0,0 +1,5 @@
+dir = File.dirname(__FILE__)
+
+Dir["#{dir}/**/*_spec.rb"].each do |spec|
+  require spec
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: piggly-nsd
+version: !ruby/object:Gem::Version
+  version: 2.3.3
+platform: ruby
+authors:
+- Kvle Putnam
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.18.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.18.4
+description: PostgreSQL PL/pgSQL stored procedure code coverage (NSD fork)
+email: putnam.kvle@gmail.com
+executables:
+- piggly
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/piggly
+- lib/piggly.rb
+- lib/piggly/command.rb
+- lib/piggly/command/base.rb
+- lib/piggly/command/report.rb
+- lib/piggly/command/trace.rb
+- lib/piggly/command/untrace.rb
+- lib/piggly/compiler.rb
+- lib/piggly/compiler/cache_dir.rb
+- lib/piggly/compiler/coverage_report.rb
+- lib/piggly/compiler/trace_compiler.rb
+- lib/piggly/config.rb
+- lib/piggly/dumper.rb
+- lib/piggly/dumper/index.rb
+- lib/piggly/dumper/qualified_name.rb
+- lib/piggly/dumper/qualified_type.rb
+- lib/piggly/dumper/reified_procedure.rb
+- lib/piggly/dumper/skeleton_procedure.rb
+- lib/piggly/installer.rb
+- lib/piggly/parser.rb
+- lib/piggly/parser/grammar.tt
+- lib/piggly/parser/nodes.rb
+- lib/piggly/parser/traversal.rb
+- lib/piggly/parser/treetop_ruby19_patch.rb
+- lib/piggly/profile.rb
+- lib/piggly/reporter.rb
+- lib/piggly/reporter/base.rb
+- lib/piggly/reporter/html_dsl.rb
+- lib/piggly/reporter/index.rb
+- lib/piggly/reporter/procedure.rb
+- lib/piggly/reporter/resources/highlight.js
+- lib/piggly/reporter/resources/piggly.css
+- lib/piggly/reporter/resources/sortable.js
+- lib/piggly/tags.rb
+- lib/piggly/task.rb
+- lib/piggly/util.rb
+- lib/piggly/util/blankslate.rb
+- lib/piggly/util/cacheable.rb
+- lib/piggly/util/enumerable.rb
+- lib/piggly/util/file.rb
+- lib/piggly/util/process_queue.rb
+- lib/piggly/util/thunk.rb
+- lib/piggly/version.rb
+- spec/examples/compiler/cacheable_spec.rb
+- spec/examples/compiler/report_spec.rb
+- spec/examples/compiler/trace_spec.rb
+- spec/examples/config_spec.rb
+- spec/examples/dumper/index_spec.rb
+- spec/examples/dumper/procedure_spec.rb
+- spec/examples/grammar/expression_spec.rb
+- spec/examples/grammar/statements/assignment_spec.rb
+- spec/examples/grammar/statements/declaration_spec.rb
+- spec/examples/grammar/statements/exception_spec.rb
+- spec/examples/grammar/statements/if_spec.rb
+- spec/examples/grammar/statements/loop_spec.rb
+- spec/examples/grammar/statements/sql_spec.rb
+- spec/examples/grammar/tokens/comment_spec.rb
+- spec/examples/grammar/tokens/datatype_spec.rb
+- spec/examples/grammar/tokens/identifier_spec.rb
+- spec/examples/grammar/tokens/keyword_spec.rb
+- spec/examples/grammar/tokens/label_spec.rb
+- spec/examples/grammar/tokens/literal_spec.rb
+- spec/examples/grammar/tokens/lval_spec.rb
+- spec/examples/grammar/tokens/number_spec.rb
+- spec/examples/grammar/tokens/sqlkeywords_spec.rb
+- spec/examples/grammar/tokens/string_spec.rb
+- spec/examples/grammar/tokens/whitespace_spec.rb
+- spec/examples/installer_spec.rb
+- spec/examples/parser/nodes_spec.rb
+- spec/examples/parser/traversal_spec.rb
+- spec/examples/parser_spec.rb
+- spec/examples/profile_spec.rb
+- spec/examples/reporter/html/dsl_spec.rb
+- spec/examples/reporter/html/index_spec.rb
+- spec/examples/reporter/html_spec.rb
+- spec/examples/reporter_spec.rb
+- spec/examples/tags_spec.rb
+- spec/examples/task_spec.rb
+- spec/examples/util/cacheable_spec.rb
+- spec/examples/util/enumerable_spec.rb
+- spec/examples/util/file_spec.rb
+- spec/examples/util/process_queue_spec.rb
+- spec/examples/util/thunk_spec.rb
+- spec/examples/version_spec.rb
+- spec/issues/007_spec.rb
+- spec/issues/008_spec.rb
+- spec/issues/018_spec.rb
+- spec/issues/028_spec.rb
+- spec/issues/032_spec.rb
+- spec/issues/036_spec.rb
+- spec/spec_helper.rb
+- spec/spec_suite.rb
+homepage: https://github.com/sergeiboikov/piggly
+licenses:
+- BSD-2-Clause
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: PL/pgSQL code coverage tool (NSD fork)
+test_files: []