activemodel-interdependence 0.0.1

data/lib/interdependence/dependency_resolver/model.rb

@@ -0,0 +1,76 @@
+module Interdependence
+  module DependencyResolver
+    # resolver for model dependencies
+    #
+    class Model < Base
+      # @!parse include Virtus.model
+
+      CACHE = {}
+
+      # @!attribute [rw] dependency_class
+      # @!scope class
+      self.dependency_class = Dependency::Model
+
+      # Map for substituting names on dependency
+      #
+      # @return [Hash{Symbol=>Symbol}] [substitution map]
+      #
+      # @api private
+      #
+      attribute :substitutions, Hash, strict: true
+
+      # Resolve a dependency
+      #
+      # @param dependency [Dependency::Base] kind of dependency
+      #
+      # @return [Dependency::Model] dependency resolution
+      #
+      # @api private
+      #
+      def resolve_with(dependency)
+        validation_dependency(
+          substitutions.fetch(dependency.field_name),
+          dependency.validator_class,
+          dependency.options
+        )
+      end
+
+      private
+
+      # Determine if a dependency is resolvable
+      #
+      # @param dependency [Dependency::Base] dependency to resolve
+      #
+      # @return [true] if dependency is a proxy field
+      # @return [false] otherwise
+      #
+      # @api private
+      #
+      def resolvable?(dependency)
+        dependency.proxy_field?
+      end
+
+      # create a validation dependency or fetch from cache if already created
+      #
+      # @param field_name [Symbol] field name
+      # @param validator_kind [Class] validator of dependency
+      # @param options [Hash] options for validation
+      #
+      # @return [Dependency::Model] new or cached dependency
+      #
+      # @api private
+      #
+      def validation_dependency(field_name, validator_kind, options)
+        key = [field_name, validator_kind, options]
+
+        CACHE.fetch(key) do
+          CACHE[key] = dependency_class.new(
+            field: field_name,
+            validator_class: validator_kind,
+            options: options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/interdependence/dependency_resolver/validator.rb

@@ -0,0 +1,34 @@
+module Interdependence
+  module DependencyResolver
+    # resolver for validator dependencies
+    #
+    class Validator < DependencyResolver::Base
+      self.dependency_class = Dependency::Validator
+
+      # Replaces a resolvable dependency with {#new_dependency}
+      #
+      # @return [Dependency::Validator] {#new_dependency}
+      #
+      # @api private
+      #
+      def resolve_with(*)
+        new_dependency
+      end
+
+      private
+
+      # Can a validator dependency be resolved
+      #
+      # @param dependency [Types::Field, Types::UnsetField] dependency field
+      #
+      # @return [true] if dependency has not set a field and shares the same validator_class
+      # @return [false] otherwise
+      #
+      # @api private
+      #
+      def resolvable?(dependency)
+        dependency.unspecified_field? && dependency.validator_class.equal?(validator_class)
+      end
+    end
+  end
+end

data/lib/interdependence/dependency_set.rb

@@ -0,0 +1,15 @@
+module Interdependence
+  # Extension of Set that manages our dependencies
+  #
+  class DependencySet < Set
+    # Clone a DependencySet and its members
+    #
+    # @return [DependencySet] [clone]
+    #
+    # @api private
+    #
+    def clone
+      self.class.new(map(&:clone))
+    end
+  end
+end

data/lib/interdependence/dependency_set_graph.rb

@@ -0,0 +1,66 @@
+module Interdependence
+  # DependencySetGraph - extension of graph structure back by DependencySet
+  #
+  # - Extends our graph data structure
+  # - Overrides `#merge!` to merge both keys and set values
+  #
+  # @see Interdependence::Graph
+  #
+  # @example Merge
+  #
+  #     dep1 # => { a: #<DependencyGraphSet: {1,2}> }
+  #     dep2 # => { a: #<DependencyGraphSet: {2,3}> }
+  #     dep1.merge(dep2) # => { a: #<DependencyGraphSet: {1,2,3}> }
+  #
+  class DependencySetGraph < Graph
+    self.default_value_class = DependencySet
+
+    # clone a DependencySetGraph
+    #
+    # @return [DependencySetGraph] clone graph by cloning each set
+    #
+    # @api private
+    #
+    def clone
+      each_with_object(self.class.new) do |(parent, dependencies), clone|
+        clone[parent] = dependencies.clone
+      end
+    end
+
+    # Replace the owner of a certain set in the graph
+    #
+    # @param new_owner: [Dependency::Base] dependency key that will replace another
+    # @param &blk [#call] block used to detect owner to replace
+    #
+    # @return [self] self with new owner
+    #
+    # @api private
+    #
+    def change_owner(new_owner:, &blk)
+      old_owner = keys.detect(&blk)
+
+      tap do |graph|
+        graph[new_owner] = delete(old_owner) do
+          fail 'could not detect or delete key for replacement'
+        end
+      end
+    end
+
+    # Merge two dependency set graphs
+    #
+    # Passes a block to `Hash#merge!` then instructs how two sets
+    # from different dependency graphs should be joined
+    #
+    # @see `Hash#merge!`
+    #
+    # @return [DependencySetGraph] [merged dependency graph]
+    #
+    # @api private
+    #
+    def merge!(*args)
+      super do |_, dependencies, other_dependencies|
+        dependencies.merge(other_dependencies)
+      end
+    end
+  end
+end

data/lib/interdependence/graph.rb

@@ -0,0 +1,103 @@
+module Interdependence
+  # Graph data structure - Topologically sortable
+  #
+  # - Accessing any key will initialize that key to a new empty set.
+  # - Topologically sortable using `tsort`
+  #
+  # @example Usage
+  #
+  #     dependencies = Interdependence::Graph.new # => {}
+  #     dependencies['foo'] # => #<Set: {}>
+  #     dependencies['foo'] << 1 # => # => #<Set: {1}>
+  #
+  class Graph < Hash
+    include TSort
+
+    class_attribute :default_value_class, instance_writer: false
+    self.default_value_class = Set
+
+    # Create a new graph utilizing Hash#default_proc
+    #
+    # #default_proc usage initializes new keys to {#default_value}
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize
+      super do |hash, key|
+        hash[key] = default_value
+      end
+    end
+
+    # Register a new key in the graph
+    #
+    # The default_proc implementation initializes values for keys
+    # when they are first accessed. Sometimes we don't want to do anything
+    # beyond initializing a new key, but `graph[:key]` by itself does not
+    # do a good job of revealing intention, so we alias `#[]` so that
+    # `graph[:key]` can be written as `graph.register(:key)`
+    #
+    # @see {#initialize} to understand default_proc
+    #
+    # @return [{#default_value}] the default value of the current class
+    #
+    # @api private
+    #
+    alias_method :register, :[]
+
+    # Iterate over each key of the graph for TSort
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    alias_method :tsort_each_node, :each_key
+
+    # Iterate over each child in the graph for TSort
+    #
+    # @param node key to fetch
+    #
+    # @yield children of `node`
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def tsort_each_child(node, &block)
+      tsort_fetch(node).each(&block)
+    end
+
+    # Fetch a key for tsort and fallback to {#default_value}
+    #
+    # `tsort_fetch` returns a new {#default_value} like `#[]` when
+    # `key` is not found. The fallback value is not added to the graph
+    # though since we do not want to mutate the graph during iteration
+    #
+    # @param key key being looked up
+    #
+    # @see Hash#fetch
+    # @see default_value
+    #
+    # @return value stored at self.fetch(key) if key exists
+    # @return {#default_value} otherwise
+    #
+    # @api private
+    #
+    def tsort_fetch(key)
+      fetch(key) { default_value }
+    end
+
+    private
+
+    # New instance of {#default_value_class}
+    #
+    # @return [{#default_value_class}] instance of {#default_value_class}
+    #
+    # @api private
+    #
+    def default_value
+      default_value_class.new
+    end
+  end
+end

data/lib/interdependence/model.rb

@@ -0,0 +1,70 @@
+module Interdependence
+  # Mixin behavior for managing validators which specify
+  # that they depend on other validators.
+  #
+  module Model
+    extend CommonMixin
+
+    # Class methods mixed into any class that includes `ActiveModel::Model`
+    #
+    module ClassMethods
+      # Clone `validate_calls` on class inherited by class
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def inherited(base)
+        super
+
+        base.validate_calls = validate_calls.clone
+      end
+
+      # Update validators attached to the current model
+      #
+      # @see ActiveModel::Validations::ClassMethods#clear_validators!
+      #
+      # @return [Void]
+      #
+      # @api private
+      #
+      def update_validators(*)
+        clear_validators!
+        validate_calls.each do |args, _|
+          active_model_validate(*args)
+        end
+
+        dependency_chain.each do |validator|
+          active_model_validates_with(*validator.to_active_model)
+        end
+      end
+
+      # adds an observer that expects {#update_validators} to be called
+      #
+      # @see CommonMixin::ClassMethods#clear_dependencies
+      # @return [Void]
+      #
+      # @api private
+      #
+      def clear_dependencies!
+        super
+        dependencies.add_observer(self, :update_validators)
+      end
+
+      private
+
+      # Topologically sort our dependencies
+      #
+      # Memoizes sorted dependencies using the current dependency set
+      # as the key
+      #
+      # @return [Array] dependency chain
+      #
+      # @api private
+      #
+      def dependency_chain
+        dependencies.tsort
+      end
+    end
+  end
+end

data/lib/interdependence/model/validator.rb

@@ -0,0 +1,99 @@
+module Interdependence
+  module Model
+    # Validator wrapper for validators added to model classes
+    #
+    class Validator
+      include Virtus.model
+
+      # Model that owns this validator
+      #
+      # @return [Class] class that implements ActiveModel::Model
+      #
+      # @api private
+      #
+      attribute :model, Class
+
+      # Field of validator
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      attribute :field, Symbol
+
+      # Validator class
+      #
+      # @return [Class] [descendant of ActiveModel::Validator]
+      #
+      # @api private
+      #
+      attribute :validator_class, Class
+
+      # Validator options hash
+      #
+      # @return [Hash] options passed to validator
+      #
+      # @api private
+      #
+      attribute :options, Hash, default: {}
+
+      # Map for substituting names on validator
+      #
+      # @return [Hash{Symbol => Symbol}] [substitution map]
+      #
+      # @api private
+      #
+      attribute :substitutions, Hash[Symbol => Symbol], default: {}
+
+      # Generic setter to unify with {Model::Validator}
+      #
+      # @return [owner]
+      #
+      # @api private
+      #
+      alias_method :owner=, :model=
+
+      # Set validator options hash
+      #
+      # @param options [Hash] options passed to validator
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def options=(options)
+        self.substitutions = options.fetch(:dependencies, {})
+        super
+      end
+
+      # @!method dependencies
+      #   Dependencies from resolver
+      #
+      #   @return [ObservableDependencySetGraph] resolveddependencies
+      #
+      #   @api private
+      #
+      delegate :dependencies, to: :resolver
+
+      # Merge model dependencies with resolver dependencies
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def save
+        model.dependencies.merge!(dependencies)
+      end
+
+      # Memoized resolver
+      #
+      # @return [DependencyResolver::Model] resolver from instance attributes
+      #
+      # @api private
+      #
+      def resolver
+        @resolver ||= DependencyResolver::Model.new(self)
+      end
+    end
+  end
+end