forme 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b392c21e8ea5b18c3b1c125b84c36379b40595bf
-  data.tar.gz: de4ef22b48745082a9661989dd745824ef75ea07
+  metadata.gz: fb06104f826067a8f31ba5778bed02029abdbb7a
+  data.tar.gz: 910a345e355680be66a4d049edaa35e8ecca6186
 SHA512:
-  metadata.gz: bfc76ba5baa373ce677fe2fc7f44703d2e8783b9752e667a356a454293b11efecabe4b03fab498b040ac7afd3e0bc10a09f463681f5b839fa7620a984ba7bc1b
-  data.tar.gz: 93b41b112be039b14e2368618e9bc00d8599d7935828fddc27870bdd1426199c58fbc6c63b4085c48368e87c717ed5b0f952d76d684143ef455e1d19854c078f
+  metadata.gz: c829a2fb78d66a347f6ae65ea600aabd80a2ef7373ca0c3ea4894a0409c75c8959df45b096413796f5140590ea8f7fa4b32c0c8b02a5f78f4ce6d7b103abde77
+  data.tar.gz: fd6f0b68a9aadbedcd53d0087e8e5c3ea215c53363834fe9c9e39ea54c728113afc0d6459119cf65bda15355eb2757ac26688cba23266c93179047c16c5cd270

data/CHANGELOG

@@ -1,3 +1,13 @@
+=== 1.5.0 (2016-08-09)
+
+* Add forme_set Sequel plugin, for handling the intake of submitted params based on form fields (jeremyevans)
+
+* Only add csrf tag in forme/erb support if there is a current session in the environment (jeremyevans)
+
+* Fix frozen string literal issue in explicit labeler (jeremyevans)
+
+* Add forme_i18n Sequel plugin, for internalization support (badosu) (#15)
+
 === 1.4.0 (2016-02-01)
 
 * Ignore submit buttons when using the :readonly formatter (jeremyevans)

data/README.rdoc

@@ -376,7 +376,6 @@ based on the format, numericality, and length validations.
 
 In addition to the default Forme options, the Sequel support includes, for specific column types, 
 these additional options to the #input method:
-.
 
 === boolean
 
@@ -425,7 +424,7 @@ This will create a form similar to:
 For one_to_many and many_to_many associations, you will probably want to use the
 +association_pks+ plugin that ships with Sequel.
 
-This supports the pg_array_to_many association type that comes with Sequel's
+This also supports the pg_array_to_many association type that comes with Sequel's
 +pg_array_association+ plugin.
 
 association input options:
@@ -509,6 +508,154 @@ subform options:
 :inputs_opts :: When using the :grid option, this allows you to specify options
                 to pass to the table InputsWrapper.
 
+== Handling form submissions
+
+The Sequel forme plugin only handles creating the forms, it does not handle processing
+input submitted via forms.  For a form such as:
+
+  Forme.form(Album[1], :action=>'/foo') do |f|
+    f.input :name
+    f.input :copies_sold
+  end
+
+Input of the form will often be submitted as the following parameter hash (this depends
+on your web framework, but Rack works this way by default):
+
+  {'album'=>{'name'=>'Rising Force', 'copies_sold'=>'100000'}}
+
+One way to handle the form submission is to use Sequel::Model#set_fields.
+
+  album = Album[1]
+  album.set_fields(params['album'], %w'name copies_sold')
+  album.save
+
+Note that you have to specify the parameter names again as the second argument to
+set_fields.
+
+Handling Submitted parameters becomes more complex as your forms become more complex.
+For example, if you are only displaying certain form fields in certain situations:
+
+  album = Album[1]
+  Forme.form(album, :action=>'/foo') do |f|
+    f.input :name
+    f.input :copies_sold if album.released?
+  end
+
+Then your parameter handling becomes more complex:
+
+  album = Album[1]
+  album.set_fields(params['album'], %w'name')
+  album.set_fields(params['album'], %w'copies_sold') if album.released?
+  album.save
+
+As you can see, you basically need to recreate the conditionals used when creating
+the form, so that that the processing of the form submission handles only the
+inputs that were displayed on the form.
+
+=== forme_set plugin
+
+The forme_set plugin is designed to make handling form submissions easier.  What it does
+is record the form fields that are used on the object, and then it uses those fields
+to handle input submitted for the object.  For example:
+
+  album = Album[1]
+  Forme.form(album, :action=>'/foo') do |f|
+    f.input :name
+    f.input :copies_sold if album.released?
+  end
+  album.forme_set(params['album'])
+
+If the album has been released, and the form would display the name and copies_sold
+inputs, then forme_set will accept input for both.  If the album has not been released,
+the form will only display the name input, so forme_set will only accept the name input.
+
+So forme_set offers two advantages over using set_fields:
+
+1. DRYs up code as you don't have to specify the names twice
+2. Simplifies complex form submissions by eliminating duplication of conditionals
+
+==== Validations
+
+forme_set offers one additional advantage over using set_fields.  When dealing with
+associations, set_fields does not check that the value submitted for an input matches
+one of the available options displayed on the form.  For example, if you have a form such as:
+
+  Forme.form(album, :action=>'/foo') do |f|
+    f.input :name
+    f.input :artist, :dataset=>proc{|ds| ds.where{name > 'M'}}
+  end
+
+The form will only display artists whose name is greater than 'M'.  However, if you process
+input using:
+
+  album.set_fields(params['album'], %w'name artist_id')
+
+Then a malicious user can submit an artist_id for an artist whose name is not greater than 'M',
+and the value will be set.  In addition to setting values, forme_set also adds validations
+that the submitted values for associated objects match one of the options displayed on the form,
+which can increase security.
+
+==== Usage
+
+Because forme_set relies on creating form inputs using the same model instance that will
+be used for accepting input, using it often requires some code rearranging.  If you are
+storing Forme::Form objects and later using them on forms, it is fairly simple to move the
+Forme::Forme object creation to a method, that you can call both in the initial display
+and when processing the input:
+
+  def show_form(album)
+    Forme.form(album, :action=>'/foo') do |f|
+      f.input :name
+      f.input :copies_sold
+    end
+  end
+
+Then when displaying the form:
+
+  <%= album_form(Album[1]) %>
+
+and when processing the form's input:
+
+  album = Album[1]
+  album_form(album)
+  album.forme_set(params['album'])
+
+However, if you use Forme's ERB/Rails template integration (see below), and are inlining
+forms in your templates, unless you want to extract the Forme::Form creation to methods,
+you have to basically rerender the template when processing the input.  How you do
+this is specific to the web framework you are using, but is it similar to:
+
+  @album = Album[1]
+  render :template
+  @album.forme_set(params['album'])
+
+==== Caveats
+
+forme_set is not perfect, there are ways to use Forme that forme_set will not handle
+correctly.  First, forme_set only works with forms that use model objects, and doesn't
+handle inputs where the :obj option is provided to change the input.
+Additionally, forme_set does not currently handle subform/nested_attributes.
+
+In cases where forme_set does not handle things correctly, you can use forme_parse,
+which will return metadata that forme_set uses (forme_set calls forme_parse
+internally).  forme_parse returns a hash with the following keys:
+
+:values :: A hash of values that can be used to update the model, suitable for passing
+           to Sequel::Model#set.
+:validations :: A hash of values suitable for merging into forme_validations. Used to
+                check that the submitted values for associated objects match one of the
+                options for the input in the form.
+
+It is possible to use forme_set for the values it can handle, and set other fields manually
+using set_fields.
+
+== Other Sequel Plugins
+
+In addition to the Sequel plugins mentioned above, Forme also ships with additional Sequel
+plugins:
+
+forme_i18n :: Handles translations for labels using i18n.
+
 = ERB Support
 
 Forme ships with a ERB extension that you can get by <tt>require "forme/erb"</tt> and using

data/Rakefile

@@ -50,7 +50,7 @@ end
 
 desc "Run specs"
 task :spec do
-  sh "#{FileUtils::RUBY} -rubygems -I lib -e 'ARGV.each{|f| require f}' ./spec/*_spec.rb"
+  sh "#{FileUtils::RUBY} spec/all.rb"
 end
 task :default => :spec
 

data/lib/forme/erb.rb

@@ -16,7 +16,7 @@ module Forme
 
     # Add CSRF token tag by default for POST forms
     add_hidden_tag do |tag|
-      if defined?(::Rack::Csrf) && (form = tag.form) && (env = form.opts[:env]) && tag.attr[:method].to_s.upcase == 'POST'
+      if defined?(::Rack::Csrf) && (form = tag.form) && (env = form.opts[:env]) && env['rack.session'] && tag.attr[:method].to_s.upcase == 'POST'
         {::Rack::Csrf.field=>::Rack::Csrf.token(env)}
       end
     end

data/lib/forme/transformers/labeler.rb

@@ -55,7 +55,7 @@ module Forme
           namespaces = input.form_opts[:namespace]
           id = "#{namespaces.join('_')}#{'_' unless namespaces.empty?}#{key}"
           if key_id = input.opts[:key_id]
-            id << "_#{key_id.to_s}"
+            id += "_#{key_id.to_s}"
           end
         end
       end

data/lib/forme/version.rb

@@ -2,7 +2,7 @@
 
 module Forme
   # Version constant, use <tt>Forme.version</tt> instead.
-  VERSION = '1.4.0'.freeze
+  VERSION = '1.5.0'.freeze
 
   # Returns the version as a frozen string (e.g. '0.1.0')
   def self.version

data/lib/sequel/plugins/forme.rb

@@ -293,11 +293,11 @@ module Sequel # :nodoc:
           label = klass.send(:singularize, ref[:name])
 
           field = if ref[:type] == :pg_array_to_many
-            handle_errors(key)
             key
           else
             "#{label}_pks"
           end
+          handle_errors(field)
 
           unless opts.has_key?(:key)
             opts[:array] = true unless opts.has_key?(:array)

data/lib/sequel/plugins/forme_i18n.rb

@@ -0,0 +1,54 @@
+require 'i18n'
+require 'sequel/plugins/forme'
+
+module Sequel # :nodoc:
+  module Plugins # :nodoc:
+    # This Sequel plugin extends Forme usage with Sequel to support I18n
+    module FormeI18n
+      module SequelFormI18n
+        # Checks if there's a translation for the
+        # 'models.<table_name>.<association>' key and merge it to the options
+        # with the :legend key
+        #
+        # Calls the original Sequel::Plugins::Forme::SequelForm method
+        def subform(association, opts={}, &block)
+          i18n_key = "models.#{obj.class.table_name}.#{association}"
+
+          if opts[:legend].nil? && I18n.exists?(i18n_key)
+            opts[:legend] = I18n.t(i18n_key)
+          end
+
+          super
+        end
+      end
+
+      def self.apply(model)
+        model.plugin(:forme)
+      end
+
+      module InstanceMethods
+
+        # Includes the SequelFormI18n methods on the original returned class
+        def forme_form_class(base)
+          klass = super
+          klass.send(:include, SequelFormI18n)
+          klass
+        end
+
+        # Checks if there's a translation for the 'models.<table_name>.<field>'
+        # key and merge it to the options with the :label key
+        #
+        # Calls the original Sequel::Plugins::Forme method
+        def forme_input(form, field, opts)
+          i18n_key = "models.#{self.class.table_name}.#{field}"
+
+          if opts[:label].nil? && I18n.exists?(i18n_key)
+            opts[:label] = I18n.t(i18n_key)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/forme_set.rb

@@ -0,0 +1,121 @@
+# frozen-string-literal: true
+
+module Sequel # :nodoc:
+  module Plugins # :nodoc:
+    # The forme_set plugin makes the model instance keep track of which form
+    # inputs have been added for it. It adds a forme_set method to handle
+    # the intake of submitted data from the form.  For more complete control,
+    # it also adds a forme_parse method that returns a hash of information that can be
+    # used to modify and validate the object.
+    module FormeSet
+      SKIP_FORMATTERS = [:disabled, :readonly, ::Forme::Formatter::Disabled, ::Forme::Formatter::ReadOnly]
+
+      # Depend on the forme plugin, as forme_input already needs to be defined.
+      def self.apply(model)
+        model.plugin :forme
+      end
+
+      module InstanceMethods
+        # Hash with column name symbol keys and Forme::SequelInput values
+        def forme_inputs
+          @forme_inputs ||= {}
+        end
+
+        # Hash with column name symbol keys and <tt>[subset, allowed_values]</tt> values.  +subset+
+        # is a boolean flag, if true, the uploaded values should be a subset of the allowed values,
+        # otherwise, there should be a single uploaded value that is a member of the allowed values.
+        def forme_validations
+          @forme_validations ||= {}
+        end
+
+        # Keep track of the inputs used.
+        def forme_input(_form, field, _opts)
+          forme_inputs[field] = super
+        end
+
+        # Given the hash of submitted parameters, return a hash containing information on how to
+        # set values in the model based on the inputs used on the related form.  Currently, the
+        # hash contains the following information:
+        # :values :: A hash of values that can be used to update the model, suitable for passing
+        #            to Sequel::Model#set.
+        # :validations :: A hash of values suitable for merging into forme_validations. Used to
+        #                 check that the submitted values for associated objects match one of the
+        #                 options for the input in the form.
+        def forme_parse(params)
+          hash = {}
+          hash_values = hash[:values] = {}
+          validations = hash[:validations] = {}
+
+          forme_inputs.each do |field, input|
+            opts = input.opts
+            next if SKIP_FORMATTERS.include?(opts.fetch(:formatter){input.form.opts[:formatter]})
+
+            if attr = opts[:attr]
+              name = attr[:name] || attr['name']
+            end
+            name ||= opts[:name] || opts[:key] || next
+
+            # Pull out last component of the name if there is one
+            column = (name =~ /\[([^\[\]]+)\]\z/ ? $1 : name)
+            column = column.to_s.sub(/\[\]\z/, '').to_sym
+
+            hash_values[column] = params[column] || params[column.to_s]
+
+            next unless ref = model.association_reflection(field)
+            next unless options = opts[:options]
+
+            values = if opts[:text_method]
+              value_method = opts[:value_method] || opts[:text_method]
+              options.map(&value_method)
+            else
+              options.map{|obj| obj.is_a?(Array) ? obj.last : obj}
+            end
+
+            if ref[:type] == :many_to_one && !opts[:required]
+              values << nil
+            end
+            validations[column] = [ref[:type] != :many_to_one ? :subset : :include, values]
+          end
+
+          hash
+        end
+
+        # Set the values in the object based on the parameters parsed from the form, and add
+        # validations based on the form to ensure that associated objects match form values.
+        def forme_set(params)
+          hash = forme_parse(params)
+          set(hash[:values])
+          unless hash[:validations].empty?
+            forme_validations.merge!(hash[:validations])
+          end
+        end
+
+        # Check associated values to ensure they match one of options in the form.
+        def validate
+          super
+
+          if validations = @forme_validations
+            validations.each do |column, (type, values)|
+              value = send(column)
+
+              valid = case type
+              when :subset
+                # Handle missing value the same as the empty array,
+                # can happen with PostgreSQL array associations 
+                !value || (value - values).empty?
+              when :include
+                values.include?(value)
+              else
+                raise Forme::Error, "invalid type used in forme_validations"
+              end
+
+              unless valid
+                errors.add(column, 'invalid value submitted')
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/all.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+$: << 'lib'
+Dir['./spec/*_spec.rb'].each{|f| require f}

data/spec/forme_spec.rb

@@ -646,6 +646,10 @@ describe "Forme plain forms" do
     @f.input(:textarea, :labeler=>:explicit, :label=>'bar', :id=>:foo, :label_position=>:after).to_s.must_equal '<textarea id="foo"></textarea><label class="label-after" for="foo">bar</label>'
   end
 
+  it "inputs handle explicit labels with :key_id" do
+    @f.input(:textarea, :labeler=>:explicit, :label=>'bar', :key=>:bar, :key_id=>:foo).to_s.must_equal '<label class="label-before" for="bar_foo">bar</label><textarea id="bar_foo" name="bar"></textarea>'
+  end
+
   it "should handle explicit labels with checkboxes" do
     @f.input(:checkbox, :labeler=>:explicit, :label=>'Foo', :value=>'foo', :name=>'a', :id=>'bar').to_s.must_equal '<input id="bar_hidden" name="a" type="hidden" value="0"/><input id="bar" name="a" type="checkbox" value="foo"/><label class="label-after" for="bar">Foo</label>'
   end

data/spec/sequel_helper.rb

@@ -1,7 +1,8 @@
 require 'rubygems'
 require 'sequel/no_core_ext'
 
-DB = Sequel.sqlite
+db_url = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' ? 'jdbc:sqlite::memory:' : 'sqlite:/'
+DB = Sequel.connect(db_url)
 Sequel.default_timezone = :utc
 DB.create_table(:artists) do
   primary_key :id
@@ -50,10 +51,13 @@ u = DB[:tags].insert(:name=>'u')
 
 Sequel::Model.plugin :forme
 class Album < Sequel::Model
+  plugin :association_pks
+  plugin :forme_set
+
   many_to_one :artist, :order=>:name
   one_to_one :album_info
   one_to_many :tracks
-  many_to_many :tags
+  many_to_many :tags, :delay_pks=>:always
 
   plugin :pg_array_associations
   pg_array_to_many :atags, :class=>:Tag
@@ -65,6 +69,13 @@ class Album < Sequel::Model
   def artist_name
     artist.name if artist
   end
+
+  alias foo= name=
+
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+    # Add workaround for no boolean handling in jdbc-sqlite3
+    plugin :typecast_on_load, :gold, :platinum, :release_date, :created_at
+  end
 end
 class Artist < Sequel::Model
   one_to_many :albums

data/spec/sequel_i18n_helper.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'sequel_helper.rb')
+
+gem 'i18n', '>= 0.7.0'
+require 'i18n'
+I18n.load_path = [File.join(File.dirname(File.expand_path(__FILE__)), 'i18n_helper.yml')] 
+
+DB.create_table(:firms) do
+  primary_key :id
+  String :name
+end
+DB.create_table(:invoices) do
+  primary_key :id
+  foreign_key :firm_id, :firms
+  String :name
+  String :summary
+end
+DB.create_table(:clients) do
+  primary_key :id
+  foreign_key :firm_id, :firms
+  String :name
+end
+
+a = DB[:firms].insert(:name=>'a')
+b = DB[:invoices].insert(:name=>'b', :firm_id=>a, :summary=>'a brief summary')
+DB[:clients].insert(:name=>'a great client', :firm_id=>a)
+
+class Firm < Sequel::Model
+  one_to_many :invoices
+  one_to_many :clients
+end
+
+class Invoice < Sequel::Model
+  many_to_one :firm
+end
+
+class Client < Sequel::Model
+  many_to_one :firm
+end
+
+[Firm, Invoice, Client].each{|c| c.plugin :forme_i18n }

data/spec/sequel_i18n_plugin_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+
+begin
+  require File.join(File.dirname(File.expand_path(__FILE__)), 'sequel_i18n_helper.rb')
+rescue LoadError
+  warn "unable to load i18n, skipping i18n Sequel plugin spec"
+else
+describe "Forme Sequel::Model forms" do
+  before do
+    @ab = Invoice[1]
+    @b = Forme::Form.new(@ab)
+  end
+
+  it "should not change the usual label input if translation is not present" do
+    @b.input(:name).to_s.must_equal '<label>Name: <input id="invoice_name" name="invoice[name]" type="text" value="b"/></label>'
+  end
+
+  it "should use the translation for the label if present" do
+    @b.input(:summary).to_s.must_equal '<label>Brief Description: <input id="invoice_summary" name="invoice[summary]" type="text" value="a brief summary"/></label>'
+  end
+
+  it "should not change the usual legend for the subform if the translation is not present" do
+    Forme.form(Firm[1]){|f| f.subform(:invoices){ f.input(:name) }}.to_s.must_equal "<form class=\"forme firm\" method=\"post\"><input id=\"firm_invoices_attributes_0_id\" name=\"firm[invoices_attributes][0][id]\" type=\"hidden\" value=\"1\"/><fieldset class=\"inputs\"><legend>Invoice #1</legend><label>Name: <input id=\"firm_invoices_attributes_0_name\" name=\"firm[invoices_attributes][0][name]\" type=\"text\" value=\"b\"/></label></fieldset></form>"
+  end
+
+  it "should use the translation for the legend on the subform if present" do
+    Forme.form(Firm[1]){|f| f.subform(:clients){ f.input(:name) }}.to_s.must_equal "<form class=\"forme firm\" method=\"post\"><input id=\"firm_clients_attributes_0_id\" name=\"firm[clients_attributes][0][id]\" type=\"hidden\" value=\"1\"/><fieldset class=\"inputs\"><legend>Clientes</legend><label>Name: <input id=\"firm_clients_attributes_0_name\" name=\"firm[clients_attributes][0][name]\" type=\"text\" value=\"a great client\"/></label></fieldset></form>"
+  end
+end
+end

data/spec/sequel_plugin_spec.rb

@@ -159,6 +159,16 @@ describe "Forme Sequel::Model forms" do
     @b.input(:artist, :type=>:string, :value=>nil).to_s.must_equal '<label>Artist: <input id="album_artist" name="album[artist]" type="text"/></label>'
   end
 
+  it "should automatically set :required for many_to_one assocations based on whether the field is required" do
+    begin
+      Album.db_schema[:artist_id][:allow_null] = false
+      @b.input(:artist).to_s.must_equal '<label>Artist<abbr title="required">*</abbr>: <select id="album_artist_id" name="album[artist_id]" required="required"><option selected="selected" value="1">a</option><option value="2">d</option></select></label>'
+      @b.input(:artist, :required=>false).to_s.must_equal '<label>Artist: <select id="album_artist_id" name="album[artist_id]"><option value=""></option><option selected="selected" value="1">a</option><option value="2">d</option></select></label>'
+    ensure
+      Album.db_schema[:artist_id][:allow_null] = true
+    end
+  end
+
   it "should use a required wrapper tag for many_to_one required associations" do
     @b.input(:artist, :required=>true, :wrapper=>:li).to_s.must_equal '<li class="many_to_one required"><label>Artist<abbr title="required">*</abbr>: <select id="album_artist_id" name="album[artist_id]" required="required"><option selected="selected" value="1">a</option><option value="2">d</option></select></label></li>'
   end

data/spec/sequel_set_plugin_spec.rb

@@ -0,0 +1,183 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'sequel_helper.rb')
+
+describe "Sequel forme_set plugin" do
+  before do
+    @ab = Album.new
+    @f = Forme::Form.new(@ab)
+  end
+  
+  it "#forme_set should only set values in the form" do
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal nil
+
+    @f.input(:name)
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal 'Foo'
+
+    @ab.forme_set('copies_sold'=>'1')
+    @ab.name.must_equal nil
+    @ab.copies_sold.must_equal nil
+
+    @f.input(:copies_sold)
+    @ab.forme_set('name'=>'Bar', 'copies_sold'=>'1')
+    @ab.name.must_equal 'Bar'
+    @ab.copies_sold.must_equal 1
+  end
+  
+  it "#forme_set should handle different ways to specify parameter names" do
+    [{:attr=>{:name=>'foo'}}, {:attr=>{'name'=>:foo}}, {:name=>'foo'}, {:name=>'bar[foo]'}, {:key=>:foo}].each do |opts|
+      @f.input(:name, opts)
+
+      @ab.forme_set(:name=>'Foo')
+      @ab.name.must_equal nil
+
+      @ab.forme_set('foo'=>'Foo')
+      @ab.name.must_equal 'Foo'
+      @ab.forme_inputs.clear
+    end
+  end
+
+  it "#forme_set should ignore values where key is explicitly set to nil" do
+    @f.input(:name, :key=>nil)
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal nil
+    @ab.forme_set(nil=>'Foo')
+    @ab.name.must_equal nil
+  end
+  
+  it "#forme_set should skip inputs with disabled/readonly formatter" do
+    @f.input(:name, :formatter=>:disabled)
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal nil
+
+    @f.input(:name, :formatter=>:readonly)
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal nil
+
+    @f.input(:name, :formatter=>:default)
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal 'Foo'
+  end
+  
+  it "#forme_set should skip inputs with disabled/readonly formatter" do
+    @f = Forme::Form.new(@ab, :formatter=>:disabled)
+    @f.input(:name)
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal nil
+
+    @f = Forme::Form.new(@ab, :formatter=>:readonly)
+    @f.input(:name)
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal nil
+
+    @f.input(:name, :formatter=>:default)
+    @ab.forme_set(:name=>'Foo')
+    @ab.name.must_equal 'Foo'
+  end
+  
+  it "#forme_set should handle setting values for associated objects" do
+    @ab.forme_set(:artist_id=>1)
+    @ab.artist_id.must_equal nil
+
+    @f.input(:artist)
+    @ab.forme_set(:artist_id=>'1')
+    @ab.artist_id.must_equal 1
+
+    @ab.forme_set('tag_pks'=>%w'1 2')
+    @ab.artist_id.must_equal nil
+    @ab.tag_pks.must_equal []
+
+    @f.input(:tags)
+    @ab.forme_set('artist_id'=>'1', 'tag_pks'=>%w'1 2')
+    @ab.artist_id.must_equal 1
+    @ab.tag_pks.must_equal [1, 2]
+  end
+  
+  it "#forme_set should handle validations for filtered associations" do
+    [
+      [{:dataset=>proc{|ds| ds.exclude(:id=>1)}},
+       {:dataset=>proc{|ds| ds.exclude(:id=>1)}}],
+      [{:options=>Artist.exclude(:id=>1).select_order_map([:name, :id])},
+       {:options=>Tag.exclude(:id=>1).select_order_map(:id), :name=>'tag_pks[]'}],
+      [{:options=>Artist.exclude(:id=>1).all, :text_method=>:name, :value_method=>:id},
+       {:options=>Tag.exclude(:id=>1).all, :text_method=>:name, :value_method=>:id}],
+    ].each do |artist_opts, tag_opts|
+      @ab.forme_inputs.clear
+      @f.input(:artist, artist_opts)
+      @f.input(:tags, tag_opts)
+
+      @ab.forme_validations.clear
+      @ab.forme_set('artist_id'=>'1', 'tag_pks'=>%w'1 2')
+      @ab.artist_id.must_equal 1
+      @ab.tag_pks.must_equal [1, 2]
+
+      @ab.valid?.must_equal false
+      @ab.errors[:artist_id].must_equal ['invalid value submitted']
+      @ab.errors[:tag_pks].must_equal ['invalid value submitted']
+
+      @ab.forme_validations.clear
+      @ab.forme_set('artist_id'=>'1', 'tag_pks'=>['2'])
+      @ab.valid?.must_equal false
+      @ab.errors[:artist_id].must_equal ['invalid value submitted']
+      @ab.errors[:tag_pks].must_equal nil
+
+      @ab.forme_validations.clear
+      @ab.forme_set('artist_id'=>'2', 'tag_pks'=>['2'])
+      @ab.valid?.must_equal true
+    end
+  end
+
+  it "#forme_set should not require associated values for many_to_one association with select boxes" do
+    @f.input(:artist)
+    @ab.forme_set({})
+    @ab.valid?.must_equal true
+  end
+
+  it "#forme_set should not require associated values for many_to_one association with radio buttons" do
+    @f.input(:artist, :as=>:radio)
+    @ab.forme_set({})
+    @ab.valid?.must_equal true
+  end
+
+  it "#forme_set should require associated values for many_to_one association with select boxes when :required is used" do
+    @f.input(:artist, :required=>true)
+    @ab.forme_set({})
+    @ab.valid?.must_equal false
+    @ab.errors[:artist_id].must_equal ['invalid value submitted']
+  end
+
+  it "#forme_set should require associated values for many_to_one association with radio buttons when :required is used" do
+    @f.input(:artist, :as=>:radio, :required=>true)
+    @ab.forme_set({})
+    @ab.valid?.must_equal false
+    @ab.errors[:artist_id].must_equal ['invalid value submitted']
+  end
+
+  it "#forme_set should handle cases where currently associated values is nil" do
+    @f.input(:tags)
+    @ab.forme_set({:tag_pks=>[1]})
+    def @ab.tag_pks; nil; end
+    @ab.valid?.must_equal true
+  end
+
+  it "#forme_parse should return hash with values and validations" do
+    @f.input(:name)
+    @ab.forme_parse(:name=>'Foo').must_equal(:values=>{:name=>'Foo'}, :validations=>{})
+
+    @f.input(:artist, :dataset=>proc{|ds| ds.exclude(:id=>1)})
+    hash = @ab.forme_parse(:name=>'Foo', 'artist_id'=>'1')
+    hash[:values] = {:name=>'Foo', :artist_id=>'1'}
+    @ab.set(hash[:values])
+    @ab.valid?.must_equal true
+
+    @ab.forme_validations.merge!(hash[:validations])
+    @ab.valid?.must_equal false
+    @ab.errors[:artist_id].must_equal ['invalid value submitted']
+  end
+
+  it "#forme_parse should return hash with values and validations" do
+    @ab.forme_validations[:name] = [:bar, []]
+    proc{@ab.valid?}.must_raise Sequel::Plugins::Forme::Error
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forme
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-02 00:00:00.000000000 Z
+date: 2016-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Forme is a forms library with the following goals:
 
@@ -160,6 +174,9 @@ files:
 - lib/forme/version.rb
 - lib/roda/plugins/forme.rb
 - lib/sequel/plugins/forme.rb
+- lib/sequel/plugins/forme_i18n.rb
+- lib/sequel/plugins/forme_set.rb
+- spec/all.rb
 - spec/bs3_reference_spec.rb
 - spec/bs3_sequel_plugin_spec.rb
 - spec/bs3_spec.rb
@@ -169,7 +186,10 @@ files:
 - spec/rails_integration_spec.rb
 - spec/roda_integration_spec.rb
 - spec/sequel_helper.rb
+- spec/sequel_i18n_helper.rb
+- spec/sequel_i18n_plugin_spec.rb
 - spec/sequel_plugin_spec.rb
+- spec/sequel_set_plugin_spec.rb
 - spec/sinatra_integration_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/jeremyevans/forme