piggly 1.2.1 → 2.0.0

data/lib/piggly/config.rb

@@ -1,34 +1,19 @@
 module Piggly
   class Config
+  end
 
-    def self.config_accessor(hash)
-      hash.keys.each do |name|
-        self.class.send(:define_method, name) do
-          instance_variable_get("@#{name}") || hash[name]
-        end
-        self.class.send(:define_method, "#{name}=") do |value|
-          instance_variable_set("@#{name}", value)
-        end
-      end
-    end
-
-    config_accessor :cache_root   => File.expand_path(File.join(Dir.pwd, 'piggly', 'cache')),
-                    :report_root  => File.expand_path(File.join(Dir.pwd, 'piggly', 'reports')),
-                    :piggly_root  => PIGGLY_ROOT,
-                    :trace_prefix => 'PIGGLY',
-                    :aggregate    => false
-
-    def self.path(root, file=nil)
-      if file
+  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)
-      else
-        root
       end
     end
 
-    def self.mkpath(root, file=nil)
+    def mkpath(root, file=nil)
       if file.nil?
         FileUtils.makedirs(root)
         root
@@ -39,5 +24,45 @@ module Piggly
       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
+    config_accessor \
+      :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          => []
+
+    alias accumulate? accumulate
+
+    def path(*args)
+      self.class.path(*args)
+    end
+
+    def mkpath(*args)
+      self.class.mkpath(*args)
+    end
   end
 end

data/lib/piggly/dumper.rb

@@ -0,0 +1,9 @@
+module Piggly
+  module Dumper
+    autoload :Index,              "piggly/dumper/index"
+    autoload :QualifiedName,      "piggly/dumper/qualified_name"
+    autoload :QualifiedType,      "piggly/dumper/qualified_type"
+    autoload :ReifiedProcedure,   "piggly/dumper/reified_procedure"
+    autoload :SkeletonProcedure,  "piggly/dumper/skeleton_procedure"
+  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.exists?(path)
+            []
+          else
+            YAML.load(File.read(path))
+          end
+
+        Util::Enumerable.index_by(contents){|x| x.identifier }
+      end
+
+      # Write the index to disk
+      def store_index
+        File.open(path, "wb"){|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,81 @@
+module Piggly
+  module Dumper
+
+    class QualifiedType
+      attr_reader :schema, :name
+
+      def initialize(schema, name)
+        @schema, @name = schema, normalize(name)
+      end
+
+      def shorten
+        self.class.new(nil, @name)
+      end
+
+      def quote
+        if @schema
+          '"' + @schema + '"."' + @name + '"'
+        else
+          '"' + @name + '"'
+        end
+      end
+
+      def to_s
+        if @schema and !%w[public pg_catalog].include?(@schema)
+          @schema + "." + readable(@name)
+        else
+          readable(@name)
+        end
+      end
+
+      def ==(other)
+        self.to_s == other.to_s
+      end
+
+    protected
+
+      def normalize(name)
+        # 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 /(.*)\[\]/                     then "_#{normalize($1)}"
+        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

data/lib/piggly/dumper/reified_procedure.rb

@@ -0,0 +1,142 @@
+module Piggly
+  module Dumper
+
+    #
+    # Differs from SkeletonProcedure in that the procedure source code is stored
+    # as an instance variable.
+    #
+    class ReifiedProcedure < SkeletonProcedure
+
+      def initialize(source, *args)
+        super(*args)
+        @source = source.strip
+      end
+
+      # @return [String]
+      def source(config)
+        @source
+      end
+
+      # @return [void]
+      def store_source(config)
+        if @source.include?("$PIGGLY$")
+          raise "Procedure `#{@name}' is already instrumented. " +
+                "This means the original source wasn't restored after the " +
+                "last coverage run. You must restore the source manually."
+        end
+
+        File.open(source_path(config), "wb"){|io| io.write(@source) }
+      end
+
+      # @return [SkeletonProcedure]
+      def skeleton
+        SkeletonProcedure.new(@oid, @name, @strict, @secdef, @setof, @type,
+                              @volatility, @arg_modes, @arg_names, @arg_types,
+                              @arg_defaults)
+      end
+
+      def skeleton?
+        false
+      end
+    end
+
+    class << ReifiedProcedure
+      # Rewrite "i", "o", and "b", otherwise pass-through
+      MODES = Hash.new{|h,k| k }.update \
+        "i" => "in",
+        "o" => "out",
+        "b" => "inout",
+        "v" => "variadic"
+
+      # Rewrite "i", "v", and "s", otherwise pass-through
+      VOLATILITY = Hash.new{|h,k| k }.update \
+         "i" => "immutable",
+         "v" => "volatile",
+         "s" => "stable"
+
+      def mode(mode)
+        MODES[mode]
+      end
+
+      def volatility(mode)
+        VOLATILITY[mode]
+      end
+
+      def defaults(exprs, count, total)
+        exprs = exprs.split(", ")
+        nreqd = total - count
+
+        if nreqd > 0 and exprs.length == count
+          Array.new(nreqd) + exprs
+        else
+          raise "Couldn't parse default arguments"
+        end
+      end
+
+      # Returns a list of all PL/pgSQL stored procedures in the current database
+      #
+      # @return [Array<ReifiedProcedure>]
+      def all(connection)
+        connection.query(<<-SQL).map{|x| from_hash(x) }
+          select
+            pro.oid,
+            nschema.nspname   as nschema,
+            pro.proname       as name,
+            pro.proisstrict   as strict,
+            pro.prosecdef     as secdef,
+            pro.provolatile   as volatility,
+            pro.proretset     as setof,
+            rschema.nspname   as tschema,
+            ret.typname       as type,
+            pro.prosrc        as source,
+            pro.pronargs      as arg_count,
+            array_to_string(pro.proargmodes, ',') as arg_modes,
+            array_to_string(pro.proargnames, ',') as arg_names,
+            case when proallargtypes is not null then
+                   -- use proalltypes array if its non-null
+                   array_to_string(array(select format_type(proallargtypes[k], null)
+                                         from generate_series(array_lower(proallargtypes, 1),
+                                                              array_upper(proallargtypes, 1)) as k), ',')
+                 else
+                   -- fallback to oidvector proargtypes
+                   oidvectortypes(pro.proargtypes)
+                 end as arg_types,
+            pro.pronargdefaults as arg_defaults_count,
+            coalesce(pg_get_expr(pro.proargdefaults, 0), '') as arg_defaults
+          from pg_proc as pro,
+               pg_type as ret,
+               pg_namespace as nschema,
+               pg_namespace as rschema
+          where pro.pronamespace = nschema.oid
+            and ret.typnamespace = rschema.oid
+            and pro.proname not like 'piggly_%'
+            and pro.prorettype = ret.oid
+            and pro.prolang = (select oid from pg_language where lanname = 'plpgsql')
+            and pro.pronamespace not in (select oid
+                                         from pg_namespace
+                                         where nspname like 'pg_%'
+                                            or nspname like 'information_schema')
+        SQL
+      end
+
+      # Construct a ReifiedProcedure from a result row (Hash)
+      #
+      # @return [ReifiedProcedure]
+      def from_hash(hash)
+        new(hash["source"],
+            hash["oid"],
+            QualifiedName.new(hash["nschema"], hash["name"]),
+            hash["strict"] == "t",
+            hash["secdef"] == "t",
+            hash["setof"]  == "t",
+            QualifiedType.new(hash["tschema"], hash["type"]),
+            volatility(hash["volatility"]),
+            hash["arg_modes"].to_s.split(",").map{|x| mode(x.strip) },
+            hash["arg_names"].to_s.split(",").map{|x| QualifiedName.new(nil, x.strip) },
+            hash["arg_types"].to_s.split(",").map{|x| QualifiedType.new(nil, x.strip) },
+            defaults(hash["arg_defaults"], hash["arg_defaults_count"].to_i, hash["arg_count"].to_i))
+      end
+    end
+
+  end
+end