activemodel-interdependence 0.0.1

data/config/rubocop.yml

@@ -0,0 +1 @@
+inherit_from: ../.rubocop.yml

data/config/yardstick.yml

@@ -0,0 +1,2 @@
+---
+threshold: 100

data/lib/activemodel/interdependence.rb

@@ -0,0 +1,12 @@
+require 'interdependence'
+require 'activemodel/model/interdependence'
+require 'activemodel/validator/interdependence'
+
+ActiveModel::Model.include(ActiveModel::Model::Interdependence)
+ActiveModel::Validator.extend(ActiveModel::Validator::Interdependence::ClassMethods)
+ActiveModel::EachValidator.extend(ActiveModel::Validator::Interdependence::ClassMethods)
+
+ActiveModel::Validations.constants.grep(/Validator\Z/).each do |name|
+  validator = ActiveModel::Validations.const_get(name)
+  validator.include(::Interdependence::Validator)
+end

data/lib/activemodel/model/interdependence.rb

@@ -0,0 +1,97 @@
+module ActiveModel
+  module Model
+    # Methods for monkey patching and extending ActiveModel::Model
+    #
+    module Interdependence
+      # Patch ActiveModel::Model directly
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.included(base)
+        super
+        base.extend(ActiveModel::Validations::ClassMethods)
+        base.singleton_class.prepend(ClassMethods)
+      end
+
+      # Extend ActiveModel::Model modules
+      #
+      module ClassMethods
+        include ::Interdependence::ActiveModel::ClassMethods
+
+        # handle ActiveModel::Model includes
+        #
+        # @example usage is the same as active model
+        #
+        #   class MyModel
+        #     include ActiveModel::Model
+        #     validates :foo, bar: true
+        #   end
+        #
+        # @return [undefined]
+        #
+        # @api semipublic
+        #
+        def included(base)
+          super
+          base.include(::Interdependence::Model)
+        end
+
+        # Expose {#validates_with}'s supermethod
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def active_model_validates_with(*args)
+          super_method(:validates_with, *args)
+        end
+
+        # Expose {#validate}'s supermethod
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def active_model_validate(*args)
+          super_method(:validate, *args)
+        end
+
+        private
+
+        # Call super of the specified method
+        #
+        # @example super_method usage
+        #   class Parent
+        #     def bar(val)
+        #       puts "parent! #{val}"
+        #     end
+        #   end
+        #
+        #   class Child < Parent
+        #     def bar(val)
+        #       puts "child! #{val}"
+        #     end
+        #
+        #     def cool
+        #       super_method(:bar, :hello)
+        #     end
+        #   end
+        #
+        #   Child.new.cool # => prints "parent! hello"
+        #
+        # @param name [Symbol] method name
+        # @param *args [Array] arguments passed to super method
+        #
+        # @return [return of super method]
+        #
+        # @api private
+        #
+        def super_method(name, *args)
+          method(name).super_method.call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/activemodel/validator/interdependence.rb

@@ -0,0 +1,107 @@
+module ActiveModel
+  class Validator
+    # Methods for monkey patching and extending ActiveModel::Validator
+    #
+    module Interdependence
+      ACTIVE_MODEL_VALIDATORS = ActiveModel::EachValidator.descendants.select do |validator|
+        validator.name =~ /\AActiveModel::Validations::/
+      end
+
+      # Methods extracted from ActiveModel::Validations::ClassMethods
+      # that allow us to define validators on other validators
+      #
+      module CherryPickedClassMethods
+        CHERRY_PICK_METHODS = %i(
+          validates
+          validates!
+          _validates_default_keys
+          _parse_validates_options
+        )
+
+        # Cherry pick methods from ActiveModel::Validations so that
+        # validations can be registered on validators
+        CHERRY_PICK_METHODS.each do |method|
+          define_method(method) do |*args|
+            ActiveModel::Validations::ClassMethods
+              .instance_method(method)
+              .bind(self)
+              .call(*args)
+          end
+        end
+      end
+
+      # Methods to extend ActiveModel::Validator
+      #
+      module ClassMethods
+        include ::Interdependence::ActiveModel::ClassMethods
+        include CherryPickedClassMethods
+
+        # Handle an ActiveModel validator inheritance
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def inherited(base)
+          super
+          return if base == EachValidator
+          base.include(::Interdependence::Validator)
+        end
+
+        # Rewrite validator kinds before ActiveModel receives it
+        #
+        # Since we pluck the methods from ActiveModel, the inflection
+        # done in the method (`"#{key.to_s.camelize}Validator"`) does not
+        # resolve like it would in the `ActiveModel` namespace.
+        #
+        # @see http://git.io/vYp2k ActiveModel::Validations::ClassMethods#validates
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def validates(*args, &blk)
+          options = args.extract_options!
+          new_options = options.each.with_object({}) do |(key, value), memo|
+            key = ensure_namespace(key) if key.is_a?(String) || key.is_a?(Symbol)
+
+            memo[key] = value
+          end
+
+          super(*args, new_options, &blk)
+        end
+
+        private
+
+        # Rewrite the namespace ActiveModel validator symbols
+        #
+        # @example when kind is from active_model
+        #   ensure_namespace(:presence) # => :"active_model/validations/:presence"
+        #
+        # @example otherwise
+        #   ensure_namespace(:custom) # => :custom
+        #
+        # @param arg [Symbol] kind
+        #
+        # @return [Symbol] rewritten kind
+        #
+        # @api private
+        #
+        def ensure_namespace(arg)
+          return arg unless active_model_validator_keys.include?(arg.to_sym)
+          :"active_model/validations/#{arg}"
+        end
+
+        # Symbol names from ActiveModel
+        #
+        # @return [Array<Symbol>] array of symbol kinds
+        #
+        # @api private
+        #
+        def active_model_validator_keys
+          @active_model_validator_keys ||= ACTIVE_MODEL_VALIDATORS.map(&:kind)
+        end
+      end
+    end
+  end
+end

data/lib/interdependence.rb

@@ -0,0 +1,87 @@
+require 'tsort'
+require 'set'
+require 'observer'
+
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_model'
+require 'virtus'
+require 'abstract_type'
+require 'adamantium'
+
+require 'interdependence/activemodel/validates_with'
+require 'interdependence/activemodel/class_methods'
+
+require 'interdependence/dependency_set'
+require 'interdependence/graph'
+require 'interdependence/dependency_set_graph'
+require 'interdependence/observable_dependency_set_graph'
+require 'interdependence/common_mixin'
+require 'interdependence/types'
+require 'interdependence/dependency/base'
+require 'interdependence/dependency/validator'
+require 'interdependence/dependency/model'
+require 'interdependence/model/validator'
+require 'interdependence/validator/validator'
+require 'interdependence/dependency_resolver/base'
+require 'interdependence/dependency_resolver/model'
+require 'interdependence/dependency_resolver/validator'
+require 'interdependence/model'
+require 'interdependence/validator'
+
+# Specify that validations depend on the validation of other fields
+#
+# Lets classes that implement ActiveModel::Model or ActiveModel::Validator
+# specify that they are dependent on other fields being valid. These specifications
+# are translated into a dependency graph, sorted, and applied in order to a model.
+# As a result, fields are only validated once the fields that they depend on are
+# validated.
+#
+# @example usage
+#
+#   class DayValidator < ActiveModel::EachValidator
+#     validates :month_field, inclusion: 1..12
+#     validates :year_field, inclusion: 0..2015
+#
+#     def validate_each(record, attribute, value)
+#       month = dependency(record, :month_field)
+#       year = dependency(record, :year_field)
+#
+#       return if (1..Time.days_in_month(month, year)).cover?(value)
+#       record.errors[attribute] << "is not valid for the month #{Date::MONTHNAMES[month]}"
+#     end
+#
+#     def dependency(record, proxy_name)
+#       name = options.fetch(:dependencies, {}).fetch(proxy_name)
+#
+#       record.send(name)
+#     end
+#   end
+#
+#   class Birthday
+#     include ActiveModel::Model
+#     attr_accessor :day, :month, :year
+#
+#     validates :day, day: {
+#       dependencies: {
+#         month_field: :month,
+#         year_field: :year
+#       }
+#     }
+#   end
+#
+#   leap_day = Birthday.new(day: 29, month: 2, year: 2000)
+#   leap_day.valid? # => true
+#
+#   not_a_leap_day = Birthday.new(day: 29, month: 2, year: 1999)
+#   not_a_leap_day.valid? # => false
+#   not_a_leap_day.errors.full_messages # => ["Day is not valid for the February"]
+#
+#   bad_month = Birthday.new(day: 29, month: 0, year: 1999)
+#   bad_month.valid? # => false
+#   bad_month.errors.full_messages # => ["Month is not included in the list"]
+#
+# @api public
+#
+module Interdependence
+end

data/lib/interdependence/activemodel/class_methods.rb

@@ -0,0 +1,50 @@
+module Interdependence
+  module ActiveModel
+    # Class methods prepended to ActiveModel's class methods
+    #
+    # Prepends methods on ActiveModel::Model and defines the methods
+    # on ActiveModel::Validator
+    #
+    module ClassMethods
+      # Monkey patch of `ActiveModel::Validations::ClassMethods#validates_with`
+      #
+      # Catches ActiveModel `#validates_with` calls (and {#validates})
+      # and registers the validator with {Interdependence}. {Interdependence} separately
+      # registers the validator later on using the original AM validates_with method.
+      #
+      # @see http://git.io/vYpWh ActiveModel #validates_with
+      # @see ActiveModel::Validations::ClassMethods#validates
+      #
+      # @return [undefined]
+      #
+      # @api semipublic
+      #
+      def validates_with(*args)
+        with = ValidatesWith.new(*args)
+        super unless with.attributes?
+
+        with.each do |(attribute, validator), options|
+          add_interdependent_validator(attribute, validator, options)
+        end
+      end
+
+      # Monkey patch of {ActiveModel::Validations::ClassMethods#validate}
+      #
+      # Catches ActiveModel {#validate} calls and then passes
+      # the arguments along to super. We track validate calls so that
+      # our dependency management doesn't drop the validate calls when
+      # dependencies are changed. Should behave the same as the ActiveModel method
+      #
+      # @see http://git.io/vYp4L ActiveModel #validate
+      #
+      # @return [undefined]
+      #
+      # @api semipublic
+      #
+      def validate(*args, &blk)
+        validate_calls << [args, blk] if args.first.instance_of?(Symbol)
+        super
+      end
+    end
+  end
+end

data/lib/interdependence/activemodel/validates_with.rb

@@ -0,0 +1,128 @@
+module Interdependence
+  module ActiveModel
+    # Handler for `validates_with` method calls intended for ActiveModel
+    #
+    # Makes it easy to iterate over attributes, options, and validators.
+    #
+    # @example when given attributes
+    #   class FancyValidator < ActiveModel::EachValidator; end
+    #
+    #   with = ValidatesWith.new(
+    #     FancyValidator,
+    #     thing: :yes,
+    #     attributes: %i(foo bar)
+    #   )
+    #
+    #   with.attributes? # => true
+    #   >> with.each # => #<Enumerator: ...>
+    #
+    #   with.each.to_a # => [
+    #   #   [[:foo, FancyValidator], {:thing=>:yes}],
+    #   #   [[:bar, FancyValidator], {:thing=>:yes}]
+    #   # ]
+    #
+    # @example when no attributes
+    #   with = ValidatesWith.new(
+    #     FancyValidator,
+    #     thing: :yes,
+    #     attributes: []
+    #   )
+    #
+    #   >> with.attributes? # => false
+    #   >> with.each.to_a # => []
+    #
+    class ValidatesWith
+      # Handle arguments intended for {#validates_with}
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(*args)
+        @validators = args
+        @options = @validators.extract_options!
+      end
+
+      # Iterate over fields and validators
+      #
+      # @example usage
+      #   with = ValidatesWith.new(
+      #     PresenceValidator,
+      #     NumericalityValidator,
+      #     thing: :yes,
+      #     attributes: %i(foo bar)
+      #   )
+      #
+      #  with.each do |(attribute, validator), options|
+      #    puts [attribute, validator.kind, options].inspect
+      #  end
+      #
+      # #=> [:foo, :presence, {:thing=>:yes}]
+      # #=> [:foo, :numericality, {:thing=>:yes}]
+      # #=> [:bar, :presence, {:thing=>:yes}]
+      # #=> [:bar, :numericality, {:thing=>:yes}]
+      #
+      # @return [undefined]
+      #
+      # @api semipublic
+      #
+      def each(&blk)
+        attributes_with_validators
+          .each
+          .with_object(options, &blk)
+      end
+
+      # Any attributes present
+      #
+      # @return [boolean] if any attributes were given
+      #
+      # @api private
+      #
+      def attributes?
+        attributes.any?
+      end
+
+      private
+
+      # List of validator classes
+      #
+      # @return [Array<Class>] list of validators
+      #
+      # @api private
+      #
+      attr_reader :validators
+
+      # Options hash without attributes
+      #
+      # @return [Hash] options hash without attibutes
+      #
+      # @api private
+      #
+      def options
+        @options.except(:attributes)
+      end
+
+      # Fetch array of attributes from options passed in
+      #
+      # @return [Array] array of attributes
+      #
+      # @api private
+      #
+      def attributes
+        @options.fetch(:attributes, [])
+      end
+
+      # Zips up each validator with each attribute
+      #
+      # @return [Array<Array>] array of field, validator pairs
+      #
+      # @api private
+      #
+      def attributes_with_validators
+        attributes.flat_map do |attribute|
+          ([attribute] * validators.size).zip(validators)
+        end
+      end
+    end
+  end
+end