activemodel-interdependence 0.0.1

data/lib/interdependence/common_mixin.rb

@@ -0,0 +1,84 @@
+module Interdependence
+  # Mixin behavior for managing modules which specify
+  # that they depend on other validators.
+  #
+  module CommonMixin
+    # Extends {MixinMethods} when included
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.extended(base)
+      base.extend(MixinMethods)
+    end
+
+    # methods mixed into {Interdependence::Model} and {Interdependence::Validator}
+    #
+    module MixinMethods
+      # Extends ClassMethods, adds and clears `dependencies` class attributes
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def included(base)
+        base.extend(ClassMethods)
+        base.extend(self::ClassMethods)
+
+        base.class_attribute :dependencies, :validate_calls
+        base.validate_calls = []
+        base.clear_dependencies!
+      end
+    end
+
+    # Common class methods for {Interdependence::Model} and {Interdependence::Validator}
+    #
+    module ClassMethods
+      # Handle dependencies on inheritance
+      #
+      # resets depenencies on base and then merges in
+      # a clone of the parent dependencies
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def inherited(base)
+        super
+
+        base.clear_dependencies!
+        base.dependencies.merge!(dependencies.clone)
+      end
+
+      # Add validator and merge its dependencies
+      #
+      # @param field [Symbol] [name of field to validate]
+      # @param validator [Class] [descendant of ActiveModel::Validator]
+      # @param options [Hash,TrueClass] [ActiveModel::Validator options]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def add_interdependent_validator(field, validator, options)
+        self::Validator.new(
+          owner: self,
+          field: field,
+          validator_class: validator,
+          options: options
+        ).save
+      end
+
+      # Resets dependencies to a new {ObservableDependencySetGraph}
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def clear_dependencies!
+        self.dependencies = ObservableDependencySetGraph.new
+      end
+    end
+  end
+end

data/lib/interdependence/dependency/base.rb

@@ -0,0 +1,177 @@
+module Interdependence
+  module Dependency
+    # Base dependency wrapper class
+    #
+    class Base
+      include Adamantium
+      include Virtus.model
+
+      # @!method field
+      #   Field of dependency
+      #
+      #   @return [Field] [field wrapper]
+      #   @return [UnsetField] [unset field abstraction]
+      #
+      #   @api private
+      #
+      # @!method field=(field)
+      #   Set field of dependency
+      #
+      #   @param field [Symbol, nil] field name. nil becomes {Types::UnsetField}
+      #
+      #   @return [undefined]
+      #
+      #   @api private
+      #
+      attribute :field, Types::Field, coercer: Types::FieldCoercer
+
+      # @!method validator_class
+      #   Validator class of dependency (coerced with {Types::ValidatorClassCoercer})
+      #
+      #   @return [Class] [descendant of ActiveModel::Validator]
+      #
+      #   @api private
+      #
+      # @!method validator_class=(validator_class)
+      #   Set validator class
+      #
+      #   @param validator_class [Class] descendant of ActiveModel::Validator
+      #
+      #   @return [undefined]
+      #
+      #   @api private
+      #
+      attribute :validator_class, Class, coercer: Types::ValidatorClassCoercer, strict: true
+
+      # @!method options
+      #   Options for {#validator_class} (coerced with {Types::OptionsCoercer}). Memoized
+      #
+      #   @return [Hash] [options]
+      #
+      #   @api private
+      #
+      # @!method options=(options)
+      #   Set options
+      #
+      #   @param options [Hash, true, nil]
+      #     set options. true becomes {}. nil becomes {Types::UnsetOptions}
+      #
+      #   @return [undefined]
+      #
+      #   @api private
+      #
+      attribute :options, Hash, coercer: Types::OptionsCoercer
+
+      memoize :options
+
+      # Clone class
+      #
+      # @return [Dependency::Base] [clone]
+      #
+      # @api private
+      #
+      def clone
+        self.class.new(self)
+      end
+
+      # Make dependencies more readable
+      #
+      # @return [String] [inspection string]
+      #
+      # @api private
+      #
+      def inspect
+        inspect_field = unspecified_field? ? '*' : field.name.inspect
+
+        "\e[1;36m#<#{self.class} #{validator_class}(#{inspect_field}, #{options.inspect})>\e[0m"
+      end
+
+      # is {field} unset?
+      #
+      # @return [true] if field is a {UnsetField}
+      # @return [false] otherwise
+      #
+      # @api private
+      #
+      def unspecified_field?
+        field.instance_of?(Types::UnsetField)
+      end
+
+      # is {options} unset?
+      #
+      # @return [true] if field is a {UnsetOptions}
+      # @return [false] otherwise
+      #
+      # @api private
+      #
+      def unspecified_options?
+        options.instance_of?(Types::UnsetOptions)
+      end
+
+      # Is this instance the equivalent of `other` with unset attributes
+      #
+      # @param other [instance of same class]
+      #
+      # @return [true] if field and options are unset and other has the same {#validator_class}
+      # @return [true] if field is unset and other has the same options and {#validator_class}
+      # @return [false] otherwise
+      #
+      # @api private
+      #
+      def unset_equivalent_of?(other)
+        unspecified_field? &&
+          (unspecified_options? || options.eql?(other.options)) &&
+          validator_class.equal?(other.validator_class)
+      end
+
+      # Is the other instance equivalent to this instance
+      #
+      # @param other [instance of same class]
+      #
+      # @return [true] if descendant of {Base} with the same validator, field, and options
+      # @return [false] otherwise
+      #
+      # @api private
+      #
+      def ==(other)
+        other.is_a?(Base) &&
+          validator_class.equal?(other.validator_class) &&
+          field.eql?(other.field) &&
+          options.eql?(other.options)
+      end
+
+      # Cloned copy of {#validator_class}'s dependencies
+      #
+      # @return [ObservableDependencySetGraph] cloned dependencies
+      #
+      # @api private
+      #
+      def dependencies
+        validator_class.dependencies.clone
+      end
+      memoize :dependencies, freezer: :noop
+
+      alias_method :eql?, :==
+
+      # @!method field_name
+      #
+      #   Get name of field
+      #
+      #   @return [Symbol] [field name]
+      #
+      #   @api private
+      #
+      delegate :name, to: :field, prefix: true
+
+      # @!method field_name=
+      #
+      #   Set name of field
+      #
+      #   @return [undefined]
+      #
+      #   @api private
+      #
+      delegate :name=, to: :field, prefix: true
+    end
+  end
+end

data/lib/interdependence/dependency/model.rb

@@ -0,0 +1,61 @@
+module Interdependence
+  module Dependency
+    # Model dependency wrapper
+    #
+    class Model < Base
+      # Map for substituting names on dependency
+      #
+      # @return [Hash{Symbol => Symbol}] [substitution map]
+      #
+      # @api private
+      attribute :substitutions, Hash
+      memoize :substitutions
+
+      # Is class a proxy field?
+      #
+      # @return [false]
+      #
+      # @api private
+      #
+      def proxy_field?
+        false
+      end
+
+      # Dependencies clone with self replacing the unset equivalent dependency
+      #
+      # @return [ObservableDependencySetGraph] dependencies
+      #
+      # @api private
+      #
+      def dependencies
+        super.change_owner(new_owner: self) do |current_owner|
+          current_owner.unset_equivalent_of?(self)
+        end
+      end
+
+      # Formats dependency as parameters for ActiveModel::Model#validates
+      #
+      # @return [Array] active model parameters
+      #
+      # @api private
+      #
+      def to_active_model
+        [validator_class, active_model_options.merge(attributes: [field_name])]
+      end
+
+      private
+
+      # {#options} rewritten to include :if option dependent there being no errors
+      #
+      # @return [Hash] [adjusted options]
+      #
+      # @api private
+      #
+      def active_model_options
+        validator_if = Array.wrap(options[:if])
+        validator_if << proc { errors.empty? }
+        options.merge(if: validator_if)
+      end
+    end
+  end
+end

data/lib/interdependence/dependency/validator.rb

@@ -0,0 +1,43 @@
+module Interdependence
+  module Dependency
+    # Validator dependency wrapper
+    #
+    class Validator < Base
+      # @!method options=(options)
+      #   Set options
+      #
+      #   @param options [Hash, true, nil]
+      #     set options. true becomes {}. nil becomes {Types::UnsetOptions}
+      #     defaults to nil
+      #
+      #   @return [undefined]
+      #
+      #   @api private
+      #
+      attribute :options, Hash, coercer: Types::OptionsCoercer, default: nil
+
+      # add an observer to the validator's dependency graph
+      #
+      # @param observer [Class] observer
+      # @param method [Symbol] message to notify observer with
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def add_validator_observer(observer, method)
+        validator_class.dependencies.add_observer(observer, method)
+      end
+
+      # Is class a proxy field?
+      #
+      # @return [false]
+      #
+      # @api private
+      #
+      def proxy_field?
+        true
+      end
+    end
+  end
+end

data/lib/interdependence/dependency_resolver/base.rb

@@ -0,0 +1,114 @@
+module Interdependence
+  module DependencyResolver
+    # Base class that consolidates common functionality for dependency resolvers
+    #
+    class Base
+      include Adamantium
+      include Virtus.model
+
+      # Field name
+      #
+      # @return [Symbol] field name
+      #
+      # @api private
+      #
+      attribute :field, Symbol, strict: true
+
+      # Descendant of ActiveModel::Model
+      #
+      # @return [Class] class that includes activemodel
+      #
+      # @api private
+      #
+      attribute :validator_class, Class, coercer: Types::ValidatorClassCoercer, strict: true
+
+      # Options for validator
+      #
+      # @return [Hash] options hash
+      #
+      # @api private
+      #
+      attribute :options, Hash, strict: true
+
+      # @!attribute [w] dependency_class
+      #   Dependency class this resolver should use
+      #
+      #   @return [Class] specified dependency class
+      #
+      #   @!scope class
+      #   @api private
+      #
+      class_attribute :dependency_class, instance_writer: false
+
+      # {ObservableDependencySetGraph} resolved dependencies
+      #
+      # @return [ObservableDependencySetGraph] resolved dependencies
+      #
+      # @api private
+      #
+      def dependencies
+        dependency_graph_mapper.each do |(parent, children), graph|
+          new_parent, new_children = resolve_pair(parent, children)
+
+          graph[new_parent].replace(new_children)
+        end
+      end
+
+      # New dependency initialized with attributes of {self}
+      #
+      # @return [dependency_class] new dependency
+      #
+      # @api private
+      #
+      def new_dependency
+        dependency_class.new(self)
+      end
+      memoize :new_dependency
+
+      # Resolve a dependency if it is resolvable
+      #
+      # @param dependency [dependency_class] dependency to resolve
+      #
+      # @return [dependency_class] resolved dependency or input
+      #
+      # @api private
+      #
+      def resolve_dependency(dependency)
+        if resolvable?(dependency)
+          resolve_with(dependency)
+        else
+          dependency
+        end
+      end
+
+      # Resolve a parent-children pair
+      #
+      # @param parent [dependency_class] dependency owner
+      # @param children [Array<dependency_class>] dependencies of parent
+      #
+      # @return resolved parent-children pair
+      #
+      # @api private
+      #
+      def resolve_pair(parent, children)
+        parent = resolve_dependency(parent)
+        children = children.map { |child| resolve_dependency(child) }
+
+        [parent, children]
+      end
+
+      # Iterator for resolving dependencies
+      #
+      # @return [Enumerator] [description]
+      #
+      # @api private
+      #
+      def dependency_graph_mapper
+        new_dependency
+          .dependencies
+          .each
+          .with_object(ObservableDependencySetGraph.new)
+      end
+    end
+  end
+end