hydra_attribute 0.4.2 → 0.5.0.rc1

data/lib/hydra_attribute/model/dirty.rb

@@ -0,0 +1,39 @@
+module HydraAttribute
+  module Model
+    module Dirty
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Defines dirty method
+        #
+        # @param [String] column_name
+        # @return [NilClass]
+        def define_attribute_method(column_name)
+          super(column_name)
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{column_name}_was
+              @attributes_were[:#{column_name}]
+            end
+
+            def #{column_name}_changed?
+              @attributes_were[:#{column_name}] != @attributes[:#{column_name}]
+            end
+          EOS
+        end
+      end
+
+      # Redefine initializer for catching previous attributes
+      def initialize(attributes = {})
+        super(attributes)
+        @attributes_were = @attributes.clone
+      end
+
+      # Update previous attributes after saving
+      def save
+        result = super
+        @attributes_were = @attributes.clone
+        result
+      end
+    end
+  end
+end

data/lib/hydra_attribute/model/has_many_through.rb

@@ -0,0 +1,168 @@
+module HydraAttribute
+  module Model
+    module HasManyThrough
+      extend ActiveSupport::Concern
+
+      class Relation
+        def initialize(object, options = {})
+          @object = object
+
+          @relation_class     = options[:relation_class]
+          @through_class      = options[:through_class]
+          @through_method     = options[:through_method]
+          @object_method_id   = options[:object_method_id]
+          @relation_method_id = options[:relation_method_id]
+          @copy_attribute     = options[:copy_attribute]
+        end
+
+        # API method
+        # build relation object
+        #
+        # @param [Hash] attributes
+        # @return [HydraAttribute::Model]
+        def build(attributes = {})
+          relation_object = @relation_class.new(prepare_relation_attributes(attributes))
+          unsaved_relation_objects << relation_object
+          relation_object
+        end
+
+        # API method
+        # create relation object
+        #
+        # @param [Hash] attributes
+        # @return [HydraAttribute::Model]
+        def create(attributes = {})
+          relation_object = @relation_class.create(prepare_relation_attributes(attributes))
+          self << relation_object
+          relation_object
+        end
+
+        # API method
+        # add relation object
+        #
+        # @param [HydraAttribute::Model] relation_object
+        # @return [HydraAttribute::Model::HasManyThrough::Relation]
+        def <<(relation_object)
+          if @object.persisted? && relation_object.persisted?
+            @through_class.create(@object_method_id => @object.id, @relation_method_id => relation_object.id)
+          else
+            unsaved_relation_objects << relation_object
+          end
+          self
+        end
+
+        # API method
+        # delete relation object
+        #
+        # @param [HydraAttribute::Model] relation_object
+        # @return [HydraAttribute::Model::HasManyThrough::Relation]
+        def destroy(relation_object)
+          if @object.persisted? and relation_object.persisted?
+            through_object = through_object_by_relation_object(relation_object)
+            through_object.destroy if through_object
+          else
+            unsaved_relation_objects.delete(relation_object)
+          end
+          self
+        end
+
+        def save_unsaved_associations #:nodoc:
+          unsaved_relation_objects.each do |relation_object|
+            self << relation_object if relation_object.save
+          end
+          unsaved_relation_objects.clear
+        end
+
+        def delete_unsaved_associations #:nodoc:
+          unsaved_relation_objects.clear
+        end
+
+        def inspect
+          relation_objects.inspect
+        end
+
+        private
+          def respond_to_missing?(method, include_private)
+            relation_objects.respond_to?(method, include_private)
+          end
+
+          def method_missing(method, *args, &block)
+            relation_objects.public_send(method, *args, &block)
+          end
+
+          def relation_objects
+            persisted_relation_objects + unsaved_relation_objects
+          end
+
+          def persisted_relation_objects
+            @through_class.send(@through_method, @object.id)
+          end
+
+          def unsaved_relation_objects
+            @unsaved_relation_objects ||= []
+          end
+
+          def through_object_by_relation_object(relation_object)
+            @through_class.all.find do |through_object|
+              through_object.send(@object_method_id) == @object.id && through_object.send(@relation_method_id) == relation_object.id
+            end
+          end
+
+          def prepare_relation_attributes(attributes)
+            if @copy_attribute
+              attributes.reverse_merge(@copy_attribute => @object.send(@copy_attribute))
+            else
+              attributes
+            end
+          end
+      end
+
+      module ClassMethods
+        def has_many(collection, options = {})
+          relation_class_name = "::HydraAttribute::#{collection.to_s.singularize.camelize}"       # HydraAttribute::HydraAttribute
+          through_class_name  = "::HydraAttribute::#{options[:through].to_s.camelize}"            # HydraAttribute::HydraAttributeSet
+          object_method_id    = "#{name.demodulize.underscore}_id"                                # 'hydra_set_id'
+          relation_method_id  = "#{collection.to_s.singularize}_id"                               # 'hydra_attribute_id'
+          through_method_name = "#{collection}_by_#{object_method_id}"                            # 'hydra_attributes_by_hydra_set_id'
+          copy_attribute      = options[:copy_attribute] ? ":#{options[:copy_attribute]}" : 'nil' # :entity_type
+
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{collection}
+              @#{collection} ||= Relation.new(self,
+                                              :relation_class     => #{relation_class_name},
+                                              :through_class      => #{through_class_name},
+                                              :through_method     => :#{through_method_name},
+                                              :object_method_id   => :#{object_method_id},
+                                              :relation_method_id => :#{relation_method_id},
+                                              :copy_attribute     => #{copy_attribute})
+            end
+
+            def create
+              result = super
+              if result
+                #{collection}.save_unsaved_associations
+              end
+              result
+            end
+
+            def update
+              result = super
+              if result
+                #{collection}.save_unsaved_associations
+              end
+              result
+            end
+
+            def delete
+              result = super
+              if result
+                #{collection}.delete_unsaved_associations
+              end
+              result
+            end
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/hydra_attribute/model/identity_map.rb

@@ -0,0 +1,59 @@
+module HydraAttribute
+  module Model
+
+    # @see HydraAttribute::Model::IdentityMap::ClassMethods ClassMethods for documentation
+    module IdentityMap
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Identity map key
+        #
+        # @return [Symbol]
+        def identity_map_cache_key
+          @identity_map_cache_key ||= name.underscore.to_sym
+        end
+
+        # Identity map
+        #
+        # @return [HydraAttribute::IdentityMap]
+        def identity_map
+          ::HydraAttribute.cache(identity_map_cache_key) { ::HydraAttribute::IdentityMap.new }
+        end
+
+        # Returns identity map object which is inserted into the default one
+        #
+        # @param [Symbol] cache_key
+        # @return [HydraAttribute::IdentityMap]
+        def nested_identity_map(cache_key)
+          identity_map.cache(cache_key) { ::HydraAttribute::IdentityMap.new }
+        end
+
+        # Proxy method to +identity_map+
+        #
+        # @param [String, Symbol] key
+        # @param [NilClass, Object] value
+        # @yield
+        # @return [Object]
+        def cache(key, value = nil, &block)
+          identity_map.cache(key, value, &block)
+        end
+
+        # Registers nested cache
+        #
+        # @param [Array<Symbol>] cache_keys
+        # @return [NilClass]
+        def register_nested_cache(*cache_keys)
+          cache_keys.each do |cache_key|
+            nested_cache_keys << cache_key
+          end
+        end
+
+        private
+          # Store all nested cache keys
+          def nested_cache_keys
+            @nested_cache_keys ||= []
+          end
+      end
+    end
+  end
+end

data/lib/hydra_attribute/model/mediator.rb

@@ -0,0 +1,89 @@
+module HydraAttribute
+  module Model
+    module Mediator
+      extend ActiveSupport::Concern
+
+      class << self
+        # Holds all subscriptions
+        #
+        # @return [Hash]
+        def subscriptions
+          @subscriptions ||= Hash.new do |reporters, reporter|
+            reporters[reporter] = Hash.new do |events, event|
+              events[event] = []
+            end
+          end
+        end
+
+        # Subscribes listeners for reporter event
+        #
+        # @param [String] listener the name of the class which listens the event
+        # @param [String] reporter
+        # @param [Hash] events
+        # @return [NilClass]
+        def subscribe(listener, reporter, events)
+          events.each do |event, callback|
+            subscriptions[reporter][event] << [listener, callback]
+          end
+        end
+
+        # Notifies listeners
+        #
+        # @param [String] reporter
+        # @param [Symbol] event
+        # @param [HydraAttribute::Model::Mediator] object
+        # @return [NilClass]
+        def notify(reporter, event, object)
+          subscriptions[reporter][event].each do |listener, callback|
+            listener.constantize.send(callback, object)
+          end
+        end
+
+        # Clears all subscriptions
+        #
+        # @return [NilClass]
+        def clear
+          @subscriptions = nil
+        end
+      end
+
+      module ClassMethods
+        # Defines which class and its methods this object should observe
+        #
+        # @example
+        #   class ModelOne
+        #     include HydraAttribute::Model::Mediator
+        #     observe 'ModelTwo', create: :model_two_created, destroy: :model_two_destroyed
+        #
+        #     def self.model_two_created(model_two)
+        #     end
+        #
+        #     def self.model_two_destroyed(model_two)
+        #     end
+        #   end
+        #
+        # @param [String] class_name
+        # @param [Hash] events
+        # @return [NilClass]
+        def observe(class_name, events)
+          Mediator.subscribe(name, class_name, events)
+        end
+      end
+
+      # Notifies all listeners about event
+      #
+      # @param [Symbol] event
+      # @return [NilClass]
+      def notify(event)
+        if block_given?
+          Mediator.notify(self.class.name, "before_#{event}".to_sym, self)
+          result = yield
+          Mediator.notify(self.class.name, "after_#{event}".to_sym, self)
+          result
+        else
+          Mediator.notify(self.class.name, event, self)
+        end
+      end
+    end
+  end
+end

data/lib/hydra_attribute/model/notifiable.rb

@@ -0,0 +1,23 @@
+module HydraAttribute
+  module Model
+    module Notifiable
+      extend ActiveSupport::Concern
+
+      private
+        # Overwrite for notifying subscribed objects
+        def create
+          notify(:create) { super }
+        end
+
+        # Overwrite for notifying subscribed objects
+        def update
+          notify(:update) { super }
+        end
+
+        # Overwrite for notifying subscribed objects
+        def delete
+          notify(:destroy) { super }
+        end
+    end
+  end
+end

data/lib/hydra_attribute/model/persistence.rb

@@ -0,0 +1,424 @@
+module HydraAttribute
+  class RecordNotFound < ::ActiveRecord::RecordNotFound
+  end
+
+  module Model
+    # @see HydraAttribute::Model::Persistence::ClassMethods ClassMethods for documentation
+    module Persistence
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Creates +Mutex+ object
+        #
+        # @return [Mutex]
+        def attribute_methods_mutex
+          @attribute_methods_mutex ||= Mutex.new
+        end
+
+        # Holds generated attribute methods status
+        #
+        # @return [TrueClass, FalseClass]
+        def generated_attribute_methods?
+          @generated_attribute_methods ||= false
+        end
+
+        # Define attribute methods based on column names
+        #
+        # @return [NilClass]
+        def define_attribute_methods
+          attribute_methods_mutex.synchronize do
+            return if generated_attribute_methods?
+            column_names.each do |column_name|
+              define_attribute_method(column_name)
+            end
+            @generated_attribute_methods = true
+          end
+        end
+
+        # Defines attribute getter and setter
+        #
+        # @param [String] column_name
+        # @return [NilClass]
+        def define_attribute_method(column_name)
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{column_name}                                                       # def name
+              attributes[:#{column_name}]                                            #   attributes[:name]
+            end                                                                      # end
+
+            def #{column_name}=(value)                                               # def name=(value)
+              attributes[:#{column_name}] = type_cast_value(:#{column_name}, value)  #   attributes[:name] = type_cast_value(:name, value)
+            end                                                                      # end
+
+            def #{column_name}?                                                      # name?
+              attributes[:#{column_name}].present?                                   #  attributes[:name].present?
+            end                                                                      # end
+          EOS
+        end
+
+        # Returns database adapter
+        #
+        # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+        def connection
+          @connection ||= ::ActiveRecord::Base.connection
+        end
+
+        # Returns table name
+        #
+        # @return [String]
+        def table_name
+          @table_name ||= name.demodulize.tableize
+        end
+
+        # Returns table columns
+        #
+        # @return [Array<ActiveRecord::ConnectionAdapters::Column>]
+        def columns
+          @columns ||= connection.schema_cache.columns[table_name]
+        end
+
+        # Returns hash of column objects with their names as a keys
+        # Keys are string
+        #
+        # @return [Hash]
+        def columns_hash
+          @columns_hash ||= connection.schema_cache.columns_hash[table_name]
+        end
+
+        # Returns hash of column objects with their names as a keys
+        # Keys are symbols
+        #
+        # @return [Hash]
+        def symbolized_columns_hash
+          @symbolized_columns_hash ||= columns_hash.symbolize_keys
+        end
+
+        # Return column object
+        #
+        # @param [String]
+        # @return [ActiveRecord::ConnectionAdapters::Column]
+        def column(name)
+          columns_hash[name]
+        end
+
+        # Returns column names
+        #
+        # @return [Array<String>]
+        def column_names
+          @column_names ||= columns.map(&:name)
+        end
+
+        # Holds attributes with default values
+        #
+        # @return [Hash]
+        def attributes
+          @attributes ||= columns.each_with_object({}) do |column, attributes|
+            attributes[column.name.to_sym] = column.default
+          end
+        end
+
+        # Returns arel table
+        #
+        # @return [Arel::Table]
+        def arel_table
+          @arel_table ||= Arel::Table.new(table_name, self)
+        end
+
+        # Finds all records
+        #
+        # @return [Array<HydraAttribute::Model>]
+        def all
+          where
+        end
+
+        # Finds one record by ID
+        #
+        # @param [Integer] id
+        # @return [HydraAttribute::Model]
+        def find(id)
+          result = connection.select_one(compile_select({id: id}, Arel.star, 1))
+          raise RecordNotFound, "Couldn't find #{name} with id=#{id}" unless result
+          new(result)
+        end
+
+        # Finds records with where filter
+        #
+        # @param [Hash] attributes
+        # @param [Array] fields
+        # @param [NilClass, Integer] limit
+        # @param [NilClass, Integer] offset
+        # @return [Array<HydraAttribute::Model>]
+        def where(attributes = {}, fields = Arel.star, limit = nil, offset = nil)
+          connection.select_all(compile_select(attributes, fields, limit, offset)).map do |values|
+            new(values)
+          end
+        end
+
+        # Finds records with negative where filter
+        #
+        # @param [Hash] attributes
+        # @param [Array] fields
+        # @param [NilClass, Integer] limit
+        # @param [NilClass, Integer] offset
+        # @return [Array<HydraAttribute::Model>]
+        def where_not(attributes = {}, fields = Arel.star, limit = nil, offset = nil)
+          select = compile_select({}, fields, limit, offset)
+          select.where(compile_where_not(attributes)) unless attributes.empty?
+          connection.select_all(select).map do |values|
+            new(values)
+          end
+        end
+
+        # Creates new record
+        #
+        # @param [Hash] attributes
+        # @return [HydraAttribute::Model]
+        def create(attributes = {})
+          model = new(attributes.except(:id, 'id'))
+          model.save
+          model
+        end
+
+        # Updates record by ID
+        #
+        # @param [Integer] id
+        # @param [Hash] attributes
+        # @return [HydraAttribute::Model]
+        def update(id, attributes = {})
+          model = find(id)
+          model.assign_attributes(attributes.except(:id, 'id'))
+          model.save
+          model
+        end
+
+        # Destroys model by its ID
+        #
+        # @param [Integer] id
+        # @return [TrueClass, FalseClass]
+        def destroy(id)
+          find(id).destroy
+        end
+
+        # Destroys all models
+        #
+        # @return [Hash] result for each deleted object
+        def destroy_all
+          all.map(&:id).each_with_object({}) do |model_id, result|
+            result[model_id] = destroy(model_id)
+          end
+        end
+
+        # Compiles attributes for performing +SELECT+ query
+        #
+        # @param [Hash] attributes
+        # @param [Array] fields attributes which should be selected
+        # @param [NilClass, Integer] limit
+        # @param [NilClass, Integer] offset
+        # @return [Arel::SelectManager]
+        def compile_select(attributes = {}, fields = Arel.star, limit = nil, offset = nil)
+          columns = Array(fields).map { |field| arel_table[field] }
+          arel    = select_manager.project(columns).take(limit).skip(offset)
+          arel.where(compile_where(attributes)) unless attributes.blank?
+          arel
+        end
+
+        # Compiles attributes for performing +INSERT+ query
+        #
+        # @param [Hash] attributes
+        # @return [Arel::InsertManager]
+        def compile_insert(attributes = {})
+          fields = attributes_to_columns(attributes)
+          arel_table.compile_insert(fields)
+        end
+
+        # Compiles attributes for performing +UPDATE+ query
+        #
+        # @param [String] id
+        # @param [Hash] attributes
+        # @return [Arel::UpdateManager]
+        def compile_update(id, attributes = {})
+          fields = attributes_to_columns(attributes)
+          compile_select(id: id).compile_update(fields)
+        end
+
+        # Compiles attributes for performing +DELETE+ query
+        #
+        # @param [Hash] attributes
+        # @return [Arel::DeleteManager]
+        def compile_delete(attributes = {})
+          compile_select(attributes).compile_delete
+        end
+
+        # Builds +arel+ object for select query
+        #
+        # @return [Arel::SelectManager]
+        def select_manager
+          arel_table.from(arel_table)
+        end
+
+        private
+          # Compiles data for +WHERE+ part
+          #
+          # @param [Hash] attributes
+          # @return [Arel::Nodes::And, Arel::Nodes::Equality]
+          def compile_where(attributes = {})
+            attributes.map do |name, value|
+              method = value.is_a?(Array) ? :in : :eq
+              arel_table[name].send(method, value)
+            end.inject(:and)
+          end
+
+          # Compiles negative data for +WHERE+ part
+          #
+          # @param [Hash] attributes
+          # @return [Arel::Nodes::And, Arel::Nodes::Equality]
+          def compile_where_not(attributes = {})
+            attributes.map do |name, value|
+              method = value.is_a?(Array) ? :not_in : :not_eq
+              arel_table[name].send(method, value)
+            end.inject(:and)
+          end
+
+          # Replaces attributes' keys to +arel+ columns
+          #
+          # @param [Hash] attributes
+          # @return [Hash]
+          def attributes_to_columns(attributes = {})
+            attributes.each_with_object({}) do |(name, value), fields|
+              fields[arel_table[name]] = value
+            end
+          end
+      end
+
+      # Model initializer
+      #
+      # @param [Hash] attributes
+      def initialize(attributes = {})
+        @destroyed  = false
+        @attributes = self.class.attributes.clone
+
+        assign_attributes(attributes)
+      end
+
+      # Assigns attributes
+      #
+      # @return [Hash] current attributes
+      def assign_attributes(new_attributes = {})
+        new_attributes.symbolize_keys.each do |name, value|
+          @attributes[name] = type_cast_value(name, value)
+        end
+      end
+
+      # Return all attributes
+      #
+      # @return [Hash]
+      def attributes
+        @attributes
+      end
+
+      # Checks if model is saved in database
+      #
+      # @return [TrueClass, FalseClass]
+      def persisted?
+        id.present? and not destroyed?
+      end
+
+      # Checks if model is destroyed
+      #
+      # @return [TrueClass, FalseClass]
+      def destroyed?
+        @destroyed
+      end
+
+      # Saves model
+      # If model is persisted, update it otherwise create it.
+      #
+      # @return [TrueClass]
+      def save
+        return true  if destroyed?
+        return false unless valid?
+
+        self.class.connection.transaction do
+          persisted? ? update : create
+        end
+      end
+
+      # Destroys record from database
+      # This method runs callbacks
+      #
+      # @return [TrueClass]
+      def destroy
+        self.class.connection.transaction do
+          delete
+        end
+      end
+
+      # Redefines base method because attribute methods define dynamically
+      #
+      # @param [Symbol] method
+      # @param [FalseClass, TrueClass] include_private
+      # @return [FalseClass, TrueClass]
+      def respond_to?(method, include_private = false)
+        self.class.define_attribute_methods unless self.class.generated_attribute_methods?
+        super
+      end
+
+      private
+        # Performs +INSERT+ query
+        #
+        # @return [Integer] primary key
+        def create
+          return id if persisted? or destroyed?
+          columns = attributes.except(:id, :created_at, :updated_at).merge(created_at: Time.now, updated_at: Time.now)
+          self.id = self.class.connection.insert(self.class.compile_insert(columns), 'SQL').to_i
+        end
+
+        # Performs +UPDATE+ query
+        #
+        # @return [TrueClass]
+        def update
+          return true unless persisted?
+          columns = attributes.except(:id, :created_at, :updated_at).merge(updated_at: Time.now)
+          self.class.connection.update(self.class.compile_update(id, columns), 'SQL')
+          true
+        end
+
+        # Deletes record from database
+        #
+        # @return [TrueClass]
+        def delete
+          return true unless persisted?
+          self.class.connection.delete(self.class.compile_delete(id: id), 'SQL')
+          @destroyed = true
+        end
+
+        # Type casts value based on its database type
+        #
+        # @param [Symbol] name
+        # @param [Object] value
+        # @return [Object] type casted value
+        def type_cast_value(name, value)
+          self.class.symbolized_columns_hash[name].type_cast(value)
+        end
+
+        # Redefine method for auto generation attribute methods
+        #
+        # @param [Symbol] symbol
+        # @params[Array] args
+        # @yield
+        # @return [Object]
+        def method_missing(symbol, *args, &block)
+          if self.class.generated_attribute_methods?
+            super
+          else
+            self.class.define_attribute_methods
+            if respond_to?(symbol)
+              send(symbol, *args, &block)
+            else
+              super
+            end
+          end
+        end
+
+    end
+  end
+end