hold 1.0.2 → 1.0.3

data/lib/hold/sequel/identity_set_repository.rb

@@ -367,16 +367,9 @@ module Hold::Sequel
     end
 
     def get_by_property(property, value, options={})
-      properties_to_fetch ||= @default_properties.dup
-      properties_to_fetch[property] = true
-      query(options[:properties]) do |dataset, property_columns|
-        filter = mapper(property).make_filter(value, property_columns[property])
-        dataset.filter(filter)
-      end.single_result
+      get_many_by_property(property, value, options).first
     end
 
-
-
     def contains_id?(id)
       dataset = dataset_to_select_tables(@main_table)
       id_filter = @identity_mapper.make_filter(id, [@tables_id_columns[@main_table]])

data/lib/hold/sequel/polymorphic_repository.rb

@@ -1,121 +1,130 @@
-module Hold::Sequel
-  class PolymorphicRepository
-    include Hold::IdentitySetRepository
-
-    attr_reader :db, :table, :type_column, :id_column, :type_to_model_class_mapping,
-                :repos_for_model_classes, :model_class_to_type_mapping
-
-    def initialize(db, options={})
-      @db = db
-      @table = options[:table] || :base
-      @type_column = options[:type_column] || :type
-      @id_column = options[:id_column] || :id
-      @type_to_model_class_mapping = options[:mapping]
-      @model_class_to_type_mapping = @type_to_model_class_mapping.invert
-
-      @repos_for_model_classes = options[:repos] || {}
-      @dataset = @db[@table].select(Sequel.as(@type_column,:_type), Sequel.as(@id_column,:_id))
-    end
+module Hold
+  module Sequel
+    # Polymorphic repository
+    class PolymorphicRepository
+      include Hold::IdentitySetRepository
+
+      attr_reader :db, :table, :type_column, :id_column,
+                  :type_to_model_class_mapping, :repos_for_model_classes,
+                  :model_class_to_type_mapping
+
+      def initialize(db, options = {})
+        @db = db
+        @table = options[:table] || :base
+        @type_column = options[:type_column] || :type
+        @id_column = options[:id_column] || :id
+        @type_to_model_class_mapping = options[:mapping]
+        @model_class_to_type_mapping = @type_to_model_class_mapping.invert
+
+        @repos_for_model_classes = options[:repos] || {}
+        @dataset = @db[@table].select(Sequel.as(@type_column, :_type),
+                                      Sequel.as(@id_column, :_id))
+      end
 
-    def can_get_class?(model_class)
-      @model_class_to_type_mapping.has_key?(model_class)
-    end
+      def can_get_class?(model_class)
+        @model_class_to_type_mapping.key?(model_class)
+      end
 
-    def can_set_class?(model_class)
-      @model_class_to_type_mapping.has_key?(model_class)
-    end
+      def can_set_class?(model_class)
+        @model_class_to_type_mapping.key?(model_class)
+      end
 
-    def get_repo_dependencies_from(repo_set)
-      @type_to_model_class_mapping.each do |type,model_class|
-        @repos_for_model_classes[model_class] ||= repo_set.repo_for_model_class(model_class)
+      def get_repo_dependencies_from(repo_set)
+        @type_to_model_class_mapping.each do |_, model_class|
+          @repos_for_model_classes[model_class] ||=
+            repo_set.repo_for_model_class(model_class)
+        end
       end
-    end
 
-    def type_to_repo_mapping
-      @type_to_repo_mapping ||= begin
-        result = {}
-        @type_to_model_class_mapping.each {|t,m| result[t] = @repos_for_model_classes[m]}
-        result
+      def type_to_repo_mapping
+        @type_to_repo_mapping ||=
+          begin
+            @type_to_repo_mapping.each_with_obeject({}) do |(t, m), hash|
+              hash[t] = @repos_for_model_classes[m]
+            end
+          end
       end
-    end
 
-    def construct_entity(property_hash, row=nil)
-      type = property_hash[:_type] or raise "missing _type in result row"
-      @type_to_model_class_mapping[type].new(property_hash)
-    end
+      def construct_entity(property_hash, _row = nil)
+        type = property_hash[:_type] || (fail 'missing _type in result row')
+        @type_to_model_class_mapping[type].new(property_hash)
+      end
 
-    def transaction(*p, &b)
-      @db.transaction(*p, &b)
-    end
+      def transaction(*p, &b)
+        @db.transaction(*p, &b)
+      end
 
-    # - Takes multiple result rows with type and id column
-    # - Groups the IDs by type and does a separate get_many_by_ids query on the relevant repo
-    # - Combines the results from the separate queries putting them into the order of the IDs from
-    #   the original rows (or in the order of the ids given, where they are given)
-    def load_from_rows(rows, options={}, ids=nil)
-      ids ||= rows.map {|row| row[:_id]}
-      ids_by_type = Hash.new {|h,k| h[k]=[]}
-      rows.each {|row| ids_by_type[row[:_type]] << row[:_id]}
-      results_by_id = {}
-      ids_by_type.each do |type, type_ids|
-        repo = type_to_repo_mapping[type] or raise "PolymorphicRepository: no repo found for type value #{type}"
-        repo.get_many_by_ids(type_ids, options).each_with_index do |result, index|
-          results_by_id[type_ids[index]] = result
+      # - Takes multiple result rows with type and id column
+      # - Groups the IDs by type and does a separate get_many_by_ids query on
+      #   the relevant repo
+      # - Combines the results from the separate queries putting them into the
+      #   order of the IDs from the original rows (or in the order of the ids
+      #   given, where they are given)
+      def load_from_rows(rows, options = {}, ids = nil)
+        ids ||= rows.map { |row| row[:_id] }
+        ids_by_type = Hash.new { |h, k| h[k] = [] }
+        rows.each { |row| ids_by_type[row[:_type]] << row[:_id] }
+        results_by_id = {}
+        ids_by_type.each do |type, type_ids|
+          repo = type_to_repo_mapping[type] ||
+                 (fail "PolymorphicRepository: no repo found for type #{type}")
+          repo.get_many_by_ids(type_ids, options)
+            .each_with_index { |res, i| results_by_id[type_ids[i]] = res }
         end
+        results_by_id.values_at(*ids)
       end
-      results_by_id.values_at(*ids)
-    end
 
-    def load_from_row(row, options={})
-      repo = type_to_repo_mapping[row[:_type]] or raise "PolymorphicRepository: no repo found for type value #{row[:_type]}"
-      repo.get_by_id(row[:_id], options)
-    end
-
-    def get_with_dataset(options={}, &b)
-      dataset = @dataset
-      dataset = yield @dataset if block_given?
-      row = dataset.limit(1).first and load_from_row(row, options)
-    end
+      def load_from_row(row, options = {})
+        repo =
+          type_to_repo_mapping[row[:_type]] ||
+          (fail "PolymorphicRepository: no repo found for type  #{row[:_type]}")
 
-    def get_by_id(id, options={})
-      get_with_dataset(options) {|ds| ds.filter(@id_column => id)}
-    end
-
-    def get_many_by_ids(ids, options={})
-      rows = @dataset.filter(@id_column => ids).all
-      load_from_rows(rows, options, ids)
-    end
+        repo.get_by_id(row[:_id], options)
+      end
 
-    def contains_id?(id)
-      @dataset.filter(@id_column => id).select(1).limit(1).single_value ? true : false
-    end
+      def get_with_dataset(options = {})
+        dataset = @dataset
+        dataset = yield @dataset if block_given?
+        (row = dataset.limit(1).first) && load_from_row(row, options)
+      end
 
+      def get_by_id(id, options = {})
+        get_with_dataset(options) { |ds| ds.filter(@id_column => id) }
+      end
 
+      def get_many_by_ids(ids, options = {})
+        rows = @dataset.filter(@id_column => ids).all
+        load_from_rows(rows, options, ids)
+      end
 
+      def contains_id?(id)
+        !@dataset.filter(@id_column => id).select(1).limit(1).single_value.nil?
+      end
 
-    def store(object)
-      repo = @repos_for_model_classes[object.class] or raise Error
-      repo.store(id, object)
-    end
+      def store(object)
+        repo = @repos_for_model_classes[object.class] || (fail StdError)
+        repo.store(id, object)
+      end
 
-    def store_new(object)
-      repo = @repos_for_model_classes[object.class] or raise Error
-      repo.store_new(id, object)
-    end
+      def store_new(object)
+        repo = @repos_for_model_classes[object.class] || (fail StdError)
+        repo.store_new(id, object)
+      end
 
-    def update(entity, update_entity)
-      repo = @repos_for_model_classes[entity.class] or raise Error
-      repo.update(entity, update_entity)
-    end
+      def update(entity, update_entity)
+        repo = @repos_for_model_classes[entity.class] || (fail StdError)
+        repo.update(entity, update_entity)
+      end
 
-    def update_by_id(id, update_entity)
-      repo = @repos_for_model_classes[update_entity.class] or raise Error
-      repo.update_by_id(id, update_entity)
-    end
+      def update_by_id(id, update_entity)
+        repo = @repos_for_model_classes[update_entity.class] || (fail StdError)
+        repo.update_by_id(id, update_entity)
+      end
 
-    def delete(object)
-      repo = @repos_for_model_classes[object.class] or raise Error
-      repo.delete(object)
+      def delete(object)
+        repo = @repos_for_model_classes[object.class] || (fail StdError)
+        repo.delete(object)
+      end
     end
   end
 end

data/lib/hold/sequel/property_mapper.rb

@@ -1,138 +1,163 @@
-module Hold::Sequel
-  # Abstract superclass.
-  # Responsibility of a PropertyMapper is to map data for a particular property of a model class, between the
-  # instances of that model class, and the database
-  class PropertyMapper
-    def self.setter_dependencies_for(options={}); {}; end
+module Hold
+  module Sequel
+    # Abstract superclass.
+    #
+    # Responsibility of a PropertyMapper is to map data for a particular
+    # property of a model class, between the instances of that model class, and
+    # the database
+    class PropertyMapper
+      def self.setter_dependencies_for(_options = {})
+        {}
+      end
 
-    attr_reader :repository, :property_name, :property
+      attr_reader :repository, :property_name, :property
 
-    # If you pass a block, it will be instance_evalled, allowing you to create one-off custom property mappers
-    # by overriding bits of this implementation in the block.
-    def initialize(repo, property_name, options=nil, &block)
-      @repository = repo
-      @property_name = property_name
-      instance_eval(&block) if block
-    end
+      # If you pass a block, it will be instance_evalled, allowing you to create
+      # one-off custom property mappers by overriding bits of this
+      # implementation in the block.
+      def initialize(repo, property_name, _options = nil, &block)
+        @repository = repo
+        @property_name = property_name
+        instance_eval(&block) if block
+      end
 
-    # columns: column names to include in a SELECT in order to select this property. these should be
-    # qualified with the relevant table name but not aliased
-    #
-    # aliases: the above columns, aliased for use in the SELECT clause. be alias should something unique
-    # which the mapper can later use to retreive from a result row.
-    #
-    # Any tables which need to be present in the FROM clause in order to select the columns.
-    # relevant joins will be constructed by the parent repo.
-    #
-    # a 'preferred_table' hint may be passed by the repo to indicate that it'd prefer you load the
-    # column off a particular table; at present this is only used by the IdentityMapper
-    def columns_aliases_and_tables_for_select(preferred_table=nil)
-      return [], [], []
-    end
+      # columns: column names to include in a SELECT in order to select this
+      # property. These should be qualified with the relevant table name but not
+      # aliased.
+      #
+      # aliases: the above columns, aliased for use in the SELECT clause. be
+      # alias should something unique which the mapper can later use to retreive
+      # from a result row.
+      #
+      # Any tables which need to be present in the FROM clause in order to
+      # select the columns. Relevant joins will be constructed by the parent
+      # repo.
+      #
+      # A 'preferred_table' hint may be passed by the repo to indicate that it'd
+      # prefer you load the column off a particular table; at present this is
+      # only used by the IdentityMapper
+      def columns_aliases_and_tables_for_select(_preferred_table = nil)
+        [[], [], []]
+      end
 
-    # Obtains the value of this property from a sequel result row and/or identity value.
-    #
-    # where the mapper has columns_aliases_and_tables_for_select, it will get passed a result row object here
-    # which contains the sql values for these columns (amongst others potentially)
-    #
-    # Where the identity value is available it will also be passed.
-    #
-    # One or other of id, row must always be passed.
-    def load_value(row=nil, id=nil, properties=nil)
-    end
+      # Obtains the value of this property from a sequel result row and/or
+      # identity value.
+      #
+      # where the mapper has columns_aliases_and_tables_for_select, it will get
+      # passed a result row object here which contains the sql values for these
+      # columns (amongst others potentially)
+      #
+      # Where the identity value is available it will also be passed.
+      #
+      # One or other of id, row must always be passed.
+      def load_value(_row = nil, _id = nil, _properties = nil)
+      end
 
-    # called inside the INSERT transaction for insertion of the given entity.
-    #
-    # this is called first thing before insert rows are built (via build_insert_row) for each table of the
-    # repo.
-    def pre_insert(entity)
-    end
+      # called inside the INSERT transaction for insertion of the given entity.
+      #
+      # this is called first thing before insert rows are built (via
+      # build_insert_row) for each table of the repo.
+      def pre_insert(_entity)
+      end
 
-    # called inside the UPDATE transaction for insertion of the given entity.
-    #
-    # this is called first thing before update rows are built (via build_update_row) for each table of the
-    # repo.
-    #
-    # anything returned from pre_update will be passed to post_update's data_from_pre_update arg if the
-    # update succeeds.
-    def pre_update(entity, update_entity)
-    end
+      # called inside the UPDATE transaction for insertion of the given entity.
+      #
+      # this is called first thing before update rows are built (via
+      # build_update_row) for each table of the repo.
+      #
+      # anything returned from pre_update will be passed to post_update's
+      # data_from_pre_update arg if the update succeeds.
+      def pre_update(_entity, _update_entity)
+      end
 
-    # called inside the DELETE transaction for a given entity.
-    #
-    # this is called first thing before rows are deleted for each table of the repo.
-    def pre_delete(entity)
-    end
+      # called inside the DELETE transaction for a given entity.
+      #
+      # this is called first thing before rows are deleted for each table of the
+      # repo.
+      def pre_delete(_entity)
+      end
 
-    # called inside the DELETE transaction for a given entity.
-    #
-    # this is called last thing after rows are deleted for each table of the repo.
-    def post_delete(entity)
-    end
+      # called inside the DELETE transaction for a given entity.
+      #
+      # this is called last thing after rows are deleted for each table of the
+      # repo.
+      def post_delete(_entity)
+      end
 
-    # gets this property off the entity, and sets associated keys on a sequel row hash for insertion
-    # into the given table. May be passed an ID if an last_insert_id id value for the entity was previously
-    # obtained from an ID sequence on insertion into another table as part of the same combined entity
-    # store_new.
-    #
-    # this is called inside the transaction which wraps the insert, so this is effectively your pre-insert
-    # hook and you can safely do other things inside it in the knowledge they'll be rolled back in the
-    # event of a subsequent problem.
-    def build_insert_row(entity, table, row, id=nil)
-    end
+      # gets this property off the entity, and sets associated keys on a sequel
+      # row hash for insertion into the given table. May be passed an ID if an
+      # last_insert_id id value for the entity was previously obtained from an
+      # ID sequence on insertion into another table as part of the same combined
+      # entity store_new.
+      #
+      # this is called inside the transaction which wraps the insert, so this is
+      # effectively your pre-insert hook and you can safely do other things
+      # inside it in the knowledge they'll be rolled back in the event of a
+      # subsequent problem.
+      def build_insert_row(_entity, _table, _row, _id = nil)
+      end
 
-    # gets this property off the update_entity, and sets associated keys on a sequel row hash for update
-    # of the given table for the given entity.
-    #
-    # as with build_update_row, this is done inside the update transaction, it's effectively your
-    # pre-update hook.
-    def build_update_row(update_entity, table, row)
-    end
+      # gets this property off the update_entity, and sets associated keys on a
+      # sequel row hash for update of the given table for the given entity.
+      #
+      # as with build_update_row, this is done inside the update transaction,
+      # it's effectively your pre-update hook.
+      def build_update_row(_update_entity, _table, _row)
+      end
 
-    # used to make a sequel filter condition setting relevant columns equal to values equivalent
-    # to the given property value. May raise if mapper doesn't support this
-    def make_filter(value, columns_mapped_to)
-      raise Hold::UnsupportedOperation
-    end
+      # used to make a sequel filter condition setting relevant columns equal to
+      # values equivalent to the given property value. May raise if mapper
+      # doesn't support this
+      def make_filter(_value, _columns_mapped_to)
+        fail Hold::UnsupportedOperation
+      end
 
-    # As for make_filter but takes multiple possible values and does a column IN (1,2,3,4) type thing.
-    def make_multi_filter(values, columns_mapped_to)
-      raise Hold::UnsupportedOperation
-    end
+      # As for make_filter but takes multiple possible values and does a column
+      # IN (1,2,3,4) type thing.
+      def make_multi_filter(_values, _columns_mapped_to)
+        fail Hold::UnsupportedOperation
+      end
 
-    # like load_value, but works in a batched fashion, allowing a batched loading strategy to
-    # be used for associated objects.
-    # takes a block and yields the loaded values one at a time to it together with their index
-    def load_values(rows=nil, ids=nil, properties=nil)
-      if rows
-        rows.each_with_index {|row, i| yield load_value(row, ids && ids[i], properties), i}
-      else
-        ids.each_with_index {|id, i| yield load_value(nil, id, properties), i}
+      # like load_value, but works in a batched fashion, allowing a batched
+      # loading strategy to be used for associated objects.
+      # takes a block and yields the loaded values one at a time to it together
+      # with their index
+      def load_values(rows = nil, ids = nil, properties = nil)
+        if rows
+          rows.each_with_index do |row, i|
+            yield load_value(row, ids && ids[i], properties), i
+          end
+        else
+          ids.each_with_index do |id, i|
+            yield load_value(nil, id, properties), i
+          end
+        end
       end
-    end
 
-    # called after rows built via build_insert_row have successfully been used in a INSERT
-    # for the entity passed. Should update the entity property, where appropriate, with any default
-    # values which were supplied by the repository (via default_for) on insert, and should do
-    # any additional work in order to save any values which are not mapped to columns on one of the repo's
-    # own :tables
-    #
-    # Is also passed the last_insert_id resulting from any insert, to help fill out any autoincrement
-    # primary key column.
-    #
-    # is executed inside the same transaction as the INSERT
-    def post_insert(entity, rows, last_insert_id=nil)
-    end
+      # called after rows built via build_insert_row have successfully been used
+      # in a INSERT for the entity passed. Should update the entity property,
+      # where appropriate, with any default values which were supplied by the
+      # repository (via default_for) on insert, and should do any additional
+      # work in order to save any values which are not mapped to columns on one
+      # of the repo's own :tables
+      #
+      # Is also passed the last_insert_id resulting from any insert, to help
+      # fill out any autoincrement primary key column.
+      #
+      # is executed inside the same transaction as the INSERT
+      def post_insert(_entity, _rows, _last_insert_id = nil)
+      end
 
-    # called after rows built via build_update_row have successfully been used in a UPDATE
-    # for the id and update_entity passed. Should update the entity property, where appropriate, with any default
-    # values which were supplied by the repository (via default_for) on update, and should do
-    # any additional work in order to save any values which are not mapped to columns on one of the repo's
-    # own :tables
-    #
-    # is executed inside the same transaction as the UPDATE
-    def post_update(entity, update_entity, rows, data_from_pre_update)
+      # called after rows built via build_update_row have successfully been used
+      # in a UPDATE for the id and update_entity passed. Should update the
+      # entity property, where appropriate, with any default values which were
+      # supplied by the repository (via default_for) on update, and should do
+      # any additional work in order to save any values which are not mapped to
+      # columns on one of the repo's own :tables
+      #
+      # is executed inside the same transaction as the UPDATE
+      def post_update(_entity, _update_entity, _rows, _data_from_pre_update)
+      end
     end
-
   end
 end