reform 2.3.0.rc1 → 2.3.0.rc2

data/lib/reform/validation.rb

@@ -7,7 +7,7 @@ module Reform::Validation
     end
 
     # DSL.
-    def validation(name=nil, options={}, &block)
+    def validation(name = nil, options = {}, &block)
       options = deprecate_validation_positional_args(name, options)
       name    = options[:name] # TODO: remove in favor of kw args in 3.0.
 
@@ -20,19 +20,17 @@ module Reform::Validation
     def deprecate_validation_positional_args(name, options)
       if name.is_a?(Symbol)
         warn "[Reform] Form::validation API is now: validation(name: :default, if:nil, schema:Schema). Please use keyword arguments instead of positional arguments."
-        return { name: name }.merge(options)
+        return {name: name}.merge(options)
       end
 
-      if name.nil?
-        return { name: :default }.merge(options)
-      end
+      return {name: :default}.merge(options) if name.nil?
 
-      { name: :default }.merge(name)
+      {name: :default}.merge(name)
     end
 
     def validation_group_class
-      raise NoValidationLibraryError, 'no validation library loaded. Please include a ' +
-                            'validation library such as Reform::Form::Dry'
+      raise NoValidationLibraryError, "no validation library loaded. Please include a " +
+                                      "validation library such as Reform::Form::Dry"
     end
   end
 
@@ -40,6 +38,10 @@ module Reform::Validation
     includer.extend(ClassMethods)
   end
 
+  def valid?
+    validate({})
+  end
+
   NoValidationLibraryError = Class.new(RuntimeError)
 end
 

data/lib/reform/validation/groups.rb

@@ -23,7 +23,7 @@ module Reform::Validation
       group
     end
 
-  private
+    private
 
     def index_for(options)
       return find_index { |el| el.first == options[:after] } + 1 if options[:after]
@@ -36,7 +36,6 @@ module Reform::Validation
       cfg[1]
     end
 
-
     # Runs all validations groups according to their rules and returns all Result objects.
     class Validate
       def self.call(groups, form)
@@ -51,7 +50,7 @@ module Reform::Validation
 
       def self.evaluate?(depends_on, results, form)
         return true if depends_on.nil?
-        return results[depends_on].success? if depends_on.is_a?(Symbol)
+        return !results[depends_on].nil? && results[depends_on].success? if depends_on.is_a?(Symbol)
         form.instance_exec(results, &depends_on)
       end
     end

data/lib/reform/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "2.3.0.rc1"
+  VERSION = "2.3.0.rc2".freeze
 end

data/reform.gemspec

@@ -1,30 +1,31 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'reform/version'
+require "reform/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "reform"
   spec.version       = Reform::VERSION
   spec.authors       = ["Nick Sutterer", "Fran Worley"]
   spec.email         = ["apotonick@gmail.com", "frances@safetytoolbox.co.uk"]
-  spec.description   = %q{Form object decoupled from models.}
-  spec.summary       = %q{Form object decoupled from models with validation, population and presentation.}
+  spec.description   = "Form object decoupled from models."
+  spec.summary       = "Form object decoupled from models with validation, population and presentation."
   spec.homepage      = "https://github.com/trailblazer/reform"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  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.2", "< 0.5.0"
-  spec.add_dependency             "uber",           "< 0.2.0"
   spec.add_dependency             "representable",  ">= 2.4.0", "< 3.1.0"
+  spec.add_dependency             "uber",           "< 0.2.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 "minitest-line"
+  spec.add_development_dependency "byebug"
   spec.add_development_dependency "multi_json"
-  spec.add_development_dependency "dry-validation", ">= 0.10.1"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rubocop"
 end

data/test/benchmarking.rb

@@ -1,29 +1,29 @@
-require 'reform'
-require 'benchmark/ips'
+require "reform"
+require "benchmark/ips"
 require "reform/form/dry"
 
 class BandForm < Reform::Form
   feature Reform::Form::Dry
-  property :name#, validates: {presence: true}
+  property :name #, validates: {presence: true}
   collection :songs do
-    property :title#, validates: {presence: true}
+    property :title #, validates: {presence: true}
   end
 end
 
 class OptimizedBandForm < Reform::Form
   feature Reform::Form::Dry
-  property :name#, validates: {presence: true}
+  property :name #, validates: {presence: true}
   collection :songs do
-    property :title#, validates: {presence: true}
-  
+    property :title #, validates: {presence: true}
+
   	def deserializer(*args)
-      # DISCUSS: should we simply delegate to class and sort out memoizing there? 
+      # DISCUSS: should we simply delegate to class and sort out memoizing there?
       self.class.deserializer_class || self.class.deserializer_class = deserializer!(*args)
- 	end
+  	end
   end
 
   def deserializer(*args)
-    # DISCUSS: should we simply delegate to class and sort out memoizing there? 
+    # DISCUSS: should we simply delegate to class and sort out memoizing there?
     self.class.deserializer_class || self.class.deserializer_class = deserializer!(*args)
   end
 end
@@ -43,7 +43,6 @@ end
 
 exit
 
-
 songs = 50.times.collect { OpenStruct.new(title: "Be Stag") }
 band = OpenStruct.new(name: "Teenage Bottlerock", songs: songs)
 

data/test/call_new_api.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class CallTest < Minitest::Spec
+  Song = Struct.new(:title)
+
+  class SongForm < TestForm
+    property :title
+
+    validation do
+      params { required(:title).filled }
+    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/{call_test.rb → call_old_api.rb}

@@ -7,11 +7,11 @@ class CallTest < Minitest::Spec
     property :title
 
     validation do
-      key(:title).required
+      required(:title).filled
     end
   end
 
-  let (:form) { SongForm.new(Song.new) }
+  let(:form) { SongForm.new(Song.new) }
 
   it { form.(title: "True North").success?.must_equal true }
   it { form.(title: "True North").failure?.must_equal false }
@@ -19,5 +19,5 @@ class CallTest < Minitest::Spec
   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"]}) }
+  it { form.(title: "").errors.messages.must_equal(title: ["must be filled"]) }
 end

data/test/changed_test.rb

@@ -1,5 +1,5 @@
-require 'test_helper'
-require 'reform/form/coercion'
+require "test_helper"
+require "reform/form/coercion"
 
 class ChangedTest < MiniTest::Spec
   Song  = Struct.new(:title, :album, :composer)
@@ -18,11 +18,11 @@ class ChangedTest < MiniTest::Spec
     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(: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) }
+  let(:form) { AlbumForm.new(album) }
 
   # nothing changed after setup.
   it do
@@ -38,4 +38,4 @@ class ChangedTest < MiniTest::Spec
     form.songs[0].changed?(:title).must_equal false
     form.songs[0].composer.changed?(:name).must_equal true
   end
-end
+end

data/test/coercion_test.rb

@@ -1,21 +1,23 @@
 require "test_helper"
 require "reform/form/coercion"
+require "disposable/twin/property/hash"
 
 class CoercionTest < BaseTest
   class Irreversible
     def self.call(value)
-      value*2
+      value * 2
     end
   end
 
   class Form < TestForm
     feature Coercion
+    include Disposable::Twin::Property::Hash
 
-    property :released_at, type: Types::Form::DateTime
+    property :released_at, type: DRY_TYPES_CONSTANT::DateTime
 
     property :hit do
-      property :length, type: Types::Form::Int
-      property :good,   type: Types::Form::Bool
+      property :length, type: DRY_TYPES_INT_CONSTANT
+      property :good,   type: DRY_TYPES_CONSTANT::Bool
     end
 
     property :band do
@@ -23,34 +25,51 @@ class CoercionTest < BaseTest
         property :value, type: Irreversible
       end
     end
+
+    property :metadata, field: :hash do
+      property :publication_settings do
+        property :featured, type: DRY_TYPES_CONSTANT::Bool
+      end
+    end
   end
 
   subject do
     Form.new(album)
   end
 
-  let (:album) {
+  let(:album) do
     OpenStruct.new(
-      :released_at => "31/03/1981",
-      :hit         => OpenStruct.new(:length => "312"),
-      :band        => Band.new(OpenStruct.new(:value => "9999.99"))
+      released_at: "31/03/1981",
+      hit: OpenStruct.new(length: "312"),
+      band: Band.new(OpenStruct.new(value: "9999.99")),
+      metadata: {}
     )
-  }
+  end
 
   # it { subject.released_at.must_be_kind_of DateTime }
   it { subject.released_at.must_equal "31/03/1981" } # NO coercion in setup.
   it { subject.hit.length.must_equal "312" }
   it { subject.band.label.value.must_equal "9999.99" }
 
-
-  let (:params) {
+  let(:params) do
     {
-      :released_at => "30/03/1981",
-      :hit         => {:length => "312"},
-      :band        => {:label => {:value => "9999.99"}}
+      released_at: "30/03/1981",
+      hit: {
+        length: "312",
+        good: "0",
+      },
+      band: {
+        label: {
+          value: "9999.99"
+        }
+      },
+      metadata: {
+        publication_settings: {
+          featured: "0"
+        }
+      }
     }
-  }
-
+  end
 
   # validate
   describe "#validate" do
@@ -58,9 +77,22 @@ class CoercionTest < BaseTest
 
     it { subject.released_at.must_equal DateTime.parse("30/03/1981") }
     it { subject.hit.length.must_equal 312 }
-    it { assert_nil subject.hit.good }
+    it { subject.hit.good.must_equal false }
     it { subject.band.label.value.must_equal "9999.999999.99" } # coercion happened once.
+    it { subject.metadata.publication_settings.featured.must_equal false }
   end
 
-  # save
+  # sync
+  describe "#sync" do
+    before do
+      subject.validate(params).must_equal true
+      subject.sync
+    end
+
+    it { album.released_at.must_equal DateTime.parse("30/03/1981") }
+    it { album.hit.length.must_equal 312 }
+    it { album.hit.good.must_equal false }
+    it { assert_nil album.metadata[:publication_settings] }
+    it { album.metadata["publication_settings"]["featured"].must_equal false }
+  end
 end

data/test/composition_new_api.rb

@@ -0,0 +1,186 @@
+require "test_helper"
+
+class FormCompositionInheritanceTest < MiniTest::Spec
+  module SizePrice
+    include Reform::Form::Module
+
+    property :price
+    property :size
+
+    module InstanceMethods
+      def price(for_size: size)
+        case for_size.to_sym
+          when :s then super() * 1
+          when :m then super() * 2
+          when :l then super() * 3
+        end
+      end
+    end
+  end
+
+  class OutfitForm < TestForm
+    include Reform::Form::Composition
+    include SizePrice
+
+    property :price,  inherit: true, on: :tshirt
+    property :size,   inherit: true, on: :measurement
+  end
+
+  let(:measurement) { Measurement.new(:l) }
+  let(:tshirt)      { Tshirt.new(2, :m) }
+  let(:form)        { OutfitForm.new(tshirt: tshirt, measurement: measurement) }
+
+  Tshirt = Struct.new(:price, :size)
+  Measurement = Struct.new(:size)
+
+  it { form.price.must_equal 6 }
+  it { form.price(for_size: :s).must_equal 2 }
+end
+
+class FormCompositionTest < MiniTest::Spec
+  Song      = Struct.new(:id, :title, :band)
+  Requester = Struct.new(:id, :name, :requester)
+  Band      = Struct.new(:title)
+
+  class RequestForm < TestForm
+    include Composition
+
+    property  :name,          on: :requester
+    property  :requester_id,  on: :requester, from: :id
+    properties :title, :id, on: :song
+    # property  :channel # FIXME: what about the "main model"?
+    property :channel, virtual: true, on: :song
+    property :requester,      on: :requester
+    property :captcha,        on: :song, virtual: true
+
+    validation do
+      params do
+        required(:name).filled
+        required(:title).filled
+      end
+    end
+
+    property :band, on: :song do
+      property :title
+    end
+  end
+
+  let(:form)       { RequestForm.new(song: song, requester: requester) }
+  let(:song)       { Song.new(1, "Rio", band) }
+  let(:requester)  { Requester.new(2, "Duran Duran", "MCP") }
+  let(:band)       { Band.new("Duran^2") }
+
+  # delegation form -> composition works
+  it { form.id.must_equal 1 }
+  it { form.title.must_equal "Rio" }
+  it { form.name.must_equal "Duran Duran" }
+  it { form.requester_id.must_equal 2 }
+  it { assert_nil form.channel }
+  it { form.requester.must_equal "MCP" } # same name as composed model.
+  it { assert_nil form.captcha }
+
+  # #model just returns <Composition>.
+  it { form.mapper.must_be_kind_of Disposable::Composition }
+
+  # #model[] -> composed models
+  it { form.model[:requester].must_equal requester }
+  it { form.model[:song].must_equal song }
+
+  it "creates Composition for you" do
+    form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb").must_equal true
+    form.validate("title" => "", "name" => "Frenzal Rhomb").must_equal false
+  end
+
+  describe "#save" do
+    # #save with {}
+    it do
+      hash = {}
+
+      form.save do |map|
+        hash[:name]   = form.name
+        hash[:title]  = form.title
+      end
+
+      hash.must_equal({name: "Duran Duran", title: "Rio"})
+    end
+
+    it "provides nested symbolized hash as second block argument" do
+      form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "channel" => "JJJ", "captcha" => "wonderful")
+
+      hash = nil
+
+      form.save do |map|
+        hash = map
+      end
+
+      hash.must_equal({
+                        song: {"title" => "Greyhound", "id" => 1, "channel" => "JJJ", "captcha" => "wonderful", "band" => {"title" => "Duran^2"}},
+                        requester: {"name" => "Frenzal Rhomb", "id" => 2, "requester" => "MCP"}
+                      }
+      )
+    end
+
+    it "xxx pushes data to models and calls #save when no block passed" do
+      song.extend(Saveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "captcha" => "1337")
+      form.captcha.must_equal "1337" # TODO: move to separate test.
+
+      form.save
+
+      requester.name.must_equal "Frenzal Rhomb"
+      requester.saved?.must_equal true
+      song.title.must_equal "Greyhound"
+      song.saved?.must_equal true
+      song.band.title.must_equal "Duran^2"
+      song.band.saved?.must_equal true
+    end
+
+    it "returns true when models all save successfully" do
+      song.extend(Saveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      form.save.must_equal true
+    end
+
+    it "returns false when one or more models don't save successfully" do
+      module Unsaveable
+        def save
+          false
+        end
+      end
+
+      song.extend(Unsaveable)
+      requester.extend(Saveable)
+      band.extend(Saveable)
+
+      form.save.must_equal false
+    end
+  end
+end
+
+class FormCompositionCollectionTest < MiniTest::Spec
+  Book = Struct.new(:id, :name)
+  Library = Struct.new(:id) do
+    def books
+      [Book.new(1, "My book")]
+    end
+  end
+
+  class LibraryForm < TestForm
+    include Reform::Form::Composition
+
+    collection :books, on: :library do
+      property :id
+      property :name
+    end
+  end
+
+  let(:form)   { LibraryForm.new(library: library) }
+  let(:library) { Library.new(2) }
+
+  it { form.save { |hash| hash.must_equal({library: {"books" => [{"id" => 1, "name" => "My book"}]}}) } }
+end