form 0.0.0 → 0.0.1.alpha1

data/Gemfile.lock

@@ -1,12 +1,22 @@
 PATH
   remote: .
   specs:
-    form (0.0.0)
+    form (0.0.1.alpha1)
+      i18n
 
 GEM
   remote: http://rubygems.org/
   specs:
+    awesome_print (1.0.2)
+    coderay (1.0.5)
     diff-lcs (1.1.3)
+    i18n (0.6.0)
+    method_source (0.7.0)
+    nokogiri (1.5.0)
+    pry (0.9.8.2)
+      coderay (~> 1.0.5)
+      method_source (~> 0.7)
+      slop (>= 2.4.4, < 3)
     rake (0.9.2.2)
     rspec (2.8.0)
       rspec-core (~> 2.8.0)
@@ -16,11 +26,15 @@ GEM
     rspec-expectations (2.8.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.8.0)
+    slop (2.4.4)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  awesome_print
   form!
+  nokogiri (~> 1.5)
+  pry
   rake (~> 0.9)
   rspec (~> 2.8)

data/README.rdoc

@@ -1,6 +1,6 @@
 = form
 
-A simple form field for Ruby objects.
+A simple form builder for Ruby objects.
 
 == Installation
 

data/examples/hash.rb

@@ -0,0 +1,27 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "form"
+
+params = {
+  :name => "John Doe",
+  :email => "john@example.org",
+  :bio => "Code-addicted.\nThat's all you need to know about me."
+}
+
+# The first argument indicates the datasource.
+# In this case, we're using a simple hash.
+# The second argument indicates the root name
+# that will compose the input's name.
+form = Form.new(params, :user)
+
+# Just output an input[type=text].
+puts form.text(:name)
+
+# Same fashion, just output an input[type=email]
+puts form.email(:email)
+
+# More inputs.
+puts form.textarea(:bio)
+puts form.submit(:create)
+
+# Output the label for name attribute.
+puts form.label(:name)

data/examples/object.rb

@@ -0,0 +1,19 @@
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "form"
+require "ostruct"
+
+user = OpenStruct.new({
+  :name => "John Doe",
+  :email => "john@example.org"
+})
+
+# Similar to hash datasource, but using a
+# regular object with attributes instead.
+#
+# Form just doesn't care about datasource's type.
+# Just provide a object that responds to [] method
+# or to the attribute you want.
+form = Form.new(user, :user)
+
+puts form.text :name
+puts form.email :email

data/form.gemspec

@@ -17,7 +17,10 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # s.add_dependency "activesupport"
+  s.add_dependency "i18n"
   s.add_development_dependency "rake", "~> 0.9"
   s.add_development_dependency "rspec", "~> 2.8"
+  s.add_development_dependency "nokogiri", "~> 1.5"
+  s.add_development_dependency "awesome_print"
+  s.add_development_dependency "pry"
 end

data/lib/form/builder.rb

@@ -0,0 +1,130 @@
+module Form
+  class Builder
+    # The object that will be used to fulfill inputs.
+    #
+    attr_accessor :data
+
+    # The input's base name.
+    #
+    attr_accessor :base_name
+
+    # Initialize a new form builder.
+    #
+    def initialize(data = nil, base_name = nil)
+      @data = data
+      @base_name = base_name
+    end
+
+    # Render a <tt>input[type=text]</tt> input.
+    #
+    #   form.text :name
+    #
+    def text(name, options = {})
+      text_input(name, "text", options)
+    end
+
+    # Render a <tt>input[type=password]</tt> input.
+    #
+    #   form.password :secret
+    #
+    def password(name, options = {})
+      text_input(name, "password", options)
+    end
+
+    # Render a <tt>input[type=file]</tt> input.
+    #
+    #   form.file :avatar
+    #
+    def file(name, options = {})
+      text_input(name, "file", options)
+    end
+
+    # Render a <tt>input[type=hidden]</tt> input.
+    #
+    #   form.hidden :honeypot
+    #
+    def hidden(name, options = {})
+      text_input(name, "hidden", options)
+    end
+
+    # Render a <tt>input[type=number]</tt> input.
+    #
+    #   form.number :quantity
+    #
+    def number(name, options = {})
+      text_input(name, "number", options)
+    end
+
+    # Render a <tt>input[type=email]</tt> input.
+    #
+    #   form.email :email
+    #
+    def email(name, options = {})
+      text_input(name, "email", options)
+    end
+
+    # Render a <tt>input[type=url]</tt> input.
+    #
+    #   form.url :blog
+    #
+    def url(name, options = {})
+      text_input(name, "url", options)
+    end
+
+    # Render a <tt>input[type=search]</tt> input.
+    #
+    #   form.search :query
+    #
+    def search(name, options = {})
+      text_input(name, "search", options)
+    end
+
+    # Render a <tt>input[type=tel]</tt> input.
+    #
+    #   form.phone :work
+    #
+    def phone(name, options = {})
+      text_input(name, "tel", options)
+    end
+
+    # Render a <tt>input[type=submit]</tt> input.
+    #
+    #   form.submit :new
+    #
+    def submit(label, options = {})
+      button_input(label, "submit", options)
+    end
+
+    # Render a <tt>input[type=button]</tt> input.
+    #
+    #   form.button :new
+    #
+    def button(label, options = {})
+      button_input(label, "button", options)
+    end
+
+    # Render a +textarea+ field.
+    #
+    #   form.text_area :content
+    #
+    def text_area(name, options = {})
+      Component::TextArea.new(self, name, options).to_html
+    end
+    alias_method :textarea, :text_area
+
+    #
+    #
+    def label(name, options = {})
+      Component::Label.new(self, name, options).to_html
+    end
+
+    private
+    def text_input(name, type, options)
+      Component::Input.new(self, name, options.merge(type: type)).to_html
+    end
+
+    def button_input(name, type, options)
+      Component::Button.new(self, name, options.merge(type: type)).to_html
+    end
+  end
+end

data/lib/form/component/base.rb

@@ -0,0 +1,69 @@
+module Form
+  module Component
+    class Base
+      extend Forwardable
+
+      def_delegators :form, :data
+
+      # The +Form::Builder+ instance. It will provide the base name
+      # and data object.
+      #
+      attr_accessor :form
+
+      # The input name. It will be used to compose
+      # the full name.
+      #
+      attr_accessor :name
+
+      # Hold the input options. It will be used as the input's
+      # attributes.
+      #
+      attr_accessor :options
+
+      # Initialize the component and set some variables.
+      #
+      def initialize(form, name, options = {})
+        @form = form
+        @name = name
+        @options = options
+      end
+
+      # Retrieve the value from the form data.
+      #
+      def value
+        if data.respond_to?(name)
+          data.public_send(name)
+        elsif data.respond_to?(:[])
+          data[name.to_sym] || data[name.to_s]
+        end
+      end
+
+      # Return a composed name like <tt>user[profile][twitter]</tt>.
+      #
+      def composed_name
+        composed_name = [form.base_name, name].flatten.compact
+        "#{composed_name.shift}" + composed_name.map {|n| "[#{n}]"}.join("")
+      end
+
+      # Just pass all arguments to <tt>I18n.t</tt>.
+      #
+      def t(*args)
+        I18n.t(*args)
+      end
+
+      #
+      #
+      def humanize(name)
+        parts = name.to_s.split("_")
+        parts.first.gsub!(/\A(.)/) { $1.upcase }
+        parts.join(" ")
+      end
+
+      #
+      #
+      def id_attribute
+        [form.base_name, name].flatten.compact.join("-")
+      end
+    end
+  end
+end

data/lib/form/component/button.rb

@@ -0,0 +1,26 @@
+module Form
+  module Component
+    class Button < Base
+      def attributes
+        {
+          :value => text,
+          :type => :submit
+        }.merge(options)
+      end
+
+      def text
+        scopes = [
+          [:form, :buttons, form.base_name, name].flatten.compact.join(".").to_sym,
+          :"form.buttons.#{name}",
+          humanize(name)
+        ].compact
+
+        options.fetch :text, t(scopes.shift, default: scopes)
+      end
+
+      def to_html
+        Tag.new(:input, attributes).to_s
+      end
+    end
+  end
+end

data/lib/form/component/input.rb

@@ -0,0 +1,17 @@
+module Form
+  module Component
+    class Input < Base
+      def attributes
+        options.merge({
+          value: value,
+          name: composed_name,
+          id: id_attribute
+        })
+      end
+
+      def to_html
+        Tag.new(:input, attributes).to_s
+      end
+    end
+  end
+end

data/lib/form/component/label.rb

@@ -0,0 +1,25 @@
+module Form
+  module Component
+    class Label < Base
+      def attributes
+        options.except(:text).tap do |attrs|
+          attrs[:for] ||= id_attribute
+        end
+      end
+
+      def text
+        scopes = [
+          [:form, :labels, form.base_name, name].flatten.compact.join(".").to_sym,
+          :"form.labels.#{name}",
+          humanize(name)
+        ].compact
+
+        options.fetch :text, t(scopes.shift, default: scopes)
+      end
+
+      def to_html
+        Tag.new(:label, text, attributes).to_s
+      end
+    end
+  end
+end

data/lib/form/component/text_area.rb

@@ -0,0 +1,23 @@
+module Form
+  module Component
+    class TextArea < Base
+      def attributes
+        defaults.merge(options).merge({
+          :name => composed_name,
+          :id => id_attribute
+        })
+      end
+
+      def defaults
+        {
+          :cols => 50,
+          :rows => 5
+        }
+      end
+
+      def to_html
+        Tag.new(:textarea, value, attributes).to_s
+      end
+    end
+  end
+end

data/lib/form/component.rb

@@ -0,0 +1,9 @@
+module Form
+  module Component
+    autoload :Base, "form/component/base"
+    autoload :Button, "form/component/button"
+    autoload :Input, "form/component/input"
+    autoload :Label, "form/component/label"
+    autoload :TextArea, "form/component/text_area"
+  end
+end

data/lib/form/extensions/hash.rb

@@ -0,0 +1,10 @@
+class Hash
+  # It returns a hash without the specified keys.
+  #
+  #   {:a => 1, "a" => 2, :b => 3}.except(:a, :b)
+  #   #=> {"a" => 2}
+  #
+  def except(*keys)
+    dup.delete_if {|key, value| keys.include?(key)}
+  end
+end

data/lib/form/locales/en.yml

@@ -0,0 +1,3 @@
+en:
+  form:
+    required: Required

data/lib/form/tag.rb

@@ -0,0 +1,106 @@
+module Form
+  class Tag
+    # List which tags don't need to be closed.
+    # Did you know that the technical name is "void elements"?
+    # http://www.w3.org/TR/html5/syntax.html#void-elements
+    #
+    VOID_ELEMENTS = [
+      :area, :base, :br, :col, :command, :embed,
+      :hr, :img, :input, :keygen, :link, :meta,
+      :param, :source, :track, :wbr
+    ]
+
+    # The tag name.
+    #
+    attr_accessor :name
+
+    # The tag content. It will be ignored in open tags.
+    #
+    attr_accessor :content
+
+    # The tag attributes.
+    #
+    attr_accessor :attributes
+
+    # Escape the value.
+    #
+    def self.html_escape(string)
+      string.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+    end
+
+    # Create a new tag.
+    #
+    #   Form::Tag.new(:p, "Hello World!", class: "greeting").render
+    #   #=> <p class="greeting">Hello World!</p>
+    #
+    def initialize(name, content = "", attributes = {}, &block)
+      if content.kind_of?(Hash)
+        attributes = content
+        content = ""
+      end
+
+      @name = name.to_sym
+      @content = content
+      @attributes = attributes
+
+      yield self if block_given?
+    end
+
+    # Detect if this tag omits the closing part.
+    #
+    def void?
+      VOID_ELEMENTS.include?(name)
+    end
+
+    # Append the specified HTML to this tag.
+    #
+    def <<(element)
+      @content << element.to_s
+    end
+
+    # Create nested tags with ease.
+    #
+    def tag(name, content = "", attributes = {}, &block)
+      @content << self.class.new(name, content, attributes, &block).to_s
+    end
+
+    # Build the tag, concating all parts.
+    #
+    def to_s
+      open_tag << (void? ? "" : content.to_s) << close_tag
+    end
+
+    def html_escape(string)
+      self.class.html_escape(string)
+    end
+
+    private
+    #
+    #
+    def render_attributes
+      attributes.collect do |name, value|
+        next unless value && value != ""
+        bool?(value) ? " #{name}" : %[ #{name}="#{html_escape(value)}"]
+      end.join("")
+    end
+
+    # Check if value is boolean.
+    # LolRuby doesn't have a Boolean class or something.
+    #
+    def bool?(value)
+      value.kind_of?(TrueClass) || value.kind_of?(FalseClass)
+    end
+
+    # The opening part of the tag.
+    #
+    def open_tag
+      "<#{name}#{render_attributes}>"
+    end
+
+    # The closing part of the tag.
+    #
+    def close_tag
+      void? ? "" : "</#{name}>"
+    end
+  end
+end