hydra_attribute 0.4.2 → 0.5.0.rc1

data/lib/hydra_attribute/hydra_set.rb

@@ -1,36 +1,34 @@
-require 'active_support/core_ext/object/with_options'
-
 module HydraAttribute
-  class HydraSet < ActiveRecord::Base
-    self.table_name = 'hydra_sets'
+  # TODO add #build_entity and #create_entity methods
+  class HydraSet
+
+    # This error is raised when called method for attribute which doesn't exist in current hydra set
+    #
+    # @example
+    #   Product.hydra_attributes.create(name: 'price', backend_type: 'float')
+    #   Product.hydra_attributes.create(name: 'title', backend_type: 'string')
+    #
+    #   hydra_set = Product.hydra_sets.create(name: 'Default')
+    #   hydra_set.hydra_attributes = [Product.hydra_attribute('title')]
+    #
+    #   product = Product.new(hydra_set_id: hydra_set.id)
+    #   product.title = 'Toy' # ok
+    #   product.price = 2.50  # raise HydraAttribute::HydraSet::MissingAttributeInHydraSetError
+    class MissingAttributeInHydraSetError < NoMethodError
+    end
 
-    attr_accessible :name
+    include ::HydraAttribute::Model
 
-    has_and_belongs_to_many :hydra_attributes, join_table: 'hydra_attribute_sets', class_name: 'HydraAttribute::HydraAttribute', conditions: proc { {hydra_attributes: {entity_type: entity_type}} }
+    define_cached_singleton_method :all_by_entity_type, cache_key: :entity_type, cache_value: :self, cache_key_cast: :to_s
 
-    with_options presence: true do |klass|
-      klass.validates :entity_type,  inclusion: { in: lambda { |attr| [(attr.entity_type.constantize.name rescue nil)] } }
-      klass.validates :name,         uniqueness: { scope: :entity_type }
-    end
+    validates :entity_type, presence: true # TODO add match validation with its hydra_attributes.entity_type
+    validates :name,        presence: true, unique: { scope: :entity_type }
 
-    after_destroy :detach_entities
-    after_commit  :clear_entity_cache
+    has_many :hydra_attributes, through: :hydra_attribute_set, copy_attribute: :entity_type
 
-    # @COMPATIBILITY with 3.1.x association module is directly added to the class instead of including module
-    def hydra_attributes_with_clearing_cache=(value)
-      self.hydra_attributes_without_clearing_cache = value
-      clear_entity_cache
-      value
+    def has_hydra_attribute_id?(hydra_attribute_id)
+      HydraAttributeSet.has_hydra_attribute_id_in_hydra_set_id?(hydra_attribute_id, id)
     end
-    alias_method_chain :hydra_attributes=, :clearing_cache
-
-    private
-      def clear_entity_cache
-        entity_type.constantize.clear_hydra_method_cache!
-      end
 
-      def detach_entities
-        entity_type.constantize.where(hydra_set_id: id).update_all(hydra_set_id: nil)
-      end
   end
 end

data/lib/hydra_attribute/hydra_value.rb

@@ -0,0 +1,210 @@
+module HydraAttribute
+  class HydraValue
+
+    # This error is raised when +:hydra_attribute_id+ key isn't passed to initialize.
+    # This key is important for determination the type of attribute which this model represents.
+    class HydraAttributeIdIsMissedError < ArgumentError
+      def initialize(msg = 'Key :hydra_attribute_id is missed')
+        super
+      end
+    end
+
+    # This error is raised when <tt>HydraAttribute::HydraValue</tt> model is saved
+    # but <tt>entity model</tt> isn't persisted
+    class EntityModelIsNotPersistedError < RuntimeError
+      def initialize(msg = 'HydraValue model cannot be saved is entity model is not persisted')
+        super
+      end
+    end
+
+    include ::HydraAttribute::Model::IdentityMap
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Dirty
+
+    attr_reader :entity, :value
+
+    define_attribute_method :value
+
+    # Initialize hydra value object
+    #
+    # @param [ActiveRecord::Base] entity link to entity model
+    # @param [Hash] attributes contain values of table row
+    # @option attributes [Symbol] :id
+    # @option attributes [Symbol] :hydra_attribute_id this field is required
+    # @option attributes [Symbol] :value
+    def initialize(entity, attributes = {})
+      raise HydraAttributeIdIsMissedError unless attributes.has_key?(:hydra_attribute_id)
+      @entity     = entity
+      @attributes = attributes
+      if attributes.has_key?(:value)
+        @value = column.type_cast(attributes[:value])
+      else
+        @value = column.type_cast(column.default)
+        attributes[:value] = column.default
+      end
+    end
+
+    class << self
+      # Holds <tt>Arel::Table</tt> objects grouped by entity table and backend type of attribute
+      #
+      # @return [Hash]
+      def arel_tables
+        @arel_tables ||= Hash.new do |entity_tables, entity_table|
+          entity_tables[entity_table] = Hash.new do |backend_types, backend_type|
+            backend_types[backend_type] = Arel::Table.new("hydra_#{backend_type}_#{entity_table}", ::ActiveRecord::Base)
+          end
+        end
+      end
+
+      # Returns database adapter
+      #
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      def connection
+        @connection ||= ::ActiveRecord::Base.connection
+      end
+
+      # Returns virtual value column
+      #
+      # @param [Fixnum] hydra_attribute_id
+      # @return [ActiveRecord::ConnectionAdapters::Column]
+      def column(hydra_attribute_id)
+        nested_identity_map(:column).cache(hydra_attribute_id.to_i) do
+          hydra_attribute = ::HydraAttribute::HydraAttribute.find(hydra_attribute_id)
+          ::ActiveRecord::ConnectionAdapters::Column.new(hydra_attribute.name, hydra_attribute.default_value, hydra_attribute.backend_type)
+        end
+      end
+
+      # Delete all values for current entity
+      #
+      # @param [HydraAttribute::HydraEntity] entity
+      # @return [NilClass]
+      def delete_entity_values(entity)
+        hydra_attributes = ::HydraAttribute::HydraAttribute.all_by_entity_type(entity.class.model_name)
+        hydra_attributes = hydra_attributes.group_by(&:backend_type)
+        hydra_attributes.each do |backend_type, attributes|
+          table = arel_tables[entity.class.table_name][backend_type]
+          where = table['hydra_attribute_id'].in(attributes.map(&:id)).and(table['entity_id'].eq(entity.id))
+          arel  = table.from(table)
+          connection.delete(arel.where(where).compile_delete, 'SQL')
+        end
+      end
+    end
+
+    # Returns virtual value column
+    #
+    # @return [ActiveRecord::ConnectionAdapters::Column]
+    def column
+      self.class.column(@attributes[:hydra_attribute_id])
+    end
+
+    # Returns model ID
+    #
+    # @return [Fixnum]
+    def id
+      @attributes[:id]
+    end
+
+    # Sets new type casted attribute value
+    #
+    # @param [Object] new_value
+    # @return [NilClass]
+    def value=(new_value)
+      value_will_change! unless value == new_value
+      @attributes[:value] = new_value
+      @value = column.type_cast(new_value)
+    end
+
+    # Returns not type cased value
+    #
+    # @return [Object]
+    def value_before_type_cast
+      @attributes[:value]
+    end
+
+    # Checks if value not blank and not zero for number types
+    #
+    # @return [TrueClass, FalseClass]
+    def value?
+      return false unless value
+
+      if column.number?
+        !value.zero?
+      else
+        value.present?
+      end
+    end
+
+    # Returns hydra attribute model which contains meta information about attribute
+    #
+    # @return [HydraAttribute::HydraAttribute]
+    def hydra_attribute
+      @hydra_attribute ||= ::HydraAttribute::HydraAttribute.find(@attributes[:hydra_attribute_id])
+    end
+
+    # Checks if model is persisted
+    #
+    # @return [TrueClass, FalseClass]
+    def persisted?
+      @attributes[:id].present?
+    end
+
+    # Saves model
+    # Performs +insert+ or +update+ sql query
+    # Method doesn't perform sql query if model isn't modified
+    #
+    # @return [TrueClass, FalseClass]
+    def save
+      raise EntityModelIsNotPersistedError unless entity.persisted?
+
+      if persisted?
+        return false unless changed?
+        update
+      else
+        create
+      end
+
+      @previously_changed = changes
+      @changed_attributes.clear
+
+      true
+    end
+
+    private
+      # Creates arel insert manager
+      #
+      # @return [Arel::InsertManager]
+      def arel_insert
+        table  = self.class.arel_tables[entity.class.table_name][hydra_attribute.backend_type]
+        fields = {}
+        fields[table[:entity_id]]          = entity.id
+        fields[table[:hydra_attribute_id]] = hydra_attribute.id
+        fields[table[:value]]              = value
+        fields[table[:created_at]]         = Time.now
+        fields[table[:updated_at]]         = Time.now
+        table.compile_insert(fields)
+      end
+
+      # Creates arel update manager
+      #
+      # @return [Arel::UpdateManager]
+      def arel_update
+        table = self.class.arel_tables[entity.class.table_name][hydra_attribute.backend_type]
+        arel  = table.from(table)
+        arel.where(table[:id].eq(id)).compile_update(table[:value] => value, table[:updated_at] => Time.now)
+      end
+
+      # Performs sql insert query
+      #
+      # @return [Integer] primary key
+      def create
+        @attributes[:id] = self.class.connection.insert(arel_insert, 'SQL')
+      end
+
+      # Performs sql update query
+      #
+      # @return [NilClass]
+      def update
+        self.class.connection.update(arel_update, 'SQL')
+      end
+  end
+end

data/lib/hydra_attribute/identity_map.rb

@@ -0,0 +1,18 @@
+# TODO isn't thread safe
+module HydraAttribute
+  class IdentityMap < Hash
+
+    # Get value if key exists otherwise set a value
+    # Block has a higher priority then value parameter
+    #
+    # @param [String, Symbol] key
+    # @param [Object] value
+    # @yield
+    # @return [Object]
+    def cache(key, value = nil)
+      fetch(key) do
+        self[key] = block_given? ? yield : value
+      end
+    end
+  end
+end

data/lib/hydra_attribute/middleware/identity_map.rb

@@ -0,0 +1,15 @@
+module HydraAttribute
+  module Middleware
+    class IdentityMap
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        HydraAttribute.identity_map.clear
+      end
+    end
+  end
+end

data/lib/hydra_attribute/migrator.rb

@@ -53,43 +53,42 @@ module HydraAttribute
           t.integer :hydra_set_id, null: true
           yield t if block_given?
         end
-        add_index name, :hydra_set_id, unique: false, name: "#{name}_hydra_set_id_index"
+        add_index name, :hydra_set_id, unique: false, name: "#{name}_hydra_set_id_idx"
       end
 
       def migrate_entity(name, options = {})
         change_table name, options do |t|
           t.integer :hydra_set_id, null: true
         end
-        add_index name, :hydra_set_id, uniqie: false, name: "#{name}_hydra_set_id_index"
+        add_index name, :hydra_set_id, unique: false, name: "#{name}_hydra_set_id_idx"
       end
 
       def create_attribute
         create_table :hydra_attributes do |t|
-          t.string   :entity_type,  limit: 32, null: false
-          t.string   :name,         limit: 32, null: false
-          t.string   :backend_type, limit: 16, null: false
-          t.string   :default_value
-          t.boolean  :white_list,              null: false, default: false
-          t.datetime :created_at # @COMPATIBILITY with 3.1.x use "datetime" method instead of "timestamps" because Rails 3.1.x and 3.2.x have a different "null" value
-          t.datetime :updated_at # @COMPATIBILITY with 3.1.x
+          t.string  :entity_type,  limit: 32, null: false
+          t.string  :name,         limit: 32, null: false
+          t.string  :backend_type, limit: 16, null: false
+          t.string  :default_value
+          t.boolean :white_list,              null: false, default: false
+          t.timestamps
         end
-        add_index :hydra_attributes, [:entity_type, :name], unique: true, name: 'hydra_attributes_index'
+        add_index :hydra_attributes, [:entity_type, :name], unique: true, name: 'hydra_attributes_idx'
       end
 
       def create_set
         create_table :hydra_sets do |t|
-          t.string   :entity_type,  limit: 32, null: false
-          t.string   :name,         limit: 32, null: false
-          t.datetime :created_at # @COMPATIBILITY with 3.1.x
-          t.datetime :updated_at # @COMPATIBILITY with 3.1.x
+          t.string :entity_type,  limit: 32, null: false
+          t.string :name,         limit: 32, null: false
+          t.timestamps
         end
-        add_index :hydra_sets, [:entity_type, :name], unique: true, name: 'hydra_sets_index'
+        add_index :hydra_sets, [:entity_type, :name], unique: true, name: 'hydra_sets_idx'
 
-        create_table :hydra_attribute_sets, id: false do |t|
+        create_table :hydra_attribute_sets do |t|
           t.integer :hydra_attribute_id, null: false
           t.integer :hydra_set_id,       null: false
+          t.timestamps
         end
-        add_index :hydra_attribute_sets, [:hydra_attribute_id, :hydra_set_id], unique: true, name: 'hydra_attribute_sets_index'
+        add_index :hydra_attribute_sets, [:hydra_attribute_id, :hydra_set_id], unique: true, name: 'hydra_attribute_sets_idx'
       end
 
       def create_values(name)
@@ -98,11 +97,15 @@ module HydraAttribute
           create_table table_name do |t|
             t.integer :entity_id,          null: false
             t.integer :hydra_attribute_id, null: false
-            t.send type, :value
-            t.datetime :created_at # @COMPATIBILITY with 3.1.x
-            t.datetime :updated_at # @COMPATIBILITY with 3.1.x
+            case type
+            when 'decimal'
+              t.send type, :value, precision: 10, scale: 4, null: true
+            else
+              t.send type, :value, null: true
+            end
+            t.timestamps
           end
-          add_index table_name, [:entity_id, :hydra_attribute_id], unique: true, name: "#{table_name}_index"
+          add_index table_name, [:entity_id, :hydra_attribute_id], unique: true, name: "#{table_name}_idx"
         end
       end
 

data/lib/hydra_attribute/model.rb

@@ -0,0 +1,47 @@
+require 'active_record/errors'
+require 'hydra_attribute/model/validations'
+require 'hydra_attribute/model/persistence'
+require 'hydra_attribute/model/mediator'
+require 'hydra_attribute/model/notifiable'
+require 'hydra_attribute/model/identity_map'
+require 'hydra_attribute/model/cacheable'
+require 'hydra_attribute/model/dirty'
+require 'hydra_attribute/model/has_many_through'
+
+module HydraAttribute
+  module Model
+    extend ActiveSupport::Concern
+
+    include Validations
+    include Persistence
+    include Mediator
+    include Notifiable
+    include IdentityMap
+    include Cacheable
+    include Dirty
+    include HasManyThrough
+
+    module ClassMethods
+      # Find first model
+      #
+      # @return [HydraAttribute::Model]
+      def first
+        all.first
+      end
+
+      # Find last model
+      #
+      # @return [HydraAttribute::Model]
+      def last
+        all.last
+      end
+
+      # Returns number of models
+      #
+      # @return [Fixnum]
+      def count
+        all.count
+      end
+    end
+  end
+end

data/lib/hydra_attribute/model/cacheable.rb

@@ -0,0 +1,207 @@
+module HydraAttribute
+  module Model
+    module Cacheable
+      extend ActiveSupport::Concern
+
+      included do
+        register_nested_cache :model
+      end
+
+      module ClassMethods
+        # Finds all records and store them into the cache
+        #
+        # @return [Array<HydraAttribute::Cacheable>]
+        def all
+          return identity_map[:all] if identity_map.has_key?(:all)
+
+          ids = nested_identity_map(:model).keys
+          ids.present? ? where_not(id: ids) : where
+
+          identity_map[:all] = []
+          nested_identity_map(:model).each do |_, model|
+            add_to_cache(model)
+          end
+          identity_map[:all]
+        end
+
+        # Find record by ID and store it into the cache
+        #
+        # @return [HydraAttribute::Cacheable]
+        def find(id)
+          model = get_from_nested_cache_or_load_all_models(:model, id.to_i)
+          raise RecordNotFound, "Couldn't find #{name} with id=#{id}" unless model
+          model
+        end
+
+        # Defines singleton method
+        #
+        # @example
+        #   ClassName.define_cached_singleton_method :method_name, cache_key: :method_key, cache_value: :method_value, cache_key_cast: :to_i
+        #   ClassName.method_method
+        #
+        # @param [Symbol] method_name
+        # @param [Hash] options
+        # @return [NilClass]
+        def define_cached_singleton_method(method_name, options = {})
+          register_nested_cache(method_name)
+
+          cache_key       = options[:cache_key]            ? ".#{options[:cache_key]}"      : ''
+          cache_value     = options[:cache_value] != :self ? ".#{options[:cache_value]}"    : ''
+          cache_key_was   = options[:cache_key]            ? "#{cache_key}_was"             : ''
+          cache_value_was = options[:cache_value] != :self ? "#{cache_value}_was"           : ''
+          type_cast_key   = options[:cache_key_cast]       ? ".#{options[:cache_key_cast]}" : ''
+
+          instance_eval <<-OES, __FILE__, __LINE__ + 1
+            def #{method_name}(param)
+              get_from_nested_cache_or_load_all_models(:#{method_name}, param#{type_cast_key}) || []
+            end
+
+            private
+              def add_to_#{method_name}_cache(model)
+                add_value_to_nested_cache(:#{method_name}, key: model#{cache_key}, value: model#{cache_value})
+              end
+
+              def update_#{method_name}_cache(model)
+                delete_value_from_nested_cache(:#{method_name}, key: model#{cache_key_was}, value: model#{cache_value_was})
+                add_to_#{method_name}_cache(model)
+              end
+
+              def delete_from_#{method_name}_cache(model)
+                delete_value_from_nested_cache(:#{method_name}, key: model#{cache_key}, value: model#{cache_value})
+              end
+          OES
+        end
+
+        # Gets data from cache or load all models and repeats the operation
+        #
+        # @param [Symbol] nested_cache_key
+        # @param [Object] identifier
+        # @return [Object]
+        def get_from_nested_cache_or_load_all_models(nested_cache_key, identifier)
+          return nested_identity_map(nested_cache_key)[identifier] if nested_identity_map(nested_cache_key).has_key?(identifier)
+          all # preload all models
+          nested_identity_map(nested_cache_key)[identifier]
+        end
+
+        # Add model to all cache objects
+        # This method should not be used outside the model
+        #
+        # @param [HydraAttribute::Model::Cacheable]
+        # @return [NilClass]
+        def add_to_cache(model)
+          notify_cache_callbacks('add_to', model)
+        end
+
+        # Update model in all registered caches
+        # This method should not be used outside the model
+        #
+        # @param [HydraAttribute::Model::Cacheable]
+        # @return [NilClass]
+        def update_cache(model)
+          notify_cache_callbacks('update', model)
+        end
+
+        # Delete model from all cache objects
+        # This method should not be used outside the model
+        #
+        # @param [HydraAttribute::Model::Cacheable]
+        # @return [NilClass]
+        def delete_from_cache(model)
+          notify_cache_callbacks('delete_from', model)
+        end
+
+        private
+          # helper method
+          def notify_cache_callbacks(method_prefix, model)
+            ([:all] + nested_cache_keys).each do |nested_cache_key|
+              method = "#{method_prefix}_#{nested_cache_key}_cache"
+              send(method, model) if respond_to?(method, true)
+            end
+          end
+
+          # helper method
+          def add_value_to_nested_cache(cache_key, options = {})
+            return unless identity_map.has_key?(:all)
+            nested_identity_map(cache_key)[options[:key]] ||= []
+            nested_identity_map(cache_key)[options[:key]] << options[:value]
+          end
+
+          # helper method
+          def delete_value_from_nested_cache(cache_key, options = {})
+            return unless nested_identity_map(cache_key)[options[:key]]
+            nested_identity_map(cache_key)[options[:key]].delete(options[:value])
+          end
+
+          # helper method
+          def add_value_to_nested_hash_cache(cache_key, options = {})
+            return unless identity_map.has_key?(:all)
+            nested_identity_map(cache_key)[options[:key]] ||= {}
+            nested_identity_map(cache_key)[options[:key]][options[:value]] = nil
+          end
+
+          # helper method
+          def delete_value_from_nested_hash_cache(cache_key, options = {})
+            return unless nested_identity_map(cache_key)[options[:key]]
+            nested_identity_map(cache_key)[options[:key]].delete(options[:value])
+          end
+
+          # cache callback
+          def add_to_all_cache(model)
+            return unless identity_map[:all]
+            identity_map[:all].push(model)
+          end
+
+          # cache callback
+          def delete_from_all_cache(model)
+            return unless identity_map[:all]
+            identity_map[:all].delete(model)
+          end
+
+          # cache callback
+          def add_to_model_cache(model)
+            nested_identity_map(:model)[model.id] = model
+          end
+
+          # cache callback
+          def delete_from_model_cache(model)
+            nested_identity_map(:model).delete(model.id)
+          end
+      end
+
+      # Initialize a model
+      # Save it into the cache if it is persisted
+      def initialize(attributes = {})
+        super(attributes)
+        self.class.add_to_cache(self) if persisted?
+      end
+
+      private
+        # Create new model and store it into the cache
+        #
+        # @return [Fixnum]
+        def create
+          id = super
+          self.class.add_to_cache(self)
+          id
+        end
+
+        # Update the model and its cache
+        #
+        # @return [TrueClass, FalseClass]
+        def update
+          result = super
+          self.class.update_cache(self)
+          result
+        end
+
+        # Delete model and remove it from the cache
+        #
+        # @return [TrueClass]
+        def delete
+          result = super
+          self.class.delete_from_cache(self)
+          result
+        end
+    end
+  end
+end