sexy_form 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f0af203c8de766b37f80dc7035d48fa38a3538d
+  data.tar.gz: 599ce829b7d97dc9c3ba0b5ec8273e3c63654b02
+SHA512:
+  metadata.gz: 98e3842d0986c28c923f5b9f368338443b341053ce5ef3554bb2a59c97fd91a423a68be6718cf9d9239bb1e748bfe0b3e3261b737c2be546302bd1010268c1fb
+  data.tar.gz: 0baf4af1e5e99584a887949a375c505061736cf88406e2014402874fa9ff6ae4eb7cb31c28a954c0cd824a6f6c3485dfac15cf4746e91037ebdbb4bd45b5deaa

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+CHANGELOG
+---------
+
+- **1.0.0** - February 15, 2019
+  - Gem Initial Release

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Weston Ganger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,275 @@
+# Sexy Form.rb
+
+<a href="https://badge.fury.io/rb/sexy_form.rb" target="_blank"><img height="21" style='border:0px;height:21px;' border='0' src="https://badge.fury.io/rb/sexy_form.rb.svg" alt="Gem Version"></a>
+<a href='https://travis-ci.org/westonganger/sexy_form.rb' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://travis-ci.org/westonganger/sexy_form.rb.svg?branch=master' border='0' alt='Build Status'></a>
+<a href='https://rubygems.org/gems/sexy_form.rb' target='_blank'><img height='21' style='border:0px;height:21px;' src='https://ruby-gem-downloads-badge.herokuapp.com/sexy_form.rb?label=rubygems&type=total&total_label=downloads&color=brightgreen' border='0' alt='RubyGems Downloads' /></a>
+<a href='https://ko-fi.com/A5071NK' target='_blank'><img height='22' style='border:0px;height:22px;' src='https://az743702.vo.msecnd.net/cdn/kofi1.png?v=a' border='0' alt='Buy Me a Coffee'></a>
+
+
+Dead simple HTML form builder for Ruby with built-in support for many popular UI libraries such as Bootstrap. Pairs nicely with any Ruby web framework such as Rails
+
+# Features
+
+- Easily generate HTML markup for forms, labels, inputs, help text and errors
+- Integrates with many UI libraries such as Bootstrap
+- Custom theme support
+
+# Supported UI Libraries
+
+Out of the box Form Builder can generate HTML markup for the following UI libraries:
+
+- Bootstrap 4 
+  * `theme: :bootstrap_4_vertical`
+  * `theme: :bootstrap_4_inline`
+  * `theme: :bootstrap_4_horizontal` or `theme: SexyForm::Themes::Bootstrap4Horizontal.new(column_classes: ["col-sm-3","col-sm-9"])`
+- Bootstrap 3
+  * `theme: :bootstrap_3_vertical`
+  * `theme: :bootstrap_3_inline`
+  * `theme: :bootstrap_3_horizontal` or `theme: SexyForm::Themes::Bootstrap3Horizontal.new(column_classes: ["col-sm-3","col-sm-9"])`
+- Bootstrap 2
+  * `theme: :bootstrap_2_vertical`
+  * `theme: :bootstrap_2_inline`
+  * `theme: :bootstrap_2_horizontal`
+- Bulma
+  * `theme: :bulma_vertical`
+  * `theme: :bulma_horizontal`
+- Foundation
+  * `theme: :foundation`
+- Materialize
+  * `theme: :materialize`
+- Milligram
+  * `theme: :milligram`
+- Semantic UI
+  * `theme: :semantic_ui_vertical`
+  * `theme: :semantic_ui_inline`
+- None (Default)
+  * `theme: :default`
+  * `theme: nil`
+  * or simply do not provide a `:theme` argument
+
+If you dont see your favourite UI library here feel free to create a PR to add it. I recommend creating an issue to discuss it first.
+
+# Installation
+
+```ruby
+gem "sexy_form"
+```
+
+# Usage
+
+The following field types are supported:
+
+- `:checkbox`
+- `:file`
+- `:hidden`
+- `:password`
+- `:radio`
+- `:select`
+- `:text`
+- `:textarea`
+
+## SexyForm in View Templates (Example in Slim)
+
+```ruby
+= SexyForm.form(theme: :bootstrap_4_vertical, action: "/products", method: :post, form_html: {style: "margin-top: 20px;", "data-foo" => "bar"}) do |f|
+  .row.main-examples
+    .col-sm-6
+      ### -- Field Options
+      ### type : (Required)
+      ### name : (Optional)
+      ### label = true : (Optional) String or Bool
+      ### help_text : (Optional)
+
+      ### value : (Optional)
+      ### -- Note: The `input_html["value"]` option will take precedence over the :value option (except for `type: :textarea/:select`)
+
+      ### errors : (Optional) String or Array of Strings
+      ### -- Note: Using an Array generates a list of help text elements. If you have an Array of errors and you only want a single help text element, then join your errors array to a single String
+
+      ### -- For the following Hash options, String keys will take precedence over any Symbol keys
+      ### input_html : (Optional) Hash ### contains attributes to be added to the input/field
+      ### label_html : (Optional) Hash ### contains attributes to be added to the label
+      ### wrapper_html : (Optional) Hash ### contains attributes to be added to the outer wrapper for the label and input
+      ### help_text_html : (Optional) Hash ### contains attributes to be added to the help text container
+      ### error_html : (Optional) Hash ### contains attributes to be added to the error container(s) 
+ 
+      = f.field name: "product[name]", label: "Name", type: :text, errors: product_errors["name"]
+
+      = f.field name: "product[description]", label: "Description", type: :textarea, input_html: {class: "foobar"}, wrapper_html: {style: "margin-top: 10px"}, label_html: {style: "color: red;"}
+
+      = f.field name: "product[file]", type: :file, help_text: "Must be a PDF", help_text_html: {style: "color: blue;"}
+
+    .col-sm-6
+      = f.field name: "product[available]", type: :checkbox, label: "In Stock?"
+
+      = f.field name: "product[class]", type: :radio, label: false
+
+      = f.field name: "product[secret]", type: :hidden, value: "foobar"
+
+  .row.select-example
+    ### -- Additional Options for `type: :select`
+    ### collection: {
+    ###   options : (Required) Array, Nested Array or String. Note: The non-Array String type is for passing in a pre-built html options string
+    ###   selected : (Optional) String or Array of Strings
+    ###   disabled : (Optional) String or Array of Strings
+    ###   include_blank : (Optional) String or Bool
+    ### }
+    ### -- Note: String keys will take precedence over any Symbol keys
+
+    ### -- When passing a Nested Array to collection[:options] the Option pairs are defined as: [required_value, optional_label]
+    - opts = [["A", "Type A"], ["B" "Type B"], ["C", "Type C"], "Other"]
+
+    = f.field name: "product[type]", label: "Type", type: :select, collection: {options: opts, selected: ["B"], disabled: ["C"]}
+```
+
+## SexyForm in Plain Ruby Code
+
+When using the `SexyForm.form` method in plain Ruby code, the `<<` syntax is required to add the generated field HTML to the form HTML string
+
+```ruby
+form_html_str = SexyForm.form(theme: :bootstrap_4_vertical, action: "/products", method: :post, form_html: {style: "margin-top: 20px;", "data-foo" => "bar"}) do |f|
+  f << f.field(name: "name", type: :text, label: "Name")
+  f << f.field(name: "sku", type: :text, label: "SKU")
+  f << %Q(<strong>Hello World</strong>"
+end
+```
+
+## SexyForm without a Form
+
+```ruby
+- f = SexyForm::Builder.new(theme: :bootstrap_4_vertical)
+
+= f.field name: "name", type: :text, label: "Name"
+= f.field name: "sku", type: :text, label: "SKU"
+```
+
+## Error Handling
+
+The form builder is capable of handling error messages too. If the `:errors` argument is provided it will generate the appropriate error help text element(s) next to the field.
+
+```ruby
+= SexyForm.form(theme: :bootstrap_4_vertical) do |f|
+  = f.field name: "name", type: :text, label: "Name", errors: "cannot be blank"
+  = f.field name: "sku", type: :text, label: "SKU", errors: ["must be unique", "incorrect SKU format")
+```
+
+## Custom Themes
+
+SexyForm allows you to create custom themes very easily.
+
+Example Usage:
+
+```ruby
+SexyForm.form(theme: :custom)
+```
+
+Example Theme Class:
+
+```ruby
+# config/initializers/sexy_form.rb
+
+module SexyForm
+  class Themes
+    class Custom < BaseTheme
+
+      ### (Optional) If your theme name doesnt perfectly match the underscored of the theme class name
+      def self.theme_name
+        "custom"
+      end
+
+      ### (Optional) If your theme requires additional variables similar to `Bootstrap3Horizontal.new(columns: ["col-sm-3", "col-sm-9"])`
+      def initialize
+        ### For an example see `lib/sexy_form/themes/bootstrap_3_horizontal.rb`
+      end
+
+      def wrap_field(field_type: , html_field: , html_label: nil, html_help_text: nil, html_errors: nil, wrapper_html_attributes: {})
+        s = ""
+
+        wrapper_html_attributes["class"] = "form-group #{wrapper_html_attributes["class"]}".strip
+
+        ### `SexyForm.build_html_attr_string` is the one and only helper method for Themes
+        ### It converts any Hash to an HTML Attributes String
+        ### Example: {"class" => "foo", "data-role" => "ninja"} converts to "class=\"foo\" data-role=\"ninja\""
+        attr_str = SexyForm.build_html_attr_string(wrapper_html_attributes)
+
+        s << "#{attr_str.empty? ? "<div>" : (<div #{attr_str}>)}"
+
+        if ["checkbox", "radio"].include?(field_type) && html_label && (i = html_label.index(">"))
+          s << html_label.insert(i+1, "#{html_field} ")
+        else
+          s << "#{html_label}"
+          s << "#{html_field}"
+        end
+        
+        s << "#{html_help_text}"
+        
+        if html_errors
+          s << html_errors.join
+        end
+
+        s << "</div>"
+
+        s
+      end
+
+      def input_html_attributes(field_type: , has_errors: , html_attrs:)
+        html_attrs["class"] = "form-field other-class #{html_attrs["class"]}".strip
+        html_attrs["style"] = "color: blue; #{html_attrs["style"]}".strip
+        
+        unless html_attrs.has_key?("data-foo")
+          html_attrs["data-foo"] = "bar"
+        end
+        
+        html_attrs
+      end
+
+      def label_html_attributes(html_attrs: , field_type: , has_errors:)
+        html_attrs["class"] = "form-label other-class #{html_attrs["class"]}".strip
+        html_attrs["style"] = "color: red; #{html_attrs["style"]}".strip
+        html_attrs
+      end
+
+      def form_html_attributes(html_attrs:)
+        html_attrs["class"] = "form-inline #{html_attrs["class"]}"
+        html_attrs
+      end
+
+      def build_html_help_text(help_text: , html_attrs:)
+        html_attrs["class"] = "help-text #{html_attrs["class"]}".strip
+
+        s = ""
+        s << (html_attrs.empty? ? "<div>" : "<div #{build_html_attr_string(html_attrs)}>")
+        s << "#{help_text}"
+        s << "</div>"
+        s
+      end
+
+      def build_html_error(error: , html_attrs:)
+        html_attrs["class"] = "help-text error #{html_attrs["class"]}".strip
+        html_attrs["style"] = "color: red; #{html_attrs["style"]}".strip
+
+        s = ""
+        s << (html_attrs.empty? ? "<div>" : "<div #{build_html_attr_string(html_attrs)}>")
+        s << "#{error}"
+        s << "</div>"
+        s
+      end
+
+    end
+  end
+end
+```
+
+# Crystal Alternative
+
+This library was originally written for Crystal language as [FormBuilder.cr](https://github.com/westonganger/form_builder.cr)
+
+The pattern/implementation of FormBuilder.cr turned out so beautifully that I felt the desire to have the same syntax available in the Ruby language. Many Ruby developers also write Crystal and vice versa so this only made sense. What was awesome is that, the Crystal and Ruby syntax is so similar that converting Crystal code to Ruby was straight forward and quite simple.
+
+# Credits
+
+Created & Maintained by [Weston Ganger](https://westonganger.com) - [@westonganger](https://github.com/westonganger)
+
+For any consulting or contract work please contact me via my company website: [Solid Foundation Web Development](https://solidfoundationwebdev.com)
+
+[![Solid Foundation Web Development Logo](https://solidfoundationwebdev.com/logo-sm.png)](https://solidfoundationwebdev.com)

data/Rakefile

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/lib/sexy_form/version')
+require 'bundler/gem_tasks'
+
+task :console do
+  require 'sexy_form'
+
+  require 'irb'
+  binding.irb
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+task test: :spec

data/lib/sexy_form.rb

@@ -0,0 +1,84 @@
+require "sexy_form/version"
+require "sexy_form/themes"
+
+### Require all themes
+require "sexy_form/themes/base_theme"
+Dir[File.join(__dir__, "sexy_form/themes/*.rb")].each do |f| 
+  require "sexy_form/themes/#{f.split("/").last}"
+end
+
+require "sexy_form/builder"
+
+module SexyForm
+  def self.form(action: nil, method: "post", theme: nil, form_html: {})
+    self.verify_argument_type(arg_name: :form_html, value: form_html, expected_type: Hash)
+
+    action = action.to_s
+    method = method.to_s
+
+    builder = SexyForm::Builder.new(theme: theme)
+
+    themed_form_html = builder.theme.form_html_attributes(html_attrs: self.safe_string_hash(form_html))
+
+    themed_form_html["method"] = method.to_s == "get" ? "get" : "post"
+
+    if themed_form_html["multipart"] == true
+      themed_form_html.delete("multipart")
+      themed_form_html["enctype"] = "multipart/form-data"
+    end
+
+    str = ""
+
+    str << %Q(<form #{self.build_html_attr_string(themed_form_html)}>)
+
+    unless ["get", "post"].include?(method.to_s)
+      str << %Q(<input type="hidden" name="_method" value="#{method}")
+    end
+
+    if block_given?
+      yield builder
+    end
+
+    unless builder.html_string.empty?
+      str << builder.html_string
+    end
+
+    str << "</form>"
+
+    str
+  end
+
+  protected
+
+  def self.build_html_attr_string(hash)
+    hash.map{|k, v| "#{k}=\"#{v}\""}.join(" ")
+  end
+
+  def self.safe_string_hash(h)
+    new_h = {}
+    h.each do |k, v|
+      unless new_h.has_key?(k.to_s)
+        if k.is_a?(String)
+          new_h[k] = v
+        elsif !h.has_key?(k.to_s)
+          new_h[k.to_s] = v
+        end
+      end
+    end
+    new_h
+  end
+
+  def self.verify_argument_type(arg_name:, value:, expected_type:)
+    if expected_type.is_a?(Array)
+      invalid = expected_type.all?{|t| !value.is_a?(t) }
+    elsif !value.is_a?(expected_type)
+      invalid = true
+    end
+
+    if invalid
+      raise ArgumentError.new("Invalid type passed to argument :#{arg_name}")
+    end
+  end
+  ### END PROTECTED METHODS
+
+end

data/lib/sexy_form/builder.rb

@@ -0,0 +1,306 @@
+module SexyForm
+  class Builder
+    FIELD_TYPES = ["checkbox", "file", "hidden", "password", "radio", "select", "text", "textarea"].freeze
+    INPUT_TYPES = ["checkbox", "file", "hidden", "password", "radio", "text"].freeze
+    COLLECTION_KEYS = ["options", "selected", "disabled", "include_blank"].freeze
+
+    def initialize(theme: nil)
+      @html = []
+
+      if theme
+        if theme.is_a?(SexyForm::Themes::BaseTheme)
+          @theme = theme
+        else
+          @theme = Themes.from_name(theme.to_s).new
+        end
+      else
+        @theme = SexyForm::Themes::Default.new
+      end
+    end
+
+    def theme
+      @theme
+    end
+
+    def <<(v)
+      v = v.to_s
+      @html.push(v)
+      v
+    end
+
+    ### This method should be considered private
+    def html_string
+      @html.join("")
+    end
+
+    def field(
+      type: ,
+      name: nil,
+      value: nil,
+      label: nil,
+      help_text: nil,
+      errors: nil,
+      input_html: {},
+      label_html: {},
+      help_text_html: {},
+      wrapper_html: {},
+      error_html: {},
+      collection: nil
+    )
+      type = type.to_s
+
+      unless FIELD_TYPES.include?(type)
+        raise ArgumentError.new("Invalid :type argument, valid field types are: #{FIELD_TYPES.join(", ")}`")
+      end
+
+      if collection && type != "select"
+        raise ArgumentError.new("Argument :collection is not supported for type: :#{type}")
+      end
+
+      if errors
+        SexyForm.verify_argument_type(arg_name: :errors, value: errors, expected_type: [Array, String])
+      end
+
+      SexyForm.verify_argument_type(arg_name: :input_html, value: input_html, expected_type: Hash)
+      SexyForm.verify_argument_type(arg_name: :label_html, value: label_html, expected_type: Hash)
+      SexyForm.verify_argument_type(arg_name: :wrapper_html, value: wrapper_html, expected_type: Hash)
+      SexyForm.verify_argument_type(arg_name: :help_text_html, value: help_text_html, expected_type: Hash)
+      SexyForm.verify_argument_type(arg_name: :error_html, value: error_html, expected_type: Hash)
+
+      if errors
+        if errors.is_a?(String)
+          errors = errors.empty? ? nil : [errors]
+        else
+          errors = errors.reject{|x| x.empty?}
+
+          if errors.empty?
+            errors = nil
+          end
+        end
+
+        if errors.nil?
+          html_errors = errors.map{|x| 
+            @theme.build_html_error(error: x, field_type: type, html_attrs: SexyForm.safe_string_hash(errors))
+          }
+        end
+      end
+
+      themed_input_html = @theme.input_html_attributes(html_attrs: SexyForm.safe_string_hash(input_html), field_type: type, has_errors: (errors && !errors.empty?))
+
+      themed_label_html = @theme.label_html_attributes(html_attrs: SexyForm.safe_string_hash(label_html), field_type: type, has_errors: (errors && !errors.empty?))
+
+      if name
+        themed_input_html["name"] ||= name.to_s
+
+        unless themed_input_html.has_key?("id")
+          themed_input_html["id"] = css_safe(name)
+        end
+      end
+
+      if !themed_input_html.has_key?("value") && value && !value.to_s.empty? && INPUT_TYPES.include?(type)
+        themed_input_html["value"] = value.to_s
+      end
+
+      if themed_input_html.has_key?("id")
+        themed_label_html["for"] ||= themed_input_html["id"]
+      end
+
+      if ["checkbox", "radio"].include?(type)
+        ### Allow passing checked=true/false
+        if themed_input_html["checked"] == "true"
+          themed_input_html["checked"] = "checked"
+        elsif themed_input_html["checked"] == "false"
+          themed_input_html.delete("checked")
+        end
+      end
+
+      case type
+      when "checkbox"
+        html_field = input_field(type: type, attrs: themed_input_html)
+      when "file"
+        html_field = input_field(type: type, attrs: themed_input_html)
+      when "hidden"
+        html_field = input_field(type: type, attrs: themed_input_html)
+      when "password"
+        html_field = input_field(type: type, attrs: themed_input_html)
+      when "radio"
+        html_field = input_field(type: type, attrs: themed_input_html)
+      when "select"
+        if !collection
+          raise ArgumentError.new("Required argument `:collection` not provided")
+        end
+
+        SexyForm.verify_argument_type(arg_name: :collection, value: collection, expected_type: Hash)
+
+        safe_collection = SexyForm.safe_string_hash(collection)
+
+        if safe_collection.keys.any?{|x| !COLLECTION_KEYS.include?(x) }
+          raise ArgumentError.new("Invalid key passed to :collection argument. Supported keys are #{COLLECTION_KEYS.map{|x| ":#{x}"}.join(", ")}")
+        end
+
+        if !safe_collection.has_key?("options")
+          raise ArgumentError.new("Required argument `collection[:options]` not provided")
+        end
+
+        if safe_collection["options"].is_a?(Array)
+          collection_options = safe_collection["options"].map do |x|
+            if x.is_a?(Enumerable)
+              x.first(2).map{|y| y.respond_to?(:to_s) ? y.to_s : ""}
+            else
+              [(x.respond_to?(:to_s) ? x.to_s : "")]
+            end
+          end
+        elsif safe_collection["options"].is_a?(String)
+          collection_options = safe_collection["options"]
+        else
+          raise ArgumentError.new("Invalid type passed to argument `collection[:options]``")
+        end
+
+        if collection_options.is_a?(String)
+          ["selected", "disabled", "include_blank"].each do |k|
+            if safe_collection.has_key?(k)
+              raise ArgumentError.new("Argument `collection[:#{k}]` is not allowed when passing a pre-made HTML Options String to `collection[:options]`")
+            end
+          end
+        else
+          if safe_collection.has_key?("include_blank") && safe_collection["include_blank"] != false
+            collection_options.unshift([(safe_collection["include_blank"] == true ? "" : "#{safe_collection["include_blank"]}")])
+          end
+
+          if safe_collection.has_key?("selected")
+            if safe_collection["selected"].is_a?(Array)
+              collection_selected = safe_collection["selected"].map{|x| x.respond_to?(:to_s) ? x.to_s : ""}
+            else
+              collection_selected = [safe_collection["selected"].to_s]
+            end
+          end
+
+          if safe_collection.has_key?("disabled")
+            if safe_collection["disabled"].is_a?(Array)
+              collection_disabled = safe_collection["disabled"].map{|x| x.respond_to?(:to_s) ? x.to_s : ""}
+            else
+              collection_disabled = [safe_collection["disabled"].to_s]
+            end
+          end
+        end
+
+        if value && safe_collection["selected"]
+          raise ArgumentError.new("Cannot provide :value and :selected arguments together. The :selected argument is recommended for field `type: :select.`")
+        else
+          v = safe_collection["selected"] || value
+          if v
+            safe_collection["selected"] = v
+          end
+        end
+
+        html_field = select_field(options: collection_options, selected: collection_selected, disabled: collection_disabled, attrs: themed_input_html)
+      when "text"
+        html_field = input_field(type: type, attrs: themed_input_html)
+      when "textarea"
+        if themed_input_html.has_key?("size")
+          themed_input_html["cols"], themed_input_html["rows"] = themed_input_html.delete("size").to_s.split("x")
+        end
+
+        html_field = ""
+        html_field << (themed_input_html.empty? ? "<textarea>" : "<textarea #{SexyForm.build_html_attr_string(themed_input_html)}>")
+        html_field << "#{themed_input_html["value"]}"
+        html_field << "</textarea>"
+      end
+
+      if label != false
+        if label.is_a?(String)
+          label_text = label
+        elsif [nil, true].include?(label) && name
+          label_text = titleize(name)
+        end
+
+        if label_text
+          html_label = ""
+          html_label << (themed_label_html.empty? ? "<label>" : "<label #{SexyForm.build_html_attr_string(themed_label_html)}>")
+          html_label << label_text
+          html_label << "</label>"
+        end
+      end
+
+      if help_text
+        html_help_text = @theme.build_html_help_text(field_type: type, help_text: help_text, html_attrs: SexyForm.safe_string_hash(help_text_html))
+      end
+
+      @theme.wrap_field(
+        field_type: type,
+        html_field: html_field,
+        html_label: html_label,
+        html_help_text: html_help_text,
+        html_errors: html_errors,
+        wrapper_html_attributes: SexyForm.safe_string_hash(wrapper_html)
+      )
+    end
+
+    private
+
+    def input_field(type: , attrs: {})
+      unless INPUT_TYPES.include?(type.to_s)
+        raise ArgumentError.new("Invalid input :type, valid input types are `#{INPUT_TYPES.join(", ")}`")
+      end
+
+      attrs.delete("type")
+
+      boolean_attrs = []
+
+      ["disabled"].each do |opt|
+        if attrs[opt]
+          boolean_attrs.push(attrs[opt])
+          attrs.delete(opt)
+        end
+      end
+
+      str_attrs = attrs.map{|k, v| "#{k}=\"#{v}\""}
+
+      if !boolean_attrs.empty?
+        str_attrs.push(boolean_attrs.join(" "))
+      end
+
+      "<input type=\"#{type}\"#{" " unless str_attrs.empty?}#{str_attrs.join(" ")}>"
+    end
+
+    def select_field(options:, selected: nil, disabled: nil, attrs: {})
+      s = ""
+
+      s << (attrs.empty? ? "<select>" : "<select #{SexyForm.build_html_attr_string(attrs)}>")
+
+      if options.is_a?(String)
+        s << options
+      else
+        options.map do |option|
+          v = option[0].to_s
+
+          s << "<option value=\"#{v}\""
+
+          if selected
+            s << "#{" selected=\"selected\"" if selected.include?(v)}"
+          end
+
+          if disabled
+            s << "#{" disabled=\"disabled\"" if disabled.include?(v)}"
+          end
+
+          s << ">#{option[1] || v}</option>"
+        end
+      end
+
+      s << "</select>"
+
+      s
+    end
+
+    def css_safe(value)
+      values = value.to_s.strip.split(" ")
+      values.map{|v| v.gsub(/[^\w-]+/, " ").strip.gsub(/\s+/, "_")}.join(" ")
+    end
+
+    def titleize(value)
+      value.to_s.gsub(/\W|_/, " ").split(" ").map{|x| x.capitalize}.join(" ")
+    end
+
+  end
+end