hold 1.0.0

data/lib/hold/sequel/property_mapper/transformed_column.rb

@@ -0,0 +1,38 @@
+module Hold::Sequel
+  # A column mapper which allows you to supply a customized pair of transformations
+  # between the sequel values persisted in the db, and the values used for the outward-facing
+  # model property
+  class PropertyMapper::TransformedColumn < PropertyMapper::Column
+    def initialize(repo, property_name, options)
+      super(repo, property_name, options)
+      @to_sequel = options[:to_sequel]
+      @from_sequel = options[:from_sequel]
+    end
+
+    def to_sequel(value)
+      @to_sequel.call(value)
+    end
+
+    def from_sequel(value)
+      @from_sequel.call(value)
+    end
+
+    def load_value(row, id=nil, properties=nil)
+      from_sequel(row[@column_alias])
+    end
+
+    def build_insert_row(entity, table, row, id=nil)
+      row[@column_name] = to_sequel(entity[@property_name]) if @table == table && entity.has_key?(@property_name)
+    end
+
+    alias :build_update_row :build_insert_row
+
+    def make_filter(value, columns_mapped_to=nil)
+      {@column_qualified => to_sequel(value)}
+    end
+
+    def make_multi_filter(values, columns_mapped_to=nil)
+      {@column_qualified => values.map {|v| to_sequel(v)}}
+    end
+  end
+end

data/lib/hold/sequel/property_mapper/updated_at.rb

@@ -0,0 +1,17 @@
+module Hold::Sequel
+  class PropertyMapper::UpdatedAt < PropertyMapper::Column
+    def build_insert_row(entity, table, row, id=nil)
+      row[@column_name] = Time.now if table == @table
+    end
+
+    alias :build_update_row :build_insert_row
+
+    def post_insert(entity, rows, last_insert_id=nil)
+      entity[@property_name] = rows[@table][@column_name]
+    end
+
+    def post_update(id, update_entity, rows, from_pre_update)
+      update_entity[@property_name] = rows[@table][@column_name]
+    end
+  end
+end

data/lib/hold/sequel/query.rb

@@ -0,0 +1,92 @@
+module Hold::Sequel
+  # A query has a dataset and mappings constructed to select a particular
+  # set of properties on a particular Sequel::IdentitySetRepository
+  class Query
+    attr_reader :dataset, :count_dataset, :property_versions, :property_columns, :aliased_columns, :tables
+
+    # Repo: repository to query
+    # properties: mapping or array of properties to fetch.
+    # properties ::=
+    #   nil or true = fetch the default set of properties for the given repository
+    #   array of property names = fetch just these properties, each in their default version
+    #   hash of property names = fetch just these properties, each in the version given in the hash
+    #
+    # can pass a block: {|dataset, property_columns| return dataset.messed_with}
+    def initialize(repo, properties)
+      @repository = repo
+
+      if properties.is_a?(::Array)
+        @property_versions = {}
+        properties.each {|p,v| @property_versions[p] = v}
+      else
+        @property_versions = properties
+      end
+
+      @property_columns, @aliased_columns, @tables =
+        @repository.columns_aliases_and_tables_for_properties(@property_versions.keys)
+
+      @dataset = @repository.dataset_to_select_tables(*@tables)
+      @dataset = yield @dataset, @property_columns if block_given?
+
+      id_cols = @property_columns[@repository.identity_property]
+      @count_dataset = @dataset.select(*id_cols)
+
+      @dataset = @dataset.select(*@aliased_columns)
+    end
+
+    private
+
+    def load_from_rows(rows, return_the_row_alongside_each_result=false)
+      return [] if rows.empty?
+
+      property_hashes = []; ids = []
+      @repository.identity_mapper.load_values(rows) do |id,i|
+        property_hashes << {@repository.identity_property => id}
+        ids << id
+      end
+
+      @property_versions.each do |prop_name, prop_version|
+        @repository.mapper(prop_name).load_values(rows, ids, prop_version) do |value, i|
+          property_hashes[i][prop_name] = value
+        end
+      end
+
+      result = []
+      property_hashes.each_with_index do |h,i|
+        row = rows[i]
+        entity = @repository.construct_entity(h, row)
+        result << (return_the_row_alongside_each_result ? [entity, row] : entity)
+      end
+      result
+    end
+
+
+    public
+
+    def results(lazy=false)
+      lazy_array = DatasetLazyArray.new(@dataset, @count_dataset) {|rows| load_from_rows(rows)}
+      lazy ? lazy_array : lazy_array.to_a
+    end
+
+    alias :to_a :results
+
+    # this one is useful if you add extra selected columns onto the dataset, and you want to get
+    # at those extra values on the underlying rows alongside the loaded entities.
+    def results_with_rows
+      load_from_rows(@dataset.all, true)
+    end
+
+    def single_result
+      row = Hold::Sequel.translate_exceptions {@dataset.first} or return
+
+      id = @repository.identity_mapper.load_value(row)
+      property_hash = {@repository.identity_property => id}
+
+      @property_versions.each do |prop_name, prop_version|
+        property_hash[prop_name] = @repository.mapper(prop_name).load_value(row, id, prop_version)
+      end
+
+      @repository.construct_entity(property_hash, row)
+    end
+  end
+end

data/lib/hold/sequel/query_array_cell.rb

@@ -0,0 +1,21 @@
+module Hold::Sequel
+  class QueryArrayCell
+    include Hold::ArrayCell
+
+    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_slice(start, length, properties=nil)
+      @repo.query(properties, &@query_block).to_a(true)[start, length]
+    end
+
+    def get_length
+      Query.new(@repo, [], &@query_block).to_a(true).length
+    end
+  end
+end

data/lib/hold/sequel/repository_observer.rb

@@ -0,0 +1,28 @@
+# 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
+
+  def post_insert(repo, entity, insert_rows, insert_id)
+  end
+
+  def pre_update(repo, entity, update_entity)
+  end
+
+  def post_update(repo, entity, update_entity, update_rows)
+  end
+
+  def pre_delete(repo, entity)
+  end
+
+  def post_delete(repo, entity)
+  end
+end

data/lib/hold/sequel/with_polymorphic_type_column.rb

@@ -0,0 +1,117 @@
+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
+
+    private
+
+      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 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)
+        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)
+
+      @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_get_class?(model_class)
+      self.class.supported_classes.include?(model_class)
+    end
+
+    def can_set_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
+
+    # 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
+
+    # 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
+
+    # 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
+
+      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"
+        end
+        row
+      end
+  end
+end

data/lib/hold/serialized.rb

@@ -0,0 +1,104 @@
+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))
+      string_hash = @serializer.deserialize(json)
+      string_hash = string_hash.inject({}){|memo,(k,v)|
+        memo[k.to_sym] = v; memo
+      }
+    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

data/lib/hold/serialized/json_serializer.rb

@@ -0,0 +1,12 @@
+require 'hold/serialized'
+require 'json'
+
+class Hold::Serialized::JSONSerializer
+  def serialize(entity)
+    entity.to_json
+  end
+
+  def deserialize(string)
+    JSON.parse(string)
+  end
+end

data/lib/hold/version.rb

@@ -0,0 +1,3 @@
+module Hold
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: hold
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matthew Willson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: test-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: wirer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: thin_models
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.4
+description: 
+email:
+- matthew@playlouder.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/hold.rb
+- lib/hold/file/hash_repository.rb
+- lib/hold/in_memory.rb
+- lib/hold/interfaces.rb
+- lib/hold/sequel.rb
+- lib/hold/sequel/dataset_lazy_array.rb
+- lib/hold/sequel/identity_set_repository.rb
+- lib/hold/sequel/polymorphic_repository.rb
+- lib/hold/sequel/property_mapper.rb
+- lib/hold/sequel/property_mapper/array.rb
+- lib/hold/sequel/property_mapper/column.rb
+- lib/hold/sequel/property_mapper/created_at.rb
+- lib/hold/sequel/property_mapper/custom_query.rb
+- lib/hold/sequel/property_mapper/custom_query_single_value.rb
+- lib/hold/sequel/property_mapper/foreign_key.rb
+- lib/hold/sequel/property_mapper/hash.rb
+- lib/hold/sequel/property_mapper/identity.rb
+- lib/hold/sequel/property_mapper/many_to_many.rb
+- lib/hold/sequel/property_mapper/one_to_many.rb
+- lib/hold/sequel/property_mapper/transformed_column.rb
+- lib/hold/sequel/property_mapper/updated_at.rb
+- lib/hold/sequel/query.rb
+- lib/hold/sequel/query_array_cell.rb
+- lib/hold/sequel/repository_observer.rb
+- lib/hold/sequel/with_polymorphic_type_column.rb
+- lib/hold/serialized.rb
+- lib/hold/serialized/json_serializer.rb
+- lib/hold/version.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A library geared towards separating persistence concerns from data model
+  classes
+test_files: []