hold 1.0.2 → 1.0.3

data/lib/hold/sequel/query_array_cell.rb

@@ -1,21 +1,26 @@
-module Hold::Sequel
-  class QueryArrayCell
-    include Hold::ArrayCell
+module Hold
+  module Sequel
+    # Query an array cell
+    class QueryArrayCell
+      include Hold::ArrayCell
 
-    def initialize(repo, *query_args, &query_block)
-      @repo, @query_block = repo, query_block
-    end
+      def initialize(repo, *_query_args, &query_block)
+        @repo, @query_block = repo, query_block
+      end
 
-    def get(properties=nil)
-      @repo.query(properties, &@query_block).to_a
-    end
+      def get(properties = nil)
+        @repo.query(properties, &@query_block).to_a
+      end
 
-    def get_slice(start, length, properties=nil)
-      @repo.query(properties, &@query_block).to_a(true)[start, length]
-    end
+      def slice(start, length, properties = nil)
+        @repo.query(properties, &@query_block).to_a(true)[start, length]
+      end
+      alias_method :get_slice, :slice
 
-    def get_length
-      Query.new(@repo, [], &@query_block).to_a(true).length
+      def length
+        Query.new(@repo, [], &@query_block).to_a(true).length
+      end
+      alias_method :get_length, :length
     end
   end
 end

data/lib/hold/sequel/repository_observer.rb

@@ -1,28 +1,32 @@
-# If you want to observe events on a Hold::Sequel::IdentitySetRepository
-# you need to implement this interface. Stubs supplied here to save you some
-# boilerplate in case you only care about certain events.
-#
-# The callback methods correspond to their counterparts on
-# Hold::Sequel::IdentityHashRepository but with an added argument
-# passing the repository instance.
-#
-# TODO: generalise this to SetRepositories in general
-module Hold::Sequel::RepositoryObserver
-  def pre_insert(repo, entity)
-  end
+module Hold
+  module Sequel
+    # If you want to observe events on a Hold::Sequel::IdentitySetRepository
+    # you need to implement this interface. Stubs supplied here to save you some
+    # boilerplate in case you only care about certain events.
+    #
+    # The callback methods correspond to their counterparts on
+    # Hold::Sequel::IdentityHashRepository but with an added argument
+    # passing the repository instance.
+    #
+    # TODO: generalise this to SetRepositories in general
+    module RepositoryObserver
+      def pre_insert(_repo, _entity)
+      end
 
-  def post_insert(repo, entity, insert_rows, insert_id)
-  end
+      def post_insert(_repo, _entity, _insert_rows, _insert_id)
+      end
 
-  def pre_update(repo, entity, update_entity)
-  end
+      def pre_update(_repo, _entity, _update_entity)
+      end
 
-  def post_update(repo, entity, update_entity, update_rows)
-  end
+      def post_update(_repo, _entity, _update_entity, _update_rows)
+      end
 
-  def pre_delete(repo, entity)
-  end
+      def pre_delete(_repo, _entity)
+      end
 
-  def post_delete(repo, entity)
+      def post_delete(_repo, _entity)
+      end
+    end
   end
 end

data/lib/hold/sequel/with_polymorphic_type_column.rb

@@ -1,117 +1,163 @@
-module Hold::Sequel
-  # Subclass of Sequel::IdentitySetRepository which adds support for a polymorphic type column which
-  # is used to persist the class of the model.
-  class IdentitySetRepository::WithPolymorphicTypeColumn < IdentitySetRepository
-
-    class << self
-      def type_column; @type_column ||= superclass.type_column; end
-      def type_column_table; @type_column_table ||= superclass.type_column_table; end
-      def class_to_type_mapping; @class_to_type_mapping ||= (superclass.class_to_type_mapping if superclass < IdentitySetRepository::WithPolymorphicTypeColumn); end
-      def type_to_class_mapping; @type_to_class_mapping ||= (superclass.type_to_class_mapping if superclass < IdentitySetRepository::WithPolymorphicTypeColumn); end
-      def restricted_to_types; @restricted_to_types ||= (superclass.restricted_to_types if superclass < IdentitySetRepository::WithPolymorphicTypeColumn); end
-
-      def supported_classes
-        if restricted_to_types
-          type_to_class_mapping.values_at(*restricted_to_types)
-        else
-          class_to_type_mapping.keys
-        end
-      end
+module Hold
+  module Sequel
+    class IdentitySetRepository
+      # Subclass of Sequel::IdentitySetRepository which adds support for a
+      # polymorphic type column which is used to persist the class of the model.
+      class WithPolymorphicTypeColumn < IdentitySetRepository
+        class << self
+          def type_column
+            @type_column ||= superclass.type_column
+          end
 
-    private
+          def type_column_table
+            @type_column_table ||= superclass.type_column_table
+          end
 
-      def set_type_column(column, table, mapping=nil)
-        unless superclass == IdentitySetRepository::WithPolymorphicTypeColumn
-          raise "set_type_column only on the topmost IdentitySetRepository::WithPolymorphicTypeColumn subclass"
-        end
-        table, mapping = tables.first.first, table if table.is_a?(Hash)
-        @type_column = column
-        @type_column_table = table
-        @class_to_type_mapping = mapping
-        @type_to_class_mapping = mapping.invert
-      end
+          def class_to_type_mapping
+            @class_to_type_mapping ||=
+              if superclass < WithPolymorphicTypeColumn
+                superclass.class_to_type_mapping
+              end
+          end
+
+          def type_to_class_mapping
+            @type_to_class_mapping ||=
+              if superclass < WithPolymorphicTypeColumn
+                superclass.type_to_class_mapping
+              end
+          end
+
+          def restricted_to_types
+            @restricted_to_types ||=
+              if superclass < WithPolymorphicTypeColumn
+                superclass.restricted_to_types
+              end
+          end
+
+          def supported_classes
+            if restricted_to_types
+              type_to_class_mapping.values_at(*restricted_to_types)
+            else
+              class_to_type_mapping.keys
+            end
+          end
+
+          private
+
+          def set_type_column(column, table, mapping = nil)
+            unless superclass == WithPolymorphicTypeColumn
+              fail 'set_type_column only on the topmost subclass'
+            end
 
-      def set_model_class(model_class)
-        @model_class = model_class
-        raise "set_type_column before set_model_class" unless class_to_type_mapping
-        klasses = class_to_type_mapping.keys.select {|klass| klass <= model_class}
-        @restricted_to_types = if klasses.size < @class_to_type_mapping.size
-          class_to_type_mapping.values_at(*klasses)
+            table, mapping = tables.first.first, table if table.is_a?(Hash)
+            @type_column = column
+            @type_column_table = table
+            @class_to_type_mapping = mapping
+            @type_to_class_mapping = mapping.invert
+          end
+
+          def set_model_class(model_class)
+            @model_class = model_class
+            unless class_to_type_mapping
+              fail 'set_type_column before set_model_class'
+            end
+
+            klasses = class_to_type_mapping.keys
+                      .select { |klass| klass <= model_class }
+
+            @restricted_to_types = if klasses.size < @class_to_type_mapping.size
+                                     class_to_type_mapping.values_at(*klasses)
+                                   end
+          end
         end
-      end
-    end
 
-    def initialize(db)
-      super
-      @qualified_type_column = Sequel::SQL::QualifiedIdentifier.new(self.class.type_column_table, self.class.type_column)
-      @aliased_type_column = Sequel::SQL::AliasedExpression.new(@qualified_type_column, :type)
+        def initialize(db)
+          super
+          @qualified_type_column =
+            ::Sequel::SQL::QualifiedIdentifier.new(self.class.type_column_table,
+                                                   self.class.type_column)
 
-      @restricted_to_types = self.class.restricted_to_types
-      @tables_restricting_type = {}
-      self.class.tables.each do |name, options|
-        @tables_restricting_type[name] = true if options[:restricts_type]
-      end
-    end
+          @aliased_type_column =
+            ::Sequel::SQL::AliasedExpression.new(@qualified_type_column, :type)
 
-    def can_get_class?(model_class)
-      self.class.supported_classes.include?(model_class)
-    end
+          @restricted_to_types = self.class.restricted_to_types
+          @tables_restricting_type = {}
+          self.class.tables.each do |name, options|
+            @tables_restricting_type[name] = true if options[:restricts_type]
+          end
+        end
 
-    def can_set_class?(model_class)
-      self.class.supported_classes.include?(model_class)
-    end
+        def can_get_class?(model_class)
+          self.class.supported_classes.include?(model_class)
+        end
 
-    def construct_entity(property_hash, row=nil)
-      type_value = row && row[:type] or return super
-      klass = self.class.type_to_class_mapping[type_value || @restricted_to_types.first] or
-        raise "WithPolymorphicTypeColumn: type column value #{type_value} not found in mapping"
-      klass.new(property_hash)
-    end
+        def can_set_class?(model_class)
+          self.class.supported_classes.include?(model_class)
+        end
 
-    # This optimisation has to be turned off for polymorphic repositories, since even if
-    # we know the ID, we have to query the db to find out the appropriate class to construct
-    # the object as.
-    def can_construct_from_id_alone?(properties)
-      super && @restricted_to_types && @restricted_to_types.length == 1
-    end
+        def construct_entity(property_hash, row = nil)
+          type_value = row && row[:type] || (return super)
+          klass =
+            self.class.type_to_class_mapping[type_value] ||
+            (fail "WithPolymorphicTypeColumn: type column value #{type_value}" \
+                  ' not found in mapping')
+          klass.new(property_hash)
+        end
 
-    # ensure we select the type column in addition to any columns for mapped properties,
-    # so we know which class to instantiate for each row.
-    #
-    # If we're restricted to only one class, we don't need to select the type column
-    def columns_aliases_and_tables_for_properties(properties)
-      columns_by_property, aliased_columns, tables = super
-      unless @restricted_to_types && @restricted_to_types.length == 1
-        aliased_columns << @aliased_type_column
-        tables << self.class.type_column_table unless tables.include?(self.class.type_column_table)
-      end
-      return columns_by_property, aliased_columns, tables
-    end
+        # This optimisation has to be turned off for polymorphic repositories,
+        # since even if we know the ID, we have to query the db to find out the
+        # appropriate class to construct the object as.
+        def can_construct_from_id_alone?(properties)
+          super && @restricted_to_types && @restricted_to_types.length == 1
+        end
 
-    # Where 'restricted_to_types' has been set, ensure we add a filter to the where
-    # clause restricting to rows with the allowed class (or classes).
-    #
-    # Except, where one of the tables used is specified in this repo's config as
-    # :restricts_type => true, this is taken to mean that (inner) joining to this table
-    # effectively acts as this repo's restricted_to_types restriction. hence no additional
-    # where clause is needed in order to do this. Helps with Class Table Inheritance.
-    def dataset_to_select_tables(*tables)
-      if @restricted_to_types && !@tables_restricting_type.values_at(*tables).any?
-        super.filter(@qualified_type_column => @restricted_to_types)
-      else
-        super
-      end
-    end
+        # ensure we select the type column in addition to any columns for mapped
+        # properties, so we know which class to instantiate for each row.
+        #
+        # If we're restricted to only one class, we don't need to select the
+        # type column
+        def columns_aliases_and_tables_for_properties(properties)
+          columns_by_property, aliased_columns, tables = super
+          unless @restricted_to_types && @restricted_to_types.length == 1
+            aliased_columns << @aliased_type_column
+            unless tables.include?(self.class.type_column_table)
+              tables << self.class.type_column_table
+            end
+          end
+          [columns_by_property, aliased_columns, tables]
+        end
+
+        # Where 'restricted_to_types' has been set, ensure we add a filter to
+        # the where clause restricting to rows with the allowed class (or
+        # classes).
+        #
+        # Except, where one of the tables used is specified in this repo's
+        # config as :restricts_type => true, this is taken to mean that (inner)
+        # joining to this table effectively acts as this repo's
+        # restricted_to_types restriction. hence no additional where clause is
+        # needed in order to do this. Helps with Class Table Inheritance.
+        def dataset_to_select_tables(*tables)
+          if @restricted_to_types &&
+             !@tables_restricting_type.values_at(*tables).any?
+            super.filter(@qualified_type_column => @restricted_to_types)
+          else
+            super
+          end
+        end
 
-    private
+        private
 
-      def insert_row_for_entity(entity, table, id=nil)
-        row = super
-        if table == self.class.type_column_table
-          row[self.class.type_column] = self.class.class_to_type_mapping[entity.class] or
-            raise "WithPolymorphicTypeColumn: class #{entity.class} not found in mapping"
+        def insert_row_for_entity(entity, table, id = nil)
+          row = super
+          if table == self.class.type_column_table
+            row[self.class.type_column] =
+              self.class .class_to_type_mapping[entity.class] ||
+              (fail "WithPolymorphicTypeColumn: class #{entity.class} not" \
+                     ' found in mapping')
+          end
+          row
         end
-        row
       end
+    end
   end
 end

data/lib/hold/serialized.rb

@@ -1,106 +1,4 @@
 require 'hold/interfaces'
 
-module Hold
-
-  module Serialized; end
-
-  # A repository which caches serialized versions of an entity in a string-based key/value cache.
-  #
-  # Wraps a string-based HashRepository, and requires a serializer responding to 'serialize' and
-  # 'deserialize'.
-  #
-  # May optionally have a 'key_prefix', which is a prefixed namespace added to the cache keys
-  # before getting/setting the serialized values in the underlying cache.
-  class Serialized::HashRepository
-    include Hold::HashRepository
-
-    attr_reader :cache, :serializer, :key_prefix
-
-    def initialize(cache, serializer, key_prefix=nil)
-      @cache = cache
-      @serializer = serializer
-      @key_prefix = key_prefix
-    end
-
-    def cache_key(key)
-      @key_prefix ? @key_prefix + key.to_s : key.to_s
-    end
-
-    def set_with_key(key, entity)
-      @cache.set_with_key(cache_key(key), @serializer.serialize(entity))
-    end
-
-    def get_with_key(key)
-      json = @cache.get_with_key(cache_key(key)) and @serializer.deserialize(json)
-    end
-
-    def get_many_with_keys(keys)
-      jsons = @cache.get_many_with_keys(*keys.map {|key| cache_key(key)})
-      jsons.map {|json| json && @serializer.deserialize(json)}
-    end
-
-    def has_key?(key)
-      @cache.has_key?(cache_key(key))
-    end
-    alias_method :key?, :has_key?
-
-    def clear_key(key)
-      @cache.clear_key(cache_key(key))
-    end
-  end
-
-  class Serialized::IdentitySetRepository
-    include Hold::IdentitySetRepository
-
-    attr_reader :cache, :serializer, :key_prefix
-
-    def initialize(cache, serializer, key_prefix=nil)
-      @cache = cache
-      @serializer = serializer
-      @key_prefix = key_prefix
-    end
-
-    def cache_key(key)
-      @key_prefix ? @key_prefix + key.to_s : key.to_s
-    end
-
-    def allocates_ids?
-      false
-    end
-
-    def store(object)
-      id = object.id or raise MissingIdentity
-      @cache.set_with_key(cache_key(id), @serializer.serialize(object))
-      object
-    end
-
-    def delete(object)
-      id = object.id or raise MissingIdentity
-      delete_id(id)
-    end
-
-    def contains?(object)
-      id = object.id or raise MissingIdentity
-      contains_id?(id)
-    end
-
-    def get_by_id(id)
-      json = @cache.get_with_key(cache_key(id))
-      if json
-        string_hash = @serializer.deserialize(json)
-        string_hash.inject({}) do |memo, (k,v)|
-          memo[k.to_sym] = v
-          memo
-        end
-      end
-    end
-
-    def delete_id(id)
-      @cache.clear_key(cache_key(id))
-    end
-
-    def contains_id?(id)
-      @cache.has_key?(cache_key(id))
-    end
-  end
-end
+require 'hold/serialized/hash_repository'
+require 'hold/serialized/identity_set_repository'