reform 2.3.3 → 2.5.0

data/test/call_new_api.rb

@@ -1,23 +0,0 @@
-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_old_api.rb

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

@@ -1,184 +0,0 @@
-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
-      required(:name).filled
-      required(:title).filled
-    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

data/test/contract_old_api.rb

@@ -1,77 +0,0 @@
-require "test_helper"
-
-class ContractTest < MiniTest::Spec
-  Song  = Struct.new(:title, :album, :composer)
-  Album = Struct.new(:name, :duration, :songs, :artist)
-  Artist = Struct.new(:name)
-
-  class ArtistForm < TestForm
-    property :name
-  end
-
-  class AlbumForm < TestContract
-    property :name
-
-    properties :duration
-    properties :year, :style, readable: false
-
-    validation do
-      required(:name).filled
-    end
-
-    collection :songs do
-      property :title
-      validation do
-        required(:title).filled
-      end
-
-      property :composer do
-        property :name
-        validation do
-          required(:name).filled
-        end
-      end
-    end
-
-    property :artist, form: ArtistForm
-  end
-
-  let(:song)               { Song.new("Broken") }
-  let(:song_with_composer) { Song.new("Resist Stance", nil, composer) }
-  let(:composer)           { Artist.new("Greg Graffin") }
-  let(:artist)             { Artist.new("Bad Religion") }
-  let(:album)              { Album.new("The Dissent Of Man", 123, [song, song_with_composer], artist) }
-
-  let(:form) { AlbumForm.new(album) }
-
-  # accept `property form: SongForm`.
-  it do
-    _(form.artist).must_be_instance_of ArtistForm
-  end
-
-  describe ".properties" do
-    it "defines a property when called with one argument" do
-      _(form).must_respond_to :duration
-    end
-
-    it "defines several properties when called with multiple arguments" do
-      _(form).must_respond_to :year
-      _(form).must_respond_to :style
-    end
-
-    it "passes options to each property when options are provided" do
-      readable = AlbumForm.new(album).options_for(:style)[:readable]
-      _(readable).must_equal false
-    end
-
-    it "returns the list of defined properties" do
-      returned_value = AlbumForm.properties(:hello, :world, virtual: true)
-      _(returned_value).must_equal %i[hello world]
-    end
-  end
-
-  describe "#options_for" do
-    it { _(AlbumForm.options_for(:name).extend(Declarative::Inspect).inspect).must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
-    it { _(AlbumForm.new(album).options_for(:name).extend(Declarative::Inspect).inspect).must_equal "#<Disposable::Twin::Definition: @options={:private_name=>:name, :name=>\"name\"}>" }
-  end
-end

data/test/errors_old_api.rb

@@ -1,230 +0,0 @@
-require "test_helper"
-
-class ErrorsTest < MiniTest::Spec
-  class AlbumForm < TestForm
-    property :title
-    validation do
-      required(:title).filled
-    end
-
-    property :artists, default: []
-    property :producer do
-      property :name
-    end
-
-    property :hit do
-      property :title
-      validation do
-        required(:title).filled
-      end
-    end
-
-    collection :songs do
-      property :title
-      validation do
-        required(:title).filled
-      end
-    end
-
-    property :band do # yepp, people do crazy stuff like that.
-      property :name
-      property :label do
-        property :name
-        validation do
-          required(:name).filled
-        end
-      end
-      # TODO: make band a required object.
-
-      validation do
-        configure do
-          config.messages_file = "test/fixtures/dry_error_messages.yml"
-
-          def good_musical_taste?(value)
-            value != "Nickelback"
-          end
-        end
-
-        required(:name).filled(:good_musical_taste?)
-      end
-    end
-
-    validation do
-      required(:title).filled
-      required(:artists).each(:str?)
-      required(:producer).schema do
-        required(:name).filled
-      end
-    end
-  end
-
-  let(:album_title) { "Blackhawks Over Los Angeles" }
-  let(:album) do
-    OpenStruct.new(
-      title: album_title,
-      hit: song,
-      songs: songs, # TODO: document this requirement,
-      band: Struct.new(:name, :label).new("Epitaph", OpenStruct.new),
-      producer: Struct.new(:name).new("Sun Records")
-    )
-  end
-  let(:song)  { OpenStruct.new(title: "Downtown") }
-  let(:songs) { [song = OpenStruct.new(title: "Calling"), song] }
-  let(:form)  { AlbumForm.new(album) }
-
-  describe "#validate with invalid array property" do
-    it do
-      _(form.validate(
-        title: "Swimming Pool - EP",
-        band: {
-          name: "Marie Madeleine",
-          label: {name: "Ekler'o'shocK"}
-        },
-        artists: [42, "Good Charlotte", 43]
-      )).must_equal false
-      _(form.errors.messages).must_equal(artists: {0 => ["must be a string"], 2 => ["must be a string"]})
-      _(form.errors.size).must_equal(1)
-    end
-  end
-
-  describe "#errors without #validate" do
-    it do
-      _(form.errors.size).must_equal 0
-    end
-  end
-
-  describe "blank everywhere" do
-    before do
-      form.validate(
-        "hit" => {"title" => ""},
-        "title" => "",
-        "songs" => [{"title" => ""}, {"title" => ""}],
-        "producer" => {"name" => ""}
-      )
-    end
-
-    it do
-      _(form.errors.messages).must_equal(
-        title: ["must be filled"],
-        "hit.title": ["must be filled"],
-        "songs.title": ["must be filled"],
-        "band.label.name": ["must be filled"],
-        "producer.name": ["must be filled"]
-      )
-    end
-
-    # it do
-    #   form.errors.must_equal({:title  => ["must be filled"]})
-    #   TODO: this should only contain local errors?
-    # end
-
-    # nested forms keep their own Errors:
-    it { _(form.producer.errors.messages).must_equal(name: ["must be filled"]) }
-    it { _(form.hit.errors.messages).must_equal(title: ["must be filled"]) }
-    it { _(form.songs[0].errors.messages).must_equal(title: ["must be filled"]) }
-
-    it do
-      _(form.errors.messages).must_equal(
-        title: ["must be filled"],
-        "hit.title": ["must be filled"],
-        "songs.title": ["must be filled"],
-        "band.label.name": ["must be filled"],
-        "producer.name": ["must be filled"]
-      )
-      _(form.errors.size).must_equal(5)
-    end
-  end
-
-  describe "#validate with main form invalid" do
-    it do
-      _(form.validate("title" => "", "band" => {"label" => {name: "Fat Wreck"}}, "producer" => nil)).must_equal false
-      _(form.errors.messages).must_equal(title: ["must be filled"], producer: ["must be a hash"])
-      _(form.errors.size).must_equal(2)
-    end
-  end
-
-  describe "#validate with middle nested form invalid" do
-    before { @result = form.validate("hit" => {"title" => ""}, "band" => {"label" => {name: "Fat Wreck"}}) }
-
-    it { _(@result).must_equal false }
-    it { _(form.errors.messages).must_equal("hit.title": ["must be filled"]) }
-    it { _(form.errors.size).must_equal(1) }
-  end
-
-  describe "#validate with collection form invalid" do
-    before { @result = form.validate("songs" => [{"title" => ""}], "band" => {"label" => {name: "Fat Wreck"}}) }
-
-    it { _(@result).must_equal false }
-    it { _(form.errors.messages).must_equal("songs.title": ["must be filled"]) }
-    it { _(form.errors.size).must_equal(1) }
-  end
-
-  describe "#validate with collection and 2-level-nested invalid" do
-    before { @result = form.validate("songs" => [{"title" => ""}], "band" => {"label" => {}}) }
-
-    it { _(@result).must_equal false }
-    it { _(form.errors.messages).must_equal("songs.title": ["must be filled"], "band.label.name": ["must be filled"]) }
-    it { _(form.errors.size).must_equal(2) }
-  end
-
-  describe "#validate with nested form using :base invalid" do
-    it do
-      result = form.validate("songs" => [{"title" => "Someday"}], "band" => {"name" => "Nickelback", "label" => {"name" => "Roadrunner Records"}})
-      _(result).must_equal false
-      _(form.errors.messages).must_equal("band.name": ["you're a bad person"])
-      _(form.errors.size).must_equal(1)
-    end
-  end
-
-  describe "#add" do
-    let(:album_title) { nil }
-    it do
-      form.errors.add(:before, "validate")
-      form.errors.add(:before, "validate 2")
-      form.errors.add(:title, "before validate")
-      result = form.validate("songs" => [{"title" => "Someday"}], "band" => {"name" => "Nickelback", "label" => {"name" => "Roadrunner Records"}})
-      _(result).must_equal false
-      _(form.errors.messages).must_equal(before: ["validate", "validate 2"], title: ["before validate", "must be filled"], "band.name": ["you're a bad person"])
-      # add a new custom error
-      form.errors.add(:policy, "error_text")
-      _(form.errors.messages).must_equal(before: ["validate", "validate 2"], title: ["before validate", "must be filled"], "band.name": ["you're a bad person"], policy: ["error_text"])
-      # does not duplicate errors
-      form.errors.add(:title, "must be filled")
-      _(form.errors.messages).must_equal(before: ["validate", "validate 2"], title: ["before validate", "must be filled"], "band.name": ["you're a bad person"], policy: ["error_text"])
-      # merge existing errors
-      form.errors.add(:policy, "another error")
-      _(form.errors.messages).must_equal(before: ["validate", "validate 2"], title: ["before validate", "must be filled"], "band.name": ["you're a bad person"], policy: ["error_text", "another error"])
-    end
-  end
-
-  describe "correct #validate" do
-    before do
-      @result = form.validate(
-        "hit"   => {"title" => "Sacrifice"},
-        "title" => "Second Heat",
-        "songs" => [{"title" => "Heart Of A Lion"}],
-        "band"  => {"label" => {name: "Fat Wreck"}}
-      )
-    end
-
-    it { _(@result).must_equal true }
-    it { _(form.hit.title).must_equal "Sacrifice" }
-    it { _(form.title).must_equal "Second Heat" }
-    it { _(form.songs.first.title).must_equal "Heart Of A Lion" }
-    it do
-      skip "WE DON'T NEED COUNT AND EMPTY? ON THE CORE ERRORS OBJECT"
-      _(form.errors.size).must_equal(0)
-      _(form.errors.empty?).must_equal(true)
-    end
-  end
-
-  describe "Errors#to_s" do
-    before { form.validate("songs" => [{"title" => ""}], "band" => {"label" => {}}) }
-
-    # to_s is aliased to messages
-    it {
-      skip "why do we need Errors#to_s ?"
-      _(form.errors.to_s).must_equal "{:\"songs.title\"=>[\"must be filled\"], :\"band.label.name\"=>[\"must be filled\"]}"
-    }
-  end
-end