reform 2.2.4

data/test/errors_test.rb

@@ -0,0 +1,165 @@
+require "test_helper"
+
+class ErrorsTest < MiniTest::Spec
+  class AlbumForm < Reform::Form
+    property :title
+
+    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
+        # required(:name).filled(:music_taste_ok?)
+
+        configure do
+          config.messages_file = "test/validation/errors.yml"
+
+          def music_taste_ok?(value)
+            value != "Nickelback"
+            # errors.add(:base, "You are a bad person") if name == "Nickelback"
+          end
+        end
+      end
+      # validate :music_taste_ok?
+
+    # private
+    #   def music_taste_ok?
+    #     errors.add(:base, "You are a bad person") if name == "Nickelback"
+    #   end
+    end
+
+    validation do
+      required(:title).filled
+    end
+  end
+
+  let (:album) do
+    OpenStruct.new(
+      :title  => "Blackhawks Over Los Angeles",
+      :hit    => song,
+      :songs  => songs, # TODO: document this requirement,
+
+      :band => Struct.new(:name, :label).new("Epitaph", OpenStruct.new),
+    )
+  end
+  let (:song)  { OpenStruct.new(:title => "Downtown") }
+  let (:songs) { [song=OpenStruct.new(:title => "Calling"), song] }
+  let (:form)  { AlbumForm.new(album) }
+
+
+  describe "incorrect #validate" do
+    before { form.validate(
+      "hit"   =>{"title" => ""},
+      "title" => "",
+      "songs" => [{"title" => ""}, {"title" => ""}]) } # FIXME: what happens if item is missing?
+
+    it do
+      form.errors.messages.must_equal({
+        :title  => ["must be filled"],
+        :"hit.title"=>["must be filled"],
+        :"songs.title"=>["must be filled"],
+        :"band.label.name"=>["is missing"]
+      })
+    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.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"=>["is missing"]
+      })
+    end
+  end
+
+
+  describe "#validate with main form invalid" do
+    it do
+      form.validate("title"=>"", "band"=>{"label"=>{:name => "Fat Wreck"}}).must_equal false
+      form.errors.messages.must_equal({:title=>["must be filled"]})
+    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"]}) }
+  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"]}) }
+  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"=>["is missing"]}) }
+  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 are a bad person"]})
+    end
+  end
+
+  describe "correct #validate" do
+    before { @result = form.validate(
+      "hit"   => {"title" => "Sacrifice"},
+      "title" => "Second Heat",
+      "songs" => [{"title"=>"Heart Of A Lion"}],
+      "band"  => {"label"=>{:name => "Fat Wreck"}}
+      ) }
+
+    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" }
+  end
+
+
+  describe "Errors#to_s" do
+    before { form.validate("songs"=>[{"title" => ""}], "band" => {"label" => {}}) }
+
+    # to_s is aliased to messages
+    it { form.errors.to_s.must_equal "{:\"songs.title\"=>[\"must be filled\"], :\"band.label.name\"=>[\"is missing\"]}" }
+  end
+end

data/test/feature_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class FeatureInheritanceTest < BaseTest
+  Song  = Struct.new(:title, :album, :composer)
+  Album = Struct.new(:name, :songs, :artist)
+  Artist = Struct.new(:name)
+
+  module Date
+    def date
+      "May 16"
+    end
+
+    def self.included(includer)
+      includer.send :register_feature, self
+    end
+  end
+
+  # module Name
+  #   def name
+  #     "Violins"
+  #   end
+  # end
+
+  class AlbumForm < Reform::Form
+    feature Date # feature.
+    property :name
+
+    collection :songs do
+      property :title
+
+      property :composer do
+        property :name
+      end
+    end
+
+    property :artist do
+      property :name
+    end
+  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", [song, song_with_composer], artist) }
+
+  let (:form) { AlbumForm.new(album) }
+
+  it do
+    form.date.must_equal "May 16"
+    form.songs[0].date.must_equal "May 16"
+  end
+
+  # it { subject.class.include?(Reform::Form::ActiveModel) }
+  # it { subject.class.include?(Reform::Form::Coercion) }
+  # it { subject.is_a?(Reform::Form::MultiParameterAttributes) }
+
+  # it { subject.band.class.include?(Reform::Form::ActiveModel) }
+  # it { subject.band.is_a?(Reform::Form::Coercion) }
+  # it { subject.band.is_a?(Reform::Form::MultiParameterAttributes) }
+
+  # it { subject.band.label.is_a?(Reform::Form::ActiveModel) }
+  # it { subject.band.label.is_a?(Reform::Form::Coercion) }
+  # it { subject.band.label.is_a?(Reform::Form::MultiParameterAttributes) }
+end

data/test/fixtures/dry_error_messages.yml

@@ -0,0 +1,44 @@
+array?: "%{name} must be an array"
+
+empty?: "%{name} cannot be empty"
+
+exclusion?: "%{name} must not be one of: %{list}"
+
+eql?: "%{name} must be equal to %{eql_value}"
+
+filled?: "%{name} must be filled"
+
+format?: "%{name} is in invalid format"
+
+gt?: "%{name} must be greater than %{num} (%{value} was given)"
+
+gteq?: "%{name} must be greater than or equal to %{num}"
+
+hash?: "%{name} must be a hash"
+
+inclusion?: "%{name} must be one of: %{list}"
+
+int?: "%{name} must be an integer"
+
+key?: "%{name} is missing"
+
+lt?: "%{name} must be less than %{num} (%{value} was given)"
+
+lteq?: "%{name} must be less than or equal to %{num}"
+
+max_size?: "%{name} size cannot be greater than %{num}"
+
+min_size?: "%{name} size cannot be less than %{num}"
+
+nil?: "%{name} cannot be nil"
+
+size?:
+  range: "%{name} size must be within %{left} - %{right}"
+  default: "%{name} size must be %{num}"
+
+str?: "%{name} must be a string"
+
+good_musical_taste?: "you're a bad person"
+
+form_access_validation?: "this doesn't look like a Reform form dude!!"
+

data/test/form_option_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class FormOptionTest < MiniTest::Spec
+  Song  = Struct.new(:title)
+  Album = Struct.new(:song)
+
+  class SongForm < Reform::Form
+    property :title
+    validation do
+      key(:title).required
+    end
+  end
+
+  class AlbumForm < Reform::Form
+    property :song, form: SongForm
+  end
+
+  it do
+    form = AlbumForm.new(Album.new(Song.new("When It Comes To You")))
+    form.song.title.must_equal "When It Comes To You"
+
+    form.validate(song: {title: "Run For Cover"})
+  end
+end

data/test/form_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class FormTest < MiniTest::Spec
+  Artist = Struct.new(:name)
+
+  class AlbumForm < Reform::Form
+    property :title
+
+    property :hit do
+      property :title
+    end
+
+    collection :songs do
+      property :title
+    end
+
+    property :band do # yepp, people do crazy stuff like that.
+      property :label do
+        property :name
+      end
+    end
+  end
+
+  describe "::dup" do
+    let (:cloned) { AlbumForm.clone }
+
+    # #dup is called in Op.inheritable_attr(:contract_class), it must be subclass of the original one.
+    it { cloned.wont_equal AlbumForm }
+    it { AlbumForm.definitions.wont_equal cloned.definitions }
+
+    it do
+      # currently, forms need a name for validation, even without AM.
+      cloned.singleton_class.class_eval do
+        def name
+          "Album"
+        end
+      end
+
+      cloned.validation do
+        key(:title).required
+      end
+
+      cloned.new(OpenStruct.new).validate({})
+    end
+  end
+
+  describe "#initialize" do
+    class ArtistForm < Reform::Form
+      property :name
+      property :current_user, virtual: true
+    end
+
+    it "allows injecting :virtual options" do
+      ArtistForm.new(Artist.new, current_user: Object).current_user.must_equal Object
+    end
+  end
+end

data/test/from_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class AsTest < BaseTest
+  class AlbumForm < Reform::Form
+    property :name, from: :title
+
+    property :single, from: :hit do
+      property :title
+    end
+
+    collection :tracks, from: :songs do
+      property :name, from: :title
+    end
+
+    property :band do
+      property :company, from: :label do
+        property :business, from: :name
+      end
+    end
+  end
+
+  let (:song2) { Song.new("Roxanne") }
+
+  let (:params) {
+      {
+        "name" => "Best Of The Police",
+        "single"   => {"title" => "So Lonely"},
+        "tracks" => [{"name" => "Message In A Bottle"}, {"name" => "Roxanne"}]
+      }
+    }
+
+  subject { AlbumForm.new(Album.new("Best Of", hit, [Song.new("Fallout"), song2])) }
+
+  it { subject.name.must_equal "Best Of" }
+  it { subject.single.title.must_equal "Roxanne" }
+  it { subject.tracks[0].name.must_equal "Fallout" }
+  it { subject.tracks[1].name.must_equal "Roxanne" }
+
+
+  describe "#validate" do
+
+
+    before { subject.validate(params) }
+
+    it { subject.name.must_equal "Best Of The Police" }
+    it { subject.single.title.must_equal "So Lonely" }
+    it { subject.tracks[0].name.must_equal "Message In A Bottle" }
+    it { subject.tracks[1].name.must_equal "Roxanne" }
+  end
+
+
+  describe "#sync" do
+    before {
+      subject.tracks[1].name = "Livin' Ain't No Crime"
+      subject.sync
+    }
+
+    it { song2.title.must_equal "Livin' Ain't No Crime" }
+  end
+
+
+  describe "#save (nested hash)" do
+    before { subject.validate(params) }
+
+    it do
+      hash = nil
+
+      subject.save do |nested_hash|
+        hash = nested_hash
+      end
+
+      hash.must_equal({"title"=>"Best Of The Police", "hit"=>{"title"=>"So Lonely"}, "songs"=>[{"title"=>"Message In A Bottle"}, {"title"=>"Roxanne"}]})
+    end
+  end
+end

data/test/inherit_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+require 'representable/json'
+
+class InheritTest < BaseTest
+  Populator = Reform::Form::Populator
+
+  class AlbumForm < Reform::Form
+    property :title, deserializer: {instance: "Instance"}, skip_if: "skip_if in AlbumForm" # allow direct configuration of :deserializer.
+
+    property :hit, populator: "Populator" do
+      property :title
+    end
+
+    collection :songs, populate_if_empty: lambda {}, skip_if: :all_blank do
+      property :title
+    end
+
+    property :artist, populate_if_empty: lambda {} do
+
+      def artist_id
+        1
+      end
+    end
+  end
+
+  puts
+  puts "inherit"
+
+  class CompilationForm < AlbumForm
+    property :title, inherit: true, skip_if: "skip_if from CompilationForm"
+    puts "[#{options_for(:title)[:deserializer].object_id}] COM@@@@@ #{options_for(:title)[:deserializer].inspect}"
+    # property :hit, :inherit => true do
+    #   property :rating
+    #   validates :title, :rating, :presence => true
+    # end
+
+    # puts representer_class.representable_attrs.
+    #   get(:hit)[:extend].evaluate(nil).new(OpenStruct.new).rating
+
+    # NO collection here, this is entirely inherited.
+    # collection :songs, ..
+
+    property :artist, inherit: true do # inherit everything, but explicitely.
+    end
+
+    # completely override.
+    property :hit, skip_if: "SkipParse" do
+    end
+
+    # override partly.
+  end
+
+  let (:album) { Album.new(nil, OpenStruct.new(:hit => OpenStruct.new()) ) }
+  subject { CompilationForm.new(album) }
+
+
+  # valid.
+  # it {
+  #   subject.validate("hit" => {"title" => "LA Drone", "rating" => 10})
+  #   subject.hit.title.must_equal "LA Drone"
+  #   subject.hit.rating.must_equal 10
+  #   subject.errors.messages.must_equal({})
+  # }
+
+  # it do
+  #   subject.validate({})
+  #   subject.hit.title.must_equal nil
+  #   subject.hit.rating.must_equal nil
+  #   subject.errors.messages.must_equal({:"hit.title"=>["can't be blank"], :"hit.rating"=>["can't be blank"]})
+  # end
+
+require "pp"
+
+  it "xxx" do
+    # sub hashes like :deserializer must be properly cloned when inheriting.
+    AlbumForm.options_for(:title)[:deserializer].object_id.wont_equal CompilationForm.options_for(:title)[:deserializer].object_id
+
+    # don't overwrite direct deserializer: {} configuration.
+    AlbumForm.options_for(:title)[:internal_populator].must_be_instance_of Reform::Form::Populator::Sync
+    AlbumForm.options_for(:title)[:deserializer][:skip_parse].must_equal "skip_if in AlbumForm"
+
+    AlbumForm.options_for(:hit)[:internal_populator].inspect.must_match /Reform::Form::Populator:.+ @user_proc="Populator"/
+    # AlbumForm.options_for(:hit)[:deserializer][:instance].inspect.must_be_instance_with Reform::Form::Populator, user_proc: "Populator"
+
+
+    AlbumForm.options_for(:songs)[:internal_populator].must_be_instance_of Reform::Form::Populator::IfEmpty
+    AlbumForm.options_for(:songs)[:deserializer][:skip_parse].must_be_instance_of Reform::Form::Validate::Skip::AllBlank
+
+    AlbumForm.options_for(:artist)[:internal_populator].must_be_instance_of Reform::Form::Populator::IfEmpty
+
+
+
+    CompilationForm.options_for(:title)[:deserializer][:skip_parse].must_equal "skip_if from CompilationForm"
+    # pp CompilationForm.options_for(:songs)
+    CompilationForm.options_for(:songs)[:internal_populator].must_be_instance_of Reform::Form::Populator::IfEmpty
+
+
+    CompilationForm.options_for(:artist)[:internal_populator].must_be_instance_of Reform::Form::Populator::IfEmpty
+
+    # completely overwrite inherited.
+    CompilationForm.options_for(:hit)[:internal_populator].must_be_instance_of Reform::Form::Populator::Sync # reset to default.
+    CompilationForm.options_for(:hit)[:deserializer][:skip_parse].must_equal "SkipParse"
+
+
+    # inherit: true with block will still inherit the original class.
+    AlbumForm.new(OpenStruct.new(artist: OpenStruct.new)).artist.artist_id.must_equal 1
+    CompilationForm.new(OpenStruct.new(artist: OpenStruct.new)).artist.artist_id.must_equal 1
+  end
+
+
+  class CDForm < AlbumForm
+    # override :artist's original populate_if_empty but with :inherit.
+    property :artist, inherit: true, populator: "CD Populator" do
+
+    end
+  end
+
+  it { CDForm.options_for(:artist)[:internal_populator].instance_variable_get(:@user_proc).must_equal "CD Populator" }
+end