reform 2.2.4 → 2.3.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 851795d3f1959935496c4a582f24dffc6020b848
-  data.tar.gz: f62755eb2d9e6302a00790b703698149838474af
+  metadata.gz: 833e85f6efec80dfacc227371dfb5ec4fe5d1fdd
+  data.tar.gz: e084df9fc8f080155d3af4398a80c78347db5b78
 SHA512:
-  metadata.gz: 865c755aea555fedc28f61ae04a7903544ad637c621e656c68a64fc9f952b0a105906f4abc77571dce490099227224cd966c12ccc802b8ae7e830c0b27d108f3
-  data.tar.gz: a90c092125bd9f2a7db2a6092267ba3ac439c6d92bd3b2e657a50156128c4de5b8f28e3f62cc2eefc47b6a8f36b1e8d5f94e393f31ab115cf297a60210fc58c4
+  metadata.gz: dba35a83313b4f5a2cecde6d85800b19c83f5b55553d2600e448ca042f1a8429a85b26ff3d522aa95b308bc1fadba731bb7a550cbe81e3ebab02d4c2052a4de8
+  data.tar.gz: cac8a4bddbbbef87379fd823bcfccce351fb9a0af36448d36d092393abaebcabc5343cc1665a68652a570bc7e765593ae0c873912033166d870e729962bddf70

data/.travis.yml

@@ -1,11 +1,17 @@
 language: ruby
+cache: bundler
+bundler_args: --without benchmarks tools
 rvm:
-  - 2.2.3
-  - 2.0.0
-gemfile:
-  - gemfiles/Gemfile.disposable-0.3
-
+  - 2.1.10
+  - 2.2.5
+  - 2.3.1
+  - 2.4.0
 matrix:
   fast_finish: true
-before_install:
-  - gem install bundler
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/680e86d98056f2ae2fd7
+    on_success: change  # options: [always|never|change] default: always
+    on_failure: always  # options: [always|never|change] default: always
+    on_start: never     # options: [always|never|change] default: always

data/CHANGES.md

@@ -1,9 +1,31 @@
+## 3.0.0
+
+[* Removed `Reform::Contract` ?]
+[* Move Form#deserializer to Form::deserializer]
+
+## 2.3.0
+
+You can upgrade from 2.2.0 without worries.
+
+* Require Representable 3.0.0 and **removed Representable 2.4 deprecation code**.
+* Require Disposable 0.4.0 which fixes issues with `nil` field values, `sync {}` and dry-validation.
+* Fix boolean coercion.
+* Allow using `:populator` classes marked with `Uber::Callable`.
+* Introduce `parse: false` as a shortcut for `deserialzer: { writeable: false}`. Thanks to @pabloh for insisting on this handy change.
+* Memoize the deserializer instance on the class level via `::deserializer`. This saves the inferal of a deserializing representer and speeds up following calls by 130%.
+* Deprecated positional arguments for `validation :default, options: {}`. New API: `validation name: :default, **`.
+* Reform now maintains a generic `Dry::Schema` class for global schema configuration. Can be overridden via `::validation`.
+* When validating with dry-validation, we now pass a symbolized hash. We also replaced `Dry::Validation::Form` with `Schema` which won't coerce values where it shouldn't.
+* [private] `Group#call` API now is: `call(form, errors)`.
+* Removed `Form#valid?`.
+
+* In `:if` for validation groups, you now get a hash of result objects, not just true/false.
+
+
 ## 2.2.4
 
-* Always require `disposable` >= 0.4.1. 
-  
-  The only difference here is that `Form#sync`/`#save` with a block will include `nil` properties into the nested hash.
-* Remove `uber` dependency.
+* You can now use any object with `call` as a populator, no need to `include Uber::Callable` anymore. This is because we have only three types and don't need a `is_a?` or `respond_to?` check.
+* Use `declarative-option` and loosen `uber` dependency.
 
 ## 2.2.3
 

data/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+## How to contribute to Reform
+
+#### **Did you find a bug?**
+
+* **Ensure the bug was not already reported** by searching on GitHub under [Issues](https://github.com/trailblazer/reform/issues).
+
+* If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/trailblazer/reform/issues/new). Be sure to follow the issue template.
+
+#### **Did you write a patch that fixes a bug?**
+
+* Open a new GitHub pull request with the patch.
+
+* Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
+
+* All code in pull requests is assumed to be MIT licensed.  Do not submit a pull request if that isn't the case.
+
+#### **Do you intend to add a new feature or change an existing one?**
+
+* Suggest your change in the [Trailblazer Gitter Room](https://gitter.im/trailblazer/chat) and start writing code.
+
+* Do not open an issue on GitHub until you have collected positive feedback about the change. GitHub issues are primarily intended for bug reports and fixes.
+
+#### **Do you have questions using Reform?**
+
+* Ask any questions about how to use Reform in the [Trailblazer Gitter Room](https://gitter.im/trailblazer/chat). Github issues are restricted to bug reports and fixes.
+
+* GitHub Issues should not be used as a help forum and any such issues will be closed.
+
+#### **Do you want to contribute to the Reform documentation?**
+
+* Reform documentation is provided via the [Trailblazer site](http://trailblazer.to/gems/reform/) and not the repository readme. Please add your contributions to the [Trailblazer site repository](https://github.com/trailblazer/trailblazer.github.io)

data/Gemfile

@@ -2,18 +2,7 @@ source 'https://rubygems.org'
 
 gemspec
 
-
-# gem "representable", "2.4.0.rc5"
-# gem 'representable', path: "../representable"
-# # gem 'representable', github: "apotonick/representable"
-# gem "disposable", path: "../disposable"
-# gem "disposable", github: "apotonick/disposable"
-
-
-# gem "declarative", path: "../declarative"
-
 gem "minitest-line"
 gem 'byebug'
+# gem "disposable", path: "../disposable"
 
-# gem "uber", path: "../uber"
-gem "representable", ">= 3.0.1"

data/ISSUE_TEMPLATE.md

@@ -0,0 +1,25 @@
+Note: If you have a question about Reform, would like help using
+Reform, want to request a feature, or do anything else other than
+submit a bug report, please use the Trailblazer gitter channel.
+
+Note: Rails/ ActiveRecord/ ActiveModel support.
+As of Reform 2.2.0 all Rails/ Active-* code was moved to the [reform-rails](https://github.com/trailblazer/reform-rails) gem.
+Make sure you are contributing to the correct gem!
+
+### Complete Description of Issue
+
+
+### Steps to reproduce
+
+
+### Expected behavior
+Tell us what should happen
+
+### Actual behavior
+Tell us what happens instead
+
+### System configuration
+**Reform version**:
+
+### Full Backtrace of Exception (if any)
+

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2013 - 2014 Nick Sutterer
+Copyright (c) 2013 - 2016 Nick Sutterer
 
 MIT License
 

data/README.md

@@ -3,7 +3,7 @@
 [![Gitter Chat](https://badges.gitter.im/trailblazer/chat.svg)](https://gitter.im/trailblazer/chat)
 [![TRB Newsletter](https://img.shields.io/badge/TRB-newsletter-lightgrey.svg)](http://trailblazer.to/newsletter/)
 [![Build
-Status](https://travis-ci.org/apotonick/reform.svg)](https://travis-ci.org/apotonick/reform)
+Status](https://travis-ci.org/trailblazer/reform.svg)](https://travis-ci.org/trailblazer/reform)
 [![Gem Version](https://badge.fury.io/rb/reform.svg)](http://badge.fury.io/rb/reform)
 
 _Form objects decoupled from your models._
@@ -296,7 +296,7 @@ Put this in an initializer or on top of your script.
 Reform allows to map multiple models to one form. The [complete documentation](https://github.com/apotonick/disposable#composition) is here, however, this is how it works.
 
 ```ruby
-class AlbumTwin < Reform::Form
+class AlbumForm < Reform::Form
   include Composition
 
   property :id,    on: :album
@@ -328,7 +328,7 @@ By explicitely defining the form layout using `::property` there is no more need
 
 ## This is not Reform 1.x!
 
-Temporary note: This is the README and API for Reform 2. On the public API, only a few tiny things have changed. Here are the [Reform 1.2 docs](https://github.com/apotonick/reform/blob/v1.2.6/README.md).
+Temporary note: This is the README and API for Reform 2. On the public API, only a few tiny things have changed. Here are the [Reform 1.2 docs](https://github.com/trailblazer/reform/blob/v1.2.6/README.md).
 
 Anyway, please upgrade and _report problems_ and do not simply assume that we will magically find out what needs to get fixed. When in trouble, join us on [Gitter](https://gitter.im/trailblazer/chat).
 

data/lib/reform.rb

@@ -6,3 +6,4 @@ require "reform/contract"
 require "reform/form"
 require "reform/form/composition"
 require "reform/form/module"
+require "reform/errors" # TODO: remove in Reform 3.

data/lib/reform/contract.rb

@@ -27,13 +27,12 @@ module Reform
       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/result"
     require 'reform/contract/validate'
     include Reform::Contract::Validate
 
@@ -44,15 +43,6 @@ module Reform
     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

data/lib/reform/contract/validate.rb

@@ -1,33 +1,59 @@
-module Reform::Contract::Validate
-  def initialize(*)
-    super
-    @errors = build_errors
-  end
+class Reform::Contract < Disposable::Twin
+  module Validate
+    def initialize(*)
+      # this will be removed in Reform 3.0. we need this for the presenting form, form builders
+      # call the Form#errors method before validation.
+      super
+      @result = Result.new([])
+    end
 
-  attr_reader :errors
+    def validate
+      validate!(nil).success?
+    end
 
-  def validate
-    validate!(errors, [])
+    # The #errors method will be removed in Reform 2.4/3.0 core.
+    def errors(*args)
+      Result::Errors.new(@result, self)
+    end
 
-    errors.empty?
-  end
+    #:private:
+    # only used in tests so far. this will be the new API in #call, where you will get @result.
+    def to_result
+      @result
+    end
 
-  def validate!(errors, prefix)
-    validate_nested!(nested_errors = build_errors, prefix) # call valid? recursively and collect nested errors.
+    def validate!(name, pointers=[])
+      # run local validations. this could be nested schemas, too.
+      local_errors_by_group = Reform::Validation::Groups::Validate.(self.class.validation_groups, self).compact # TODO: discss compact
 
-    valid?  # calls AM/Lotus validators and invokes self.errors=.
+      # blindly add injected pointers. will be readable via #errors.
+      # also, add pointers from local errors here.
+      pointers_for_nested = pointers + local_errors_by_group.collect { |errs| Result::Pointer.new(errs, []) }.compact
 
-    errors.merge!(self.errors, prefix) # local errors.
-    errors.merge!(nested_errors, [])
-  end
+      nested_errors = validate_nested!(pointers_for_nested)
+
+      # Result: unified interface #success?, #messages, etc.
+      @result = Result.new(local_errors_by_group + pointers, nested_errors)
+    end
+
+  private
+
+    # Recursively call validate! on nested forms.
+    # A pointer keeps an entire result object (e.g. Dry result) and
+    # the relevant path to its fragment, e.g. <Dry::result{.....} path=songs,0>
+    def validate_nested!(pointers)
+      arr = []
+
+      schema.each(twin: true) do |dfn|
+        # on collections, this calls validate! on each item form.
+        Disposable::Twin::PropertyProcessor.new(dfn, self).() { |form, i|
+          nested_pointers = pointers.collect { |pointer| pointer.advance(dfn[:name].to_sym, i) }.compact # pointer contains fragment for us, so go deeper
 
-private
+          arr << form.validate!(dfn[:name], nested_pointers)
+        }
+      end
 
-  # 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]]) }
+      arr
     end
   end
-end
+end

data/lib/reform/errors.rb

@@ -0,0 +1,49 @@
+# Provides the old API for Rails and friends.
+# Note that this might become an optional "deprecation" gem in Reform 3.
+class Reform::Contract::Result::Errors
+  def initialize(result, form)
+    @result        = result # DISCUSS: we don't use this ATM?
+    @form          = form
+    @dotted_errors = {} # Reform does not endorse this style of error msgs.
+
+    DottedErrors.(@form, [], @dotted_errors)
+  end
+
+  # PROTOTYPING. THIS WILL GO TO A SEPARATE GEM IN REFORM 2.4/3.0.
+  DottedErrors = ->(form, prefix, hash) do
+    result = form.to_result
+    result.messages.collect { |k,v| hash[ [*prefix, k].join(".").to_sym] = v }
+
+    form.schema.each(twin: true) { |dfn|
+      Disposable::Twin::PropertyProcessor.new(dfn, form).() do |frm, i|
+        # DottedErrors.(form.send(dfn[:name])[i], [*prefix, dfn[:name], i], hash) and next if i
+        DottedErrors.(form.send(dfn[:name])[i], [*prefix, dfn[:name]], hash) and next if i
+        DottedErrors.(form.send(dfn[:name]), [*prefix, dfn[:name]], hash)
+      end
+    }
+  end
+
+  def messages(*args)
+    @dotted_errors
+  end
+
+  def full_messages
+		@dotted_errors.collect do |path, errors|
+			human_field = path.to_s.gsub(/([\.\_])+/, " ").gsub(/(\b\w)+/) { |s| s.capitalize }
+			errors.collect { |message| "#{human_field} #{message}" }
+		end.flatten
+  end
+
+  def [](name)
+  	@dotted_errors[name]
+  end
+
+  def size
+    messages.size
+  end
+end
+
+    # Ensure that we can return Active Record compliant full messages when using dry
+    # we only want unique messages in our array
+    #
+    # @full_errors.add()

data/lib/reform/form.rb

@@ -16,7 +16,22 @@ module Reform
     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.
+        # if composition and inherited we also need this setting
+        # to correctly inherit modules
+        if options.key?(:on) && options.key?(:inherit)
+          options[:_inherited] = options[:inherit]
+        end
+
+        if options.key?(:parse)
+          options[:deserializer] ||= {}
+          options[:deserializer][:writeable] = options.delete(:parse)
+        end
+
+        if options.key?(:writable)
+          options[:writeable] ||= options.delete(:writable)
+        end
+
+        definition = super # let disposable and declarative gems sort out inheriting of properties, and so on.
         definition.merge!(deserializer: {}) unless definition[:deserializer] # always keep :deserializer per property.
 
         deserializer_options = definition[:deserializer]
@@ -35,8 +50,8 @@ module Reform
         # 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)
+          parse_pipeline = ->(input, opts) do
+            functions = opts[: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)
@@ -45,8 +60,8 @@ module Reform
             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)
+          parse_pipeline = ->(input, opts) do
+            functions = opts[: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).

data/lib/reform/form/dry.rb

@@ -9,10 +9,6 @@ module Reform::Form::Dry
   end
 
   module Validations
-    def build_errors
-      Reform::Contract::Errors.new(self)
-    end
-
     module ClassMethods
       def validation_group_class
         Group
@@ -23,44 +19,76 @@ module Reform::Form::Dry
       includer.extend(ClassMethods)
     end
 
+
     class Group
-      def initialize
-        @schemas = []
+      def initialize(options = {})
+        options ||= {}
+        schema_class = options[:schema] || Dry::Validation::Schema
+        @validator = Dry::Validation.Schema(schema_class, build: false)
+
+        @schema_inject_params = options[:with] || {}
       end
 
       def instance_exec(&block)
-        @schemas << block
-        @validator = Builder.new(@schemas.dup).validation_graph
-      end
+        @validator = Dry::Validation.Schema(@validator, build: false, &block)
 
-      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)
+        # inject the keys into the configure block automatically
+        keys = @schema_inject_params.keys
+        @validator.class_eval do
+          configure do
+            keys.each { |k| option k }
           end
         end
       end
 
-      class Builder < Array
-        def initialize(array)
-          super(array)
-          @validator = Dry::Validation.Form({}, &shift)
-        end
+      def call(form)
+        dynamic_options = {}
+        dynamic_options[:form] = form if @schema_inject_params[:form]
+        inject_options  = @schema_inject_params.merge(dynamic_options)
 
-        def validation_graph
-          build_graph(@validator)
-        end
+        # TODO: only pass submitted values to Schema#call?
+        dry_result      = call_schema(inject_options, input_hash(form))
+        # dry_messages    = dry_result.messages
+
+        return dry_result
+        reform_errors   = Reform::Contract::Errors.new(dry_result) # TODO: dry should be merged here.
+      end
 
+    private
+      def call_schema(inject_options, input)
+        @validator.new(@validator.rules, inject_options).(input)
+      end
 
-        private
+      # if dry_error is a hash rather than an array then it contains
+      # the messages for a nested property
+      # these messages need to be added to the correct collection
+      # objects.
 
-        def build_graph(validator)
-          if empty?
-            return validator
-          end
-          build_graph(Dry::Validation.Schema(validator, {}, &shift))
-        end
+      # collections:
+      # {0=>{:name=>["must be filled"]}, 1=>{:name=>["must be filled"]}}
+
+      # Objects:
+      # {:name=>["must be filled"]}
+      # simply load up the object and attach the message to it
+
+      # we can't use to_nested_hash as it get's messed up by composition.
+      def input_hash(form)
+        hash = form.class.nested_hash_representer.new(form).to_hash
+        symbolize_hash(hash)
+      end
+
+      # dry-v needs symbolized keys
+      # TODO: Don't do this here... Representers??
+      def symbolize_hash(old_hash)
+        old_hash.each_with_object({}) { |(k, v), new_hash|
+          new_hash[k.to_sym] = if v.is_a?(Hash)
+                             symbolize_hash(v)
+                           elsif v.is_a?(Array)
+                             v.map{ |h| h.is_a?(Hash) ? symbolize_hash(h) : h }
+                           else
+                             v
+                           end
+        }
       end
     end
   end