hydra_attribute 0.4.2 → 0.5.0.rc1

data/lib/hydra_attribute/active_record/mass_assignment_security.rb

@@ -0,0 +1,39 @@
+module HydraAttribute
+  module ActiveRecord
+    module MassAssignmentSecurity
+
+      class PermissionSet
+        def initialize(entity, authorizer)
+          @entity     = entity
+          @authorizer = authorizer
+        end
+
+        def deny?(attribute_name)
+          hydra_attribute = hydra_attribute_by_name(attribute_name)
+          hydra_attribute ? !hydra_attribute.white_list : @authorizer.deny?(attribute_name)
+        end
+
+        private
+          def respond_to_missing?(method, include_private)
+            @authorizer.respond_to?(method, include_private)
+          end
+
+          def method_missing(method, *args, &block)
+            @authorizer.send(method, *args, &block)
+          end
+
+          # TODO should be optimized. List of allowed attributes should be cached
+          def hydra_attribute_by_name(attribute_name)
+            ::HydraAttribute::HydraAttribute.all_by_entity_type(@entity.class.name).find do |attribute|
+              attribute.name == attribute_name
+            end
+          end
+      end
+
+      protected
+        def mass_assignment_authorizer(role)
+          PermissionSet.new(self, super(role))
+        end
+    end
+  end
+end

data/lib/hydra_attribute/active_record/migration.rb

@@ -2,19 +2,19 @@ module HydraAttribute
   module ActiveRecord
     module Migration
       def create_hydra_entity(name, options = {}, &block)
-        Migrator.create(self, name, options, &block)
+        ::HydraAttribute::Migrator.create(self, name, options, &block)
       end
 
       def drop_hydra_entity(name)
-        Migrator.drop(self, name)
+        ::HydraAttribute::Migrator.drop(self, name)
       end
 
       def migrate_to_hydra_entity(name, options = {}, &block)
-        Migrator.migrate(self, name, options, &block)
+        ::HydraAttribute::Migrator.migrate(self, name, options, &block)
       end
 
       def rollback_from_hydra_entity(name)
-        Migrator.rollback(self, name)
+        ::HydraAttribute::Migrator.rollback(self, name)
       end
     end
   end

data/lib/hydra_attribute/active_record/relation.rb

@@ -1,3 +1,7 @@
+require 'hydra_attribute/active_record/relation/calculations'
+require 'hydra_attribute/active_record/relation/query_methods'
+require 'hydra_attribute/active_record/association_preloader'
+
 module HydraAttribute
   module ActiveRecord
     module Relation
@@ -6,16 +10,11 @@ module HydraAttribute
       included do
         include Calculation
         include QueryMethods
-
-        # @COMPATIBILITY with 3.1.x active_record 3.1 doesn't have "exec_queries" method
-        target = ::ActiveRecord::VERSION::STRING.starts_with?('3.1.') ? :to_a : :exec_queries
-        alias_method :__old_exec_queries__, target
-        alias_method target, :__exec_queries__
       end
 
-      def __exec_queries__
+      def exec_queries
         return @records if loaded?
-        records = __old_exec_queries__
+        records = super
         return records if records.empty?
 
         AssociationPreloader.run(self, records)

data/lib/hydra_attribute/active_record/relation/query_methods.rb

@@ -23,7 +23,7 @@ module HydraAttribute
 
           if opts.is_a?(Hash)
             opts.inject(self) do |relation, (name, value)|
-              if klass.hydra_attribute_names.include?(name.to_s)
+              if ::HydraAttribute::HydraAttribute.names_by_entity_type(klass.model_name).include?(name.to_s)
                 relation, name = relation.clone, name.to_s
                 relation.hydra_attributes    << name
                 relation.hydra_joins_aliases << hydra_helper.ref_alias(name, value)
@@ -40,16 +40,12 @@ module HydraAttribute
         end
 
         def build_arel
+          # remove duplicate columns and add table prefix to all of them
           @group_values = hydra_helper.quote_columns(@group_values.uniq.reject(&:blank?))
           @order_values = hydra_helper.quote_columns(@order_values.uniq.reject(&:blank?))
 
-          # @COMPATIBILITY with 3.1.x active_record 3.1 uses the separate @reorder_value instance
-          if instance_variable_defined?(:@reorder_value) and instance_variable_get(:@reorder_value).present?
-            @reorder_value = hydra_helper.quote_columns(@reorder_value.uniq.reject(&:blank?))
-          end
-
           # detect hydra attributes from select list
-          @hydra_select_values, @select_values = @select_values.partition { |value| klass.hydra_attribute_names.include?(value.to_s) }
+          @hydra_select_values, @select_values = @select_values.partition { |value| ::HydraAttribute::HydraAttribute.names_by_entity_type(klass.model_name).include?(value.to_s) }
           @hydra_select_values.map!(&:to_s)
           @select_values.map!{ |value| hydra_helper.prepend_table_name(value) }
 
@@ -61,8 +57,16 @@ module HydraAttribute
             @select_values << hydra_helper.prepend_table_name('hydra_set_id')
           end
 
-          if hydra_attributes.any?
-            hydra_sets = klass.hydra_sets.select { |hydra_set| hydra_set.hydra_attributes.any? { |attr| attr.name.in?(hydra_attributes) } }
+          # Add filter by hydra sets which have all these attributes
+          if hydra_attributes.any? or @hydra_select_values.any?
+            hydra_attribute_ids = (hydra_attributes | hydra_select_values).map { |name| hydra_helper.hydra_attribute_id(name) }
+
+            hydra_sets = ::HydraAttribute::HydraSet.all_by_entity_type(klass.model_name).select do |hydra_set|
+              hydra_attribute_ids.all? do |hydra_attribute_id|
+                hydra_set.has_hydra_attribute_id?(hydra_attribute_id)
+              end
+            end
+
             @where_values << table[:hydra_set_id].in(hydra_sets.map(&:id)).or(table[:hydra_set_id].eq(nil))
           end
 
@@ -125,13 +129,9 @@ module HydraAttribute
             {ref_alias(name, value) => {value: value}}
           end
 
-          def ref_class(name)
-            type = klass.hydra_attribute(name).backend_type
-            AssociationBuilder.class_name(klass, type).constantize
-          end
-
           def ref_table(name)
-            ref_class(name).table_name
+            hydra_attribute = hydra_attribute_by_name(name)
+            "hydra_#{hydra_attribute.backend_type}_#{klass.table_name}"
           end
 
           def ref_alias(name, value)
@@ -139,17 +139,27 @@ module HydraAttribute
           end
 
           def join_type(value)
-            value.nil? ? 'LEFT' : 'INNER'
+            if value.nil? or (value.is_a?(Array) and value.include?(nil))
+              'LEFT'
+            else
+              'INNER'
+            end
           end
 
           def hydra_attribute_id(name)
-            klass.hydra_attribute(name).id
+            hydra_attribute_by_name(name).id
+          end
+
+          def hydra_attribute_by_name(name)
+            ::HydraAttribute::HydraAttribute.all_by_entity_type(klass.model_name).find do |hydra_attribute|
+              hydra_attribute.name == name.to_s
+            end
           end
 
           def quote_columns(columns)
             columns.map do |column|
               column = column.respond_to?(:to_sql) ? column.to_sql : column.to_s
-              if klass.hydra_attribute_names.include?(column)
+              if ::HydraAttribute::HydraAttribute.names_by_entity_type(klass.model_name).include?(column)
                 join_alias = ref_alias(column, 'inner') # alias for inner join
                 join_alias = ref_alias(column, nil) unless relation.hydra_joins_aliases.include?(join_alias) # alias for left join
 

data/lib/hydra_attribute/hydra_attribute.rb

@@ -1,58 +1,21 @@
-require 'active_support/core_ext/object/with_options'
-
 module HydraAttribute
-  class HydraAttribute < ActiveRecord::Base
-    self.table_name = 'hydra_attributes'
-
-    with_options as: [:default, :admin] do |klass|
-      klass.attr_accessible :name, :backend_type, :default_value
-    end
-    attr_accessible :white_list, as: :admin
-
-    has_and_belongs_to_many :hydra_sets, join_table: 'hydra_attribute_sets', class_name: 'HydraAttribute::HydraSet', conditions: proc { {hydra_sets: {entity_type: entity_type}} }
-
-    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 }
-      klass.validates :backend_type, inclusion: SUPPORTED_BACKEND_TYPES
-    end
-
-    before_destroy :delete_dependent_values
-    after_commit   :clear_entity_cache
-    after_commit   :update_mass_assignment_security
-
-    # @COMPATIBILITY with 3.1.x association module is directly added to the class instead of including module
-    def hydra_sets_with_clearing_cache=(value)
-      self.hydra_sets_without_clearing_cache = value
-      entity_type.constantize.clear_hydra_method_cache!
-      value
-    end
-    alias_method_chain :hydra_sets=, :clearing_cache
+  class HydraAttribute
 
-    def update_mass_assignment_security
-      if destroyed? or !white_list?
-        remove_from_white_list
-      else
-        add_to_white_list
-      end
+    # This error is raised when created +HydraAttribute::HydraAttribute+ models don't have this ID
+    class UnknownHydraAttributeIdError < ArgumentError
     end
 
-    private
-      def delete_dependent_values
-        value_class = AssociationBuilder.class_name(entity_type.constantize, backend_type).constantize
-        value_class.delete_all(hydra_attribute_id: id)
-      end
+    include ::HydraAttribute::Model
 
-      def clear_entity_cache
-        entity_type.constantize.reset_hydra_attribute_methods!
-      end
+    validates :entity_type,  presence: true
+    validates :name,         presence: true, unique: { scope: :entity_type }
+    validates :backend_type, presence: true, inclusion: { in: ::HydraAttribute::SUPPORTED_BACKEND_TYPES }
 
-      def add_to_white_list
-        entity_type.constantize.accessible_attributes.add(name)
-      end
+    define_cached_singleton_method :all_by_entity_type,           cache_key: :entity_type, cache_value: :self,         cache_key_cast: :to_s
+    define_cached_singleton_method :ids_by_entity_type,           cache_key: :entity_type, cache_value: :id,           cache_key_cast: :to_s
+    define_cached_singleton_method :names_by_entity_type,         cache_key: :entity_type, cache_value: :name,         cache_key_cast: :to_s
+    define_cached_singleton_method :backend_types_by_entity_type, cache_key: :entity_type, cache_value: :backend_type, cache_key_cast: :to_s
 
-      def remove_from_white_list
-        entity_type.constantize.accessible_attributes.delete(name)
-      end
+    has_many :hydra_sets, through: :hydra_attribute_set, copy_attribute: :entity_type
   end
 end

data/lib/hydra_attribute/hydra_attribute_set.rb

@@ -0,0 +1,67 @@
+module HydraAttribute
+  class HydraAttributeSet
+    include ::HydraAttribute::Model
+
+    define_cached_singleton_method :all_by_hydra_attribute_id,           cache_key: :hydra_attribute_id, cache_value: :self,               cache_key_cast: :to_i
+    define_cached_singleton_method :all_by_hydra_set_id,                 cache_key: :hydra_set_id,       cache_value: :self,               cache_key_cast: :to_i
+    define_cached_singleton_method :hydra_attributes_by_hydra_set_id,    cache_key: :hydra_set_id,       cache_value: :hydra_attribute,    cache_key_cast: :to_i
+    define_cached_singleton_method :hydra_sets_by_hydra_attribute_id,    cache_key: :hydra_attribute_id, cache_value: :hydra_set,          cache_key_cast: :to_i
+    define_cached_singleton_method :hydra_attribute_ids_by_hydra_set_id, cache_key: :hydra_set_id,       cache_value: :hydra_attribute_id, cache_key_cast: :to_i
+    define_cached_singleton_method :hydra_set_ids_by_hydra_attribute_id, cache_key: :hydra_attribute_id, cache_value: :hydra_set_id,       cache_key_cast: :to_i
+
+    register_nested_cache :hydra_attribute_ids_by_hydra_set_id_as_hash
+
+    observe 'HydraAttribute::HydraAttribute', after_destroy: :hydra_attribute_destroyed
+    observe 'HydraAttribute::HydraSet',       after_destroy: :hydra_set_destroyed
+
+    validates :hydra_set_id,       presence: true
+    validates :hydra_attribute_id, presence: true, unique: { scope: :hydra_set_id }
+
+    class << self
+      def has_hydra_attribute_id_in_hydra_set_id?(hydra_attribute_id, hydra_set_id)
+        hydra_attribute_ids = get_from_nested_cache_or_load_all_models(:hydra_attribute_ids_by_hydra_set_id_as_hash, hydra_set_id.to_i)
+        hydra_attribute_ids and hydra_attribute_ids.has_key?(hydra_attribute_id.to_i)
+      end
+
+      # Remove hydra attribute from the cache
+      def hydra_attribute_destroyed(hydra_attribute) #:nodoc:
+        all_by_hydra_attribute_id(hydra_attribute.id).each(&:destroy)
+      end
+
+      # Remove hydra set from the cache
+      def hydra_set_destroyed(hydra_set) #:nodoc:
+        all_by_hydra_set_id(hydra_set.id).each(&:destroy)
+      end
+
+      private
+        def add_to_hydra_attribute_ids_by_hydra_set_id_as_hash_cache(hydra_attribute_set)
+          add_value_to_nested_hash_cache(:hydra_attribute_ids_by_hydra_set_id_as_hash, key: hydra_attribute_set.hydra_set_id, value: hydra_attribute_set.hydra_attribute_id)
+        end
+
+        def update_hydra_attribute_ids_by_hydra_set_id_as_hash_cache(hydra_attribute_set)
+          delete_value_from_nested_hash_cache(:hydra_attribute_ids_by_hydra_set_id_as_hash, key: hydra_attribute_set.hydra_set_id_was, value: hydra_attribute_set.hydra_attribute_id_was)
+          add_to_hydra_attribute_ids_by_hydra_set_id_as_hash_cache(hydra_attribute_set)
+        end
+
+        def delete_from_hydra_attribute_ids_by_hydra_set_id_as_hash_cache(hydra_attribute_set)
+          delete_value_from_nested_hash_cache(:hydra_attribute_ids_by_hydra_set_id_as_hash, key: hydra_attribute_set.hydra_set_id, value: hydra_attribute_set.hydra_attribute_id)
+        end
+    end
+
+    # Returns hydra attribute for this relation
+    #
+    # @return [HydraAttribute::HydraAttribute, NilClass]
+    def hydra_attribute
+      ::HydraAttribute::HydraAttribute.find(hydra_attribute_id) if hydra_attribute_id
+    end
+    alias_method :hydra_attribute_was, :hydra_attribute # used for cache sweepers
+
+    # Returns hydra set for this relation
+    #
+    # @return [HydraAttribute::HydraSet, NilClass]
+    def hydra_set
+      ::HydraAttribute::HydraSet.find(hydra_set_id) if hydra_set_id
+    end
+    alias_method :hydra_set_was, :hydra_set # used for cache sweepers
+  end
+end

data/lib/hydra_attribute/hydra_entity.rb

@@ -0,0 +1,110 @@
+module HydraAttribute
+  module HydraEntity
+    class RelationDecorator
+      def initialize(entity_type, model_class)
+        @entity_type = entity_type
+        @model_class = model_class
+      end
+
+      def create(attributes = {})
+        @model_class.create(attributes.merge(entity_type: @entity_type))
+      end
+
+      def build(attributes = {})
+        @model_class.new(attributes.merge(entity_type: @entity_type))
+      end
+
+      private
+        def respond_to_missing?(symbol, include_private)
+          _models.respond_to?(symbol, include_private)
+        end
+
+        def method_missing(method, *args, &block)
+          _models.send(method, *args, &block)
+        end
+
+        def _models
+          @model_class.all_by_entity_type(@entity_type)
+        end
+    end
+
+    extend ActiveSupport::Concern
+
+    included do
+      after_save    :save_hydra_attributes
+      after_destroy :destroy_hydra_attributes
+    end
+
+    module ClassMethods
+      # Returns collection of hydra attributes for current entity
+      #
+      # @return [HydraAttribute::HydraEntity::RelationDecorator]
+      def hydra_attributes
+        @hydra_attributes ||= RelationDecorator.new(model_name, ::HydraAttribute::HydraAttribute)
+      end
+
+      # Returns collection of hydra sets for current entity
+      #
+      # @return [HydraAttribute::HydraEntity::RelationDecorator]
+      def hydra_sets
+        @hydra_sets ||= RelationDecorator.new(model_name, ::HydraAttribute::HydraSet)
+      end
+    end
+
+    # Returns association between hydra attributes and their values
+    #
+    # @return [HydraAttribute::HydraEntityAttributeAssociation]
+    def hydra_attribute_association
+      @hydra_attribute_association ||= HydraEntityAttributeAssociation.new(self)
+    end
+
+    # Sets association object which connects hydra attributes with their values
+    #
+    # @param [HydraAttribute::HydraEntityAttributeAssociation]
+    def hydra_attribute_association=(association)
+      @hydra_attribute_association = association
+    end
+
+    # Return +HydraSet+ object if it exists
+    #
+    # @return [HydraAttribute::HydraSet]
+    def hydra_set
+      HydraSet.find(hydra_set_id) if hydra_set_id
+    end
+
+    # Returns hydra attribute names with theirs values
+    #
+    # @return [Hash]
+    def hydra_attributes
+      hydra_attribute_association.hydra_attributes
+    end
+
+    # Returns hydra attribute names with theirs values before type casting
+    #
+    # @return [Hash]
+    def hydra_attributes_before_type_cast
+      hydra_attribute_association.hydra_attributes_before_type_cast
+    end
+
+    def respond_to?(method, include_private = false)
+      hydra_attribute_association.has_proxy_method?(method) || super
+    end
+
+    private
+      def save_hydra_attributes
+        hydra_attribute_association.save
+      end
+
+      def destroy_hydra_attributes
+        hydra_attribute_association.destroy
+      end
+
+      def method_missing(method, *args, &block)
+        hydra_attribute_association.delegate(method, *args, &block)
+      rescue HydraSet::MissingAttributeInHydraSetError, HydraEntityAttributeAssociation::AttributeWasNotSelectedError
+        raise
+      rescue
+        super
+      end
+  end
+end

data/lib/hydra_attribute/hydra_entity_attribute_association.rb

@@ -0,0 +1,155 @@
+module HydraAttribute
+  class HydraEntityAttributeAssociation
+    class WrongProxyMethodError < ArgumentError
+      def initialize(method)
+        super("Unknown :#{method} method")
+      end
+    end
+
+    class AttributeWasNotSelectedError < ArgumentError
+      def initialize(attribute_id)
+        super("Attribute ID #{attribute_id} was not selected from DB")
+      end
+    end
+
+    include ::HydraAttribute::Model::Mediator
+    include ::HydraAttribute::Model::IdentityMap
+
+    observe 'HydraAttribute::HydraAttribute', after_create: :hydra_attribute_created, after_update: :hydra_attribute_updated, after_destroy: :hydra_attribute_destroyed
+
+    attr_reader :entity
+
+    class << self
+      # Generate hydra attribute methods
+      def generate_methods
+        ::HydraAttribute::HydraAttribute.all.each do |hydra_attribute|
+          add_to_cache(hydra_attribute.entity_type, hydra_attribute.name, hydra_attribute.id)
+        end
+        identity_map[:___methods_generated___] = true
+      end
+
+      # Checks if methods were generated
+      def methods_generated?
+        identity_map[:___methods_generated___] ||= false
+      end
+
+      # Callback
+      def hydra_attribute_created(hydra_attribute) # :nodoc:
+        return unless methods_generated?
+        add_to_cache(hydra_attribute.entity_type, hydra_attribute.name, hydra_attribute.id)
+      end
+
+      # Callback
+      def hydra_attribute_updated(hydra_attribute) # :nodoc:
+        delete_from_cache(hydra_attribute.entity_type_was, hydra_attribute.name_was)
+        add_to_cache(hydra_attribute.entity_type, hydra_attribute.name, hydra_attribute.id)
+      end
+
+      # Callback
+      def hydra_attribute_destroyed(hydra_attribute) # :nodoc:
+        delete_from_cache(hydra_attribute.entity_type, hydra_attribute.name)
+      end
+
+      private
+        def add_to_cache(entity_type, name, id)
+          identity_map[entity_type] ||= {names: {}, names_as_hash: {}, ids_as_hash: {}}
+          ::ActiveRecord::Base.attribute_method_matchers.each do |matcher|
+            current = matcher.method_name(name).to_sym
+            proxy   = matcher.method_name(:value)
+
+            identity_map[entity_type][:names][name] ||= []
+            identity_map[entity_type][:names][name] << current
+            identity_map[entity_type][:names_as_hash][current] = proxy
+            identity_map[entity_type][:ids_as_hash][current]   = id
+          end
+        end
+
+        def delete_from_cache(entity_type, name)
+          current_methods = identity_map[entity_type] && identity_map[entity_type][:names][name]
+          return unless current_methods
+          current_methods.each do |current_method|
+            identity_map[entity_type][:names_as_hash].delete(current_method)
+            identity_map[entity_type][:ids_as_hash].delete(current_method)
+          end
+          identity_map[entity_type][:names].delete(name)
+        end
+    end
+
+    def initialize(entity)
+      @entity = entity
+    end
+
+    def save
+      touch = false
+      accessible_hydra_values do |hydra_value|
+        touch = true if hydra_value.save
+      end
+      entity.touch if touch
+    end
+
+    def destroy
+      HydraValue.delete_entity_values(entity)
+    end
+
+    def hydra_values
+      @hydra_values ||= ::HydraAttribute::HydraAttribute.ids_by_entity_type(entity.class.model_name).inject({}) do |hydra_values, hydra_attribute_id|
+        hydra_values[hydra_attribute_id] = HydraValue.new(entity, hydra_attribute_id: hydra_attribute_id)
+        hydra_values
+      end
+    end
+
+    def hydra_attributes
+      to_enum(:accessible_hydra_values).each_with_object({}) do |hydra_value, hydra_attributes|
+        hydra_attributes[hydra_value.hydra_attribute.name] = hydra_value.value
+      end
+    end
+
+    def hydra_attributes_before_type_cast
+      to_enum(:accessible_hydra_values).each_with_object({}) do |hydra_value, hydra_attributes|
+        hydra_attributes[hydra_value.hydra_attribute.name] = hydra_value.value_before_type_cast
+      end
+    end
+
+    def lock_values
+      @hydra_values ||= {}
+    end
+
+    def hydra_value_options=(options = {})
+      hydra_values[options[:hydra_attribute_id]] = HydraValue.new(entity, options)
+    end
+
+    def has_proxy_method?(method)
+      self.class.generate_methods unless self.class.methods_generated?
+      identity_map = self.class.identity_map[entity.class.model_name]
+      return false unless identity_map
+      !!identity_map[:names_as_hash][method.to_sym]
+    end
+
+    def delegate(method, *args, &block)
+      self.class.generate_methods unless self.class.methods_generated?
+      identity_map     = self.class.identity_map[entity.class.model_name] or raise WrongProxyMethodError, method
+      attribute_id     = identity_map[:ids_as_hash][method]               or raise WrongProxyMethodError, method
+      attribute_method = identity_map[:names_as_hash][method]             or raise WrongProxyMethodError, method
+
+      if has_attribute_id?(attribute_id)
+        hydra_value = hydra_values[attribute_id] or raise AttributeWasNotSelectedError, attribute_id
+        hydra_value.send(attribute_method, *args, &block)
+      else
+        raise HydraSet::MissingAttributeInHydraSetError, "Attribute ID #{attribute_id} is missed in Set ID #{entity.hydra_set.id}"
+      end
+    end
+
+    private
+      def has_attribute_id?(hydra_attribute_id)
+        !entity.hydra_set || entity.hydra_set.has_hydra_attribute_id?(hydra_attribute_id)
+      end
+
+      def accessible_hydra_values
+        hydra_values.each do |hydra_attribute_id, hydra_value|
+          if has_attribute_id?(hydra_attribute_id)
+            yield hydra_value
+          end
+        end
+      end
+  end
+end