reform 2.3.0.rc2 → 2.6.0

data/.travis.yml

@@ -1,32 +0,0 @@
-language: ruby
-cache: bundler
-bundler_args: --without benchmarks tools
-rvm:
-  - ruby-head
-  - 2.5
-  - 2.4
-env:
-  - "DRY_VALIDATION='~> 1.3.0'"
-  - "DRY_VALIDATION='~> 1.2.0'"
-  - "DRY_VALIDATION='~> 1.1.0'"
-  - "DRY_VALIDATION='~> 1.0.0'"
-  - "DRY_VALIDATION='~> 0.13.0'"
-  - "DRY_VALIDATION='~> 0.12.0'"
-matrix:
-  fast_finish: true
-  allow_failures:
-    - rvm: ruby-head
-  include:
-    - { rvm: 2.2, env: "DRY_VALIDATION='~> 0.11.0'" }
-    - { rvm: 2.3, env: "DRY_VALIDATION='~> 0.12.0'" }
-    - { rvm: 2.3, env: "DRY_VALIDATION='~> 0.13.0'" }
-
-
-# maybe move this to slack in a private channel
-# notifications:
-#   webhooks:
-#     urls:
-#       - https://webhooks.gitter.im/e/680e86d98056f2ae2fd7
-#     on_success: change  # options: [always|never|change] default: always
-#     on_failure: always  # options: [always|never|change] default: always
-#     on_start: never     # options: [always|never|change] default: always

data/lib/reform/form/dry/new_api.rb

@@ -1,58 +0,0 @@
-module Reform::Form::Dry
-  module NewApi
-    class Contract < Dry::Validation::Contract
-    end
-
-    module Validations
-      module ClassMethods
-        def validation_group_class
-          Group
-        end
-      end
-
-      def self.included(includer)
-        includer.extend(ClassMethods)
-      end
-
-      class Group
-        include InputHash
-
-        def initialize(options = {})
-          options ||= {}
-          @validator = options[:schema] || Reform::Form::Dry::NewApi::Contract
-
-          @schema_inject_params = options[:with] || {}
-        end
-
-        def instance_exec(&block)
-          Dry::Validation.load_extensions(:hints)
-          @block = block
-        end
-
-        def call(form)
-          dynamic_options = {}
-          dynamic_options[:form] = form if @schema_inject_params[:form]
-          inject_options = @schema_inject_params.merge(dynamic_options)
-
-          Dry::Schema::DSL.class_eval do
-            inject_options.each do |key, value|
-              define_method(key) { value }
-            end
-          end
-
-          # when passing options[:schema] the class instance is already created so we just need to call
-          # "call"
-          @validator = @validator.build(&@block) if @validator == Reform::Form::Dry::NewApi::Contract
-
-          # TODO: only pass submitted values to Schema#call?
-          dry_result = @validator.call(input_hash(form))
-          # dry_messages    = dry_result.messages
-
-          return dry_result
-
-          _reform_errors = Reform::Contract::Errors.new(dry_result) # TODO: dry should be merged here.
-        end
-      end
-    end
-  end
-end

data/lib/reform/form/dry/old_api.rb

@@ -1,61 +0,0 @@
-module Reform::Form::Dry
-  module OldApi
-    class Schema < Dry::Validation::Schema
-    end
-
-    module Validations
-      module ClassMethods
-        def validation_group_class
-          Group
-        end
-      end
-
-      def self.included(includer)
-        includer.extend(ClassMethods)
-      end
-
-      class Group
-        include InputHash
-
-        def initialize(options = {})
-          options ||= {}
-          schema_class = options[:schema] || Reform::Form::Dry::OldApi::Schema
-          @validator = Dry::Validation.Schema(schema_class, build: false)
-
-          @schema_inject_params = options[:with] || {}
-        end
-
-        def instance_exec(&block)
-          @validator = Dry::Validation.Schema(@validator, build: false, &block)
-          # inject the keys into the configure block automatically
-          keys = @schema_inject_params.keys
-          @validator.class_eval do
-            configure do
-              keys.each { |k| option k }
-            end
-          end
-        end
-
-        def call(form)
-          dynamic_options = {}
-          dynamic_options[:form] = form if @schema_inject_params[:form]
-          inject_options = @schema_inject_params.merge(dynamic_options)
-
-          # TODO: only pass submitted values to Schema#call?
-          dry_result = call_schema(inject_options, input_hash(form))
-          # dry_messages    = dry_result.messages
-
-          return dry_result
-
-          _reform_errors = Reform::Contract::Errors.new(dry_result) # TODO: dry should be merged here.
-        end
-
-        private
-
-        def call_schema(inject_options, input)
-          @validator.new(@validator.rules, inject_options).(input)
-        end
-      end
-    end
-  end
-end

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