inventory_refresh 0.0.1

data/lib/inventory_refresh/inventory_object.rb

@@ -0,0 +1,303 @@
+require "inventory_refresh/application_record_reference"
+require "active_support/core_ext/module/delegation"
+
+module InventoryRefresh
+  class InventoryObject
+    attr_accessor :object, :id
+    attr_reader :inventory_collection, :data, :reference
+
+    delegate :manager_ref, :base_class_name, :model_class, :to => :inventory_collection
+    delegate :[], :[]=, :to => :data
+
+    # @param inventory_collection [InventoryRefresh::InventoryCollection] InventoryCollection object owning the
+    #        InventoryObject
+    # @param data [Hash] Data of the InventoryObject object
+    def initialize(inventory_collection, data)
+      @inventory_collection     = inventory_collection
+      @data                     = data
+      @object                   = nil
+      @id                       = nil
+      @reference                = inventory_collection.build_reference(data)
+    end
+
+    # @return [String] stringified reference
+    def manager_uuid
+      reference.stringified_reference
+    end
+
+    # @return [InventoryRefresh::InventoryObject] returns self
+    def load
+      self
+    end
+
+    def key
+      nil
+    end
+
+    # Transforms InventoryObject object data into hash format with keys that are column names and resolves correct
+    # values of the foreign keys (even the polymorphic ones)
+    #
+    # @param inventory_collection_scope [InventoryRefresh::InventoryCollection] parent InventoryCollection object
+    # @return [Hash] Data in DB format
+    def attributes(inventory_collection_scope = nil)
+      # We should explicitly pass a scope, since the inventory_object can be mapped to more InventoryCollections with
+      # different blacklist and whitelist. The generic code always passes a scope.
+      inventory_collection_scope ||= inventory_collection
+
+      attributes_for_saving = {}
+      # First transform the values
+      data.each do |key, value|
+        if !allowed?(inventory_collection_scope, key)
+          next
+        elsif value.kind_of?(Array) && value.any? { |x| loadable?(x) }
+          # Lets fill also the original data, so other InventoryObject referring to this attribute gets the right
+          # result
+          data[key] = value.compact.map(&:load).compact
+          # We can use built in _ids methods to assign array of ids into has_many relations. So e.g. the :key_pairs=
+          # relation setter will become :key_pair_ids=
+          attributes_for_saving[(key.to_s.singularize + "_ids").to_sym] = data[key].map(&:id).compact.uniq
+        elsif loadable?(value) || inventory_collection_scope.association_to_foreign_key_mapping[key]
+          # Lets fill also the original data, so other InventoryObject referring to this attribute gets the right
+          # result
+          data[key] = value.load if value.respond_to?(:load)
+          if (foreign_key = inventory_collection_scope.association_to_foreign_key_mapping[key])
+            # We have an association to fill, lets fill also the :key, cause some other InventoryObject can refer to it
+            record_id                                 = data[key].try(:id)
+            attributes_for_saving[foreign_key.to_sym] = record_id
+
+            if (foreign_type = inventory_collection_scope.association_to_foreign_type_mapping[key])
+              # If we have a polymorphic association, we need to also fill a base class name, but we want to nullify it
+              # if record_id is missing
+              base_class = data[key].try(:base_class_name) || data[key].class.try(:base_class).try(:name)
+              attributes_for_saving[foreign_type.to_sym] = record_id ? base_class : nil
+            end
+          elsif data[key].kind_of?(::InventoryRefresh::InventoryObject)
+            # We have an association to fill but not an Activerecord association, so e.g. Ancestry, lets just load
+            # it here. This way of storing ancestry is ineffective in DB call count, but RAM friendly
+            attributes_for_saving[key.to_sym] = data[key].base_class_name.constantize.find_by(:id => data[key].id)
+          else
+            # We have a normal attribute to fill
+            attributes_for_saving[key.to_sym] = data[key]
+          end
+        else
+          attributes_for_saving[key.to_sym] = value
+        end
+      end
+
+      attributes_for_saving
+    end
+
+    # Transforms InventoryObject object data into hash format with keys that are column names and resolves correct
+    # values of the foreign keys (even the polymorphic ones)
+    #
+    # @param inventory_collection_scope [InventoryRefresh::InventoryCollection] parent InventoryCollection object
+    # @param all_attribute_keys [Array<Symbol>] Attribute keys we will modify based on object's data
+    # @return [Hash] Data in DB format
+    def attributes_with_keys(inventory_collection_scope = nil, all_attribute_keys = [])
+      # We should explicitly pass a scope, since the inventory_object can be mapped to more InventoryCollections with
+      # different blacklist and whitelist. The generic code always passes a scope.
+      inventory_collection_scope ||= inventory_collection
+
+      attributes_for_saving = {}
+      # First transform the values
+      data.each do |key, value|
+        if !allowed?(inventory_collection_scope, key)
+          next
+        elsif loadable?(value) || inventory_collection_scope.association_to_foreign_key_mapping[key]
+          # Lets fill also the original data, so other InventoryObject referring to this attribute gets the right
+          # result
+          data[key] = value.load if value.respond_to?(:load)
+          if (foreign_key = inventory_collection_scope.association_to_foreign_key_mapping[key])
+            # We have an association to fill, lets fill also the :key, cause some other InventoryObject can refer to it
+            record_id = data[key].try(:id)
+            foreign_key_to_sym = foreign_key.to_sym
+            attributes_for_saving[foreign_key_to_sym] = record_id
+            all_attribute_keys << foreign_key_to_sym
+            if (foreign_type = inventory_collection_scope.association_to_foreign_type_mapping[key])
+              # If we have a polymorphic association, we need to also fill a base class name, but we want to nullify it
+              # if record_id is missing
+              base_class = data[key].try(:base_class_name) || data[key].class.try(:base_class).try(:name)
+              foreign_type_to_sym = foreign_type.to_sym
+              attributes_for_saving[foreign_type_to_sym] = record_id ? base_class : nil
+              all_attribute_keys << foreign_type_to_sym
+            end
+          else
+            # We have a normal attribute to fill
+            attributes_for_saving[key] = data[key]
+            all_attribute_keys << key
+          end
+        else
+          attributes_for_saving[key] = value
+          all_attribute_keys << key
+        end
+      end
+
+      attributes_for_saving
+    end
+
+    # Given hash of attributes, we assign them to InventoryObject object using its public writers
+    #
+    # @param attributes [Hash] attributes we want to assign
+    # @return [InventoryRefresh::InventoryObject] self
+    def assign_attributes(attributes)
+      attributes.each do |k, v|
+        # We don't want timestamps or resource versions to be overwritten here, since those are driving the conditions
+        next if %i(resource_timestamps resource_timestamps_max resource_timestamp).include?(k)
+        next if %i(resource_versions resource_versions_max resource_version).include?(k)
+
+        if data[:resource_timestamp] && attributes[:resource_timestamp]
+          assign_only_newest(:resource_timestamp, :resource_timestamps, attributes, data, k, v)
+        elsif data[:resource_version] && attributes[:resource_version]
+          assign_only_newest(:resource_version, :resource_versions, attributes, data, k, v)
+        else
+          public_send("#{k}=", v)
+        end
+      end
+
+      if attributes[:resource_timestamp]
+        assign_full_row_version_attr(:resource_timestamp, attributes, data)
+      elsif attributes[:resource_version]
+        assign_full_row_version_attr(:resource_version, attributes, data)
+      end
+
+      self
+    end
+
+    # @return [String] stringified UUID
+    def to_s
+      manager_uuid
+    end
+
+    # @return [String] string format for nice logging
+    def inspect
+      "InventoryObject:('#{manager_uuid}', #{inventory_collection})"
+    end
+
+    # @return [TrueClass] InventoryObject object is always a dependency
+    def dependency?
+      true
+    end
+
+    # Adds setters and getters based on :inventory_object_attributes kwarg passed into InventoryCollection
+    # Methods already defined should not be redefined (causes unexpected behaviour)
+    #
+    # @param inventory_object_attributes [Array<Symbol>]
+    def self.add_attributes(inventory_object_attributes)
+      defined_methods = InventoryRefresh::InventoryObject.instance_methods(false)
+
+      inventory_object_attributes.each do |attr|
+        unless defined_methods.include?("#{attr}=".to_sym)
+          define_method("#{attr}=") do |value|
+            data[attr] = value
+          end
+        end
+
+        unless defined_methods.include?(attr.to_sym)
+          define_method(attr) do
+            data[attr]
+          end
+        end
+      end
+    end
+
+    private
+
+    # Assigns value based on the version attributes. If versions are specified, it asigns attribute only if it's
+    # newer than existing attribute.
+    #
+    # @param full_row_version_attr [Symbol] Attr name for full rows, allowed values are
+    #        [:resource_timestamp, :resource_version]
+    # @param partial_row_version_attr [Symbol] Attr name for partial rows, allowed values are
+    #        [:resource_timestamps, :resource_versions]
+    # @param attributes [Hash] New attributes we are assigning
+    # @param data [Hash] Existing attributes of the InventoryObject
+    # @param k [Symbol] Name of the attribute we are assigning
+    # @param v [Object] Value of the attribute we are assigning
+    def assign_only_newest(full_row_version_attr, partial_row_version_attr, attributes, data, k, v)
+      # If timestamps are in play, we will set only attributes that are newer
+      specific_attr_timestamp = attributes[partial_row_version_attr].try(:[], k)
+      specific_data_timestamp = data[partial_row_version_attr].try(:[], k)
+
+      assign = if !specific_attr_timestamp
+                 # Data have no timestamp, we will ignore the check
+                 true
+               elsif specific_attr_timestamp && !specific_data_timestamp
+                 # Data specific timestamp is nil and we have new specific timestamp
+                 if data.key?(k)
+                   if attributes[full_row_version_attr] >= data[full_row_version_attr]
+                     # We can save if the full timestamp is bigger, if the data already contains the attribute
+                     true
+                   end
+                 else
+                   # Data do not contain the attribute, so we are saving the newest
+                   true
+                 end
+                 true
+               elsif specific_attr_timestamp > specific_data_timestamp
+                 # both partial timestamps are there, newer must be bigger
+                 true
+               end
+
+      if assign
+        public_send("#{k}=", v) # Attribute is newer than current one, lets use it
+        (data[partial_row_version_attr] ||= {})[k] = specific_attr_timestamp if specific_attr_timestamp # and set the latest timestamp
+      end
+    end
+
+    # Assigns attribute representing version of the whole row
+    #
+    # @param full_row_version_attr [Symbol] Attr name for full rows, allowed values are
+    #        [:resource_timestamp, :resource_version]
+    # @param attributes [Hash] New attributes we are assigning
+    # @param data [Hash] Existing attributes of the InventoryObject
+    def assign_full_row_version_attr(full_row_version_attr, attributes, data)
+      if attributes[full_row_version_attr] && data[full_row_version_attr]
+        # If both timestamps are present, store the bigger one
+        data[full_row_version_attr] = attributes[full_row_version_attr] if attributes[full_row_version_attr] > data[full_row_version_attr]
+      elsif attributes[full_row_version_attr] && !data[full_row_version_attr]
+        # We are assigning timestamp that was missing
+        data[full_row_version_attr] = attributes[full_row_version_attr]
+      end
+    end
+
+    # Return true passed key representing a getter is an association
+    #
+    # @param inventory_collection_scope [InventoryRefresh::InventoryCollection]
+    # @param key [Symbol] key representing getter
+    # @return [Boolean] true if the passed key points to association
+    def association?(inventory_collection_scope, key)
+      # Is the key an association on inventory_collection_scope model class?
+      !inventory_collection_scope.association_to_foreign_key_mapping[key].nil?
+    end
+
+    # Return true if the attribute is allowed to be saved into the DB
+    #
+    # @param inventory_collection_scope [InventoryRefresh::InventoryCollection] InventoryCollection object owning the
+    #        attribute
+    # @param key [Symbol] attribute name
+    # @return true if the attribute is allowed to be saved into the DB
+    def allowed?(inventory_collection_scope, key)
+      foreign_to_association = inventory_collection_scope.foreign_key_to_association_mapping[key] ||
+                               inventory_collection_scope.foreign_type_to_association_mapping[key]
+
+      return false if inventory_collection_scope.attributes_blacklist.present? &&
+                      (inventory_collection_scope.attributes_blacklist.include?(key) ||
+                        (foreign_to_association && inventory_collection_scope.attributes_blacklist.include?(foreign_to_association)))
+
+      return false if inventory_collection_scope.attributes_whitelist.present? &&
+                      (!inventory_collection_scope.attributes_whitelist.include?(key) &&
+                        (!foreign_to_association || (foreign_to_association && inventory_collection_scope.attributes_whitelist.include?(foreign_to_association))))
+
+      true
+    end
+
+    # Return true if the object is loadable, which we determine by a list of loadable classes.
+    #
+    # @param value [Object] object we test
+    # @return true if the object is loadable
+    def loadable?(value)
+      value.kind_of?(::InventoryRefresh::InventoryObjectLazy) || value.kind_of?(::InventoryRefresh::InventoryObject) ||
+        value.kind_of?(::InventoryRefresh::ApplicationRecordReference)
+    end
+  end
+end

data/lib/inventory_refresh/inventory_object_lazy.rb

@@ -0,0 +1,151 @@
+require "active_support/core_ext/module/delegation"
+
+module InventoryRefresh
+  class InventoryObjectLazy
+    attr_reader :reference, :inventory_collection, :key, :default, :transform_nested_lazy_finds
+
+    delegate :stringified_reference, :ref, :[], :to => :reference
+
+    # @param inventory_collection [InventoryRefresh::InventoryCollection] InventoryCollection object owning the
+    #        InventoryObject
+    # @param index_data [Hash] data of the InventoryObject object
+    # @param ref [Symbol] reference name
+    # @param key [Symbol] key name, will be used to fetch attribute from resolved InventoryObject
+    # @param default [Object] a default value used if the :key will resolve to nil
+    # @param transform_nested_lazy_finds [Boolean] True if we want to convert all lazy objects in InventoryObject
+    #        objects and reset the Reference. TODO(lsmola) we should be able to do this automatically, then we can
+    #        remove this option
+    def initialize(inventory_collection, index_data, ref: :manager_ref, key: nil, default: nil, transform_nested_lazy_finds: false)
+      @inventory_collection = inventory_collection
+      @reference            = inventory_collection.build_reference(index_data, ref)
+      @key                  = key
+      @default              = default
+
+      @transform_nested_lazy_finds = transform_nested_lazy_finds
+
+      # We do not support skeletal pre-create for :key, since :key will not be available, we want to use local_db_find
+      # instead.
+      skeletal_precreate! unless @key
+    end
+
+    # @return [String] stringified reference
+    def to_s
+      # TODO(lsmola) do we need this method?
+      stringified_reference
+    end
+
+    # @return [String] string format for nice logging
+    def inspect
+      suffix = ""
+      suffix += ", ref: #{ref}" if ref.present?
+      suffix += ", key: #{key}" if key.present?
+      "InventoryObjectLazy:('#{self}', #{inventory_collection}#{suffix})"
+    end
+
+    # @return [InventoryRefresh::InventoryObject, Object] InventoryRefresh::InventoryObject instance or an attribute
+    #         on key
+    def load
+      transform_nested_secondary_indexes! if transform_nested_lazy_finds && nested_secondary_index?
+
+      key ? load_object_with_key : load_object
+    end
+
+    # return [Boolean] true if the Lazy object is causing a dependency, Lazy link is always a dependency if no :key
+    #        is provider or if it's transitive_dependency
+    def dependency?
+      # If key is not set, InventoryObjectLazy is a dependency, cause it points to the record itself. Otherwise
+      # InventoryObjectLazy is a dependency only if it points to an attribute which is a dependency or a relation.
+      !key || transitive_dependency?
+    end
+
+    # return [Boolean] true if the Lazy object is causing a transitive dependency, which happens if the :key points
+    #        to an attribute that is causing a dependency.
+    def transitive_dependency?
+      # If the dependency is inventory_collection.lazy_find(:ems_ref, :key => :stack)
+      # and a :stack is a relation to another object, in the InventoryObject object,
+      # then this relation is considered transitive.
+      key && association?(key)
+    end
+
+    # @return [Boolean] true if the key is an association on inventory_collection_scope model class
+    def association?(key)
+      # TODO(lsmola) remove this if there will be better dependency scan, probably with transitive dependencies filled
+      # in a second pass, then we can get rid of this hardcoded symbols. Right now we are not able to introspect these.
+      return true if [:parent, :genealogy_parent].include?(key)
+
+      inventory_collection.dependency_attributes.key?(key) ||
+        !inventory_collection.association_to_foreign_key_mapping[key].nil?
+    end
+
+    def transform_nested_secondary_indexes!(depth = 0)
+      raise "Nested references are too deep!" if depth > 20
+
+      keys.each do |x|
+        attr = full_reference[x]
+        next unless attr.kind_of?(InventoryRefresh::InventoryObjectLazy)
+        next if attr.primary?
+
+        if attr.nested_secondary_index?
+          attr.transform_nested_secondary_indexes!(depth + 1)
+        end
+
+        full_reference[x] = full_reference[x].load
+      end
+
+      # Rebuild the reference to get the right value
+      self.reference = inventory_collection.build_reference(full_reference, ref)
+    end
+
+    private
+
+    delegate :parallel_safe?, :saved?, :saver_strategy, :skeletal_primary_index, :targeted?, :to => :inventory_collection
+    delegate :nested_secondary_index?, :primary?, :full_reference, :keys, :primary?, :to => :reference
+
+    attr_writer :reference
+
+    # Instead of loading the reference from the DB, we'll add the skeletal InventoryObject (having manager_ref and
+    # info from the default_values) to the correct InventoryCollection. Which will either be found in the DB or
+    # created as a skeletal object. The later refresh of the object will then fill the rest of the data, while not
+    # touching the reference.
+    #
+    # @return [InventoryRefresh::InventoryObject, NilClass] Returns pre-created InventoryObject or nil
+    def skeletal_precreate!
+      # We can do skeletal pre-create only for strategies using unique indexes. Since this can build records out of
+      # the given :arel scope, we will always attempt to create the recod, so we need unique index to avoid duplication
+      # of records.
+      return unless parallel_safe?
+      # Pre-create only for strategies that will be persisting data, i.e. are not saved already
+      return if saved?
+      # We can only do skeletal pre-create for primary index reference, since that is needed to create DB unique index
+      return unless primary?
+      # Full reference must be present
+      return if full_reference.blank?
+
+      # To avoid pre-creating invalid records all fields of a primary key must have value
+      # TODO(lsmola) for composite keys, it's still valid to have one of the keys nil, figure out how to allow this
+      return if keys.any? { |x| full_reference[x].blank? }
+
+      skeletal_primary_index.build(full_reference)
+    end
+
+    # @return [Object] value found or :key or default value if the value is nil
+    def load_object_with_key
+      # TODO(lsmola) Log error if we are accessing path that is present in blacklist or not present in whitelist
+      found = inventory_collection.find(reference)
+      if found.present?
+        if found.try(:data).present?
+          found.data[key] || default
+        else
+          found.public_send(key) || default
+        end
+      else
+        default
+      end
+    end
+
+    # @return [InventoryRefresh::InventoryObject, NilClass] InventoryRefresh::InventoryObject instance or nil if not found
+    def load_object
+      inventory_collection.find(reference)
+    end
+  end
+end