piggly-nsd 2.3.3

data/lib/piggly/command.rb

@@ -0,0 +1,8 @@
+module Piggly
+  module Command
+    autoload :Base,     "piggly/command/base"
+    autoload :Report,   "piggly/command/report"
+    autoload :Trace,    "piggly/command/trace"
+    autoload :Untrace,  "piggly/command/untrace"
+  end
+end

data/lib/piggly/compiler/cache_dir.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+module Piggly
+  module Compiler
+
+    #
+    # Each cache unit (any group of data that should be expired and created
+    # together) can be broken apart, to prevent unmarshaling a huge block of
+    # data all at once.
+    #
+    # The interface works like a Hash, so the compile method should return a
+    # hash of objects. Each object is writen to a different file (named by the
+    # hash key) within the same directory. String objects are (usually) read
+    # and written directly to disk, while all other objects are (un-)Marshal'd
+    #
+    # Cache invalidation is done by comparing mtime timestamps on the cached
+    # object's file to all the "source" files (ruby libs, input files, etc)
+    # required to regenerate the data.
+    #
+    class CacheDir
+      # Non-printable ASCII char indicates data should be Marshal'd
+      HINT = /[\u{0000}-\u{0008}\u{000E}-\u{001F}\u{007F}-\u{00C0}]/
+
+      def initialize(dir)
+        @dir  = dir
+        @data = Hash.new do |h, k|
+          path = File.join(@dir, k.to_s)
+          if File.exist?(path)
+            h[k.to_s] = File.open(path, "rb:UTF-8") do |io|
+              # Detect Marshal'd data
+              if io.read(2) !~ HINT
+                io.rewind
+                io.read
+              else
+                io.rewind
+                Marshal.load(io)
+              end
+            end
+          end
+        end
+      end
+
+      # Load given key from file system into memory if needed
+      #   @return [Object]
+      def [](key)
+        @data[key.to_s]
+      end
+
+      # Writes through to file system
+      #   @return [void]
+      def []=(key, value)
+        @data[key.to_s] = value
+        write(key.to_s => value)
+      end
+
+      # Writes through to file system and returns self
+      #   @return [CacheDir] self
+      def update(hash)
+        hash.each{|k,v| self[k] = v }
+        self
+      end
+
+      # @return [void]
+      def delete(key)
+        path = File.join(@dir, key.to_s)
+        File.unlink(path) if File.exist?(path)
+        @data.delete(key)
+      end
+
+      # @return [Array<String>]
+      def keys
+        Dir[@dir + "/*"].map{|f| File.basename(f) }
+      end
+
+      # Creates cachedir, destroys its contents, and returns self
+      #   @return [CacheDir] self
+      def clear
+        @data.clear
+
+        if File.exist?(@dir)
+          FileUtils.rm(Dir["#{@dir}/*"])
+          FileUtils.touch(@dir)
+        else
+          FileUtils.mkdir(@dir) 
+        end
+
+        self
+      end
+
+      # Clears entire cache, replaces contents, and returns self
+      #   @return [CacheDir] self
+      def replace(hash)
+        clear
+        update(hash)
+      end
+
+    private
+
+      # Serializes each entry to disk
+      #   @return [void]
+      def write(hash)
+        FileUtils.mkdir(@dir) unless File.exist?(@dir)
+        FileUtils.touch(@dir) # Update mtime
+
+        hash.each do |key, value|
+          File.open(File.join(@dir, key.to_s), "wb:UTF-8") do |io|
+            # Marshal if the first two bytes contain non-ASCII
+            if value.is_a?(String) and value[0,2] !~ HINT
+              io.write(value)
+            else
+              Marshal.dump(value, io)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/piggly/compiler/coverage_report.rb

@@ -0,0 +1,63 @@
+module Piggly
+  module Compiler
+
+    #
+    # Produces HTML output to report coverage of tagged nodes in the tree
+    #
+    class CoverageReport
+      include Reporter::HtmlDsl
+
+      def initialize(config)
+        @config = config
+      end
+
+      def compile(procedure, profile)
+        trace = Compiler::TraceCompiler.new(@config)
+
+        if trace.stale?(procedure)
+          raise StaleCacheError,
+            "stale cached syntax tree for #{procedure.name}"
+        end
+
+        # Get (copies of) the tagged nodes from the compiled tree
+        data = trace.compile(procedure)
+
+        return :html  => traverse(data[:tree], profile),
+               :lines => 1 .. procedure.source(@config).count("\n") + 1
+      end
+
+    protected
+
+      # @return [String]
+      def traverse(node, profile, string = "")
+        if node.tagged?
+          tag = profile[node.tag_id]
+
+          if tag.complete?
+            string << %[<span class="#{tag.style}" id="T#{tag.id}">]
+          else
+            string << %[<span class="#{tag.style}" id="T#{tag.id}" title="#{tag.description}">]
+          end
+        end
+
+        if node.terminal?
+          if style = node.style
+            string << %[<span class="#{style}">#{e(node.text_value)}</span>]
+          else
+            string << e(node.text_value)
+          end
+        else
+          # Non-terminals never write their text_value
+          node.elements.each{|child| traverse(child, profile, string) }
+        end
+
+        if node.tagged?
+          string << %[</span>]
+        end
+
+        string
+      end
+
+    end
+  end
+end

data/lib/piggly/compiler/trace_compiler.rb

@@ -0,0 +1,117 @@
+module Piggly
+  module Compiler
+
+    #
+    # Walks the parse tree, attaching Tag values and rewriting source code to ping them.
+    #
+    class TraceCompiler
+      include Util::Cacheable
+
+      def initialize(config)
+        @config = config
+      end
+
+      # Is the cache_path is older than its source path or the other files?
+      def stale?(procedure)
+        Util::File.stale?(cache_path(procedure.source_path(@config)),
+                          procedure.source_path(@config),
+                          *self.class.cache_sources)
+      end
+
+      def compile(procedure)
+        cache = CacheDir.new(cache_path(procedure.source_path(@config)))
+
+        if stale?(procedure)
+          begin
+          $stdout.puts "Compiling #{procedure.name}"
+          tree = Parser.parse(IO.read(procedure.source_path(@config)))
+          tree = tree.force! if tree.respond_to?(:thunk?)
+
+          tags = []
+          code = traverse(tree, procedure.oid, tags)
+
+          cache.replace(:tree => tree, :code => code, :tags => tags)
+          rescue RuntimeError => e
+            $stdout.puts <<-EXMSG
+            ****
+            Error compiling procedure #{procedure.name}
+            Source: #{procedure.source_path(@config)}
+            Exception Message:
+            #{e.message}
+            ****
+            EXMSG
+          end
+
+        end
+
+        cache
+      end
+
+    protected
+
+      # Rewrites the parse tree to call instrumentation helpers, and destructively
+      # updates `tags` by appending the tags of instrumented nodes
+      #   @return [String]
+      def traverse(node, oid, tags)
+        if node.terminal? or node.expression?
+          node.source_text
+        else
+          if node.respond_to?(:condStub) and node.respond_to?(:cond)
+            # Preserve opening parenthesis and whitespace before injecting code. This way 
+            # IF(test) becomes IF(piggly_cond(TAG, test)) instead of IFpiggly_cond(TAG, (test))
+            pre, cond = node.cond.expr.text_value.match(/\A(\(?[\t\n\r ]*)(.+)\z/m).captures
+            node.cond.source_text = ""
+
+            tags << node.cond.tag(oid)
+
+            node.condStub.source_text  = "#{pre}public.piggly_cond($PIGGLY$#{node.cond.tag_id}$PIGGLY$, (#{cond}))"
+            node.condStub.source_text << traverse(node.cond.tail, oid, tags) # preserve trailing whitespace
+          end
+
+          if node.respond_to?(:bodyStub)
+            if node.respond_to?(:exitStub) and node.respond_to?(:cond)
+              tags << node.body.tag(oid)
+              tags << node.cond.tag(oid)
+
+              # Hack to simulate a loop conditional statement in stmtForLoop and stmtLoop.
+              # signal condition is true when body is executed, and false when exit stub is reached
+              node.bodyStub.source_text  = "perform public.piggly_cond($PIGGLY$#{node.cond.tag_id}$PIGGLY$, true);#{node.indent(:bodySpace)}"
+              node.bodyStub.source_text << "perform public.piggly_branch($PIGGLY$#{node.body.tag_id}$PIGGLY$);#{node.indent(:bodySpace)}"
+
+              if node.respond_to?(:doneStub)
+                # Signal the end of an iteration was reached
+                node.doneStub.source_text  = "#{node.indent(:bodySpace)}perform public.piggly_signal($PIGGLY$#{node.cond.tag_id}$PIGGLY$, $PIGGLY$@$PIGGLY$);"
+                node.doneStub.source_text << node.body.indent
+              end
+
+              # Signal the loop terminated
+              node.exitStub.source_text  = "\n#{node.indent}perform public.piggly_cond($PIGGLY$#{node.cond.tag_id}$PIGGLY$, false);"
+            elsif node.respond_to?(:body)
+              # Unconditional branches (or blocks)
+              #   BEGIN ... END;
+              #   ... ELSE ... END;
+              #   CONTINUE label;
+              #   EXIT label;
+              tags << node.body.tag(oid)
+              node.bodyStub.source_text = "perform public.piggly_branch($PIGGLY$#{node.body.tag_id}$PIGGLY$);#{node.indent(:bodySpace)}"
+            end
+          end
+
+          # Traverse children (in which we just injected code)
+          node.elements.map{|e| traverse(e, oid, tags) }.join
+        end
+      end
+    end
+
+    class << TraceCompiler
+
+      # Each of these files' mtimes are used to determine when another file is stale
+      def cache_sources
+        [Parser.grammar_path,
+         Parser.parser_path,
+         Parser.nodes_path]
+      end
+    end
+
+  end
+end

data/lib/piggly/compiler.rb

@@ -0,0 +1,7 @@
+module Piggly
+  module Compiler
+    autoload :CacheDir,       "piggly/compiler/cache_dir"
+    autoload :TraceCompiler,  "piggly/compiler/trace_compiler"
+    autoload :CoverageReport, "piggly/compiler/coverage_report"
+  end
+end

data/lib/piggly/config.rb

@@ -0,0 +1,80 @@
+module Piggly
+  class Config
+  end
+
+  class << Config
+    def path(root, file=nil)
+      if file.nil?
+        root
+      else
+        file[%r{^\.\.|^\/|^(?:[A-Z]:)?/}i] ?
+          file : # ../path, /path, or D:\path that isn't relative to root
+          File.join(root, file)
+      end
+    end
+
+    def mkpath(root, file=nil)
+      if file.nil?
+        FileUtils.makedirs(root)
+        root
+      else
+        path = path(root, file)
+        FileUtils.makedirs(File.dirname(path))
+        path
+      end
+    end
+
+  private
+
+    def config_accessor(hash)
+      hash = hash.clone
+      hash.keys.each do |name|
+        define_method(name) do
+          instance_variable_get("@#{name}") || hash[name]
+        end
+
+        define_method("#{name}?") do
+          instance_variable_get("@#{name}") || hash[name]
+        end
+
+        define_method("#{name}=") do |value|
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+  end
+
+  class Config
+    attr_accessor \
+      :cache_root,
+      :report_root,
+      :database_yml,
+      :connection_name,
+      :trace_prefix,
+      :accumulate,
+      :dry_run,
+      :filters
+
+    alias accumulate? accumulate
+    alias dry_run? dry_run
+
+    def path(*args)
+      self.class.path(*args)
+    end
+
+    def mkpath(*args)
+      self.class.mkpath(*args)
+    end
+
+    def initialize
+      @cache_root       = File.expand_path("#{Dir.pwd}/piggly/cache")
+      @report_root      = File.expand_path("#{Dir.pwd}/piggly/reports")
+      @database_yml     = nil
+      @connection_name  = "piggly"
+      @trace_prefix     = "PIGGLY"
+      @accumulate       = false
+      @dry_run          = false
+      @filters          = []
+    end
+  end
+end

data/lib/piggly/dumper/index.rb

@@ -0,0 +1,121 @@
+module Piggly
+  module Dumper
+
+    #
+    # The index file stores metadata about every procedure, but the source
+    # code is stored in a separate file for each procedure.
+    #
+    class Index
+
+      def initialize(config)
+        @config = config
+      end
+
+      # @return [String]
+      def path
+        @config.mkpath("#{@config.cache_root}/Dumper", "index.yml")
+      end
+
+      # Updates the index with the given list of Procedure values
+      # @return [void]
+      def update(procedures)
+        newest = Util::Enumerable.index_by(procedures){|x| x.identifier }
+
+        removed = index.values.reject{|p| newest.include?(p.identifier) }
+        removed.each{|p| p.purge_source(@config) }
+
+        added = procedures.reject{|p| index.include?(p.identifier) }
+        added.each{|p| p.store_source(@config) }
+
+        changed = procedures.select do |p|
+          if mine = index[p.identifier]
+            # If both are skeletons, they will have the same source because they
+            # are read from the same file, so don't bother checking that case
+            not (mine.skeleton? and p.skeleton?) and
+              mine.source(@config) != p.source(@config)
+          end
+        end
+        changed.each{|p| p.store_source(@config) }
+
+        @index = newest
+        store_index
+      end
+
+      # Returns a list of Procedure values from the index
+      def procedures
+        index.values
+      end
+
+      # Returns the Procedure with the given identifier
+      def [](identifier)
+        p = index[identifier]
+        p.dup if p
+      end
+
+      # Returns the shortest human-readable label that distinctly identifies
+      # the given procedure from the other procedures in the index
+      def label(procedure)
+        others =
+          procedures.reject{|p| p.oid == procedure.oid }
+
+        same =
+          others.all?{|p| p.name.schema == procedure.name.schema }
+
+        name =
+          if same
+            procedure.name.name
+          else
+            procedure.name.to_s
+          end
+
+        samenames =
+          others.select{|p| p.name == procedure.name }
+
+        if samenames.empty?
+          # Name is unique enough
+          name.to_s
+        else
+          sameargs =
+            samenames.select{|p| p.arg_types == procedure.arg_types }
+
+          if sameargs.empty?
+            # Name and arg types are unique enough
+            "#{name}(#{procedure.arg_types.join(", ")})"
+          else
+            samemodes =
+              sameargs.select{|p| p.arg_modes == procedure.arg_modes }
+
+            if samemodes.empty?
+              # Name, arg types, and arg modes are unique enough
+              "#{name}(#{procedure.arg_modes.zip(procedure.arg_types).map{|a,b| "#{a} #{b}" }.join(", ")})"
+            end
+          end
+        end
+      end
+
+    private
+
+      def index
+        @index ||= load_index
+      end
+
+      # Load the index from disk
+      def load_index
+        contents =
+          unless File.exist?(path)
+            []
+          else
+            YAML.unsafe_load(File.read(path, encoding: 'UTF-8'))
+          end
+
+        Util::Enumerable.index_by(contents){|x| x.identifier }
+      end
+
+      # Write the index to disk
+      def store_index
+        File.open(path, "wb:UTF-8"){|io| YAML.dump(procedures.map{|p| p.skeleton }, io) }
+      end
+
+    end
+  end
+end

data/lib/piggly/dumper/qualified_name.rb

@@ -0,0 +1,36 @@
+module Piggly
+  module Dumper
+
+    class QualifiedName
+      attr_reader :schema, :name
+
+      def initialize(schema, name)
+        @schema, @name = schema, name
+      end
+
+      # @return [String]
+      def quote
+        if @schema
+          '"' + @schema + '"."' + @name + '"'
+        else
+          '"' + @name + '"'
+        end
+      end
+
+      # @return [String]
+      def to_s
+        if @schema
+          @schema + "." + @name
+        else
+          @name
+        end
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        self.to_s == other.to_s
+      end
+    end
+
+  end
+end

data/lib/piggly/dumper/qualified_type.rb

@@ -0,0 +1,141 @@
+module Piggly
+  module Dumper
+
+    # used for RETURN TABLE(...)
+    class RecordType
+      attr_reader :types, :names, :modes, :defaults
+
+      def initialize(types, names, modes, defaults)
+        @types, @names, @modes, @defaults =
+          types, names, modes, defaults
+      end
+
+      def quote
+        "table (#{@types.zip(@names, @modes, @defaults).map do |type, name, mode, default|
+          "#{name.quote + " " if name}#{type.quote}#{" default " + default if default}"
+        end.join(", ")})"
+      end
+
+      def table?
+        true
+      end
+    end
+
+    class QualifiedType
+      attr_reader :schema, :name
+
+      def self.parse(name, rest = nil)
+        if rest.to_s == ""
+          schema = nil
+        else
+          schema = unquote(name)
+          name   = rest
+        end
+
+        case name
+        when /(.*)\[\]$/
+          name  = $1
+          array = "[]"
+        else
+          array = ""
+        end
+
+        if schema.to_s == ""
+          fst, snd = name.split(".", 2)
+          if snd.nil?
+            new(nil, unquote(fst), array)
+          else
+            new(unquote(fst), unquote(snd), array)
+          end
+        else
+          new(schema, unquote(name), array)
+        end
+      end
+
+      def self.unquote(s)
+        return s if s.nil?
+        s[/^"(.*)"$/, 1] || s
+      end
+
+      def initialize(schema, name, array)
+        @schema, @name, @array = schema, name, array
+      end
+
+      def table?
+        false
+      end
+
+      def shorten
+        self.class.new(nil, @name, @array)
+      end
+
+      def quote
+        if @schema
+          '"' + @schema + '"."' + normalize(@name) + '"' + @array
+        else
+          '"' + normalize(@name) + '"' + @array
+        end
+      end
+
+      def to_s
+        unless [nil, "", "pg_catalog"].include?(@schema)
+          @schema + "." + readable(@name) + @array
+        else
+          readable(@name) + @array
+        end
+      end
+
+      def ==(other)
+        self.to_s == other.to_s
+      end
+
+    protected
+
+      def normalize(name)
+        unless [nil, "", "pg_catalog"].include?(@schema)
+          return name
+        end
+
+        # select format_type(ret.oid, null), ret.typname
+        # from pg_type as ret
+        # where ret.typname <> format_type(ret.oid, null)
+        #   and ret.typname not like '\\_%'
+        # group by ret.typname, format_type(ret.oid, null)
+        # order by format_type(ret.oid, null);
+        case name
+        when '"any"'                        then "any"
+        when "bigint"                       then "int8"
+        when "bit varying"                  then "varbit"
+        when "boolean"                      then "bool"
+        when '"char"'                       then "char"
+        when "character"                    then "bpchar"
+        when "character varying"            then "varchar"
+        when "double precision"             then "float8"
+        when "information_schema\.(.*)"     then $1
+        when "integer"                      then "int4"
+        when "real"                         then "float4"
+        when "smallint"                     then "int2"
+        when "timestamp without time zone"  then "timestamp"
+        when "timestamp with time zone"     then "timestamptz"
+        when "time without time zone"       then "time"
+        when "time with time zone"          then "timetz"
+        else name
+        end
+      end
+
+      def readable(name)
+        case name
+        when /^_(.*)/                 then "#{readable($1)}[]"
+        when "bpchar"                 then "char"
+        when /^float4(.*)/            then "real#{$1}"
+        when /^int2(.*)/              then "smallint#{$1}"
+        when /^int4(.*)/              then "int#{$1}"
+        when /^int8(.*)/              then "bigint#{$1}"
+        when /^serial4(.*)/           then "serial#{$1}"
+        else name
+        end
+      end
+    end
+
+  end
+end