pod4 0.8.3 → 0.9.0

data/lib/pod4/model.rb

@@ -9,7 +9,7 @@ module Pod4
 
 
   ##
-  # The parent of all models.
+  # The parent of all CRUDL models.
   #
   # Models & Interfaces
   # -------------------
@@ -21,7 +21,7 @@ module Pod4
   # not. The model doesn't care about where the data comes from. Models are all subclasses of
   # Pod4::Model.
   #
-  # An interface encapsulates the connection to whatever is providing the data.# it might be a
+  # An interface encapsulates the connection to whatever is providing the data. It might be a
   # wrapper for calls to the Sequel ORM, for example. Or it could be a making a series of calls to
   # a set of Nebulous verbs. It only cares about dealing with the data source, and it is only
   # called by the model.
@@ -91,7 +91,6 @@ module Pod4
         attr_accessor *cols
       end
 
-
       ##
       # Returns the list of columns from attr_columns
       #
@@ -99,7 +98,6 @@ module Pod4
         []
       end
 
-
       ##
       # Call this to return an array of record information.
       #
@@ -107,12 +105,17 @@ module Pod4
       # ID in each array element.  
       #
       # For the purposes of Model we assume that we can make an instance out of each array element,
-      # and we return an array of instances of the model.# Override this method if that is not true
+      # and we return an array of instances of the model. Override this method if that is not true
       # for your Interface.
       #
       # Note that list should ALWAYS return an array, and array elements should always respond to
       # :id -- otherwise we raise a Pod4Error.
       #
+      # Note also that while list returns an array of model objects, `read` has _not_ been run
+      # against each object. The data is there, but @model_status == :empty, and validation has not
+      # been run.  This is partly for the sake of efficiency, partly to help avoid recursive loops
+      # in validation.
+      #
       def list(params=nil)
         fail_no_id_fld unless interface.id_fld
 
@@ -123,37 +126,29 @@ module Pod4
           rec.map_to_model(ot) # seperately, in case model forgot to return self
           rec 
         end
-
       end
 
-
       def test_for_octo(param)
         raise( ArgumentError, 'Parameter must be a Hash or Octothorpe', caller ) \
           unless param.kind_of?(Hash) || param.kind_of?(Octothorpe)
 
       end
 
-
       def test_for_invalid_status(action, status)
         raise( Pod4Error, "Invalid model status for an action of #{action}", caller ) \
           if [:empty, :deleted].include? status
 
       end
 
-
-
       def fail_no_id_fld
         raise Pod4Error, "No ID field defined in interface", caller
       end
 
-
       def fail_no_id
         raise Pod4Error, "ID field missing from record", caller
       end
 
-    end
-    ##
-
+    end # of class << self
 
     ##
     # Syntactic sugar; pretty much the same as self.class.columns, which returns the `attr_columns`
@@ -161,21 +156,21 @@ module Pod4
     #
     def columns; self.class.columns.dup; end
 
-
     ##
     # Call this to write a new record to the data source.
     #
     # Note: create needs to set @id. But interface.create should return it, so that's okay.
     #
     def create
-      validate
+      run_validation(:create)
       @model_id = interface.create(map_to_interface) unless @model_status == :error
 
       @model_status = :okay if @model_status == :empty
       self
+    rescue Pod4::WeakError
+      add_alert(:error, $!)
     end
 
-
     ##
     # Call this to fetch the data for this instance from the data source
     #
@@ -186,26 +181,29 @@ module Pod4
         add_alert(:error, "Record ID '#@model_id' not found on the data source")
       else
         map_to_model(r)
+        run_validation(:read)
         @model_status = :okay if @model_status == :empty
       end
 
       self
+    rescue Pod4::WeakError
+      add_alert(:error, $!)
     end
 
-
     ##
     # Call this to update the data source with the current attribute values
     #
     def update
       Model.test_for_invalid_status(:update, @model_status)
 
-      clear_alerts; validate 
+      clear_alerts; run_validation(:update)
       interface.update(@model_id, map_to_interface) unless @model_status == :error
 
       self
+    rescue Pod4::WeakError
+      add_alert(:error, $!)
     end
 
-
     ##
     # Call this to delete the record on the data source.
     #
@@ -213,13 +211,14 @@ module Pod4
     #
     def delete
       Model.test_for_invalid_status(:delete, @model_status)
-      clear_alerts; validate 
+      clear_alerts; run_validation(:delete)
       interface.delete(@model_id) 
       @model_status = :deleted
       self
+    rescue Pod4::WeakError
+      add_alert(:error, $!)
     end
 
-
     ##
     # Call this to validate the model.
     #
@@ -228,14 +227,14 @@ module Pod4
     # Note that you can only validate what is actually stored on the model. If you want to check
     # the data being passed to the model in `set`, you need to override that routine.
     #
-    # Also, you don't have any way of telling whether you are currently creating a new record or
-    # updating an old one: override `create` and `update` respectively.
+    # You may optionally catch the vmode parameter, which is one of :create,
+    # :read, :update, :delete, to have different validation under these circumstances; or you may
+    # safely ignore it and override `create`, `read`, `update` or `delete` as you wish.
     #
-    def validate
+    def validate(vmode=nil)
       # Holding pattern. All models should use super, in principal
     end
 
-
     ##
     # Set instance values on the model from a Hash or Octothorpe.
     #
@@ -252,7 +251,6 @@ module Pod4
       self
     end
 
-
     ##
     # Return an Octothorpe of all the attr_columns attributes.
     #
@@ -264,7 +262,6 @@ module Pod4
       Octothorpe.new(to_h)
     end
 
-
     ##
     # Used by the interface to set the column values on the model.
     #
@@ -278,11 +275,9 @@ module Pod4
     #
     def map_to_model(ot)
       merge(ot)
-      validate
       self
     end
 
-
     ##
     # used by the model to get an OT of column values for the interface. 
     #
@@ -302,10 +297,8 @@ module Pod4
       Octothorpe.new(to_h)
     end
 
-
     private
 
-
     ##
     # Output a hash of the columns
     #
@@ -315,7 +308,6 @@ module Pod4
       end
     end
 
-
     ##
     # Merge an OT with our columns
     #
@@ -327,8 +319,15 @@ module Pod4
       end
     end
 
-  end
-  ##
+    ##
+    # Call the validate method on the model.  Allow the user to override the method with or without
+    # the vmode paramter, as they choose.
+    #
+    def run_validation(vmode)
+      method(:validate).arity == 0 ? validate : validate(vmode)
+    end
+
+  end # of Model
 
 
 end

data/lib/pod4/nebulous_interface.rb

@@ -291,7 +291,8 @@ module Pod4
           else                :response
         end
 
-      raise Pod4::CantContinue, "Nebulous returned an error verb" if @response_status == :verberror
+      raise Pod4::WeakError, "Nebulous returned an error verb: #{@response.description}" \
+        if @response_status == :verberror
 
       self
 

data/lib/pod4/sequel_interface.rb

@@ -79,16 +79,37 @@ module Pod4
       raise(Pod4Error, 'no call to set_table in the interface definition') if self.class.table.nil?
       raise(Pod4Error, 'no call to set_id_fld in the interface definition') if self.class.id_fld.nil?
 
-      @db     = db # referemce to the db object
-      @table  = db[schema ? "#{schema}__#{table}".to_sym : table]
-      @id_fld = self.class.id_fld
-
+      @sequel_version = Sequel.respond_to?(:qualify) ? 5 : 4
+      @db             = db # reference to the db object
+      @id_fld         = self.class.id_fld
+
+      @table  = 
+        if schema
+          if @sequel_version == 5
+            db[ Sequel[schema][table] ]
+          else
+            db[ "#{schema}__#{table}".to_sym ]
+          end
+        else
+          db[table]
+        end
+          
       # Work around a problem with jdbc-postgresql where it throws an exception whenever it sees
       # 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}
-        Sequel::JDBC::Postgres::Dataset::PG_SPECIFIC_TYPES << Java::JavaSQL::Types::DOUBLE
+        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]
+          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
+          c::PG_SPECIFIC_TYPES << Java::JavaSQL::Types::DOUBLE
+        end
       end
 
     rescue => e
@@ -323,8 +344,11 @@ module Pod4
             m[k] = v.kind_of?(Symbol) ? v.to_s : v 
           end
 
+        when nil
+          nil
+
         else 
-          sel
+          fail Pod4::DatabaseError, "Expected a selection hash, got: #{sel.inspect}"
 
       end
 

data/lib/pod4/version.rb

@@ -1,3 +1,3 @@
 module Pod4 
-  VERSION = '0.8.3'
+  VERSION = '0.9.0'
 end

data/lib/pod4.rb

@@ -5,6 +5,7 @@ require_relative 'pod4/param'
 require_relative 'pod4/basic_model'
 require_relative 'pod4/model'
 require_relative 'pod4/alert'
+require_relative 'pod4/version'
 
 
 

data/pod4.gemspec

@@ -25,6 +25,6 @@ Gem::Specification.new do |spec|
   spec.extra_rdoc_files = spec.files.grep(%r{^md/})
 
   spec.add_runtime_dependency "devnull",    '~>0.1'
-  spec.add_runtime_dependency "octothorpe", '~>0.3'
+  spec.add_runtime_dependency "octothorpe", '~>0.4'
 
 end

data/spec/README.md

@@ -12,8 +12,3 @@ assumes that the schema names can be hardcoded, and since we create and wipe
 tables in these tests, you should really have a seperate database for them
 anyway.)
 
-Sequel
-------
-Note that the Sequel ORM adapter does **not** require a database -- we
-currently use an in-memory sqlite database instead.
-

data/spec/common/basic_model_spec.rb

@@ -158,7 +158,7 @@ describe 'WeirdModel' do
       lurch = 'Dnhhhhhh'
       2.times { model.fake_an_alert(:error, :price, lurch) }
 
-      expect( model.alerts.size ).to eq 2
+      expect( model.alerts.size ).to eq 1
     end
 
   end

data/spec/common/model_new_validate_spec.rb

@@ -0,0 +1,204 @@
+require 'octothorpe'
+
+require 'pod4/model'
+require 'pod4/null_interface'
+
+
+##
+# This is purely here to test that model works when you have a validate that accepts the new
+# vmode parameter
+#
+describe 'Customer Model with new validate' do
+
+  let(:customer_model_class) do
+    Class.new Pod4::Model do
+      attr_columns :id, :name, :groups
+      attr_columns :price  # specifically testing multiple calls to attr_columns
+      set_interface NullInterface.new(:id, :name, :price, :groups, [])
+
+      def map_to_model(ot)
+        super
+        @groups = @groups ? @groups.split(',') : []
+        self
+      end
+
+      def map_to_interface
+        x = super
+        g = (x.>>.groups || []).join(',')
+        x.merge(groups: g)
+      end
+
+      def fake_an_alert(*args)
+        add_alert(*args) #private method
+      end
+
+      def validate(vmode)
+        add_alert(:error, "falling over for mode #{vmode}") if name == "fall over"
+      end
+
+      def reset_alerts; @alerts = []; end
+    end
+  end
+
+  let(:records) do
+    [ {id: 10, name: 'Gomez',     price: 1.23, groups: 'trains'       },
+      {id: 20, name: 'Morticia',  price: 2.34, groups: 'spanish'      },
+      {id: 30, name: 'Wednesday', price: 3.45, groups: 'school'       },
+      {id: 40, name: 'Pugsley',   price: 4.56, groups: 'trains,school'} ]
+
+  end
+
+  let(:records_as_ot)  { records.map{|r| Octothorpe.new(r) } }
+
+  # model is just a plain newly created object that you can call read on.
+  # model2 and model3 are in an identical state - they have been filled with a
+  # read(). We have two so that we can RSpec 'allow' on one and not the other.
+
+  let(:model) { customer_model_class.new(20) }
+
+  let(:model2) do
+    m = customer_model_class.new(30)
+
+    allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[2]) )
+    m.read.or_die
+  end
+
+  let(:model3) do
+    m = customer_model_class.new(40)
+
+    allow( m.interface ).to receive(:read).and_return( Octothorpe.new(records[3]) )
+    m.read.or_die
+  end
+
+  ##
+
+
+  describe '#create' do
+
+    let (:new_model) { customer_model_class.new }
+
+    it 'calls validate and passes the parameter' do
+      # validation tests arity of the validate method; rspec freaks out. So we can't 
+      # `expect( new_model ).to receive(:validate)`
+
+      m = customer_model_class.new
+      m.name = "fall over"
+      m.create
+      expect( m.model_status ).to eq :error
+      expect( m.alerts.map(&:message) ).to include( include "create" )
+    end
+
+    it 'calls create on the interface if the record is good' do
+      expect( customer_model_class.interface ).to receive(:create)
+      customer_model_class.new.create
+
+      new_model.fake_an_alert(:warning, :name, 'foo')
+      expect( new_model.interface ).to receive(:create)
+      new_model.create
+    end
+
+    it 'doesnt call create on the interface if the record is bad' do
+      new_model.fake_an_alert(:error, :name, 'foo')
+      expect( new_model.interface ).not_to receive(:create)
+      new_model.create
+    end
+
+  end
+  ##
+
+
+  describe '#read' do
+
+    it 'calls validate and passes the parameter' do
+      # again, because rspec is a bit stupid, we can't just `expect(model).to receive(:validate)`
+
+      allow( model.interface ).
+        to receive(:read).
+        and_return( records_as_ot.first.merge(name: "fall over") )
+
+      model.read
+      expect( model.model_status ).to eq :error
+      expect( model.alerts.map(&:message) ).to include( include "mode read" )
+    end
+
+  end
+  ##
+
+
+  describe '#update' do
+
+    before do
+      allow( model2.interface ).
+        to receive(:update).
+        and_return( model2.interface )
+
+    end
+
+    it 'calls validate and passes the parameter' do
+      # again, we can't `expect(model2).to receive(:validate)` because we're testing arity there
+      model2.name = "fall over"
+      model2.update
+      expect( model2.model_status ).to eq :error
+      expect( model2.alerts.map(&:message) ).to include( include "mode update" )
+    end
+
+    it 'calls update on the interface if the validation passes' do
+      expect( model3.interface ).
+        to receive(:update).
+        and_return( model3.interface )
+
+      model3.update
+    end
+
+    it 'doesn\'t call update on the interface if the validation fails' do
+      expect( model3.interface ).not_to receive(:update)
+
+      model3.name = "fall over"  # triggers validation
+      model3.update
+    end
+
+  end
+  ##
+
+
+  describe '#delete' do
+
+    before do
+      allow( model2.interface ).
+        to receive(:delete).
+        and_return( model2.interface )
+
+    end
+
+    it 'calls validate and passes the parameter' do
+      # again, because rspec can't cope with us testing arity in Pod4::Model, we can't say
+      # `expect(model2).to receive(:validate)`. But for delete we are only running validation as a
+      # courtesy -- a validation fail does not stop the delete, it just sets alerts. So the model
+      # status should be :deleted and not :error
+      model2.name = "fall over"
+      model2.delete
+      expect( model2.alerts.map(&:message) ).to include(include "mode delete")
+    end
+
+    it 'calls delete on the interface if the model status is good' do
+      expect( model3.interface ).
+        to receive(:delete).
+        and_return( model3.interface )
+
+      model3.delete 
+    end
+
+    it 'calls delete on the interface if the model status is bad' do
+      expect( model3.interface ).
+        to receive(:delete).
+        and_return( model3.interface )
+
+      model3.fake_an_alert(:error, :price, 'qar')
+      model3.delete 
+    end
+
+  end
+  ##
+
+end
+

data/spec/common/model_spec.rb

@@ -347,15 +347,6 @@ describe 'CustomerModel' do
   ##
 
 
-  describe '#validate' do
-    it 'takes no parameters' do
-      expect{ customer_model_class.new.validate(12) }.to raise_exception ArgumentError
-      expect{ customer_model_class.new.validate     }.not_to raise_exception
-    end
-  end
-  ##
-
-
   describe '#set' do
 
     let (:ot) { records_as_ot[3] }
@@ -482,8 +473,13 @@ describe 'CustomerModel' do
     end
 
     it 'calls validate' do
-      expect( new_model ).to receive(:validate)
-      new_model.create
+      # validation tests arity of the validate method; rspec freaks out. So we can't 
+      # `expect( new_model ).to receive(:validate)`
+
+      m = customer_model_class.new
+      m.name = "fall over"
+      m.create
+      expect( m.model_status ).to eq :error
     end
 
     it 'calls create on the interface if the record is good' do
@@ -544,6 +540,16 @@ describe 'CustomerModel' do
       expect{ new_model.create }.not_to raise_error
     end
 
+    it "creates an alert instead when the interface raises WeakError" do
+      allow( new_model.interface ).to receive(:create).and_raise Pod4::WeakError, "foo"
+
+      new_model.id   = 50
+      new_model.name = "Lurch"
+      expect{ new_model.create }.not_to raise_exception
+      expect( new_model.model_status ).to eq :error
+      expect( new_model.alerts.map(&:message) ).to include( include "foo" )
+    end
+
   end
   ##
 
@@ -572,12 +578,14 @@ describe 'CustomerModel' do
     end
 
     it 'calls validate' do
+      # again, because rspec is a bit stupid, we can't just `expect(model).to receive(:validate)`
+
       allow( model.interface ).
         to receive(:read).
-        and_return( records_as_ot.first )
+        and_return( records_as_ot.first.merge(name: "fall over") )
 
-      expect( model ).to receive(:validate)
       model.read
+      expect( model.model_status ).to eq :error
     end
 
     it 'sets the attribute columns using map_to_model' do
@@ -629,6 +637,14 @@ describe 'CustomerModel' do
 
     end
 
+    it "creates an alert instead when the interface raises WeakError" do
+      allow( model.interface ).to receive(:read).and_raise Pod4::WeakError, "foo"
+
+      expect{ model.read }.not_to raise_exception
+      expect( model.model_status ).to eq :error
+      expect( model.alerts.map(&:message) ).to include( include "foo" )
+    end
+
   end
   ##
 
@@ -664,8 +680,10 @@ describe 'CustomerModel' do
     end
 
     it 'calls validate' do
-      expect( model2 ).to receive(:validate)
+      # again, we can't `expect(model2).to receive(:validate)` because we're testing arity there
+      model2.name = "fall over"
       model2.update
+      expect( model2.model_status ).to eq :error
     end
 
     it 'calls update on the interface if the validation passes' do
@@ -709,6 +727,13 @@ describe 'CustomerModel' do
 
     end
 
+    it "creates an alert instead when the interface raises WeakError" do
+      allow( model3.interface ).to receive(:update).and_raise Pod4::WeakError, "foo"
+
+      expect{ model3.update }.not_to raise_exception
+      expect( model3.model_status ).to eq :error
+      expect( model3.alerts.map(&:message) ).to include( include "foo" )
+    end
 
   end
   ##
@@ -745,8 +770,15 @@ describe 'CustomerModel' do
     end
 
     it 'calls validate' do
-      expect( model2 ).to receive(:validate)
+      # again, because rspec can't cope with us testing arity in Pod4::Model, we can't say
+      # `expect(model2).to receive(:validate)`. But for delete we are only running validation as a
+      # courtesy -- a validation fail does not stop the delete, it just sets alerts. So the model
+      # status should be :deleted and not :error
+      model2.name = "fall over"
       model2.delete
+
+      # one of the elements of the alerts array should include the word "falling"
+      expect( model2.alerts.map(&:message) ).to include(include "falling")
     end
 
     it 'calls delete on the interface if the model status is good' do
@@ -787,6 +819,12 @@ describe 'CustomerModel' do
       model4.delete
     end
 
+    it "creates an alert instead when the interface raises WeakError" do
+      allow( model3.interface ).to receive(:delete).and_raise Pod4::WeakError, "foo"
+
+      expect{ model3.delete }.not_to raise_exception
+      expect( model3.alerts.map(&:message) ).to include( include "foo" )
+    end
 
   end
   ##