reform 2.3.0.rc1 → 2.5.0

data/lib/reform/version.rb

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

data/reform.gemspec

@@ -1,30 +1,30 @@
-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 "pry-byebug"
   spec.add_development_dependency "multi_json"
-  spec.add_development_dependency "dry-validation", ">= 0.10.1"
+  spec.add_development_dependency "rake"
 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_test.rb

@@ -7,17 +7,17 @@ class CallTest < Minitest::Spec
     property :title
 
     validation do
-      key(:title).required
+      params { 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 }
-  it { form.(title: "").success?.must_equal false }
-  it { form.(title: "").failure?.must_equal true }
+  it { assert form.(title: "True North").success? }
+  it { refute form.(title: "True North").failure? }
+  it { refute form.(title: "").success? }
+  it { assert form.(title: "").failure? }
 
-  it { form.(title: "True North").errors.messages.must_equal({}) }
-  it { form.(title: "").errors.messages.must_equal({:title=>["must be filled"]}) }
+  it { assert_equal form.(title: "True North").errors.messages, {} }
+  it { assert_equal form.(title: "").errors.messages, 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,24 +18,24 @@ 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
-    form.changed?(:name).must_equal false
-    form.songs[0].changed?(:title).must_equal false
-    form.songs[0].composer.changed?(:name).must_equal false
+    refute form.changed?(:name)
+    refute form.songs[0].changed?(:title)
+    refute form.songs[0].composer.changed?(:name)
   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
+    assert form.changed?(:name)
+    refute form.songs[0].changed?(:title)
+    assert form.songs[0].composer.changed?(:name)
   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: Types::Params::DateTime
 
     property :hit do
-      property :length, type: Types::Form::Int
-      property :good,   type: Types::Form::Bool
+      property :length, type: Types::Params::Integer
+      property :good,   type: Types::Params::Bool
     end
 
     property :band do
@@ -23,44 +25,74 @@ class CoercionTest < BaseTest
         property :value, type: Irreversible
       end
     end
+
+    property :metadata, field: :hash do
+      property :publication_settings do
+        property :featured, type: Types::Params::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" }
-
+  it { assert_equal subject.released_at, "31/03/1981" } # NO coercion in setup.
+  it { assert_equal subject.hit.length, "312" }
+  it { assert_equal subject.band.label.value, "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
     before { subject.validate(params) }
 
-    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.band.label.value.must_equal "9999.999999.99" } # coercion happened once.
+    it { assert_equal subject.released_at, DateTime.parse("30/03/1981") }
+    it { assert_equal subject.hit.length, 312 }
+    it { assert_equal subject.hit.good, false }
+    it { assert_equal subject.band.label.value, "9999.999999.99" } # coercion happened once.
+    it { assert_equal subject.metadata.publication_settings.featured, false }
   end
 
-  # save
+  # sync
+  describe "#sync" do
+    before do
+      assert subject.validate(params)
+      subject.sync
+    end
+
+    it { assert_equal album.released_at, DateTime.parse("30/03/1981") }
+    it { assert_equal album.hit.length, 312 }
+    it { assert_equal album.hit.good, false }
+    it { assert_nil album.metadata[:publication_settings] }
+    it { assert_equal album.metadata["publication_settings"]["featured"], false }
+  end
 end

data/test/composition_test.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require "test_helper"
 
 class FormCompositionInheritanceTest < MiniTest::Spec
   module SizePrice
@@ -26,16 +26,15 @@ class FormCompositionInheritanceTest < MiniTest::Spec
     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) }
+  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 }
+  it { assert_equal form.price, 6 }
+  it { assert_equal form.price(for_size: :s), 2 }
 end
 
 class FormCompositionTest < MiniTest::Spec
@@ -46,49 +45,50 @@ class FormCompositionTest < MiniTest::Spec
   class RequestForm < TestForm
     include Composition
 
-    property  :name,          :on =>  :requester
-    property  :requester_id,  :on => :requester, :from => :id
-    properties :title, :id, :on => :song
+    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
+    property :channel, virtual: true, on: :song
+    property :requester,      on: :requester
+    property :captcha,        on: :song, virtual: true
 
     validation do
-      required(:name).filled
-      required(:title).filled
+      params do
+        required(:name).filled
+        required(:title).filled
+      end
     end
 
-    property :band,           :on => :song do
+    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") }
+  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_equal form.id, 1 }
+  it { assert_equal form.title, "Rio" }
+  it { assert_equal form.name, "Duran Duran" }
+  it { assert_equal form.requester_id, 2 }
   it { assert_nil form.channel }
-  it { form.requester.must_equal "MCP" } # same name as composed model.
+  it { assert_equal form.requester, "MCP" } # same name as composed model.
   it { assert_nil form.captcha }
 
   # #model just returns <Composition>.
-  it { form.mapper.must_be_kind_of Disposable::Composition }
+  it { assert form.mapper.is_a? Disposable::Composition }
 
   # #model[] -> composed models
-  it { form.model[:requester].must_equal requester }
-  it { form.model[:song].must_equal song }
-
+  it { assert_equal form.model[:requester], requester }
+  it { assert_equal form.model[:song], 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
+    assert_equal form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb"), true
+    assert_equal form.validate("title" => "", "name" => "Frenzal Rhomb"), false
   end
 
   describe "#save" do
@@ -101,7 +101,7 @@ class FormCompositionTest < MiniTest::Spec
         hash[:title]  = form.title
       end
 
-      hash.must_equal({:name=>"Duran Duran", :title=>"Rio"})
+      assert_equal hash, name: "Duran Duran", title: "Rio"
     end
 
     it "provides nested symbolized hash as second block argument" do
@@ -113,11 +113,10 @@ class FormCompositionTest < MiniTest::Spec
         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"}
-        }
-      )
+      assert_equal hash, {
+        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
@@ -126,16 +125,16 @@ class FormCompositionTest < MiniTest::Spec
       band.extend(Saveable)
 
       form.validate("title" => "Greyhound", "name" => "Frenzal Rhomb", "captcha" => "1337")
-      form.captcha.must_equal "1337" # TODO: move to separate test.
+      assert_equal form.captcha, "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
+      assert_equal requester.name, "Frenzal Rhomb"
+      assert_equal requester.saved?, true
+      assert_equal song.title, "Greyhound"
+      assert_equal song.saved?, true
+      assert_equal song.band.title, "Duran^2"
+      assert_equal song.band.saved?, true
     end
 
     it "returns true when models all save successfully" do
@@ -143,7 +142,7 @@ class FormCompositionTest < MiniTest::Spec
       requester.extend(Saveable)
       band.extend(Saveable)
 
-      form.save.must_equal true
+      assert_equal form.save, true
     end
 
     it "returns false when one or more models don't save successfully" do
@@ -157,17 +156,16 @@ class FormCompositionTest < MiniTest::Spec
       requester.extend(Saveable)
       band.extend(Saveable)
 
-      form.save.must_equal false
+      assert_equal form.save, 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")]
+      [Book.new(1, "My book")]
     end
   end
 
@@ -180,8 +178,8 @@ class FormCompositionCollectionTest < MiniTest::Spec
     end
   end
 
-  let (:form)   { LibraryForm.new(library: library) }
-  let (:library) { Library.new(2) }
+  let(:form)   { LibraryForm.new(library: library) }
+  let(:library) { Library.new(2) }
 
-  it { form.save do |hash| hash.must_equal({:library=>{"books"=>[{"id"=>1, "name"=>"My book"}]}}) end }
+  it { form.save { |hash| assert_equal hash, { library: { "books" => [{ "id" => 1, "name" => "My book" }] } } } }
 end