pg_funcall 0.1.0 → 0.1.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzIxZDQ2YzkwNTc2MTZjMjNmMWRlNjY2M2M0YmE4YWUyY2Q5MTZiZQ==
+    NTZmYzA2NzhiMGI5NTc1OTVhZDJmOWI3MjdmMzc1OTA1ZThmZDgzYQ==
   data.tar.gz: !binary |-
-    M2I5OGY2NWI3ZmZhZmQzNjdkNzI5ZjQ3ZmIyZGExZTc3MmEzM2Q5Mw==
+    ZjFkN2I1ODI5ZmY3ODJhODg5ZmUyZjJlYWU3YzdiZjU2ZTNhNDRlZA==
 SHA512:
   metadata.gz: !binary |-
-    ZDhmYzEwYzc1MzIxMjJjODcxZGM5ZGRjOTkyNmY4ZmIxNzlmY2U2Y2YzNzM3
-    OWNiNTJhZWJjMDYwNWZmN2RkNzBmMTVlM2Q1ODk1ZmM4NzRkMjVhMjU5Mzcx
-    NmQxN2QxY2U5NWUzYmM3NzdhNDkxNDg0NTkzOTdhYzUyYzYzNTI=
+    OGEyNjg1N2Y0MWNhZjY5NDJjZjc5MDEzN2FkMmRhYmY2ODYxZTY1ZDM3NzIw
+    ZmUyOWNjMzJmNDkwOTEzMDA0N2FmMzZhZGY4OGFmMzU5MjM1MjkyZmMzMmYy
+    MWIxOTI2NDdhODM5MjE0NzA0MWM5ZGFlMmE0ODA5NmJjNTE5Njc=
   data.tar.gz: !binary |-
-    YjAxZDQyODNmZjczMzk3NzkxZmQ3NGVlN2FkZDk1Y2I1YTQ2M2VjZjQxNTNl
-    NDBlZmEzNzczNTMzZjcwZWIyNjgwMDFiNzUyMmFiZjk4ZjNjMTViODhjYTMy
-    ODkwMTk4Njc3NzEyMDg2MTQ1NGM4NGVhOWI1YTQ1ZjMyOTc3ZjY=
+    MWRhZjY2YWVmZTRlY2NjMTJkYzZhMWMyYWYzZDA3ZmJlMzVkNzNjYWJiZTkw
+    ODE3ZDdiNjY1Y2FkY2Q2ZjU2ZGY4MWNjZmE0YjM1ZWIwZWY4MWYzYjM0MzI5
+    Zjk2YTRhYjg5MzFhZDAwODgyNTIzYzA5MTYzMmQwYmViMjY1ODg=

data/.gitignore

@@ -1,3 +1,5 @@
-/vendor
+/tmp
 /coverage
 /gemfiles/.bundle
+/pkg
+/vendor

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pg_funcall (0.1.0)
+    pg_funcall (0.1.1)
       activerecord (>= 4.0.0)
       ipaddr_extensions
       pg (>= 0.17.0)

data/lib/pg_funcall/ipaddr_monkeys.rb

@@ -1,6 +1,9 @@
 require 'ipaddr'
 require 'ipaddr_extensions'
 
+#
+# TODO: we probably shouldn't do go around monkey-patching like this.
+#
 class IPAddr
   def prefixlen
     mask = @mask_addr

data/lib/pg_funcall/type_info.rb

@@ -1,149 +1,151 @@
-class PgFuncall::TypeInfo
-  attr_accessor :ar_type
-  attr_accessor :array_type
-  attr_accessor :element_type
-
-  def initialize(row, ar_type = nil)
-    @row = {}
-    # copy and convert int-looking things to int along the way
-    row.each do |key, val|
-      @row[key] =
-          (val && val.respond_to?(:match) && val.match(/^-?\d+$/)) ? val.to_i : val
+class PgFuncall
+  class TypeInfo
+    attr_accessor :ar_type
+    attr_accessor :array_type
+    attr_accessor :element_type
+
+    def initialize(row, ar_type = nil)
+      @row = {}
+      # copy and convert int-looking things to int along the way
+      row.each do |key, val|
+        @row[key] =
+            (val && val.respond_to?(:match) && val.match(/^-?\d+$/)) ? val.to_i : val
+      end
+      @row.freeze
+      @ar_type = ar_type
     end
-    @row.freeze
-    @ar_type = ar_type
-  end
 
-  # TODO: replace this to not use ar_type
-  def cast_from_database(value)
-    @ar_type.respond_to?(:type_cast_from_database) ?
-        @ar_type.type_cast_from_database(value) :
-        @ar_type.type_cast(value)
-  end
+    # TODO: replace this to not use ar_type
+    def cast_from_database(value)
+      @ar_type.respond_to?(:type_cast_from_database) ?
+          @ar_type.type_cast_from_database(value) :
+          @ar_type.type_cast(value)
+    end
 
+      #
+    # Represent a Ruby object in a string form to be passed as a parameter
+    # within a descriptor hash, rather than substituted into a string-form
+    # query.
     #
-  # Represent a Ruby object in a string form to be passed as a parameter
-  # within a descriptor hash, rather than substituted into a string-form
-  # query.
-  #
-  def _format_param_for_descriptor(param, type=nil)
-    return param.value if param.is_a?(PgFuncall::Literal)
-
-    case param
-      when PgFuncall::TypedArray
-        _format_param_for_descriptor(param.value, param.type + "[]")
-      when PgFuncall::Typed
-        _format_param_for_descriptor(param.value, param.type)
-      when PgFuncall::PGTyped
-        param.respond_to?(:__pg_value) ?
-            param.__pg_value :
-            _format_param_for_descriptor(param, type)
-      when TrueClass
-        'true'
-      when FalseClass
-        'false'
-      when String
-        if type == 'bytea' || param.encoding == Encoding::BINARY
-          '\x' + param.unpack('C*').map {|x| sprintf("%02X", x)}.join("")
-        else
-          param
-        end
-      when Array
-        "{" + param.map {|p| _format_param_for_descriptor(p)}.join(",") + "}"
-      when IPAddr
-        param.to_cidr_string
-      when Range
-        last_char = param.exclude_end? ? ')' : ']'
-        case type
-          when 'tsrange', 'tstzrange'
-            "[#{param.first.utc},#{param.last.utc}#{last_char}"
+    def _format_param_for_descriptor(param, type=nil)
+      return param.value if param.is_a?(PgFuncall::Literal)
+
+      case param
+        when PgFuncall::TypedArray
+          _format_param_for_descriptor(param.value, param.type + "[]")
+        when PgFuncall::Typed
+          _format_param_for_descriptor(param.value, param.type)
+        when PgFuncall::PGTyped
+          param.respond_to?(:__pg_value) ?
+              param.__pg_value :
+              _format_param_for_descriptor(param, type)
+        when TrueClass
+          'true'
+        when FalseClass
+          'false'
+        when String
+          if type == 'bytea' || param.encoding == Encoding::BINARY
+            '\x' + param.unpack('C*').map {|x| sprintf("%02X", x)}.join("")
           else
-            "[#{param.first},#{param.last}#{last_char}"
-        end
-      when Set
-        _format_param_for_descriptor(param.to_a)
-      when Hash
-        param.map do |k,v|
-          "#{k} => #{v}"
-        end.join(',')
-      else
-        ActiveRecord::Base.connection.quote(param)
+            param
+          end
+        when Array
+          "{" + param.map {|p| _format_param_for_descriptor(p)}.join(",") + "}"
+        when IPAddr
+          param.to_cidr_string
+        when Range
+          last_char = param.exclude_end? ? ')' : ']'
+          case type
+            when 'tsrange', 'tstzrange'
+              "[#{param.first.utc},#{param.last.utc}#{last_char}"
+            else
+              "[#{param.first},#{param.last}#{last_char}"
+          end
+        when Set
+          _format_param_for_descriptor(param.to_a)
+        when Hash
+          param.map do |k,v|
+            "#{k} => #{v}"
+          end.join(',')
+        else
+          ActiveRecord::Base.connection.quote(param)
+      end
     end
-  end
 
-    # TODO: replace this to not use ar_type
-  def cast_to_database(value)
-    @ar_type.respond_to?(:type_cast_for_database) ?
-        @ar_type.type_cast_for_database(value).to_s :
-        _format_param_for_descriptor(value, name)
-  end
+      # TODO: replace this to not use ar_type
+    def cast_to_database(value)
+      @ar_type.respond_to?(:type_cast_for_database) ?
+          @ar_type.type_cast_for_database(value).to_s :
+          _format_param_for_descriptor(value, name)
+    end
 
-  def name
-    @row['typname']
-  end
+    def name
+      @row['typname']
+    end
 
-  def namespace
-    @row['nspname']
-  end
+    def namespace
+      @row['nspname']
+    end
 
-  #
-  # Don't fully qualify base types -- this is pretty, but is it wise?
-  #
-  def fqname
-    namespace == 'pg_catalog' ?
-        name :
-        namespace + '.' + name
-  end
+    #
+    # Don't fully qualify base types -- this is pretty, but is it wise?
+    #
+    def fqname
+      namespace == 'pg_catalog' ?
+          name :
+          namespace + '.' + name
+    end
 
-  def oid
-    @row['oid']
-  end
+    def oid
+      @row['oid']
+    end
 
-  def category
-    @row['typcategory']
-  end
+    def category
+      @row['typcategory']
+    end
 
-  def temporal?
-    datetime? || timespan?
-  end
+    def temporal?
+      datetime? || timespan?
+    end
 
-  CATEGORY_MAP =
-      {'A' => 'array',
-       'B' => 'boolean',
-       'C' => 'composite',
-       'D' => 'datetime',
-       'E' => 'enum',
-       'G' => 'geometric',
-       'I' => 'network_address',
-       'N' => 'numeric',
-       'P' => 'pseudotype',
-       'S' => 'string',
-       'T' => 'timespan',
-       'U' => 'user_defined',
-       'V' => 'bit_string',
-       'X' => 'unknown'
-      }
-
-  CATEGORY_MAP.each do |typ, name|
-    define_method("#{name}?") do
-      category == typ
+    CATEGORY_MAP =
+        {'A' => 'array',
+         'B' => 'boolean',
+         'C' => 'composite',
+         'D' => 'datetime',
+         'E' => 'enum',
+         'G' => 'geometric',
+         'I' => 'network_address',
+         'N' => 'numeric',
+         'P' => 'pseudotype',
+         'S' => 'string',
+         'T' => 'timespan',
+         'U' => 'user_defined',
+         'V' => 'bit_string',
+         'X' => 'unknown'
+        }
+
+    CATEGORY_MAP.each do |typ, name|
+      define_method("#{name}?") do
+        category == typ
+      end
     end
-  end
 
-  def category_name
-    CATEGORY_MAP[category]
-  end
+    def category_name
+      CATEGORY_MAP[category]
+    end
 
-  def element_type_oid
-    raise "Can only call on array" unless array?
-    @row['typelem']
-  end
+    def element_type_oid
+      raise "Can only call on array" unless array?
+      @row['typelem']
+    end
 
-  def array_type_oid
-    @row['typarray']
-  end
+    def array_type_oid
+      @row['typarray']
+    end
 
-  def [](element)
-    @row[element.to_s]
+    def [](element)
+      @row[element.to_s]
+    end
   end
 end

data/lib/pg_funcall/version.rb

@@ -1,3 +1,3 @@
 class PgFuncall
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_funcall
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Robert Sanders