reform 2.2.4

data/lib/reform/form/orm.rb

@@ -0,0 +1,26 @@
+module Reform::Form::ORM
+  def model_for_property(name)
+    return model unless is_a?(Reform::Form::Composition) # i am too lazy for proper inheritance. there should be a ActiveRecord::Composition that handles this.
+
+    model_name = options_for(name)[:on]
+    model[model_name]
+  end
+
+  module UniquenessValidator
+    # when calling validates it should create the Vali instance already and set @klass there! # TODO: fix this in AM.
+    def validate(form)
+      property = attributes.first
+
+      # here is the thing: why does AM::UniquenessValidator require a filled-out record to work properly? also, why do we need to set
+      # the class? it would be way easier to pass #validate a hash of attributes and get back an errors hash.
+      # the class for the finder could either be infered from the record or set in the validator instance itself in the call to ::validates.
+      record = form.model_for_property(property)
+      record.send("#{property}=", form.send(property))
+
+      @klass = record.class # this is usually done in the super-sucky #setup method.
+      super(record).tap do |res|
+        form.errors.add(property, record.errors.first.last) if record.errors.present?
+      end
+    end
+  end
+end

data/lib/reform/form/populator.rb

@@ -0,0 +1,123 @@
+# Implements the :populator option.
+#
+#  populator: -> (fragment:, model:, :binding)
+#  populator: -> (fragment:, collection:, index:, binding:)
+#
+# For collections, the entire collection and the currently deserialised index is passed in.
+class Reform::Form::Populator
+  def initialize(user_proc)
+    @user_proc = user_proc # the actual `populator: ->{}` block from the user, via ::property.
+    @value     = Declarative::Option(user_proc, instance_exec: true) # we can now process Callable, procs, :symbol.
+  end
+
+  def call(input, options)
+    model = get(options)
+    twin  = call!(options.merge(model: model, collection: model))
+
+    return twin if twin == Representable::Pipeline::Stop
+
+    # this kinda sucks. the proc may call self.composer = Artist.new, but there's no way we can
+    # return the twin instead of the model from the #composer= setter.
+    twin = get(options) unless options[:binding].array?
+
+    # we always need to return a twin/form here so we can call nested.deserialize().
+    handle_fail(twin, options)
+
+    twin
+  end
+
+private
+  def call!(options)
+    form = options[:represented]
+
+    deprecate_positional_args(form, @user_proc, options) do
+      @value.(form, options)
+    end
+  end
+
+  def handle_fail(twin, options)
+    raise "[Reform] Your :populator did not return a Reform::Form instance for `#{options[:binding].name}`." if options[:binding][:nested] && !twin.is_a?(Reform::Form)
+  end
+
+  def get(options)
+     Representable::GetValue.(nil, options)
+  end
+
+  def deprecate_positional_args(form, proc, options) # TODO: remove in 2.2.
+    arity = proc.is_a?(Symbol) ? form.method(proc).arity : proc.arity
+    return yield if arity == 1
+    warn "[Reform] Positional arguments for :populator and friends are deprecated. Please use ->(options) and enjoy the rest of your day. Learn more at http://trailblazerb.org/gems/reform/upgrading-guide.html#to-21"
+    args = []
+    args <<  options[:index] if  options[:index]
+    args << options[:representable_options]
+    form.instance_exec(options[:fragment], options[:model], *args, &proc)
+  end
+
+
+  class IfEmpty < self # Populator
+    def call!(options)
+      binding, twin, index, fragment = options[:binding], options[:model], options[:index], options[:fragment] # TODO: remove once we drop 2.0.
+      form = options[:represented]
+
+      if binding.array?
+        item = twin.original[index] and return item
+
+        new_index = [index, twin.count].min # prevents nil items with initially empty/smaller collections and :skip_if's.
+        # this means the fragment index and populated nested form index might be different.
+
+        twin.insert(new_index, run!(form, fragment, options)) # form.songs.insert(Song.new)
+      else
+        return if twin
+
+        form.send(binding.setter, run!(form, fragment, options)) # form.artist=(Artist.new)
+      end
+    end
+
+  private
+    def run!(form, fragment, options)
+      return @user_proc.new if @user_proc.is_a?(Class) # handle populate_if_empty: Class. this excludes using Callables, though.
+
+      deprecate_positional_args(form, @user_proc, options) do
+        @value.(form, options)
+      end
+    end
+
+    def deprecate_positional_args(form, proc, options) # TODO: remove in 2.2.
+      arity = proc.is_a?(Symbol) ? form.method(proc).arity : proc.arity
+      return yield if arity == 1
+      warn "[Reform] Positional arguments for :prepopulate and friends are deprecated. Please use ->(options) and enjoy the rest of your day. Learn more at http://trailblazerb.org/gems/reform/upgrading-guide.html#to-21"
+
+      @value.(form, options[:fragment], options[:user_options])
+    end
+
+  end
+
+  # Sync (default) blindly grabs the corresponding form twin and returns it. This might imply that nil is returned,
+  # and in turn #validate! is called on nil.
+  class Sync < self
+    def call!(options)
+      if options[:binding].array?
+        return options[:model][options[:index]]
+      else
+        options[:model]
+      end
+    end
+  end
+
+  # This function is added to the deserializer's pipeline.
+  #
+  # When deserializing, the representer will call this function and thereby delegate the
+  # entire population process to the form. The form's :internal_populator will run its
+  # :populator option function and return the new/existing form instance.
+  # The deserializing representer will then continue on that returned form.
+  #
+  # Goal of this indirection is to leave all population logic in the form, while the
+  # representer really just traverses an incoming document and dispatches business logic
+  # (which population is) to the form.
+  class External
+    def call(input, options)
+      options[:represented].class.definitions.
+        get(options[:binding][:name])[:internal_populator].(input, options)
+    end
+  end
+end

data/lib/reform/form/prepopulate.rb

@@ -0,0 +1,24 @@
+# prepopulate!(options)
+# prepopulator: ->(model, user_options)
+module Reform::Form::Prepopulate
+  def prepopulate!(options={})
+    prepopulate_local!(options)  # call #prepopulate! on local properties.
+    prepopulate_nested!(options) # THEN call #prepopulate! on nested forms.
+
+    self
+  end
+
+private
+  def prepopulate_local!(options)
+    schema.each do |dfn|
+      next unless block = dfn[:prepopulator]
+      Declarative::Option(block, instance_exec: true).(self, options)
+    end
+  end
+
+  def prepopulate_nested!(options)
+    schema.each(twin: true) do |dfn|
+      Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form| form.prepopulate!(options) }
+    end
+  end
+end

data/lib/reform/form/validate.rb

@@ -0,0 +1,60 @@
+# Mechanics for writing to forms in #validate.
+module Reform::Form::Validate
+  module Skip
+    class AllBlank
+      include Uber::Callable
+
+      def call(form, options)
+        params = options[:input]
+        # TODO: Schema should provide property names as plain list.
+        properties = options[:binding][:nested].definitions.collect { |dfn| dfn[:name] }
+
+        properties.each { |name| (!params[name].nil? && params[name] != "") and return false }
+        true # skip
+      end
+    end
+  end
+
+
+  def validate(params)
+    # allow an external deserializer.
+    block_given? ? yield(params) : deserialize(params)
+
+    super() # run the actual validation on self.
+  end
+
+  def deserialize(params)
+    params = deserialize!(params)
+    deserializer.new(self).from_hash(params)
+  end
+
+private
+  # Meant to return params processable by the representer. This is the hook for munching date fields, etc.
+  def deserialize!(params)
+    # NOTE: it is completely up to the form user how they want to deserialize (e.g. using an external JSON-API representer).
+      # use the deserializer as an external instance to operate on the Twin API,
+      # e.g. adding new items in collections using #<< etc.
+    # DISCUSS: using self here will call the form's setters like title= which might be overridden.
+    params
+  end
+
+  # Default deserializer for hash.
+  # This is input-specific, e.g. Hash, JSON, or XML.
+  def deserializer(source=self.class, options={}) # called on top-level, only, for now.
+    deserializer = Disposable::Rescheme.from(source,
+      {
+        include:          [Representable::Hash::AllowSymbols, Representable::Hash],
+        superclass:       Representable::Decorator,
+        definitions_from: lambda { |inline| inline.definitions },
+        options_from:     :deserializer,
+        exclude_options:  [:default, :populator] # Reform must not copy Disposable/Reform-only options that might confuse representable.
+      }.merge(options)
+    )
+
+    deserializer
+  end
+
+
+  class DeserializeError < RuntimeError
+  end
+end

data/lib/reform/mongoid.rb

@@ -0,0 +1,4 @@
+require 'reform/form/active_model'
+require 'reform/form/orm'
+require 'reform/form/mongoid'
+require 'reform/form/active_model/model_reflections' # only load this in AR context as simple_form currently is bound to AR.

data/lib/reform/validation.rb

@@ -0,0 +1,40 @@
+# Adds ::validates and friends, and #valid? to the object.
+# This is completely form-independent.
+module Reform::Validation
+  module ClassMethods
+    def validation_groups
+      @groups ||= Groups.new(validation_group_class) # TODO: inheritable_attr with Inheritable::Hash
+    end
+
+    # DSL.
+    def validation(name=:default, options={}, &block)
+      heritage.record(:validation, name, options, &block)
+
+      group = validation_groups.add(name, options)
+
+      group.instance_exec(&block)
+    end
+
+    def validates(*args, &block)
+      validation(:default, inherit: true) { validates *args, &block }
+    end
+
+    def validate(*args, &block)
+      validation(:default, inherit: true) { validate *args, &block }
+    end
+
+    def validates_with(*args, &block)
+      validation(:default, inherit: true) { validates_with *args, &block }
+    end
+  end
+
+  def self.included(includer)
+    includer.extend(ClassMethods)
+  end
+
+  def valid?
+    Groups::Result.new(self.class.validation_groups).(to_nested_hash, errors, self)
+  end
+end
+
+require "reform/validation/groups"

data/lib/reform/validation/groups.rb

@@ -0,0 +1,73 @@
+module Reform::Validation
+  # A Group is a set of native validations, targeting a validation backend (AM, Lotus, Dry).
+  # Group receives configuration via #validates and #validate and translates that to its
+  # internal backend.
+  #
+  # The #call method will run those validations on the provided objects.
+
+  # Set of Validation::Group objects.
+  # This implements adding, iterating, and finding groups, including "inheritance" and insertions.
+  class Groups < Array
+    def initialize(group_class)
+      @group_class = group_class
+    end
+
+    def add(name, options)
+      if options[:inherit]
+        return self[name] if self[name]
+      end
+
+      i = index_for(options)
+
+      self.insert(i, [name, group = @group_class.new, options]) # Group.new
+      group
+    end
+
+  private
+
+    def index_for(options)
+      return find_index { |el| el.first == options[:after] } + 1 if options[:after]
+      size # default index: append.
+    end
+
+    def [](name)
+      cfg = find { |cfg| cfg.first == name }
+      return unless cfg
+      cfg[1]
+    end
+
+
+    # Runs all validations groups according to their rules and returns result.
+    # Populates errors passed into #call.
+    class Result # DISCUSS: could be in Groups.
+      def initialize(groups)
+        @groups = groups
+      end
+
+      def call(fields, errors, form)
+        result = true
+        results = {}
+
+        @groups.each do |cfg|
+          name, group, options = cfg
+          depends_on = options[:if]
+
+          if evaluate_if(depends_on, results, form)
+            # puts "evaluating #{group.instance_variable_get(:@validator).instance_variable_get(:@checker).inspect}"
+            results[name] = group.(fields, errors, form).empty? # validate.
+          end
+
+          result &= errors.empty?
+        end
+
+        result
+      end
+
+      def evaluate_if(depends_on, results, form)
+        return true if depends_on.nil?
+        return results[depends_on] if depends_on.is_a?(Symbol)
+        form.instance_exec(results, &depends_on)
+      end
+    end
+  end
+end

data/lib/reform/version.rb

@@ -0,0 +1,3 @@
+module Reform
+  VERSION = "2.2.4"
+end

data/reform.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'reform/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "reform"
+  spec.version       = Reform::VERSION
+  spec.authors       = ["Nick Sutterer", "Garrett Heinlen"]
+  spec.email         = ["apotonick@gmail.com", "heinleng@gmail.com"]
+  spec.description   = %q{Form object decoupled from models.}
+  spec.summary       = %q{Form object decoupled from models with validation, population and presentation.}
+  spec.homepage      = "https://github.com/apotonick/reform"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency             "disposable",    ">= 0.4.1"
+  spec.add_dependency             "representable", ">= 2.4.0", "< 3.1.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "dry-types"
+  spec.add_development_dependency "multi_json"
+  spec.add_development_dependency "dry-validation", ">= 0.10.0"
+end

data/test/benchmarking.rb

@@ -0,0 +1,26 @@
+require 'reform'
+require 'ostruct'
+require 'benchmark'
+
+class BandForm < Reform::Form
+  property :name, validates: {presence: true}
+
+  collection :songs do
+    property :title, validates: {presence: true}
+  end
+end
+
+songs = 50.times.collect { OpenStruct.new(title: "Be Stag") }
+band = OpenStruct.new(name: "Teenage Bottlerock", songs: songs)
+
+songs_params = 50.times.collect { {title: "Commando"} }
+
+time = Benchmark.measure do
+  100.times.each do
+    form = BandForm.new(band)
+    form.validate("name" => "Ramones", "songs" => songs_params)
+    form.save
+  end
+end
+
+puts time

data/test/call_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class CallTest < Minitest::Spec
+  Song = Struct.new(:title)
+
+  class SongForm < Reform::Form
+    property :title
+
+    validation do
+      key(:title).required
+    end
+  end
+
+  let (:form) { SongForm.new(Song.new) }
+
+  it { form.(title: "True North").success?.must_equal true }
+  it { form.(title: "True North").failure?.must_equal false }
+  it { form.(title: "").success?.must_equal false }
+  it { form.(title: "").failure?.must_equal true }
+
+  it { form.(title: "True North").errors.messages.must_equal({}) }
+  it { form.(title: "").errors.messages.must_equal({:title=>["must be filled"]}) }
+end

data/test/changed_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+require 'reform/form/coercion'
+
+class ChangedTest < MiniTest::Spec
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  class AlbumForm < Reform::Form
+    property :name
+
+    collection :songs do
+      property :title
+
+      property :composer do
+        property :name
+      end
+    end
+  end
+
+  let (:song_with_composer) { Song.new("Resist Stance", nil, composer) }
+  let (:composer)           { Artist.new("Greg Graffin") }
+  let (:album)              { Album.new("The Dissent Of Man", [song_with_composer]) }
+
+  let (:form) { AlbumForm.new(album) }
+
+  # nothing changed after setup.
+  it do
+    form.changed?(:name).must_equal false
+    form.songs[0].changed?(:title).must_equal false
+    form.songs[0].composer.changed?(:name).must_equal false
+  end
+
+  # after validate, things might have changed.
+  it do
+    form.validate("name" => "Out Of Bounds", "songs" => [{"composer" => {"name" => "Ingemar Jansson & Mikael Danielsson"}}])
+    form.changed?(:name).must_equal true
+    form.songs[0].changed?(:title).must_equal false
+    form.songs[0].composer.changed?(:name).must_equal true
+  end
+end