reform 1.1.1 → 1.2.0.beta1

data/lib/reform/schema.rb

@@ -0,0 +1,23 @@
+module Reform
+  module Schema
+  # Converts the Representer->Form->Representer->Form tree into Representer->Representer.
+  # It becomes obvious that the form will be the main schema-defining instance in Trb, so this
+  # method makes sense. Consider private. This is experimental.
+    class Converter
+      def self.from(representer_class) # TODO: can we re-use this for all the decorator logic in #validate, etc?
+        representer = Class.new(representer_class)
+        representer.representable_attrs.each do |dfn|
+          next unless form = dfn[:form]
+          dfn.merge!(:extend => from(form.representer_class))
+        end
+
+        representer
+      end
+    end
+
+    # It's your job to make sure you memoize it correctly.
+    def schema
+      Converter.from(representer_class)
+    end
+  end
+end

data/lib/reform/twin.rb

@@ -0,0 +1,20 @@
+require 'disposable/twin'
+
+module Reform
+  module Twin
+    def self.included(base)
+      base.send :include, Disposable::Twin::Builder
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def twin(twin_class)
+        super(twin_class) { |dfn| property dfn.name } # create readers to twin model.
+      end
+    end
+
+    def initialize(model, options={})
+      super(build_twin(model, options))
+    end
+  end
+end

data/lib/reform/version.rb

@@ -1,3 +1,3 @@
 module Reform
-  VERSION = "1.1.1"
+  VERSION = "1.2.0.beta1"
 end

data/reform.gemspec

@@ -18,13 +18,13 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency             "representable",  "~> 2.0.3"
+  spec.add_dependency             "representable",  "~> 2.1.0"
   spec.add_dependency             "disposable",     "~> 0.0.5"
   spec.add_dependency             "uber",           "~> 0.0.8"
   spec.add_dependency             "activemodel"
   spec.add_development_dependency "bundler",        "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest",       "4.2.0"
+  spec.add_development_dependency "minitest",       "5.4.1"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "virtus"

data/test/active_model_test.rb

@@ -100,8 +100,8 @@ class ActiveModelWithCompositionTest < MiniTest::Spec
     include Composition
     include Reform::Form::ActiveModel
 
-    property  :title,           :on => :song
-    properties [:name, :genre], :on => :artist # we need to check both ::property and ::properties here!
+    property  :title,         :on => :song
+    properties :name, :genre, :on => :artist # we need to check both ::property and ::properties here!
 
     model :hit, :on => :song
   end

data/test/active_record_test.rb

@@ -46,13 +46,16 @@ class ActiveRecordTest < MiniTest::Spec
   end
 
   # uniqueness
-  it "is valid when title is unique for the same artist and album" do
-    form.validate("title" => "The Gargoyle", "artist_id" => artist.id, "album" => album.id, "created_at" => "November 6, 1966").must_equal true
+  it "has no errors on title when title is unique for the same artist and album" do
+    form.validate("title" => "The Gargoyle", "artist_id" => artist.id, "album" => album.id, "created_at" => "November 6, 1966")
+    assert_empty form.errors[:title]
   end
 
-  it "is invalid when title is taken for the same artist and album" do
+  it "has errors on title when title is taken for the same artist and album" do
+    skip "replace ActiveModel::Validations with our own, working and reusable gem."
     Song.create(title: "Windowpane", artist_id: artist.id, album_id: album.id)
-    form.validate("title" => "Windowpane", "artist_id" => artist.id, "album" => album).must_equal false
+    form.validate("title" => "Windowpane", "artist_id" => artist.id, "album" => album)
+    refute_empty form.errors[:title]
   end
 
   # nested object taken.

data/test/changed_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+require 'reform/form/coercion'
+
+class ChangedTest < BaseTest
+  class AlbumForm < Reform::Form
+    include Coercion
+
+    property :title
+
+    property :hit do
+      property :title
+      property :length, type: Integer
+      validates :title, :presence => true
+    end
+
+    collection :songs do
+      property :title
+      validates :title, :presence => true
+    end
+
+    property :band do # yepp, people do crazy stuff like that.
+      property :label do
+        property :name
+        property :location
+        validates :name, :presence => true
+      end
+      # TODO: make band a required object.
+    end
+
+    validates :title, :presence => true
+  end
+
+  Label = Struct.new(:name, :location)
+
+  # setup: changed? is always false
+  let (:form) { AlbumForm.new(Album.new("Drawn Down The Moon", Song.new("The Ripper", 9), [Song.new("Black Candles"), Song.new("The Ripper")], Band.new(Label.new("Cleopatra Records")))) }
+
+  it { form.changed?(:title).must_equal false }
+  it { form.changed?("title").must_equal false }
+  it { form.hit.changed?(:title).must_equal false }
+  it { form.hit.changed?.must_equal false }
+
+
+  describe "#validate" do
+    before { form.validate(
+      "title" => "Five", # changed.
+      "hit"   => {"title"  => "The Ripper", # same, but overridden.
+                  "length" => "9"}, # gets coerced, then compared, so not changed.
+      "band"  => {"label" => {"name" => "Shrapnel Records"}} # only label.name changes.
+    ) }
+
+    it { form.changed?(:title).must_equal true }
+
+    # it { form.changed?(:hit).must_equal false }
+
+    # overridden with same value is no change.
+    it { form.hit.changed?(:title).must_equal false }
+    # coerced value is identical to form's => not changed.
+    it { form.hit.changed?(:length).must_equal false }
+
+    # it { form.changed?(:band).must_equal true }
+    # it { form.band.changed?(:label).must_equal true }
+    it { form.band.label.changed?(:name).must_equal true }
+
+    # not present key/value in #validate is no change.
+    it { form.band.label.changed?(:location).must_equal false }
+    # TODO: parent form changed when child has changed!
+  end
+end

data/test/custom_validation_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+unless ActiveModel::VERSION::MAJOR == 3 and ActiveModel::VERSION::MINOR == 0
+
+  class UnexistantTitleValidator < ActiveModel::Validator
+    def validate record
+      if record.title == 'unexistant_song'
+        record.errors.add(:title, 'this title does not exist!')
+      end
+    end
+  end
+
+  class CustomValidationTest < MiniTest::Spec
+
+    class Album
+      include ActiveModel::Validations
+      attr_accessor :title, :artist
+
+      validates_with UnexistantTitleValidator
+    end
+
+    class AlbumForm < Reform::Form
+      extend ActiveModel::ModelValidations
+
+      property :title
+      property :artist_name, as: :artist
+      copy_validations_from Album
+    end
+
+    let(:album) { Album.new }
+
+    describe 'non-composite form' do
+
+      let(:album_form) { AlbumForm.new(album) }
+
+      it 'is not valid when title is unexistant_song' do
+        album_form.validate(artist_name: 'test', title: 'unexistant_song').must_equal false
+      end
+
+      it 'is valid when title is something existant' do
+        album_form.validate(artist_name: 'test', title: 'test').must_equal true
+      end
+
+    end
+
+  end
+end

data/test/deserialize_test.rb

@@ -1,16 +1,11 @@
 require 'test_helper'
-require 'representable/json'
+require 'reform/form/json'
 
 class DeserializeTest < BaseTest
   class AlbumContract < Reform::Form
     include Reform::Form::ActiveModel::FormBuilderMethods # overrides #update!, too.
 
-    self.representer_class.class_eval do
-      include Representable::JSON
-    end
-    def deserialize_method
-      :from_json
-    end
+    include Reform::Form::JSON
 
     property :title
     validates :title, :presence => true, :length => {:minimum => 3}

data/test/empty_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class EmptyAttributesTest < MiniTest::Spec
+  Credentials = Struct.new(:password)
+
+  class PasswordForm < Reform::Form
+    property :password
+    property :password_confirmation, :empty => true
+  end
+
+  let (:cred) { Credentials.new }
+  let (:form) { PasswordForm.new(cred) }
+
+  it {
+    form.validate("password" => "123", "password_confirmation" => "321")
+
+    form.password.must_equal "123"
+    form.password_confirmation.must_equal "321"
+
+    form.sync
+    cred.password.must_equal "123"
+
+    hash = {}
+    form.save do |nested|
+      hash = nested
+    end
+
+    hash.must_equal("password"=> "123", "password_confirmation" => "321")
+  }
+end

data/test/fields_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class FieldsTest < MiniTest::Spec
+  describe "#new" do
+    it "accepts list of properties" do
+      fields = Reform::Contract::Fields.new([:name, :title])
+      fields.name.must_equal  nil
+      fields.title.must_equal nil
+    end
+
+    it "accepts list of properties and values" do
+      fields = Reform::Contract::Fields.new(["name", "title"], "title" => "The Body")
+      fields.name.must_equal  nil
+      fields.title.must_equal "The Body"
+    end
+
+    it "processes value syms" do
+      skip "we don't need to test this as representer.to_hash always returns strings"
+      fields = Reform::Fields.new(["name", "title"], :title => "The Body")
+      fields.name.must_equal  nil
+      fields.title.must_equal "The Body"
+    end
+  end
+end

data/test/form_composition_test.rb

@@ -10,7 +10,7 @@ class FormCompositionTest < MiniTest::Spec
 
     property  :name,          :on =>  :requester
     property  :requester_id,  :on => :requester, :as => :id
-    properties [:title, :id], :on => :song
+    properties :title, :id, :on => :song
     # property  :channel # FIXME: what about the "main model"?
     property :channel, :empty => true, :on => :song
     property :requester,      :on => :requester
@@ -78,7 +78,7 @@ class FormCompositionTest < MiniTest::Spec
       )
     end
 
-    it "pushes data to models and calls #save when no block passed" do
+    it "xxx pushes data to models and calls #save when no block passed" do
       song.extend(Saveable)
       requester.extend(Saveable)
       band.extend(Saveable)
@@ -95,6 +95,28 @@ class FormCompositionTest < MiniTest::Spec
       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
 

data/test/form_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+class FormTest < MiniTest::Spec
+  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
+
+  # combined property/validates syntax.
+  class SongForm < Reform::Form
+    property :composer
+    property :title, validates: {presence: true}
+    properties :genre, :band, validates: {presence: true}
+  end
+  it do
+    form = SongForm.new(OpenStruct.new)
+    form.validate({})
+    form.errors.to_s.must_equal "{:title=>[\"can't be blank\"], :genre=>[\"can't be blank\"], :band=>[\"can't be blank\"]}"
+  end
+
+  # ::schema
+  describe "::schema" do
+    let (:schema) { AlbumForm.schema }
+
+    # it must be a clone
+    it { schema.wont_equal AlbumForm.representer_class }
+    it { assert schema < Representable::Decorator }
+    it { schema.representable_attrs.get(:title).name.must_equal "title" }
+
+    # hit is clone.
+    it { schema.representable_attrs.get(:hit).representer_module.object_id.wont_equal AlbumForm.representer_class.representable_attrs.get(:hit).representer_module.object_id }
+    it { assert schema.representable_attrs.get(:hit).representer_module < Representable::Decorator }
+
+    # band:label is clone.
+    # this test might look ridiculous but it is mission-critical to assert that schema is really a clone and doesn't mess up the original structure.
+    let (:label) { schema.representable_attrs.get(:band).representer_module.representable_attrs.get(:label) }
+    it { assert label.representer_module < Representable::Decorator }
+    it { label.representer_module.object_id.wont_equal AlbumForm.representer_class.representable_attrs.get(:band).representer_module.representer_class.representable_attrs.get(:label).representer_module.object_id }
+
+    # #apply
+    it do
+      properties = []
+
+      schema.apply do |dfn|
+        properties << dfn.name
+      end
+
+      properties.must_equal ["title", "hit", "title", "songs", "title", "band", "label", "name"]
+    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.representer_class.wont_equal cloned.representer_class }
+
+    it do
+      # currently, forms need a name for validation, even without AM.
+      cloned.singleton_class.class_eval do
+        def name
+          "Album"
+        end
+      end
+      cloned.validates :title, presence: true
+      cloned.new(OpenStruct.new).validate({})
+    end
+  end
+end

data/test/inherit_test.rb

@@ -2,6 +2,18 @@ require 'test_helper'
 require 'representable/json'
 
 class InheritTest < BaseTest
+  class AlbumForm < Reform::Form
+    property :title
+
+    property :hit do
+      property :title
+    end
+
+    collection :songs do
+      property :title
+    end
+  end
+
   class CompilationForm < AlbumForm
 
     property :hit, :inherit => true do