pod4 0.10.5 → 0.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3438ad2d9f28358a99d1704f7b3f3fd39ec7a8bc
-  data.tar.gz: 12e1ca2d33bff64be209509c42c2695dad462d9f
+  metadata.gz: d97fb4e3c277219cfee34b8d28bf0464f5ab6424
+  data.tar.gz: a49c67b03b4dab994775eb5774b41cb897a494d4
 SHA512:
-  metadata.gz: 76f2db877e9ef30b57409f7b9d31ef9fa718cd21e58ac4a58d9f8512378bd6d39a1cc574575a0b558d3d48d1cce2ebd2b0e03d173188b947ecbf316870902945
-  data.tar.gz: 677f152afb19ba659f2b6d1fe0ffa31c4e81c76eb1d3bb31e7c464895116630339ee76afff59930b646261f81d24040d94f12b2d7bc7d19cbaa9771682ae3936
+  metadata.gz: e567aa380a11cbbe270c89bd69a2b60d2c69583cb8d5dd71208d15e9b9b8511bb766be5a164f6cc57b23ad3e1cd63cb17f80e4e27373356f4b48527df8c79d55
+  data.tar.gz: d62957ca14ceb46dfd33face48e48da8674fe5a82023ff7a259a048b45031be49ef09a114986f37c7b76dc2402c5041d8059e0ef6f0e2947d7621fb66f72902a

data/.bugs/bugs

@@ -0,0 +1,2 @@
+Fixnum is Deprecated                                         | owner:Andy Jones <andy.jones@jameshall.co.uk>, open:True, id:274eb8828bd4e7d879e4f7a99317c75eb2a2e2b0, time:1533817328.12
+BigDecimal.new is deprecated                                 | owner:Andy Jones <andy.jones@jameshall.co.uk>, open:True, id:3979ce1679bc4f8c4aef8436e344e10e3773480d, time:1533817342.0

data/.bugs/details/3979ce1679bc4f8c4aef8436e344e10e3773480d.txt

@@ -0,0 +1,27 @@
+# Lines starting with '#' and sections without content
+# are not displayed by a call to 'details'
+#
+[paths]
+# Paths related to this bug.
+# suggested format: REPO_PATH:LINENUMBERS
+
+
+[details]
+# Additional details
+Use BigDecimal("0") instead.
+
+
+[expected]
+# The expected result
+
+
+[actual]
+# What happened instead
+
+
+[reproduce]
+# Reproduction steps
+
+
+[comments]
+# Comments and updates - leave your name

data/.hgtags

@@ -31,3 +31,4 @@ f1b3a814e7a8c7d818b57f6d35ce7ed749573d76 0.9.1
 7a39c71dceaf05b9204e1f2870f904940fdac4d3 0.10.3
 e98232cdc6cbe61e2bf0513fcf578001a2931018 0.10.4
 daae29a48272b5c3029b6509354bd3c3e6bf339a 0.10.5
+48d204fe041672e6df5845ad552497df8db3029a 0.10.6

data/README.md

@@ -121,10 +121,10 @@ Simple Model Usage
     x.two = "new value"
     x.update
 
-    # create a new record from the params hash -- unless validation fails.
+    # create a new record from the params hash
     y = ExampleModel.new
     y.set(params)
-    y.create unless y.model_status == :error
+    y.create 
 
 A model is a class, each instance of which represents a single record. on that instance you can
 call the following for basic operation:
@@ -141,7 +141,7 @@ call the following for basic operation:
 instance might be represented on the data source as several records, or something else entirely.)
 
 There is one more operation - `list`. Call this on the model class itself, and it will return an
-array of model instances that match the criteria you pass. What you can pass to list depends on
+array of model objects that match the criteria you pass. What you can pass to list depends on
 your model class (of course); by default it also depends on the interface the model uses. But
 normally it should except a hash, like so:
 
@@ -265,8 +265,9 @@ Here's a model with some validation:
       set_interface CustomerInterface.new($pg_conn)
       attr_columns :cust_code, :name, :group
 
-      def validate
+      def validate(mode)
         super
+        return if mode == :delete
 
         add_alert(:error, :name, "Name cannot be empty") \
           unless @name && @name =~ \^\s*$\
@@ -278,13 +279,12 @@ Here's a model with some validation:
 
     end
 
-(Note: as a general principal, you should always call super when overriding a
-method in Pod4 model, unless you have good reason not to.)
+(Note: as a general principal, you should always call super when overriding a method in Pod4 model,
+unless you have good reason not to.)
 
-Validation is run on create, read, update and delete.  If the model has a status of :error, then an
-update or create will fail. A delete, however, will succeed -- if you want to create validation
-that aborts a delete operation, you should override the `delete` method and only call super if the
-validation passes.  
+Validation is run on create, read, update and delete.  If the model has a status of :error, then
+the validation will fail.  (Probably you do not want this on delete; test the parameter passed
+to validate as in the example above).
 
 In passing I should note that validation is _not_ run on list: every record that list returns
 should be complete, but the `model_status` will be :empty because validation has not been run.
@@ -295,24 +295,6 @@ possible to set a model to an invalid state and not raise any alerts against it
 commit to the database.  If you want to change the state of the model and then validate it before
 that, you must call `validate` yourself.
 
-### Conditional Validation for CRUD modes ###
-
-If you want to write validation that only fires on some of :create, :read, :update or :delete --
-for example, to stop deletion if a foreign key points to another record that exists -- then you
-have two options.  The recomended way to do this is to add a parameter to your `validate()` method:
-
-    def validate(vmode)
-      super
-      add_alert(:error, "foo") if vmode == :delete && bar
-    end
-
-There's a little bit of magic here; when you override `validate()` you can choose to give it a
-parameter or not; either way will work. The value passed to the parameter will either be :create,
-:read, :update or :delete.
-
-Your second option is to override the create/read/update/delete method, instead.  Just remember to return
-self, and only call super if you want the operation to go ahead.
-
 
 Changine How a Model Represents Data
 ------------------------------------
@@ -339,7 +321,7 @@ yourself.
 
       def map_to_model(ot)
         super
-        @cost = Bigdecimal.new(@cost)
+        @cost = Bigdecimal(@cost)
       end
 
       def map_to_interface

data/lib/pod4/encrypting.rb

@@ -257,7 +257,7 @@ module Pod4
             cipher.update(answer) + cipher.final
         end
 
-      rescue OpenSSL::Cipher::CipherError
+      rescue OpenSSL::Cipher::CipherError, ArgumentError
         raise Pod4::Pod4Error, $!
       end
 

data/lib/pod4/pg_interface.rb

@@ -299,7 +299,7 @@ module Pod4
     end
 
 
-    protected
+    private
 
 
     ##
@@ -402,9 +402,6 @@ module Pod4
     end
 
 
-    private
-
-
     ##
     # build a hash of column -> oid
     #
@@ -430,7 +427,7 @@ module Pod4
       lInt    =->(s) { Integer(s,10) rescue s }
       lTime   =->(s) { Time.parse(s) rescue s }
       lDate   =->(s) { Date.parse(s) rescue s }
-      lBigDec =->(s) { BigDecimal.new(s) rescue s }
+      lBigDec =->(s) { BigDecimal(s) rescue s }
 
       row.each_with_object({}) do |(k,v),h|
         key = k.to_sym

data/lib/pod4/sequel_interface.rb

@@ -98,13 +98,13 @@ module Pod4
       # the money type. This workaround actually allows us to return a BigDecimal, so it's better
       # than using postgres_pr when under jRuby!
       if @db.uri =~ /jdbc:postgresql/
-        @db.conversion_procs[790] = ->(s){BigDecimal.new s[1..-1] rescue nil}
+        @db.conversion_procs[790] = ->(s){BigDecimal(s[1..-1]) rescue nil}
         c = Sequel::JDBC::Postgres::Dataset
 
         if @sequel_version >= 5
           # In Sequel 5 everything is frozen, so some hacking is required.
           # See https://github.com/jeremyevans/sequel/issues/1458
-          vals = c::PG_SPECIFIC_TYPES + [Java::JavaSQL::Types::DOUBLE]
+          vals = c::PG_SPECIFIC_TYPES + [Java::JavaSQL::Types::DOUBLE] 
           c.send(:remove_const, :PG_SPECIFIC_TYPES) # We can probably get away with just const_set, but.
           c.send(:const_set,    :PG_SPECIFIC_TYPES, vals.freeze)
         else
@@ -288,7 +288,7 @@ module Pod4
     end
 
 
-    protected
+    private
 
 
     ##
@@ -355,9 +355,6 @@ module Pod4
     end
 
 
-    private
-
-
     def read_or_die(id)
       raise CantContinue, "'No record found with ID '#{id}'" if read(id).empty?
     end

data/lib/pod4/tds_interface.rb

@@ -303,7 +303,7 @@ module Pod4
     end
 
 
-    protected
+    private
 
 
     ##

data/lib/pod4/typecasting.rb

@@ -57,7 +57,9 @@ module Pod4
   # so. 
   #
   # `map_to_model`: incoming data from the data source is coerced to the given encoding if
-  # `force_encoding` has been used.
+  # `force_encoding` has been used. Typecast attributes are cast as per their settings, or if they
+  # cannot be cast, are left alone. (Unless you have specified strict: true, in which case they are
+  # set to nil.)
   #
   # `set()`: typecast attributes are cast as per their settings, or if they cannot be cast, are left
   # alone. (Unless you have specified `strict: true`, in which case they are set to nil.)
@@ -68,6 +70,9 @@ module Pod4
   # `map_to_interface()`: typecast attributes are cast as per their settings, or if they cannot be
   # cast, are set to nil.
   #
+  # Note: Typecasting does not prevent you from setting any value you please on a model attibute
+  # @foo by using `model.foo = value`.
+  #
   # Additional methods
   # ------------------
   #
@@ -91,13 +96,17 @@ module Pod4
   # where value is the value to be typecast, and options is the hash of options you specified for
   # that column.  Pod4 will set the column to whatever your method returns.
   #
+  # The options hash will have an additional key :mode in case you need to cast differently in
+  # different circumstances.  Mode will be one of :set, :map_to_interface, :map_to_model, or
+  # :typecast? (if you call `typecast?` yourself).
+  #
   # What you don't get
   # ------------------
   #
   # None of this has any direct effect on validation, although of course we do provide methods such
   # as `typecast?()` to specifically help you with validation.
   #
-  # Naming an attribute using `typecast` does not automatically make is a Pod4 column; you need to
+  # Naming an attribute using `typecast` does not automatically make it a Pod4 column; you need to
   # use `attr_column`, just as in plain Pod4. Furthermore, *only* Pod4 columns can be named in the
   # typecast command, although you can use the `typecast` instance method, etc., to help you roll
   # your own typecasting for non-column attributes.
@@ -109,6 +118,10 @@ module Pod4
   # regardless of how it is typecast. (On the contrary: by forcing strict columns to nil if they
   # fail typecasting, we help you validate.)
   #
+  # It's theoretically possible that you could typecast a column into something that the
+  # interface cannot cast back onto the database.  We don't cover you in that case. If it happens,
+  # you will have to deal with it yourself in `map_to_interface`.
+  #
   module TypeCasting
 
     TYPES = [ Date, Time, Integer, Float, BigDecimal, :boolean ]
@@ -171,17 +184,18 @@ module Pod4
           v.force_encoding(enc) if v.kind_of?(String) && enc
         end
 
-        super(ot)
+        hash = typecast_ot(ot, mode: :map_to_model)
+        super(ot.merge hash)
       end
 
       def set(ot)
-        hash = typecast_ot(ot)
+        hash = typecast_ot(ot, mode: :set)
         super(ot.merge hash)
       end
 
       def map_to_interface
         ot   = super
-        hash = typecast_ot(ot, strict: true)
+        hash = typecast_ot(ot, strict: true, mode: :map_to_interface)
         ot.merge hash
       end
 
@@ -234,7 +248,7 @@ module Pod4
           unless (tc = self.class.typecasts[attr])
 
         val = instance_variable_get("@#{attr}".to_sym) if val.nil?
-        !typecast_one(val, tc.merge(strict: true)).nil?
+        !typecast_one(val, tc.merge(strict: true, mode: :typecast?)).nil?
       end
 
       ## 
@@ -291,7 +305,7 @@ module Pod4
       #
       def set_guard(ot, fld, tc)
         case tc.to_s
-          when "BigDecimal" then ot.guard(fld) { BigDecimal.new("0")  }
+          when "BigDecimal" then ot.guard(fld) { BigDecimal("0")      }
           when "Float"      then ot.guard(fld) { Float(0)             }
           when "Integer"    then ot.guard(fld) { Integer(0)           }
           when "Date"       then ot.guard(fld) { Date.new(1900, 1, 1) }
@@ -302,7 +316,7 @@ module Pod4
 
       def tc_bigdecimal(thing)
         Float(thing) # BigDecimal sucks at catching bad decimals
-        BigDecimal.new(thing.to_s)
+        BigDecimal(thing.to_s)
       end
 
       def tc_float(thing)

data/lib/pod4/version.rb

@@ -1,3 +1,3 @@
 module Pod4 
-  VERSION = '0.10.5'
+  VERSION = '0.10.6'
 end

data/spec/common/model_plus_encrypting_spec.rb

@@ -24,14 +24,14 @@ describe "(Model with Encryption)" do
     Base64.strict_encode64(answer)
   end
 
-  let(:encryption_key) { "dflkasdgklajndgnalkghlgasdgasdghaalsdg" }
+  let(:encryption_key) { "dflkasdgklajndgn" }
 
   let(:medical_model_class) do  # model with an IV column
     Class.new Pod4::Model do
       include Pod4::Encrypting
       attr_columns :id, :nhs_no  # note, we don't bother to name encrypted columns
       encrypted_columns :name, :ailment, :prescription
-      set_key "dflkasdgklajndgnalkghlgasdgasdghaalsdg"
+      set_key "dflkasdgklajndgn"
       set_iv_column :nonce
       set_interface NullInterface.new(:id, :nhs_no, :name, :ailment, :prescription, :nonce, [])
     end
@@ -64,7 +64,7 @@ describe "(Model with Encryption)" do
       include Pod4::Encrypting
       attr_columns :id, :date, :heading, :text
       encrypted_columns :heading, :text
-      set_key "dflkasdgklajndgnalkghlgasdgasdghaalsdg"
+      set_key "dflkasdgklajndgn"
       set_interface NullInterface.new(:id, :date, :heading, :text, [])
     end
   end

data/spec/common/model_plus_typecasting_spec.rb

@@ -31,7 +31,7 @@ describe "ProductModel" do
       set_interface NullInterface.new( :id, :code, :band, :sales, :created, :yrstart, 
                                        :flag, :foo, :bar, [] )
 
-      def mycast(value, opts); "blarg" end
+      def mycast(value, opts); "blarg"; end
     end
   end
 
@@ -160,6 +160,99 @@ describe "ProductModel" do
       expect( ot.>>.product.encoding ).to eq Encoding::ISO_8859_1
     end
 
+    it "typecasts strings to whatever" do
+      c  = customer_model_class.new(77)
+      ot = Octothorpe.new( id:      77,
+                           code:    "seven",
+                           band:    "7",
+                           sales:   "12.34",
+                           created: "2018-01-01 12:34",
+                           yrstart: "2018-01-02",
+                           flag:    "true",
+                           bar:     "34.56" )
+      
+      expect( c.interface ).to receive(:read).and_return(ot)
+      c.read
+
+      expect( c.id      ).to eq 77
+      expect( c.code    ).to eq "seven"
+      expect( c.band    ).to eq 7
+      expect( c.sales   ).to eq 12.34
+      expect( c.created ).to eq Time.parse("2018-01-01 12:34")
+      expect( c.yrstart ).to eq Date.parse("2018-01-02")
+      expect( c.flag    ).to eq true
+      expect( c.bar     ).to eq 34.56
+    end
+
+
+    it "allows the attribute to be nil" do
+      c  = customer_model_class.new(11)
+      ot = Octothorpe.new( id:      11,
+                           code:    "foo",
+                           band:    nil,
+                           sales:   nil,
+                           created: nil,
+                           yrstart: nil,
+                           flag:    nil,
+                           bar:     nil )
+
+      expect( c.interface ).to receive(:read).and_return(ot)
+      c.read
+
+      expect( c.code    ).to eq "foo"
+      expect( c.band    ).to eq nil
+      expect( c.sales   ).to eq nil
+      expect( c.created ).to eq nil
+      expect( c.yrstart ).to eq nil
+      expect( c.flag    ).to eq nil
+      expect( c.bar     ).to eq nil
+    end
+
+    it "leaves the column alone if it can't typecast (with strict off)" do
+      c  = customer_model_class.new(23)
+      ot = Octothorpe.new( id:      23,
+                           created: "bloob",
+                           yrstart: "flarg",
+                           flag:    "blobe",
+                           bar:     "xing" )
+
+      expect( c.interface ).to receive(:read).and_return(ot)
+      c.read
+
+      expect( c.created ).to eq "bloob"
+      expect( c.yrstart ).to eq "flarg"
+      expect( c.flag    ).to eq "blobe"
+      expect( c.bar     ).to eq "xing"
+    end
+
+    it "sets the column to nil if it can't typecast (with strict on)" do
+      c  = customer_model_class.new(23)
+      ot = Octothorpe.new( id:    23,
+                           band:  "bloob",
+                           sales: "flarg" )
+
+      expect( c.interface ).to receive(:read).and_return(ot)
+      c.read
+
+      expect( c.band  ).to be_nil
+      expect( c.sales ).to be_nil
+    end
+
+    it "calls the use method to get a typecast when the use option is given" do
+      c  = customer_model_class.new(43)
+      ot = Octothorpe.new( id: 43, foo: "12345" )
+
+      expect( c.interface ).to receive(:read).and_return(ot)
+      expect( c ).
+        to receive(:mycast).
+        with("12345", {use: :mycast, bar: 42, mode: :map_to_model} ).
+        and_call_original
+
+      c.read
+
+      expect( c.foo ).to eq "blarg"
+    end
+
   end
 
 
@@ -232,9 +325,14 @@ describe "ProductModel" do
 
     it "calls the use method to get a typecast when the use option is given" do
       c = customer_model_class.new
-      expect( c ).to receive(:mycast).with("12345", {use: :mycast, bar: 42} )
+      expect( c ).
+        to receive(:mycast).
+        with("12345", {use: :mycast, bar: 42, mode: :set} ).
+        and_call_original
 
       c.set( foo: "12345" )
+
+      expect( c.foo ).to eq "blarg"
     end
 
   end # of #set
@@ -257,7 +355,7 @@ describe "ProductModel" do
       record = customer_model_class.interface.read(11)
       expect( record.>>.code    ).to eq "foo"
       expect( record.>>.band    ).to eq 12
-      expect( record.>>.sales   ).to eq BigDecimal.new("98.76")
+      expect( record.>>.sales   ).to eq BigDecimal("98.76")
       expect( record.>>.created ).to eq Time.parse("2018-04-04 11:59")
       expect( record.>>.yrstart ).to eq Date.parse("2018-01-09")
       expect( record.>>.flag    ).to eq true
@@ -309,7 +407,10 @@ describe "ProductModel" do
     it "calls the use method to get a typecast when the use option is given" do
       c = customer_model_class.new
       # Note that we have gained the strict option automatically since we're in map_to_interface
-      expect( c ).to receive(:mycast).with("12345", {use: :mycast, bar: 42, strict: true} )
+      expect( c ).
+        to receive(:mycast).
+        with("12345", {use: :mycast, bar: 42, strict: true, mode: :map_to_interface}).
+        and_call_original
 
       c.id   = 33
       c.code = "baz"
@@ -335,7 +436,7 @@ describe "ProductModel" do
      
     it "casts any columns with the ot_as option as per that option" do
       c1 = customer_model_class.new
-      c1.sales = BigDecimal.new("45.67")
+      c1.sales = BigDecimal("45.67")
       ot = c1.to_ot
       expect( ot.>>.sales ).to be_a Float
       expect( ot.>>.sales ).to eq 45.67
@@ -364,7 +465,7 @@ describe "ProductModel" do
     it "typecasts strings to any type" do
       expect( cmodel.typecast(Integer,    "123")            ).to eq 123
       expect( cmodel.typecast(Float,      "23.45")          ).to eq 23.45
-      expect( cmodel.typecast(BigDecimal, "34.56")          ).to eq BigDecimal.new("34.56")
+      expect( cmodel.typecast(BigDecimal, "34.56")          ).to eq BigDecimal("34.56")
       expect( cmodel.typecast(Date,       "2018-01-01")     ).to eq Date.parse("2018-01-01")
       expect( cmodel.typecast(Time,       "2018-02-02 14:56") ).to eq Time.parse("2018-02-02 14:56")
       expect( cmodel.typecast(:boolean,   "true")             ).to eq true
@@ -375,16 +476,16 @@ describe "ProductModel" do
       expect( cmodel.typecast(Float, 12) ).to be_a Float
       expect( cmodel.typecast(Float, 12) ).to eq 12.0
 
-      expect( cmodel.typecast(Float, BigDecimal.new("12.34")) ).to be_a Float
-      expect( cmodel.typecast(Float, BigDecimal.new("12.34")) ).to eq 12.34
+      expect( cmodel.typecast(Float, BigDecimal("12.34")) ).to be_a Float
+      expect( cmodel.typecast(Float, BigDecimal("12.34")) ).to eq 12.34
     end
     
     it "typecasts Integer and Float to BigDecimal" do
       expect( cmodel.typecast(BigDecimal, 12) ).to be_a BigDecimal
-      expect( cmodel.typecast(BigDecimal, 12) ).to eq BigDecimal.new("12.0")
+      expect( cmodel.typecast(BigDecimal, 12) ).to eq BigDecimal("12.0")
 
       expect( cmodel.typecast(BigDecimal, 12.34) ).to be_a BigDecimal
-      expect( cmodel.typecast(BigDecimal, 12.34) ).to eq BigDecimal.new("12.34")
+      expect( cmodel.typecast(BigDecimal, 12.34) ).to eq BigDecimal("12.34")
     end
 
 
@@ -423,8 +524,8 @@ describe "ProductModel" do
     end
 
     it "will not cast a float or a BigDecimal to an Integer" do
-      expect( cmodel.typecast(Integer, 12.34,                   strict: true) ).to eq nil
-      expect( cmodel.typecast(Integer, BigDecimal.new("12.34"), strict: true) ).to eq nil
+      expect( cmodel.typecast(Integer, 12.34,               strict: true) ).to eq nil
+      expect( cmodel.typecast(Integer, BigDecimal("12.34"), strict: true) ).to eq nil
     end
     
     it "will not cast a Time to a Date" do
@@ -440,7 +541,7 @@ describe "ProductModel" do
     it "returns true if the value can be cast to the type" do
       expect( cmodel.typecast?(:band,    123)                            ).to eq true
       expect( cmodel.typecast?(:bar,     23.45)                          ).to eq true
-      expect( cmodel.typecast?(:sales,   BigDecimal.new("34.56"))        ).to eq true
+      expect( cmodel.typecast?(:sales,   BigDecimal("34.56"))            ).to eq true
       expect( cmodel.typecast?(:created, Time.parse("2018-02-02 14:56")) ).to eq true
       expect( cmodel.typecast?(:yrstart, Date.parse("2018-01-01"))       ).to eq true
       expect( cmodel.typecast?(:flag,    true)                           ).to eq true

data/spec/common/sequel_interface_pg_spec.rb

@@ -41,22 +41,22 @@ describe "SequelInterface (Pg)" do
            level:     1.23,
            day:       Date.parse("2016-01-01"),
            timestamp: Time.parse('2015-01-01 12:11'),
-           qty:       BigDecimal.new("1.24"),
-           price:     BigDecimal.new("1.24") }
+           qty:       BigDecimal("1.24"),
+           price:     BigDecimal("1.24") }
 
     d << { name:      'Fred',
            level:     2.34,
            day:       Date.parse("2016-02-02"),
            timestamp: Time.parse('2015-01-02 12:22'),
-           qty:       BigDecimal.new("2.35"),
-           price:     BigDecimal.new("2.35") }
+           qty:       BigDecimal("2.35"),
+           price:     BigDecimal("2.35") }
 
     d << { name:      'Betty',
            level:     3.45,
            day:       Date.parse("2016-03-03"),
            timestamp: Time.parse('2015-01-03 12:33'),
-           qty:       BigDecimal.new("3.46"),
-           price:     BigDecimal.new("3.46") }
+           qty:       BigDecimal("3.46"),
+           price:     BigDecimal("3.46") }
 
     d
   end
@@ -97,6 +97,7 @@ describe "SequelInterface (Pg)" do
   let(:prod_interface) { prod_interface_class.new(db) }
 
 
+
   before do
     interface.execute %Q|
       truncate table customer restart identity;
@@ -132,6 +133,7 @@ describe "SequelInterface (Pg)" do
     let(:hash) { {name: 'Bam-Bam', qty: 4.44} }
     let(:ot)   { Octothorpe.new(name: 'Wilma', qty: 5.55) }
 
+
     it 'raises a Pod4::DatabaseError if anything goes wrong' do
       expect{ interface.create(one: 'two') }.to raise_exception DatabaseError
     end
@@ -165,6 +167,8 @@ describe "SequelInterface (Pg)" do
     end
 
     it 'shouldnt have a problem with strings containing special characters' do
+      # Note that in passing we retest that create returns the ID for identity columns
+      
       record = {name: "T'Challa[]", price: nil}
       expect{ interface.create(record) }.not_to raise_exception
       id = interface.create(record)
@@ -172,6 +176,8 @@ describe "SequelInterface (Pg)" do
     end
 
     it 'shouldn\'t have a problem with non-integer keys' do
+      # Note that in passing we retest that create returns the ID for non-identity columns
+
       hash = {code: "foo", name: "bar"}
       id = prod_interface.create( Octothorpe.new(hash) )
 

data/spec/common/sql_helper_spec.rb

@@ -103,7 +103,7 @@ describe "SQLHelper" do
     end
 
     it "returns a BigDecimal as a float" do
-      bd = BigDecimal.new("14.98")
+      bd = BigDecimal("14.98")
       expect( tester1.send :quote, bd ).to eq 14.98
     end
 
@@ -112,7 +112,7 @@ describe "SQLHelper" do
     end
 
     it "will wrap the value in some other character if you pass that" do
-      bd = BigDecimal.new("14.98")
+      bd = BigDecimal("14.98")
       expect( tester1.send :quote, "thing", nil ).to eq %Q|thing|
       expect( tester1.send :quote, "thing", "x" ).to eq %Q|xthingx|
       expect( tester1.send :quote, bd ).to eq 14.98

data/spec/jruby/sequel_interface_jdbc_ms_spec.rb

@@ -46,21 +46,21 @@ describe "SequelInterface (JDBC/MSSQL)" do
            level:     1.23,
            day:       Date.parse("2016-01-01"),
            timestamp: Time.parse('2015-01-01 12:11'),
-           qty:       BigDecimal.new("1.24"),
+           qty:       BigDecimal("1.24"),
            price:     nil }
 
     d << { name:      'Fred',
            level:     2.34,
            day:       Date.parse("2016-02-02"),
            timestamp: Time.parse('2015-01-02 12:22'),
-           qty:       BigDecimal.new("2.35"),
+           qty:       BigDecimal("2.35"),
            price:     nil }
 
     d << { name:      'Betty',
            level:     3.45,
            day:       Date.parse("2016-03-03"),
            timestamp: Time.parse('2015-01-03 12:33'),
-           qty:       BigDecimal.new("3.46"),
+           qty:       BigDecimal("3.46"),
            price:     nil }
 
     d
@@ -244,8 +244,8 @@ describe "SequelInterface (JDBC/MSSQL)" do
                  level:     4.56,
                  day:       Date.parse("2016-03-03"),
                  timestamp: Time.parse('2015-01-03 12:44'),
-                 qty:       BigDecimal.new("4.57"),
-                 price:     BigDecimal.new("4.58") }
+                 qty:       BigDecimal("4.57"),
+                 price:     BigDecimal("4.58") }
 
       interface.create(dibble)
       price = interface.read(4).>>.price