reform 2.2.4

data/lib/reform.rb

@@ -0,0 +1,8 @@
+module Reform
+end
+
+require "disposable"
+require "reform/contract"
+require "reform/form"
+require "reform/form/composition"
+require "reform/form/module"

data/lib/reform/contract.rb

@@ -0,0 +1,77 @@
+require "uber/inheritable_attr"
+
+module Reform
+  # Define your form structure and its validations. Instantiate it with a model,
+  # and then +validate+ this object graph.
+  class Contract < Disposable::Twin
+    require "disposable/twin/composition" # Expose.
+    include Expose
+
+    feature Setup
+    feature Setup::SkipSetter
+    feature Default
+
+    def self.default_nested_class
+      Contract
+    end
+
+    def self.property(name, options={}, &block)
+      if twin = options.delete(:form)
+        options[:twin] = twin
+      end
+
+      if validates_options = options[:validates]
+        validates name, validates_options
+      end
+
+      super
+    end
+
+    # FIXME: test me.
+    def self.properties(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each { |name| property(name, options.dup) }
+    end
+
+    require "reform/contract/errors"
+    require 'reform/contract/validate'
+    include Reform::Contract::Validate
+
+    require "reform/validation"
+    include Reform::Validation # ::validates and #valid?
+
+    # FIXME: this is only for #to_nested_hash, #sync shouldn't be part of Contract.
+    require "disposable/twin/sync"
+    include Disposable::Twin::Sync
+
+
+
+    # module ValidatesWarning
+    #   def validates(*)
+    #     raise "[Reform] Please include either Reform::Form::ActiveModel::Validations or Reform::Form::Lotus in your form class."
+    #   end
+    # end
+    # extend ValidatesWarning
+
+  private
+    # DISCUSS: separate file?
+    module Readonly
+      def readonly?(name)
+        options_for(name)[:writeable] == false
+      end
+      def options_for(name)
+       self.class.options_for(name)
+      end
+    end
+
+    def self.options_for(name)
+      definitions.get(name)
+    end
+    include Readonly
+
+
+    def self.clone # TODO: test. THIS IS ONLY FOR Trailblazer when contract gets cloned in suboperation.
+      Class.new(self)
+    end
+  end
+end

data/lib/reform/contract/errors.rb

@@ -0,0 +1,43 @@
+class Reform::Contract::Errors
+  def initialize(*)
+    @errors = {}
+  end
+
+  module Merge
+    def merge!(errors, prefix)
+      errors.messages.each do |field, msgs|
+        unless field.to_sym == :base
+          field = (prefix+[field]).join(".").to_sym # TODO: why is that a symbol in Rails?
+        end
+
+        msgs.each do |msg|
+          next if messages[field] and messages[field].include?(msg)
+          add(field, msg)
+        end # Forms now contains a plain errors hash. the errors for each item are still available in item.errors.
+      end
+    end
+
+    def to_s
+      messages.inspect
+    end
+  end
+  include Merge
+
+  def add(field, message)
+    @errors[field] ||= []
+    @errors[field] << message
+  end
+
+  def messages
+    @errors
+  end
+
+  def empty?
+    @errors.empty?
+  end
+
+  # needed by Rails form builder.
+  def [](name)
+    @errors[name] || []
+  end
+end

data/lib/reform/contract/validate.rb

@@ -0,0 +1,33 @@
+module Reform::Contract::Validate
+  def initialize(*)
+    super
+    @errors = build_errors
+  end
+
+  attr_reader :errors
+
+  def validate
+    validate!(errors, [])
+
+    errors.empty?
+  end
+
+  def validate!(errors, prefix)
+    validate_nested!(nested_errors = build_errors, prefix) # call valid? recursively and collect nested errors.
+
+    valid?  # calls AM/Lotus validators and invokes self.errors=.
+
+    errors.merge!(self.errors, prefix) # local errors.
+    errors.merge!(nested_errors, [])
+  end
+
+private
+
+  # runs form.validate! on all nested forms
+  def validate_nested!(errors, prefixes)
+    schema.each(twin: true) do |dfn|
+      # recursively call valid? on nested form.
+      Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form| form.validate!(errors, prefixes+[dfn[:name]]) }
+    end
+  end
+end

data/lib/reform/form.rb

@@ -0,0 +1,94 @@
+module Reform
+  class Form < Contract
+    def self.default_nested_class
+      Form
+    end
+
+    require "reform/form/validate"
+    include Validate # override Contract#validate with additional behaviour.
+
+    require "reform/form/populator"
+
+    # called after populator: form.deserialize(params)
+    # as this only included in the typed pipeline, it's not applied for scalars.
+    Deserialize = ->(input, options) { input.deserialize(options[:fragment]) } # TODO: (result:, fragment:, **o) once we drop 2.0.
+
+    module Property
+      # Add macro logic, e.g. for :populator.
+      def property(name, options={}, &block)
+        definition = super # let representable sort out inheriting of properties, and so on.
+        definition.merge!(deserializer: {}) unless definition[:deserializer] # always keep :deserializer per property.
+
+        deserializer_options = definition[:deserializer]
+
+        # Populators
+        internal_populator = Populator::Sync.new(nil)
+        if block = definition[:populate_if_empty]
+          internal_populator = Populator::IfEmpty.new(block)
+        end
+        if block = definition[:populator] # populator wins over populate_if_empty when :inherit
+          internal_populator = Populator.new(block)
+        end
+        definition.merge!(internal_populator: internal_populator) unless options[:internal_populator]
+        external_populator = Populator::External.new
+
+        # always compute a parse_pipeline for each property of the deserializer and inject it via :parse_pipeline.
+        # first, let representable compute the pipeline functions by invoking #parse_functions.
+        if definition[:nested]
+          parse_pipeline = ->(input, options) do
+            functions = options[:binding].send(:parse_functions)
+            pipeline  = Representable::Pipeline[*functions] # Pipeline[StopOnExcluded, AssignName, ReadFragment, StopOnNotFound, OverwriteOnNil, Collect[#<Representable::Function::CreateObject:0xa6148ec>, #<Representable::Function::Decorate:0xa6148b0>, Deserialize], Set]
+
+            pipeline  = Representable::Pipeline::Insert.(pipeline, external_populator,            replace: Representable::CreateObject::Instance)
+            pipeline  = Representable::Pipeline::Insert.(pipeline, Representable::Decorate,       delete: true)
+            pipeline  = Representable::Pipeline::Insert.(pipeline, Deserialize,                   replace: Representable::Deserialize)
+            pipeline  = Representable::Pipeline::Insert.(pipeline, Representable::SetValue,       delete: true) # FIXME: only diff to options without :populator
+          end
+        else
+          parse_pipeline = ->(input, options) do
+            functions = options[:binding].send(:parse_functions)
+            pipeline  = Representable::Pipeline[*functions] # Pipeline[StopOnExcluded, AssignName, ReadFragment, StopOnNotFound, OverwriteOnNil, Collect[#<Representable::Function::CreateObject:0xa6148ec>, #<Representable::Function::Decorate:0xa6148b0>, Deserialize], Set]
+
+            # FIXME: this won't work with property :name, inherit: true (where there is a populator set already).
+            pipeline  = Representable::Pipeline::Insert.(pipeline, external_populator,            replace: Representable::SetValue) if definition[:populator] # FIXME: only diff to options without :populator
+            pipeline
+          end
+        end
+
+        deserializer_options[:parse_pipeline] ||= parse_pipeline
+
+        if proc = definition[:skip_if]
+          proc = Reform::Form::Validate::Skip::AllBlank.new if proc == :all_blank
+          deserializer_options.merge!(skip_parse: proc) # TODO: same with skip_parse ==> External
+        end
+
+
+        # per default, everything should be writeable for the deserializer (we're only writing on the form). however, allow turning it off.
+        deserializer_options.merge!(writeable: true) unless deserializer_options.has_key?(:writeable)
+
+        definition
+      end
+    end
+    extend Property
+
+    require "disposable/twin/changed"
+    feature Disposable::Twin::Changed
+
+    require "disposable/twin/sync"
+    feature Disposable::Twin::Sync
+    feature Disposable::Twin::Sync::SkipGetter
+
+    require "disposable/twin/save"
+    feature Disposable::Twin::Save
+
+    require "reform/form/prepopulate"
+    include Prepopulate
+
+    def skip!
+      Representable::Pipeline::Stop
+    end
+
+    require "reform/form/call"
+    include Call
+  end
+end

data/lib/reform/form/call.rb

@@ -0,0 +1,23 @@
+module Reform::Form::Call
+  def call(params, &block)
+    bool = validate(params, &block)
+
+    Result.new(bool, self)
+  end
+
+  # TODO: the result object might soon come from dry.
+  class Result < SimpleDelegator
+    def initialize(success, data)
+      @success = success
+      super(data)
+    end
+
+    def success?
+      @success
+    end
+
+    def failure?
+      ! @success
+    end
+  end
+end

data/lib/reform/form/coercion.rb

@@ -0,0 +1,3 @@
+require "disposable/twin/coercion"
+
+Reform::Form::Coercion = Disposable::Twin::Coercion

data/lib/reform/form/composition.rb

@@ -0,0 +1,34 @@
+require "disposable/twin/composition"
+
+module Reform::Form::Composition
+  # Automatically creates a Composition object for you when initializing the form.
+  def self.included(base)
+    base.class_eval do
+      # extend Reform::Form::ActiveModel::ClassMethods # ::model.
+      extend ClassMethods
+      include Disposable::Twin::Composition
+    end
+  end
+
+  module ClassMethods
+    # Same as ActiveModel::model but allows you to define the main model in the composition
+    # using +:on+.
+    #
+    # class CoverSongForm < Reform::Form
+    #   model :song, on: :cover_song
+    def model(main_model, options={})
+      super
+
+      composition_model = options[:on] || main_model
+
+      # FIXME: this should just delegate to :model as in FB, and the comp would take care of it internally.
+      [:persisted?, :to_key, :to_param].each do |method|
+        define_method method do
+          model[composition_model].send(method)
+        end
+      end
+
+      self
+    end
+  end
+end

data/lib/reform/form/dry.rb

@@ -0,0 +1,67 @@
+require "dry-validation"
+require "dry/validation/schema/form"
+require "reform/validation"
+
+module Reform::Form::Dry
+  def self.included(includer)
+    includer.send :include, Validations
+    includer.extend Validations::ClassMethods
+  end
+
+  module Validations
+    def build_errors
+      Reform::Contract::Errors.new(self)
+    end
+
+    module ClassMethods
+      def validation_group_class
+        Group
+      end
+    end
+
+    def self.included(includer)
+      includer.extend(ClassMethods)
+    end
+
+    class Group
+      def initialize
+        @schemas = []
+      end
+
+      def instance_exec(&block)
+        @schemas << block
+        @validator = Builder.new(@schemas.dup).validation_graph
+      end
+
+      def call(fields, reform_errors, form)
+        # a message item looks like: {:confirm_password=>["confirm_password size cannot be less than 2"]}
+        @validator.with(form: form).call(fields).messages.each do |field, dry_error|
+          dry_error.each do |attr_error|
+            reform_errors.add(field, attr_error)
+          end
+        end
+      end
+
+      class Builder < Array
+        def initialize(array)
+          super(array)
+          @validator = Dry::Validation.Form({}, &shift)
+        end
+
+        def validation_graph
+          build_graph(@validator)
+        end
+
+
+        private
+
+        def build_graph(validator)
+          if empty?
+            return validator
+          end
+          build_graph(Dry::Validation.Schema(validator, {}, &shift))
+        end
+      end
+    end
+  end
+end

data/lib/reform/form/module.rb

@@ -0,0 +1,27 @@
+# Include this in every module that gets further included.
+module Reform::Form::Module
+  # DISCUSS: could this be part of Declarative?
+  def self.included(base)
+    base.extend ClassMethods
+    base.extend Declarative::Heritage::DSL # ::heritage
+    # base.extend Declarative::Heritage::Included # ::included
+    base.extend Included
+  end
+
+  module Included
+    # Gets imported into your module and will be run when including it.
+    def included(includer)
+      super
+      # first, replay all declaratives like ::property on includer.
+      heritage.(includer) # this normally happens via Heritage::Included.
+      # then, include optional accessors.
+      includer.send(:include, self::InstanceMethods) if const_defined?(:InstanceMethods)
+    end
+  end
+
+  module ClassMethods
+    def method_missing(method, *args, &block)
+      heritage.record(method, *args, &block)
+    end
+  end
+end

data/lib/reform/form/mongoid.rb

@@ -0,0 +1,37 @@
+module Reform::Form::Mongoid
+  def self.included(base)
+    base.class_eval do
+      register_feature Reform::Form::Mongoid
+      include Reform::Form::ActiveModel
+      include Reform::Form::ORM
+      extend ClassMethods
+    end
+  end
+
+  module ClassMethods
+    def validates_uniqueness_of(attribute, options={})
+      options = options.merge(:attributes => [attribute])
+      validates_with(UniquenessValidator, options)
+    end
+    def i18n_scope
+      :mongoid
+    end
+  end
+
+
+  def self.mongoid_namespace
+    if mongoid_is_4_or_more?
+      'Validatable'
+    else
+      'Validations'
+    end
+  end
+
+  def self.mongoid_is_4_or_more?
+    Mongoid::VERSION.split('.').first.to_i >= 4
+  end
+
+  UniquenessValidator = Class.new("::Mongoid::#{mongoid_namespace}::UniquenessValidator".constantize) do
+    include Reform::Form::ORM::UniquenessValidator
+  end
+end