hydra_attribute 0.3.2 → 0.4.0.rc1

data/lib/hydra_attribute/hydra_attribute_methods.rb

@@ -0,0 +1,85 @@
+module HydraAttribute
+  module HydraAttributeMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      extend Memoize
+
+      def hydra_attributes
+        HydraAttribute.where(entity_type: base_class.model_name)
+      end
+      hydra_memoize :hydra_attributes
+
+      def hydra_attribute(identifier)
+        hydra_attributes.find do |hydra_attribute|
+          hydra_attribute.id == identifier || hydra_attribute.name == identifier
+        end
+      end
+      hydra_memoize :hydra_attribute
+
+      def hydra_attribute_backend_types
+        hydra_attributes.map(&:backend_type).uniq
+      end
+      hydra_memoize :hydra_attribute_backend_types
+
+      %w(id name).each do |prefix|
+        module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def hydra_attribute_#{prefix}s
+            hydra_attributes.map(&:#{prefix})
+          end
+          hydra_memoize :hydra_attribute_#{prefix}s
+        EOS
+      end
+
+      def hydra_attributes_by_backend_type
+        hydra_attributes.group_by(&:backend_type)
+      end
+      hydra_memoize :hydra_attributes_by_backend_type
+
+      %w(id name).each do |prefix|
+        module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def hydra_attribute_#{prefix}s_by_backend_type
+            hydra_attributes.each_with_object({}) do |hydra_attribute, object|
+              object[hydra_attribute.backend_type] ||= []
+              object[hydra_attribute.backend_type] << hydra_attribute.#{prefix}
+            end
+          end
+          hydra_memoize :hydra_attribute_#{prefix}s_by_backend_type
+        EOS
+      end
+
+      def hydra_attributes_for_backend_type(backend_type)
+        hydra_attributes = hydra_attributes_by_backend_type[backend_type]
+        hydra_attributes.nil? ? [] : hydra_attributes
+      end
+
+      %w(id name).each do |prefix|
+        module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def hydra_attribute_#{prefix}s_for_backend_type(backend_type)
+            values = hydra_attribute_#{prefix}s_by_backend_type[backend_type]
+            values.nil? ? [] : values
+          end
+        EOS
+      end
+
+      def clear_hydra_attribute_cache!
+        [
+          :@hydra_attributes,
+          :@hydra_attribute,
+          :@hydra_attribute_ids,
+          :@hydra_attribute_names,
+          :@hydra_attribute_backend_types,
+          :@hydra_attributes_by_backend_type,
+          :@hydra_attribute_ids_by_backend_type,
+          :@hydra_attribute_names_by_backend_type,
+        ].each do |variable|
+          remove_instance_variable(variable) if instance_variable_defined?(variable)
+        end
+      end
+    end
+
+    def hydra_attribute?(name)
+      self.class.hydra_attribute_names.include?(name.to_s)
+    end
+  end
+end

data/lib/hydra_attribute/hydra_methods.rb

@@ -0,0 +1,123 @@
+module HydraAttribute
+  module HydraMethods
+    extend ActiveSupport::Concern
+    extend Memoize
+
+    include HydraSetMethods
+    include HydraAttributeMethods
+    include HydraValueMethods
+
+    included do
+      alias_method_chain :write_attribute, :hydra_set_id
+    end
+
+    module ClassMethods
+      extend Memoize
+
+      def hydra_set_attributes(hydra_set_id)
+        hydra_set = hydra_set(hydra_set_id)
+        hydra_set.nil? ? hydra_attributes : hydra_set.hydra_attributes
+      end
+
+      %w(id name backend_type).each do |prefix|
+        module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def hydra_set_attribute_#{prefix}s(hydra_set_id)
+            hydra_set_attributes(hydra_set_id).map(&:#{prefix})
+          end
+          hydra_memoize :hydra_set_attribute_#{prefix}s
+        EOS
+      end
+
+      def hydra_set_attributes_by_backend_type(hydra_set_id)
+        hydra_set_attributes(hydra_set_id).group_by(&:backend_type)
+      end
+      hydra_memoize :hydra_set_attributes_by_backend_type
+
+      %w(id name).each do |prefix|
+        module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def hydra_set_attribute_#{prefix}s_by_backend_type(hydra_set_id)
+            hydra_set_attributes(hydra_set_id).each_with_object({}) do |hydra_attribute, object|
+              object[hydra_attribute.backend_type] ||= []
+              object[hydra_attribute.backend_type] << hydra_attribute.#{prefix}
+            end
+          end
+          hydra_memoize :hydra_set_attribute_#{prefix}s_by_backend_type
+        EOS
+      end
+
+      def hydra_set_attributes_for_backend_type(hydra_set_id, backend_type)
+        hydra_attributes = hydra_set_attributes_by_backend_type(hydra_set_id)[backend_type]
+        hydra_attributes.nil? ? [] : hydra_attributes
+      end
+
+      %w(id name).each do |prefix|
+        module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def hydra_set_attribute_#{prefix}s_for_backend_type(hydra_set_id, backend_type)
+            values = hydra_set_attribute_#{prefix}s_by_backend_type(hydra_set_id)[backend_type]
+            values.nil? ? [] : values
+          end
+        EOS
+      end
+
+      def clear_hydra_method_cache!
+        clear_hydra_set_cache!
+        clear_hydra_attribute_cache!
+        clear_hydra_value_cache!
+
+        [
+          :@hydra_set_attributes,
+          :@hydra_set_attribute_ids,
+          :@hydra_set_attribute_names,
+          :@hydra_set_attribute_backend_types,
+          :@hydra_set_attributes_by_backend_type,
+          :@hydra_set_attribute_ids_by_backend_type,
+          :@hydra_set_attribute_names_by_backend_type
+        ].each do |variable|
+          remove_instance_variable(variable) if instance_variable_defined?(variable)
+        end
+      end
+    end
+
+    def hydra_attributes
+      hydra_value_models.inject({}) do |hydra_attributes, model|
+        hydra_attributes[model.hydra_attribute_name] = model.value
+        hydra_attributes
+      end
+    end
+
+    %w(ids names backend_types).each do |prefix|
+      module_eval <<-EOS, __FILE__, __LINE__ + 1
+        def hydra_attribute_#{prefix}
+          self.class.hydra_set_attribute_#{prefix}(hydra_set_id)
+        end
+      EOS
+    end
+
+    def hydra_value_model(identifier)
+      hydra_attribute = self.class.hydra_attribute(identifier)
+      if hydra_attribute
+        association = hydra_value_association(hydra_attribute.backend_type)
+        association.find_model_or_build(hydra_attribute_id: hydra_attribute.id)
+      end
+    end
+    hydra_memoize :hydra_value_model
+
+    def hydra_value_models
+      self.class.hydra_set_attribute_backend_types(hydra_set_id).inject([]) do |models, backend_type|
+        models + hydra_value_association(backend_type).all_models
+      end
+    end
+    hydra_memoize :hydra_value_models
+
+    private
+      def write_attribute_with_hydra_set_id(attr_name, value)
+        if attr_name.to_s == 'hydra_set_id'
+          self.class.hydra_attribute_backend_types.each do |backend_type|
+            hydra_value_association(backend_type).clear_cache!
+          end
+          remove_instance_variable(:@hydra_value_models) if instance_variable_defined?(:@hydra_value_models)
+        end
+        write_attribute_without_hydra_set_id(attr_name, value)
+      end
+  end
+end

data/lib/hydra_attribute/hydra_set.rb

@@ -0,0 +1,36 @@
+require 'active_support/core_ext/object/with_options'
+
+module HydraAttribute
+  class HydraSet < ActiveRecord::Base
+    self.table_name = 'hydra_sets'
+
+    attr_accessible :name
+
+    has_and_belongs_to_many :hydra_attributes, join_table: 'hydra_attribute_sets', class_name: 'HydraAttribute::HydraAttribute', conditions: proc { {hydra_attributes: {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 }
+    end
+
+    after_destroy :detach_entities
+    after_commit  :clear_entity_cache
+
+    # @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
+    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_set_methods.rb

@@ -0,0 +1,39 @@
+module HydraAttribute
+  class MissingAttributeInHydraSetError < NoMethodError
+  end
+
+  module HydraSetMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      extend Memoize
+
+      def hydra_sets
+        HydraSet.where(entity_type: base_class.model_name)
+      end
+      hydra_memoize :hydra_sets
+
+      def hydra_set(identifier)
+        hydra_sets.find do |hydra_set|
+          hydra_set.id == identifier || hydra_set.name == identifier
+        end
+      end
+      hydra_memoize :hydra_set
+
+      %w(id name).each do |prefix|
+        module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def hydra_set_#{prefix}s
+            hydra_sets.map(&:#{prefix})
+          end
+          hydra_memoize :hydra_set_#{prefix}s
+        EOS
+      end
+
+      def clear_hydra_set_cache!
+        [:@hydra_sets, :@hydra_set, :@hydra_set_ids, :@hydra_set_names].each do |variable|
+          remove_instance_variable(variable) if instance_variable_defined?(variable)
+        end
+      end
+    end
+  end
+end

data/lib/hydra_attribute/hydra_value_methods.rb

@@ -0,0 +1,14 @@
+module HydraAttribute
+  module HydraValueMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def clear_hydra_value_cache!
+      end
+    end
+
+    def hydra_value_association(backend_type)
+      association(::HydraAttribute::AssociationBuilder.association_name(backend_type))
+    end
+  end
+end

data/lib/hydra_attribute/memoize.rb

@@ -0,0 +1,37 @@
+module HydraAttribute
+  module Memoize
+    def hydra_memoize(*methods)
+      methods.each do |method_name|
+        bound_method = instance_method(method_name)
+        alias_method "unmemoized_#{method_name}", method_name
+
+        if bound_method.arity.abs == 0
+          module_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{method_name}
+              @#{method_name} = unmemoized_#{method_name} unless instance_variable_defined?(:@#{method_name})
+              @#{method_name}
+            end
+          EOS
+        else
+          args = 1.upto(bound_method.arity.abs).map { |i| "a#{i}" }
+          keys = 1.upto(bound_method.arity.abs).map { |i| "k#{i}" }
+
+          call = args.inject("@#{method_name}") do |hash_call, arg|
+            "#{hash_call}[#{arg}]"
+          end
+
+          hash = keys.reverse.inject("unmemoized_#{method_name}(#{keys.join(', ')})") do |code, key|
+            "Hash.new { |hash, #{key}| hash[#{key}] = #{code} }"
+          end
+
+          module_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{method_name}(#{args.join(', ')})      # def method(a1)
+              @#{method_name} ||= #{hash}               #   @method ||= Hash.new { |hash, key1| hash[key1] = unmemoized_method(key1) }
+              #{call}                                   #   @method[a1]
+            end                                         # end
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/hydra_attribute/migrator.rb

@@ -6,7 +6,7 @@ module HydraAttribute
     end
 
     class << self
-      %w(create remove migrate rollback).each do |method|
+      %w(create drop migrate rollback).each do |method|
         class_eval <<-EOS, __FILE__, __LINE__ + 1
           def #{method}(migration, *args, &block)
             new(migration).#{method}(*args, &block)
@@ -18,90 +18,139 @@ module HydraAttribute
     def create(name, options = {}, &block)
       create_entity(name, options, &block)
       create_attribute unless attribute_exists?
+      create_set       unless set_exists?
       create_values(name)
     end
 
     def drop(name)
       drop_values(name)
-      drop_attributes unless values_exists?
+      unless values_exists?
+        drop_set
+        drop_attribute
+      end
       drop_entity(name)
     end
 
-    def migrate(name)
+    def migrate(name, options = {}, &block)
+      migrate_entity(name, options, &block)
       create_attribute unless attribute_exists?
+      create_set       unless set_exists?
       create_values(name)
     end
 
     def rollback(name)
       drop_values(name)
-      drop_attribute unless values_exists?
+      unless values_exists?
+        drop_attribute
+        drop_set
+      end
+      rollback_entity(name)
     end
 
     private
+      def create_entity(name, options = {})
+        create_table name, options do |t|
+          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"
+      end
 
-    def create_entity(name, options = {})
-      create_table name, options do |t|
-        yield t if block_given?
+      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"
       end
-    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.timestamps
+      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
+        end
+        add_index :hydra_attributes, [:entity_type, :name], unique: true, name: 'hydra_attributes_index'
       end
-      add_index :hydra_attributes, [:entity_type, :name], unique: true, name: 'hydra_attributes_index'
-    end
 
-    def create_values(name)
-      SUPPORT_TYPES.each do |type|
-        table_name = value_table(name, type)
-        create_table table_name do |t|
-          t.integer :entity_id,          null: false
+      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
+        end
+        add_index :hydra_sets, [:entity_type, :name], unique: true, name: 'hydra_sets_index'
+
+        create_table :hydra_attribute_sets, id: false do |t|
           t.integer :hydra_attribute_id, null: false
-          t.send type, :value
-          t.timestamps
+          t.integer :hydra_set_id,       null: false
         end
-        add_index table_name, [:entity_id, :hydra_attribute_id], unique: true, name: "#{table_name}_index"
+        add_index :hydra_attribute_sets, [:hydra_attribute_id, :hydra_set_id], unique: true, name: 'hydra_attribute_sets_index'
       end
-    end
 
-    def drop_entity(name)
-      drop_table(name)
-    end
+      def create_values(name)
+        SUPPORTED_BACKEND_TYPES.each do |type|
+          table_name = value_table(name, type)
+          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
+          end
+          add_index table_name, [:entity_id, :hydra_attribute_id], unique: true, name: "#{table_name}_index"
+        end
+      end
 
-    def drop_attribute
-      drop_table(:hydra_attributes)
-    end
+      def drop_entity(name)
+        drop_table(name)
+      end
 
-    def drop_values(name)
-      SUPPORT_TYPES.each do |type|
-        drop_table(value_table(name, type))
+      def rollback_entity(name)
+        remove_column name, :hydra_set_id
       end
-    end
 
-    def value_table(name, type)
-      "hydra_#{type}_#{name}"
-    end
+      def drop_attribute
+        drop_table(:hydra_attributes)
+      end
 
-    def attribute_exists?
-      table_exists?(:hydra_attributes)
-    end
+      def drop_set
+        drop_table(:hydra_attribute_sets)
+        drop_table(:hydra_sets)
+      end
 
-    def values_exists?
-      tables.any? do |table|
-        SUPPORT_TYPES.any? do |type|
-          table.start_with?("hydra_#{type}_")
+      def drop_values(name)
+        SUPPORTED_BACKEND_TYPES.each do |type|
+          drop_table(value_table(name, type))
         end
       end
-    end
 
-    def method_missing(symbol, *args, &block)
-      @migration.send(symbol, *args, &block)
-    end
+      def value_table(name, type)
+        "hydra_#{type}_#{name}"
+      end
+
+      def attribute_exists?
+        table_exists?(:hydra_attributes)
+      end
+
+      def set_exists?
+        table_exists?(:hydra_sets)
+      end
+
+      def values_exists?
+        tables.any? do |table|
+          SUPPORTED_BACKEND_TYPES.any? do |type|
+            table.start_with?("hydra_#{type}_")
+          end
+        end
+      end
+
+      def method_missing(symbol, *args, &block)
+        @migration.send(symbol, *args, &block)
+      end
   end
 end

data/lib/hydra_attribute/railtie.rb

@@ -2,9 +2,7 @@ module HydraAttribute
   class Railtie < Rails::Railtie
     initializer 'hydra_attribute.active_record' do
       ActiveSupport.on_load :active_record do
-        extend ::HydraAttribute::ActiveRecord
-
-        ::ActiveRecord::Migration.send :include, ::HydraAttribute::ActiveRecord::Migration
+        ::ActiveRecord::Migration.send(:include, ::HydraAttribute::ActiveRecord::Migration)
       end
     end
   end

data/lib/hydra_attribute/version.rb

@@ -1,3 +1,3 @@
 module HydraAttribute
-  VERSION = '0.3.2'
+  VERSION = '0.4.0.rc1'
 end

data/lib/hydra_attribute.rb

@@ -1,5 +1,5 @@
 module HydraAttribute
-  SUPPORT_TYPES = %w(string text integer float boolean datetime).freeze
+  SUPPORTED_BACKEND_TYPES = %w(string text integer float boolean datetime).freeze
 
   class << self
     def config
@@ -18,8 +18,14 @@ require 'hydra_attribute/configuration'
 require 'hydra_attribute/association_builder'
 require 'hydra_attribute/builder'
 require 'hydra_attribute/migrator'
+require 'hydra_attribute/memoize'
 require 'hydra_attribute/hydra_attribute'
+require 'hydra_attribute/hydra_set'
 require 'hydra_attribute/entity_callbacks'
+require 'hydra_attribute/hydra_set_methods'
+require 'hydra_attribute/hydra_value_methods'
+require 'hydra_attribute/hydra_attribute_methods'
+require 'hydra_attribute/hydra_methods'
 require 'hydra_attribute/active_record'
 require 'hydra_attribute/active_record/scoping'
 require 'hydra_attribute/active_record/reflection'