forme 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f907e786f16f2b923a7b06def6a58680fc922d27
-  data.tar.gz: 88e4c51dc087507766783ee18b45fac47cf8007d
+  metadata.gz: b392c21e8ea5b18c3b1c125b84c36379b40595bf
+  data.tar.gz: de4ef22b48745082a9661989dd745824ef75ea07
 SHA512:
-  metadata.gz: d76cdda658389678ae596350be89a0f42c9e6210ec55bf28d9c7f1df8615b429c0e537475616f9e37e77027d6123012538aa0a997967484954e2c8d598b58247
-  data.tar.gz: 283d18147c8ca75e75b000af73d4a90030f65b672ff242b6124473ff5ed626a0a5fc9ec7798db6e62a497d0557b17d79ca9adde1b60065df36e7b5cf285aa71e
+  metadata.gz: bfc76ba5baa373ce677fe2fc7f44703d2e8783b9752e667a356a454293b11efecabe4b03fab498b040ac7afd3e0bc10a09f463681f5b839fa7620a984ba7bc1b
+  data.tar.gz: 93b41b112be039b14e2368618e9bc00d8599d7935828fddc27870bdd1426199c58fbc6c63b4085c48368e87c717ed5b0f952d76d684143ef455e1d19854c078f

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 1.4.0 (2016-02-01)
+
+* Ignore submit buttons when using the :readonly formatter (jeremyevans)
+
+* Respect :formatter option for radioset and checkboxset inputs (jeremyevans)
+
+* Add support for running with --enable-frozen-string-literal on ruby 2.3 (jeremyevans)
+
+* Integrate with the Sequel association_pks plugin in the Sequel plugin (jeremyevans)
+
+* Do not add required * to label if :label=>nil in the Sequel plugin (jeremyevans)
+
+* Add forme/bs3 library for Bootstrap 3 support (kematzy, jeremyevans) (#12, #14)
+
+* Support an :html option in the default formatter to override the HTML created (jeremyevans)
+
 === 1.3.0 (2015-04-17)
 
 * Support option groups in select, checkboxset, and radioset inputs via :optgroups option (jeremyevans)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2015 Jeremy Evans
+Copyright (c) 2011-2016 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -73,7 +73,6 @@ passing the appopriate option to +input+ or +inputs+:
 
   f.input(:name, :wrapper=>:p)
 
-
 = Installation
 
   gem install forme
@@ -842,6 +841,15 @@ You can mark a configuration as the default using:
 
   Forme.default_config = :mine
 
+=== Bootstrap 3 Support
+
+Forme ships with support for Bootstrap 3 HTML formatting. This support is shipped in
+it's own file, so if you don't use it, you don't pay the memory penalty for loading
+it.
+
+  require 'forme/bs3'
+  Forme.default_config = :bs3
+
 = Other Similar Projects
 
 All of these have external dependencies:

data/Rakefile

@@ -48,45 +48,16 @@ end
 
 ### Specs
 
-begin
-  begin
-    raise LoadError if ENV['RSPEC1']
-    # RSpec 2+
-    require "rspec/core/rake_task"
-    spec_class = RSpec::Core::RakeTask
-    spec_files_meth = :pattern=
-  rescue LoadError
-    # RSpec 1
-    require "spec/rake/spectask"
-    spec_class = Spec::Rake::SpecTask
-    spec_files_meth = :spec_files=
-  end
-
-  spec = lambda do |name, files, d|
-    lib_dir = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
-    ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
-    desc d
-    spec_class.new(name) do |t|
-      t.send spec_files_meth, files
-      t.spec_opts = ENV["#{NAME.upcase}_SPEC_OPTS"].split if ENV["#{NAME.upcase}_SPEC_OPTS"]
-    end
-  end
-
-  spec_with_cov = lambda do |name, files, d|
-    spec.call(name, files, d)
-    desc "#{d} with coverage"
-    task "#{name}_cov" do
-      ENV['COVERAGE'] = '1'
-      Rake::Task[name].invoke
-    end
-  end
-  
-  task :default => [:spec]
-  spec_with_cov.call("spec", Dir["spec/*_spec.rb"], "Run specs")
-rescue LoadError
-  task :default do
-    puts "Must install rspec to run the default task (which runs specs)"
-  end
+desc "Run specs"
+task :spec do
+  sh "#{FileUtils::RUBY} -rubygems -I lib -e 'ARGV.each{|f| require f}' ./spec/*_spec.rb"
+end
+task :default => :spec
+
+desc "Run specs with coverage"
+task :spec do
+  ENV['COVERAGE'] = '1'
+  Rake::Task['spec'].invoke
 end
 
 ### Other

data/lib/forme.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 require 'date'
 require 'bigdecimal'
 
@@ -18,7 +20,7 @@ module Forme
   end
 
   # Array of all supported transformer types.
-  TRANSFORMER_TYPES = [:formatter, :serializer, :wrapper, :error_handler, :helper, :labeler, :inputs_wrapper]
+  TRANSFORMER_TYPES = [:formatter, :serializer, :wrapper, :error_handler, :helper, :labeler, :inputs_wrapper, :tag_wrapper, :set_wrapper]
 
   # Transformer symbols shared by wrapper and inputs_wrapper
   SHARED_WRAPPERS = [:tr, :table, :ol, :fieldset_ol]
@@ -37,6 +39,7 @@ module Forme
     CONFIGURATIONS[:default][t] = :default
     TRANSFORMERS[t] = {}
   end
+  CONFIGURATIONS[:default].delete(:set_wrapper)
 
   # Register a new transformer with this library. Arguments:
   # +type+ :: Transformer type symbol
@@ -91,7 +94,7 @@ module Forme
       case type
       when :inputs_wrapper
         yield
-      when :labeler, :error_handler, :wrapper, :helper
+      when :labeler, :error_handler, :wrapper, :helper, :set_wrapper, :tag_wrapper
         args.first
       else
         raise Error, "No matching #{type}: #{trans_name.inspect}"
@@ -107,9 +110,10 @@ module Forme
   #           default transformer for the receiver.
   # +nil+ :: Assume the default transformer for this receiver.
   # otherwise :: return +trans+ directly if it responds to +call+, and raise an +Error+ if not.
-  def self.transformer(type, trans, default_opts)
+  def self.transformer(type, trans, default_opts=nil)
     case trans
     when Symbol
+      type = :wrapper if type == :set_wrapper || type == :tag_wrapper
       TRANSFORMERS[type][trans] || raise(Error, "invalid #{type}: #{trans.inspect} (valid #{type}s: #{TRANSFORMERS[type].keys.map(&:inspect).join(', ')})")
     when Hash
       if trans.has_key?(type)
@@ -120,7 +124,7 @@ module Forme
         transformer(type, nil, default_opts)
       end
     when nil
-      transformer(type, default_opts[type], nil) if default_opts
+      transformer(type, default_opts[type]) if default_opts
     else
       if trans.respond_to?(:call)
         trans

data/lib/forme/bs3.rb

@@ -0,0 +1,387 @@
+# frozen-string-literal: true
+
+module Forme
+  register_config(:bs3, :formatter=>:bs3, :inputs_wrapper=>:bs3, :wrapper=>:bs3, :error_handler=>:bs3, :serializer=>:bs3, :labeler=>:bs3, :tag_wrapper=>:bs3, :set_wrapper=>:div)
+
+  # BS3 Boostrap formatted error handler which adds a span tag 
+  # with "help-block with-errors" classes for the error message.
+  # 
+  # Uses [github.com/1000hz/bootstrap-validator] formatting.
+  # 
+  # Note! The default "error" class on the input is being removed.
+  #
+  # Registered as :bs3.
+  class ErrorHandler::Bootstrap3 < ErrorHandler
+    Forme.register_transformer(:error_handler, :bs3, new)
+
+    # Return tag with error message span tag after it.
+    def call(tag, input)
+      if tag.is_a?(Tag)
+        tag.attr[:class] = tag.attr[:class].to_s.gsub(/\s*error\s*/,'')
+        tag.attr.delete(:class) if tag.attr[:class].to_s == ''
+      end
+      attr = input.opts[:error_attr]
+      attr = attr ? attr.dup : {}
+      Forme.attr_classes(attr, 'help-block with-errors')
+      return [tag] if input.opts[:skip_error_message]
+
+      case input.type
+      when :submit, :reset
+        [tag]
+      when :textarea
+        input.opts[:wrapper] = :bs3
+        if input.opts[:wrapper_attr]
+          Forme.attr_classes(input.opts[:wrapper_attr], 'has-error')
+        else
+          input.opts[:wrapper_attr] = { :class => 'has-error' }
+        end
+        [ tag, input.tag(:span, attr, input.opts[:error]) ]
+        
+      when :select
+        input.opts[:wrapper] = :bs3
+        if input.opts[:wrapper_attr]
+          Forme.attr_classes(input.opts[:wrapper_attr], 'has-error')
+        else
+          input.opts[:wrapper_attr] = { :class => 'has-error' }
+        end
+        [ tag, input.tag(:span, attr, input.opts[:error]) ]
+        
+      when :checkbox, :radio
+        
+        input.opts[:wrapper] = :div
+        if input.opts[:wrapper_attr]
+          Forme.attr_classes(input.opts[:wrapper_attr], 'has-error')
+        else
+          input.opts[:wrapper_attr] = { :class => 'has-error' }
+        end
+        
+        [ 
+          input.tag(:div, { :class=> input.type.to_s }, [tag] ), 
+          input.tag(:span, attr, input.opts[:error]) 
+        ]
+      else
+        if input.opts[:wrapper_attr]
+          Forme.attr_classes(input.opts[:wrapper_attr], 'has-error')
+        else
+          input.opts[:wrapper_attr] = { :class => 'has-error' }
+        end
+        [tag, input.tag(:span, attr, input.opts[:error])]
+      end
+    end
+  end
+
+  class Formatter::Bs3 < Formatter
+    Forme.register_transformer(:formatter, :bs3, self)
+
+    private
+
+    # Copied to remove .error from class attrs
+    def normalize_options
+      copy_options_to_attributes(ATTRIBUTE_OPTIONS)
+      copy_boolean_options_to_attributes(ATTRIBUTE_BOOLEAN_OPTIONS)
+      handle_key_option
+
+      Forme.attr_classes(@attr, @opts[:class]) if @opts.has_key?(:class)
+      # Forme.attr_classes(@attr, 'error') if @opts[:error]
+
+      if data = opts[:data]
+        data.each do |k, v|
+          sym = :"data-#{k}"
+          @attr[sym] = v unless @attr.has_key?(sym)
+        end
+      end
+    end
+
+    def set_label
+      form._tag(:span, {:class=>'set-label'}, @opts[:set_label])
+    end
+
+    def _add_set_error(tags)
+      tags << input.tag(:span, {:class=>'help-block with-errors'}, @opts[:set_error])
+    end
+
+    def format_radioset
+      @opts[:wrapper_attr] ||= {}
+      klasses = 'radioset'
+      klasses = @opts[:error] || @opts[:set_error] ? "#{klasses} has-error" : klasses
+      Forme.attr_classes(@opts[:wrapper_attr], klasses)
+      super
+    end
+
+    def format_checkboxset
+      @opts[:wrapper_attr] ||= {}
+      klasses = 'checkboxset'
+      klasses = @opts[:error] || @opts[:set_error] ? "#{klasses} has-error" : klasses
+      Forme.attr_classes(@opts[:wrapper_attr], klasses)
+      super
+    end
+    
+    def _format_set(type, tag_attrs={})
+      raise Error, "can't have radioset with no options" unless @opts[:optgroups] || @opts[:options]
+      key = @opts[:key]
+      name = @opts[:name]
+      id = @opts[:id]
+      if @opts[:error]
+        @opts[:set_error] = @opts.delete(:error)
+      end
+      if @opts[:label]
+        @opts[:set_label] = @opts.delete(:label)
+      end
+
+      tag_wrapper = Forme.transformer(:tag_wrapper, @opts.delete(:tag_wrapper), @input.form_opts) || :default
+      wrapper = @opts.fetch(:wrapper){@opts[:wrapper] = @input.form_opts[:set_wrapper] || @input.form_opts[:wrapper]}
+      wrapper = Forme.transformer(:wrapper, wrapper)
+
+      tags = process_select_optgroups(:_format_set_optgroup) do |label, value, sel, attrs|
+        value ||= label
+        r_opts = attrs.merge(tag_attrs).merge(:label=>label||value, :label_attr=>{:class=>:option}, :wrapper=>tag_wrapper)
+        r_opts[:value] ||= value if value
+        r_opts[:checked] ||= :checked if sel
+
+        if name
+          r_opts[:name] ||= name
+        end
+        if id
+          r_opts[:id] ||= "#{id}_#{value}"
+        end
+        if key
+          r_opts[:key] ||= key
+          r_opts[:key_id] ||= value
+        end
+
+        form._input(type, r_opts)
+      end
+
+      if @opts[:set_error]
+       _add_set_error(tags)
+      end
+
+      tags.unshift(form._tag(:label, {}, @opts[:set_label])) if @opts[:set_label]
+
+      tags
+    end
+    
+  end
+  
+  # Formatter that adds "readonly" for most input types,
+  # and disables select/radio/checkbox inputs.
+  #
+  # Registered as :bs3_readonly.
+  class Formatter::Bs3ReadOnly < Formatter
+    Forme.register_transformer(:formatter, :bs3_readonly, self)
+
+    private
+
+    # Disabled checkbox inputs.
+    def format_checkbox
+      @attr[:disabled] = :disabled
+      super
+    end
+
+    # Use a span with text instead of an input field.
+    def _format_input(type)
+      @attr[:readonly] = :readonly
+      super
+    end
+
+    # Disabled radio button inputs.
+    def format_radio
+      @attr[:disabled] = :disabled
+      super
+    end
+
+    # Use a span with text of the selected values instead of a select box.
+    def format_select
+      @attr[:disabled] = :disabled
+      super
+    end
+
+    # Use a span with text instead of a text area.
+    def format_textarea
+      @attr[:readonly] = :readonly
+      super
+    end
+  end
+
+  # Use a <fieldset> tag to wrap the inputs.
+  #
+  # Registered as :bs3.
+  class InputsWrapper::Bootstrap3
+    Forme.register_transformer(:inputs_wrapper, :bs3, new)
+
+    def call(form, opts, &block)
+      attr = opts[:attr] ? opts[:attr].dup : {}
+      Forme.attr_classes(attr, 'inputs')
+      if legend = opts[:legend]
+        form.tag(:fieldset, attr) do
+          form.emit(form.tag(:legend, opts[:legend_attr], legend))
+          yield
+        end
+      else
+        form.tag(:fieldset, attr, &Proc.new)
+      end
+    end
+  end
+
+  # Use a <table class="table"> tag to wrap the inputs.
+  #
+  # Registered as :bs3_table.
+  class InputsWrapper::Bs3Table
+    Forme.register_transformer(:inputs_wrapper, :bs3_table, new)
+
+    # Wrap the inputs in a <table> tag.
+    def call(form, opts, &block)
+      attr = opts[:attr] ? opts[:attr].dup : { :class=>'table table-bordered'}
+      form.tag(:table, attr) do
+        if legend = opts[:legend]
+          form.emit(form.tag(:caption, opts[:legend_attr], legend))
+        end
+
+        if (labels = opts[:labels]) && !labels.empty?
+          form.emit(form.tag(:tr, {}, labels.map{|l| form._tag(:th, {}, l)}))
+        end
+
+        yield
+      end
+    end
+  end
+
+  # Labeler that creates BS3 label tags referencing the the given tag's id 
+  # using a +for+ attribute. Requires that all tags with labels have +id+ fields.
+  #
+  # Registered as :bs3.
+  class Labeler::Bootstrap3
+    Forme.register_transformer(:labeler, :bs3, new)
+
+    # Return an array with a label tag as the first entry and +tag+ as
+    # a second entry.  If the +input+ has a :label_for option, use that,
+    # otherwise use the input's :id option.  If neither the :id or
+    # :label_for option is used, the label created will not be
+    # associated with an input.
+    def call(tag, input)
+      unless id = input.opts[:id]
+        if key = input.opts[:key]
+          namespaces = input.form_opts[:namespace]
+          id = "#{namespaces.join('_')}#{'_' unless namespaces.empty?}#{key}"
+          if key_id = input.opts[:key_id]
+            id += "_#{key_id.to_s}"
+          end
+        end
+      end
+
+      label_attr = input.opts[:label_attr]
+      label_attr = label_attr ? label_attr.dup : {}
+      
+      label_attr[:for] = label_attr[:for] === false ? nil : input.opts.fetch(:label_for, id)
+      label = input.opts[:label]
+      lpos = input.opts[:label_position] || ([:radio, :checkbox].include?(input.type) ? :after : :before)
+      
+      case input.type
+      when :checkbox, :radio
+        label = if lpos == :before
+          [label, ' ', tag]
+        else
+          [tag, ' ', label]
+        end
+        input.tag(:label, label_attr, label)
+      when :submit
+        [tag]
+      else
+        label = input.tag(:label, label_attr, [input.opts[:label]])
+        if lpos == :after
+          [tag, ' ', label]
+        else
+          [label, ' ', tag]
+        end
+      end
+    end
+  end
+  
+  # Wraps inputs with <div class="form-group">
+  class Wrapper::Bootstrap3 < Wrapper
+    # Wrap the input in the tag of the given type.
+
+    def call(tag, input)
+      attr = input.opts[:wrapper_attr] ? input.opts[:wrapper_attr].dup : { }
+      klass = attr[:class] ? attr[:class].split(' ').unshift('form-group').uniq : ['form-group']
+      
+      case input.type
+      when :submit, :reset
+        klass.delete('form-group')
+        attr[:class] = klass.sort.uniq.join(' ').strip
+        attr.delete(:class) if attr[:class].empty?
+        [tag]
+      when :radio, :checkbox
+        klass.delete('form-group')
+        klass.unshift( input.type.to_s )
+        attr[:class] = klass.sort.uniq.join(' ').strip
+        [input.tag(:div, attr, tag)]
+      when :hidden
+        super
+      else
+        attr[:class] = klass.sort.uniq.join(' ').strip
+        [input.tag(:div, attr, [tag])]
+      end
+
+    end
+    
+    Forme.register_transformer(:wrapper, :bs3, new)
+  end
+  
+  # Serializer class that converts tags to BS3 bootstrap tags.
+  #
+  # Registered at :bs3.
+  class Serializer::Bootstrap3 < Serializer
+    Forme.register_transformer(:serializer, :bs3, new)
+
+    def call(tag)
+      # All textual <input>, <textarea>, and <select> elements with .form-control
+      case tag
+      when Tag
+        case tag.type
+        when :input
+          # default to <input type="text"...> if not set
+          tag.attr[:type] = :text if tag.attr[:type].nil?
+          
+          case tag.attr[:type].to_sym
+          when :checkbox, :radio, :hidden
+            # .form-control class causes rendering problems, so remove if found
+            tag.attr[:class].gsub!(/\s*form-control\s*/,'') if tag.attr[:class]
+            tag.attr[:class] = nil if tag.attr[:class] && tag.attr[:class].empty?
+            
+          when :file
+            tag.attr[:class] = nil unless tag.attr[:class] && tag.attr[:class].strip != ''
+          
+          when :submit, :reset
+            klass = ['btn', 'btn-default']
+            if tag.attr[:class] && tag.attr[:class].strip != ''
+              tag.attr[:class].split(' ').each { |c| klass.push c }
+            end
+            tag.attr[:class] = klass.uniq
+            ['btn-primary','btn-success', 'btn-info', 'btn-warning','btn-danger',
+              'btn-outline','btn-link' 
+            ].each do |k|
+              tag.attr[:class].delete('btn-default') if tag.attr[:class].include?(k)
+            end
+            tag.attr[:class].join(' ')
+            
+          else
+            klass = tag.attr[:class] ? "form-control #{tag.attr[:class].to_s}" : ''
+            tag.attr[:class] = "form-control #{klass.gsub(/\s*form-control\s*/,'')}".strip
+          end
+          
+          return "<#{tag.type}#{attr_html(tag.attr)}/>"
+          
+        when :textarea, :select
+          klass = tag.attr[:class] ? "form-control #{tag.attr[:class].to_s}" : ''
+          tag.attr[:class] = "form-control #{klass.gsub(/\s*form-control\s*/,'')}".strip
+          return "#{serialize_open(tag)}#{call(tag.children)}#{serialize_close(tag)}"
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+  end
+end