inventory_refresh 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 626a8e6090e589367699c61e7e6c0a72de3cb836b1f08c5c83ba205a5c5ef20f
-  data.tar.gz: 0e360910809bc50a3f36fadb597ab5543e9c6e13ce4e5cb520ec517ba7397d11
+  metadata.gz: 3265443d41b8a0158121da387b749145f05c55ff5b1a579dc8dfd84fca5b4c77
+  data.tar.gz: 7a740afeebf95a4f204c37cca426eee592360c27e6636ee0471604f7cdd9aaf9
 SHA512:
-  metadata.gz: '08480055a3d389a312b14521cadf86096ccf1a20a1d964081ba9d2e8c22e6e9a884147fd82fc677c02ee84d789cf2238cc2f23028c7147569c1aedeb2391a020'
-  data.tar.gz: 4aabdcba7bf3532f3141e78aa4b7ba34f4dac2082d16e685522c842e8ffbf033923c04b57f89182b405a2e4f3ea18ef3185e2c0a359be8c16db58dc8568f8a1c
+  metadata.gz: d6c8d595edc1cf199628804d4fd4a52234b0cb5b6194a2f80ab6f173775c1e3377ec959b628d67c38bb68b9b062a1c7b488554b1143f68a2f8a665db1134e1be
+  data.tar.gz: '065609f61113e2beef237730befdf7a79f1f4fb104baedfc6fb639b3d6c45156b0ead76aea9550848ecb337bb0494b590d7760ea9a413262321c18621b2a40c6'

data/.gitignore

@@ -10,5 +10,11 @@
 
 /Gemfile.lock
 
+# ignore included plugins in bundler.d
+bundler.d/*
+
 # rspec failure tracking
 .rspec_status
+
+# generated rubocop file
+.rubocop-https*

data/Gemfile

@@ -4,3 +4,7 @@ git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in inventory_refresh.gemspec
 gemspec
+
+# Load other additional Gemfiles
+#   Developers can create a file ending in .rb under bundler.d/ to specify additional development dependencies
+Dir.glob(File.join(__dir__, 'bundler.d/*.rb')).each { |f| eval_gemfile(File.expand_path(f, __dir__)) }

data/inventory_refresh.gemspec

@@ -22,13 +22,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", "~> 5.0.6"
+  spec.add_dependency "activerecord", "~> 5.0"
   spec.add_dependency "more_core_extensions", "~> 3.5"
-  spec.add_dependency "pg"
+  spec.add_dependency "pg", "> 0"
 
   spec.add_development_dependency "ancestry"
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "factory_girl", "~> 4.5.0"
+  spec.add_development_dependency "bundler", "~> 2.0.1"
+  spec.add_development_dependency "factory_bot", "~> 4.11.1"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "simplecov"

data/lib/inventory_refresh/inventory_collection/builder.rb

@@ -0,0 +1,249 @@
+module InventoryRefresh
+  class InventoryCollection
+    class Builder
+      class MissingModelClassError < StandardError; end
+
+      def self.allowed_properties
+        %i(all_manager_uuids            arel                    association
+           attributes_blacklist         attributes_whitelist    batch_extra_attributes
+           complete                     create_only             custom_save_block
+           custom_reconnect_block       default_values          delete_method
+           dependency_attributes        check_changed           inventory_object_attributes
+           manager_ref                  manager_ref_allowed_nil manager_uuids
+           model_class                  name                    parent
+           parent_inventory_collections retention_strategy      strategy
+           saver_strategy               secondary_refs          targeted
+           targeted_arel                update_only             use_ar_object
+           assert_graph_integrity).to_set
+      end
+
+      def allowed_properties
+        @allowed_properties ||= self.class.allowed_properties
+      end
+
+      # Default options for builder
+      #   :adv_settings
+      #     - values from Advanced settings (doesn't overwrite values specified in code)
+      #     - @see method ManageIQ::Providers::Inventory::Persister.make_builder_settings()
+      #   :shared_properties
+      #     - any properties applied if missing (not explicitly specified)
+      def self.default_options
+        {
+          :shared_properties => {},
+        }
+      end
+
+      # Entry point
+      # Creates builder and builds data for inventory collection
+      # @param name [Symbol, Array] InventoryCollection.association value. <name> method not called when Array
+      #        (optional) method with this name also used for concrete inventory collection specific properties
+      # @param persister_class [Class] used for "guessing" model_class
+      # @param options [Hash]
+      def self.prepare_data(name, persister_class, options = {})
+        options = default_options.merge(options)
+        builder = new(name, persister_class, options)
+        builder.construct_data
+
+        yield(builder) if block_given?
+
+        builder
+      end
+
+      # @see prepare_data()
+      def initialize(name, persister_class, options = self.class.default_options)
+        @name = name
+        @persister_class = persister_class
+
+        @properties = {}
+        @inventory_object_attributes = []
+        @default_values = {}
+        @dependency_attributes = {}
+
+        @options = options
+        skip_auto_inventory_attributes(false) if @options[:auto_inventory_attributes].nil?
+        skip_model_class(false) if @options[:without_model_class].nil?
+
+        @shared_properties = options[:shared_properties] # From persister
+      end
+
+      # Builds data for InventoryCollection
+      # Calls method @name (if exists) with specific properties
+      # Yields for overwriting provider-specific properties
+      def construct_data
+        add_properties({:association => @name}, :if_missing)
+
+        add_properties(@shared_properties, :if_missing)
+
+        send(@name.to_sym) if @name.respond_to?(:to_sym) && respond_to?(@name.to_sym)
+
+        if @properties[:model_class].nil?
+          add_properties(:model_class => auto_model_class) unless @options[:without_model_class]
+        end
+      end
+
+      # Creates InventoryCollection
+      def to_inventory_collection
+        if @properties[:model_class].nil? && !@options[:without_model_class]
+          raise MissingModelClassError, "Missing model_class for :#{@name} (\"#{@name.to_s.classify}\" or subclass expected)."
+        end
+
+        ::InventoryRefresh::InventoryCollection.new(to_hash)
+      end
+
+      #
+      # Missing method
+      #   - add_some_property(value)
+      # converted to:
+      #   - add_properties(:some_property => value)
+      #
+      def method_missing(method_name, *arguments, &block)
+        if method_name.to_s.starts_with?('add_')
+          add_properties(
+            method_name.to_s.gsub('add_', '').to_sym => arguments[0]
+          )
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        method_name.to_s.starts_with?('add_')
+      end
+
+      # Merges @properties
+      # @see ManagerRefresh::InventoryCollection.initialize for list of properties
+      #
+      # @param props [Hash]
+      # @param mode [Symbol] :overwrite | :if_missing
+      def add_properties(props = {}, mode = :overwrite)
+        props.each_key { |property_name| assert_allowed_property(property_name) }
+
+        @properties = merge_hashes(@properties, props, mode)
+      end
+
+      # Adds inventory object attributes (part of @properties)
+      def add_inventory_attributes(array)
+        @inventory_object_attributes += (array || [])
+      end
+
+      # Removes specified inventory object attributes
+      def remove_inventory_attributes(array)
+        @inventory_object_attributes -= (array || [])
+      end
+
+      # Clears all inventory object attributes
+      def clear_inventory_attributes!
+        @options[:auto_inventory_attributes] = false
+        @inventory_object_attributes = []
+      end
+
+      # Adds key/values to default values (InventoryCollection.default_values) (part of @properties)
+      def add_default_values(params = {}, mode = :overwrite)
+        @default_values = merge_hashes(@default_values, params, mode)
+      end
+
+      # Evaluates lambda blocks
+      def evaluate_lambdas!(persister)
+        @default_values = evaluate_lambdas_on(@default_values, persister)
+        @dependency_attributes = evaluate_lambdas_on(@dependency_attributes, persister)
+      end
+
+      # Adds key/values to dependency_attributes (part of @properties)
+      def add_dependency_attributes(attrs = {}, mode = :overwrite)
+        @dependency_attributes = merge_hashes(@dependency_attributes, attrs, mode)
+      end
+
+      # Deletes key from dependency_attributes
+      def remove_dependency_attributes(key)
+        @dependency_attributes.delete(key)
+      end
+
+      # Returns whole InventoryCollection properties
+      def to_hash
+        add_inventory_attributes(auto_inventory_attributes) if @options[:auto_inventory_attributes]
+
+        @properties[:inventory_object_attributes] ||= @inventory_object_attributes
+
+        @properties[:default_values] ||= {}
+        @properties[:default_values].merge!(@default_values)
+
+        @properties[:dependency_attributes] ||= {}
+        @properties[:dependency_attributes].merge!(@dependency_attributes)
+
+        @properties
+      end
+
+      protected
+
+      def assert_allowed_property(name)
+        unless allowed_properties.include?(name)
+          raise "InventoryCollection property :#{name} is not allowed. Allowed properties are:\n#{self.allowed_properties.to_a.map(&:to_s).join(', ')}"
+        end
+      end
+
+      # Extends source hash with
+      # - a) all keys from dest (overwrite mode)
+      # - b) missing keys (missing mode)
+      #
+      # @param mode [Symbol] :overwrite | :if_missing
+      def merge_hashes(source, dest, mode)
+        return source if source.nil? || dest.nil?
+
+        if mode == :overwrite
+          source.merge(dest)
+        else
+          dest.merge(source)
+        end
+      end
+
+      # Derives model_class from @name
+      # Can be disabled by options :without_model_class => true
+      # @return [Class | nil] when class doesn't exist, returns nil
+      def auto_model_class
+        "::#{@name.to_s.classify}".safe_constantize
+      end
+
+      # Enables/disables auto_model_class and exception check
+      # @param skip [Boolean]
+      def skip_model_class(skip = true)
+        @options[:without_model_class] = skip
+      end
+
+      # Inventory object attributes are derived from setters
+      #
+      # Can be disabled by options :auto_inventory_attributes => false
+      #   - attributes can be manually set via method add_inventory_attributes()
+      def auto_inventory_attributes
+        return if @properties[:model_class].nil?
+
+        (@properties[:model_class].new.methods - ar_base_class.methods).grep(/^[\w]+?\=$/).collect do |setter|
+          setter.to_s[0..setter.length - 2].to_sym
+        end
+      end
+
+      # used for ignoring unrelated auto_inventory_attributes
+      def ar_base_class
+        ActiveRecord::Base
+      end
+
+      # Enables/disables auto_inventory_attributes
+      # @param skip [Boolean]
+      def skip_auto_inventory_attributes(skip = true)
+        @options[:auto_inventory_attributes] = !skip
+      end
+
+      # Evaluates lambda blocks in @default_values and @dependency_attributes
+      # @param values [Hash]
+      # @param persister [ManageIQ::Providers::Inventory::Persister]
+      def evaluate_lambdas_on(values, persister)
+        values&.transform_values do |value|
+          if value.respond_to?(:call)
+            value.call(persister)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/inventory_refresh/inventory_collection/graph.rb

@@ -52,26 +52,11 @@ module InventoryRefresh
         # depth 10. We should throw a warning maybe asking for simplifying the interconnections in the models.
         assert_graph!(edges)
 
-        self.nodes = sort_nodes(nodes)
-
         self
       end
 
       private
 
-      # Sort the nodes putting child nodes as last. Child nodes are InventoryCollection objects having
-      # :parent_inventory_collections definition.
-      #
-      # @param nodes [Array<InventoryRefresh::InventoryCollection>] List of Inventory collection nodes
-      # @return [Array<InventoryRefresh::InventoryCollection>] Sorted list of Inventory collection nodes
-      def sort_nodes(nodes)
-        # Separate to root nodes and child nodes, where child nodes are determined by having parent_inventory_collections
-        root_nodes, child_nodes = nodes.partition { |node| node.parent_inventory_collections.blank? }
-        # And order it that root nodes comes first, that way the disconnect of the child nodes should be always done as
-        # a part of the root nodes, as intended.
-        root_nodes + child_nodes
-      end
-
       # Asserts all nodes are of class ::InventoryRefresh::InventoryCollection
       #
       # @param inventory_collections [Array<InventoryRefresh::InventoryCollection>] List of Inventory collection nodes

data/lib/inventory_refresh/inventory_collection/helpers/associations_helper.rb

@@ -0,0 +1,80 @@
+require_relative "../helpers"
+
+module InventoryRefresh
+  class InventoryCollection
+    module Helpers
+      module AssociationsHelper
+        # @return [Array<ActiveRecord::Reflection::BelongsToReflection">] All belongs_to associations
+        def belongs_to_associations
+          model_class.reflect_on_all_associations.select { |x| x.kind_of?(ActiveRecord::Reflection::BelongsToReflection) }
+        end
+
+        # @return [Hash{Symbol => String}] Hash with association name mapped to foreign key column name
+        def association_to_foreign_key_mapping
+          return {} unless model_class
+
+          @association_to_foreign_key_mapping ||= belongs_to_associations.each_with_object({}) do |x, obj|
+            obj[x.name] = x.foreign_key
+          end
+        end
+
+        # @return [Hash{String => Hash}] Hash with foreign_key column name mapped to association name
+        def foreign_key_to_association_mapping
+          return {} unless model_class
+
+          @foreign_key_to_association_mapping ||= belongs_to_associations.each_with_object({}) do |x, obj|
+            obj[x.foreign_key] = x.name
+          end
+        end
+
+        # @return [Hash{Symbol => String}] Hash with association name mapped to polymorphic foreign key type column name
+        def association_to_foreign_type_mapping
+          return {} unless model_class
+
+          @association_to_foreign_type_mapping ||= model_class.reflect_on_all_associations.each_with_object({}) do |x, obj|
+            obj[x.name] = x.foreign_type if x.polymorphic?
+          end
+        end
+
+        # @return [Hash{Symbol => String}] Hash with polymorphic foreign key type column name mapped to association name
+        def foreign_type_to_association_mapping
+          return {} unless model_class
+
+          @foreign_type_to_association_mapping ||= model_class.reflect_on_all_associations.each_with_object({}) do |x, obj|
+            obj[x.foreign_type] = x.name if x.polymorphic?
+          end
+        end
+
+        # @return [Hash{Symbol => String}] Hash with association name mapped to base class of the association
+        def association_to_base_class_mapping
+          return {} unless model_class
+
+          @association_to_base_class_mapping ||= model_class.reflect_on_all_associations.each_with_object({}) do |x, obj|
+            obj[x.name] = x.klass.base_class.name unless x.polymorphic?
+          end
+        end
+
+        # @return [Array<Symbol>] List of all column names that are foreign keys
+        def foreign_keys
+          return [] unless model_class
+
+          @foreign_keys_cache ||= belongs_to_associations.map(&:foreign_key).map!(&:to_sym)
+        end
+
+        # @return [Array<Symbol>] List of all column names that are foreign keys and cannot removed, otherwise we couldn't
+        #         save the record
+        def fixed_foreign_keys
+          # Foreign keys that are part of a manager_ref must be present, otherwise the record would get lost. This is a
+          # minimum check we can do to not break a referential integrity.
+          return @fixed_foreign_keys_cache unless @fixed_foreign_keys_cache.nil?
+
+          manager_ref_set = (manager_ref - manager_ref_allowed_nil)
+          @fixed_foreign_keys_cache = manager_ref_set.map { |x| association_to_foreign_key_mapping[x] }.compact
+          @fixed_foreign_keys_cache += foreign_keys & manager_ref
+          @fixed_foreign_keys_cache.map!(&:to_sym)
+          @fixed_foreign_keys_cache
+        end
+      end
+    end
+  end
+end