hungryform 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a3eb50bf1ab74b3a5540384c4985bdaa0320666
+  data.tar.gz: 97110432dcc56453c65f81b1df816fc8a4dd1019
+SHA512:
+  metadata.gz: bb6ca009dcf1d557b5485e76810dd2d3001debea174634e125de56ceccc797a3d84153b2fe51ade45082d3d79d393c5e23d82ad2c7b5f2876e696fcdbcfc79b6
+  data.tar.gz: b63768d3bca0af1a22b5c1845f80bd5fc770f77ced167cc4d42cf62f03f75cb972f9aaebd79a31ba8c72d50bd807b36bd425d17c8fc2b2a04cb5633b2c949669

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hungryform.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    hungryform (0.0.1)
+      activesupport
+      hashie
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.1.6)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    diff-lcs (1.2.5)
+    hashie (3.3.1)
+    i18n (0.6.11)
+    json (1.8.1)
+    minitest (5.4.2)
+    rake (10.3.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.6)
+  hungryform!
+  rake
+  rspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Andrey
+
+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,29 @@
+# HungryForm
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hungryform'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hungryform
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/andrba/hungryform/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/hungryform.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hungryform/version'
+require 'json'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hungryform"
+  spec.version       = HungryForm::VERSION
+  spec.authors       = ["Andrey Bazhutkin"]
+  spec.email         = ["andrey.bazhutkin@gmail.com"]
+  spec.summary       = "A Ruby Library for working with multi page forms"
+  spec.homepage      = "https://github.com/andrba/hungryform"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "hashie", "~> 3.3"
+end

data/lib/hungryform/elements/base_active_element.rb

@@ -0,0 +1,38 @@
+class HungryForm
+  class BaseActiveElement < BaseElement
+    attr_accessor :error
+
+    def initialize(name, parent, resolver, options = {}, &block)
+      super
+      self.error = ''
+
+      # Filter only the options that are present in the HungryForm::Validator singleton class
+      @validation_rules = options.select { |key, val| HungryForm::Validator.respond_to?(key) }
+
+      self.required = false unless parent.visible?
+
+      if options.has_key?(:params)
+        self.value = options[:params][self.name] || ''
+      else
+        self.value = ''
+      end
+    end
+
+    def valid?
+      self.error = ''
+
+      return true if !visible?
+
+      is_valid = true
+      @validation_rules.each do |key, rule|
+        error = HungryForm::Validator.send(key, self, rule) || ''
+        unless error.empty?
+          is_valid = false
+          break
+        end
+      end
+
+      is_valid
+    end
+  end
+end

data/lib/hungryform/elements/base_element.rb

@@ -0,0 +1,22 @@
+class HungryForm
+  class BaseElement < ::Hashie::Mash
+    attr_accessor :name, :placeholders, :resolver
+
+    def initialize(name, parent, resolver, options = {})
+      self.placeholders ||= {}
+      self.resolver = resolver
+
+      super(options)
+
+      self.visible = true unless self.key?(:visible)
+      self.visible &&= resolver.resolve_dependency(::JSON.parse(self.dependency)) if self.key?(:dependency)
+      self.name = (parent.nil?? "" : "#{parent.name}_") + resolver.get_value(name, self)
+
+      if self.key?(:label)
+        self.label = resolver.get_value(self.label, self)
+      else
+        self.label = resolver.get_value(name, self).humanize
+      end
+    end
+  end
+end

data/lib/hungryform/elements/base_group.rb

@@ -0,0 +1,81 @@
+class HungryForm
+  # A base group object is used to handle nested elements.
+  # Nested element can be a regular BaseElement or BaseActiveElement, as well as a BaseGroup element.
+  # 
+  # The following sample has three BaseGroup elements (page, group and nested group) that define a structure
+  # of a single form page
+  # 
+  # page :about do
+  #   group :about_yourself do
+  #     html :about, value: "Tell us about yourself"
+  #     group :address do
+  #       text_field :street
+  #       text_field :city
+  #     end
+  #     group :contact do
+  #       text_field :phone
+  #     end
+  #   end
+  # end
+  # 
+  # Every group element except for a nested group is 
+  class BaseGroup < BaseElement
+    attr_accessor :elements, :errors
+
+    def initialize(name, parent, resolver, options = {}, &block)
+      raise HungryFormException, 'No group structure block given' unless block_given?
+
+      super
+
+      self.name = parent.nil?? name : "#{parent.name}_#{name}"
+      self.elements = []
+      self.errors = {}
+
+      instance_eval(&block)
+    end
+
+    def group(name, options = {}, &block)
+      elements << HungryForm::Group.new(name, self, @resolver, options, &block)
+    end
+
+    # Validates an entire group. If a group consists of nested groups
+    # they will be validated recursively
+    def valid?
+      errors.clear
+      is_valid = true
+
+      elements.each do |el|
+        if el.invalid?
+          is_valid = false
+          case el
+          when BaseActiveElement
+            errors[el.name] = el.error
+          when BaseGroupObject
+            errors.merge!(el.errors)
+          end
+        end
+      end
+
+      is_valid
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def method_missing(name, *args, &block)
+      #Find a matching class
+      klass = HungryForm.constants.find {|c| Class === HungryForm.const_get(c) && c.to_s.underscore.to_sym == name}
+      return super if klass.nil?
+
+      # Create a new element based on a symbol provided and push it into the group elements array
+      element = HungryForm::const_get(klass).send(:new, *([args[0], self, @resolver, args[1..-1]].flatten), &block)
+      elements << element
+
+      #Resolver keeps a hash of all elements of the form
+      @resolver.elements[element.name] = element
+
+      element
+    end
+  end
+end

data/lib/hungryform/elements/group.rb

@@ -0,0 +1,8 @@
+class HungryForm
+  class Group < BaseGroup
+    def initialize(name, parent, resolver, options = {}, &block)
+      super
+      instance_eval(&block)
+    end
+  end
+end

data/lib/hungryform/elements/html.rb

@@ -0,0 +1,4 @@
+class HungryForm
+  class Html < BaseElement
+  end
+end

data/lib/hungryform/elements/page.rb

@@ -0,0 +1,27 @@
+class HungryForm
+  # Page is a main element of a form.
+  # Each page can include a page structure, defined in the block
+  # 
+  # A sample page could look like this:
+  #   page :about do
+  #     html :before, value: "Please fill out the following fields"
+  #     text_field :first_name
+  #     text_field :last_name
+  #   end
+  # 
+  # The only required argument of a page is its name.
+  # You can specify a title and a label in the options like this:
+  # 
+  # page :about, title: "About me", label: "About"
+  # 
+  # If there is no title or label specified, they will be created
+  # from the :name argument
+  class Page < BaseGroup
+    attr_accessor :title
+
+    def initialize(name, parent, resolver, options = {}, &block)
+      super
+      self.title = self.title || self.label
+    end
+  end
+end

data/lib/hungryform/elements/text_field.rb

@@ -0,0 +1,4 @@
+class HungryForm
+  class TextField < BaseActiveElement
+  end
+end

data/lib/hungryform/elements.rb

@@ -0,0 +1,7 @@
+require_relative 'elements/base_element'
+require_relative 'elements/base_active_element'
+require_relative 'elements/base_group'
+require_relative 'elements/page'
+require_relative 'elements/group'
+require_relative 'elements/html'
+require_relative 'elements/text_field'

data/lib/hungryform/resolver.rb

@@ -0,0 +1,79 @@
+class HungryForm
+  # The class is responsible for dependency resolving.
+  # It contains all form elements and params
+  class Resolver
+    attr_accessor :elements
+
+    def initialize(options = {})
+      @params = options[:params] || {}
+      @elements = {}
+    end
+
+    # Gets element value by element's name. 
+    # If name is lambda - returns lambda's result
+    # If name is present in the resolvers' elements hash - returns element's value
+    # If name is present in the resolvers' params hash - returns params value
+    # Otherwise returns the argument without changes
+    def get_value(name, element = nil)
+      return name.call(element) if name.respond_to? :call
+
+      name = name.to_s.dup
+      
+      # Apply placeholders to the name.
+      # A sample name string can look like this: page1_group[GROUP_NUMBER]_field
+      # where [GROUP_NUMBER] is a placeholder. When an element is present
+      # we get its placeholders and replace substrings in the name argument
+      if element
+        element.placeholders.each { |k, v| name[k] &&= v }
+      end
+
+      return @elements[name].value if @elements.has_key?(name)
+      return @params[name] if @params.has_key?(name)
+
+      name
+    end
+
+    # Gets dependency rules hash and returns true or false depending on
+    # the result of a recursive processing of the rules
+    def resolve_dependency(dependency)
+      dependency.each do |operator, arguments|
+        case operator
+        when 'AND'
+          raise HungryFormException, "No arguments for AND comparison: #{arguments}" if arguments.size == 0
+
+          arguments.each do |argument|
+            return false unless resolve_dependency(argument)
+          end
+
+          return true
+        when 'OR'
+          raise HungryFormException, "No arguments for OR comparison: #{arguments}" if arguments.size == 0
+
+          arguments.each do |argument|
+            return true if resolve_dependency(argument)
+          end
+
+          return false
+        when 'NOT'
+          return !resolve_dependency(arguments)
+        end
+
+        arguments = [arguments] unless arguments.is_a?(Array)
+
+        arguments = arguments[0..1].map {|name| get_value(name)}
+        return false if arguments.any?{ |arg| arg.nil? }
+
+        case operator
+        when 'EQ'
+          return arguments[0].to_s == arguments[1].to_s
+        when 'LT'
+          return arguments[0].to_f < arguments[1].to_f
+        when 'GT'
+          return arguments[0].to_f > arguments[1].to_f
+        when 'SET'
+          return !arguments[0].empty?
+        end
+      end
+    end
+  end
+end

data/lib/hungryform/validator.rb

@@ -0,0 +1,13 @@
+class HungryForm
+  class Validator
+    class << self
+      def required(element, rule)
+        if rule.respond_to? :call
+          return rule.call(element)
+        else
+          return "is required" if element.value.to_s.empty? && rule
+        end
+      end
+    end
+  end
+end

data/lib/hungryform/version.rb

@@ -0,0 +1,3 @@
+class HungryForm
+  VERSION = "0.0.1"
+end

data/lib/hungryform.rb

@@ -0,0 +1,63 @@
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+require 'hashie'
+require "hungryform/version"
+require "hungryform/resolver"
+require "hungryform/validator"
+require "hungryform/elements"
+
+# HungryForm is an object that manages form creation and validation.
+# A sample object could look like this:
+# 
+# form = HungryForm.new :params => params do
+#   page :about_yourself do
+#     text_field :first_name, :required => true
+#     text_field :last_name, :required => true
+#     checkbox :dog, label: "Do you have a dog?"
+#   end
+#   page :about_your_dog, visible: '{"SET": "about_yourself_dog"}' do
+#     text_field :name, :required
+#     text_area :what_can_it_do, label: "What can it do?"
+#   end
+# end
+# 
+# A form must contain only pages.
+# Whenever a specific form error occurres inside the form it raises a HungryFormException
+# 
+# When a new instance of a HungryForm is created, it uses options[:params] to
+# build a structure of itself. The pages with dependencies, that resolve during this
+# process will be included in the form.pages array. Pages without dependencies will be allways resolved. 
+# The rest of the pages will be ignored
+class HungryForm
+  HungryFormException = Class.new(StandardError)
+
+  attr_reader :current_page, :pages
+
+  def initialize(options = {}, &block)
+    raise HungryFormException, 'No form structure block given' unless block_given?
+    @resolver = Resolver.new(options.slice(:params))
+    @pages = []
+    instance_eval(&block)
+  end
+
+  # Create a form page
+  def page(name, options = {}, &block)
+    page = Page.new(name, nil, @resolver, options, &block)
+    pages << page if page.visible?
+  end
+
+  # Entire form validation. Loops through the form pages and validates each page
+  def valid?
+    is_valid = true
+    pages.each do |page|
+      #Loop through pages to get all errors
+      is_valid = false if page.invalid?
+    end
+
+    is_valid
+  end
+
+  def invalid?
+    !valid?
+  end
+end

data/spec/elements/group_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe HungryForm::Group do
+  it_behaves_like "a group"
+end

data/spec/elements/html_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe HungryForm::Html do
+  it_behaves_like "an element"
+
+  describe ".new" do
+    let(:resolver) { HungryForm::Resolver.new() }
+    let(:options) { {value: "body text"} }
+    subject { HungryForm::Html.new(:html, nil, resolver, options) {} }
+
+    it "should have a value" do
+      expect(subject.value).to eq "body text"
+    end
+
+  end
+end

data/spec/elements/page_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe HungryForm::Page do
+  let(:resolver) { HungryForm::Resolver.new() }
+  let(:options) { {} }
+  let(:page) { HungryForm::Page.new(:pagename, nil, resolver, options) {} }
+
+  it_behaves_like "a group"
+
+  describe ".new" do
+    it "should have one element" do
+      page = HungryForm::Page.new(:pagename, nil, resolver, options) do
+        html :html_name, value: "<p>Test html block</p>"
+      end
+      expect(page.elements.size).to eq 1
+    end
+  end
+
+  describe "#group" do 
+    it "should contain a group" do
+      page.group(:group_name, {}) {}
+      expect(page.elements.first.class).to eq HungryForm::Group
+    end
+  end
+end

data/spec/elements/text_field_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe HungryForm::TextField do
+  it_behaves_like "an active element"
+end

data/spec/hungryform_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe HungryForm do
+  describe ".new" do
+    subject(:form) { HungryForm.new {
+      page :first do 
+      end
+      page :second, visible: false do 
+      end
+      page :third do 
+      end
+    } }
+
+    it "should contain 2 pages" do
+      expect(subject.pages.size).to eq 2
+    end
+  end
+
+  describe "#page" do 
+    subject(:form) { HungryForm.new() {} }
+
+    it "should contain a page" do
+      form.page(:page_name, {}) {}
+      expect(form.pages.first.class).to eq HungryForm::Page
+    end
+  end
+end

data/spec/resolver_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+describe HungryForm::Resolver do
+  let(:resolver_params) { {:params => {}} }
+  subject(:resolver) { HungryForm::Resolver.new(resolver_params) }
+
+  describe ".get_value" do
+    let(:element) { HungryForm::Html.new(:html_name, nil, resolver, { value: "value" }) {} }
+
+    it "should get value from lambda param" do
+      value = subject.get_value( ->(el){ "value" } )
+      expect(value).to eq "value"
+    end
+
+    it "should get value from a form element" do
+      subject.elements[element.name] = element
+      expect(subject.get_value("html_name")).to eq "value"
+    end
+
+    it "should get value from a form params" do
+      resolver_params[:params] = { "param1" => "param_value" }
+      expect(subject.get_value("param1")).to eq "param_value"
+    end
+
+    it "should get value that equals the name" do
+      expect(subject.get_value("name that doesn't exist")).to eq "name that doesn't exist"
+    end
+  end
+
+  describe ".resolve_dependency" do
+    it "should resolve EQ dependency" do
+      dependency = { "EQ" => ["Text", "Text"] }
+      expect(subject.resolve_dependency(dependency)).to eq true
+    end
+
+    it "should resolve LT dependency" do
+      dependency = { "LT" => ["0", "1"] }
+      expect(subject.resolve_dependency(dependency)).to eq true
+    end
+
+    it "should resolve GT dependency" do
+      dependency = { "GT" => ["1", "0"] }
+      expect(subject.resolve_dependency(dependency)).to eq true
+    end 
+
+    it "should resolve SET dependency" do
+      dependency = { "SET" => "1" }
+      expect(subject.resolve_dependency(dependency)).to eq true
+    end 
+
+    it "should resolve AND dependency" do
+      dependency = { "AND" => [{"SET" => "1"}, {"SET" => "1"}] }
+      expect(subject.resolve_dependency(dependency)).to eq true
+    end
+
+    it "should resolve OR dependency" do
+      dependency = { "OR" => [{"SET" => ""}, {"SET" => "1"}] }
+      expect(subject.resolve_dependency(dependency)).to eq true
+    end
+
+    it "should resolve NOT dependency" do
+      dependency = { "NOT" => {"SET" => ""} }
+      expect(subject.resolve_dependency(dependency)).to eq true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+Bundler.setup
+
+require "hungryform"
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  config.order = :random
+end

data/spec/support/shared_active_element.rb

@@ -0,0 +1,41 @@
+RSpec.shared_examples "an active element" do
+  let(:resolver) { HungryForm::Resolver.new() }
+  
+  let(:group_options) { {} }
+  let(:group) { HungryForm::Group.new(:group, nil, resolver, group_options) {} }
+
+  let(:element_options) { {} }
+  let(:element) { described_class.new(:element_name, group, resolver, element_options) {} }
+
+  it_behaves_like "an element"
+
+  describe ".new" do
+    it "should have empty error" do
+      expect(element.error).to eq ""
+    end
+
+    it "should not be required if its parent is not visible" do
+      group_options[:visible] = false
+      element_options[:required] = true
+      expect(element.required?).to eq false
+    end
+  end
+
+  describe "#valid?" do
+    describe "when required" do
+      before(:each) do
+        element_options[:required] = true
+      end
+
+      it "is valid" do
+        element.value = "value"
+        expect(element.valid?).to eq true
+      end
+
+      it "is invalid" do
+        element.value = ""
+        expect(element.valid?).to eq false
+      end
+    end
+  end
+end

data/spec/support/shared_element.rb

@@ -0,0 +1,48 @@
+RSpec.shared_examples "an element" do
+  let(:resolver) { HungryForm::Resolver.new() }
+  
+  let(:group) { HungryForm::Group.new(:group, nil, resolver, {}) {} }
+
+  let(:element_options) { {} }
+  let(:element) { described_class.new(:element_name, group, resolver, element_options) {} }
+
+  describe "#visible?" do
+    it "should be visible" do
+      expect(element.visible?).to eq true
+    end
+
+    it "should not be visible" do
+      element_options[:visible] = false
+      expect(element.visible?).to eq false
+    end
+
+    context "when dependency is present" do
+      it "should not be visible" do
+        element_options[:dependency] = '{"EQ": ["0", "1"]}'
+        expect(element.visible?).to eq false
+      end
+
+      it "should never be visible" do
+        element_options[:visible] = false
+        element_options[:dependency] = '{"EQ": ["1", "1"]}'
+        expect(element.visible?).to eq false
+      end
+
+      it "should be visible" do
+        element_options[:dependency] = '{"EQ": ["1", "1"]}'
+        expect(element.visible?).to eq true
+      end
+    end
+  end
+
+  describe "#label" do
+    it "should have a humanized label based on element's name" do
+      expect(element.label).to eq "Element name"
+    end
+
+    it "should have a label defined in options" do
+      element_options[:label] = "Special Label"
+      expect(element.label).to eq "Special Label"
+    end
+  end
+end

data/spec/support/shared_group.rb

@@ -0,0 +1,34 @@
+RSpec.shared_examples "a group" do
+  let(:resolver) { HungryForm::Resolver.new() }
+  
+  let(:page) { described_class.new(:parent_name, nil, resolver, {}) {} }
+
+  let(:group_options) { {} }
+  let(:group) { described_class.new(:name, page, resolver, group_options) {} }
+
+  it_behaves_like "an element"
+
+  describe "#group" do
+    it "creates a nested group" do
+      group.group(:nested, {}) {}
+      expect(group.elements.first.class).to eq HungryForm::Group
+    end
+
+    it "concatenates nested element's name with the parent's one" do
+      group.group(:nested, {}) {}
+      expect(group.elements.first.name).to eq "parent_name_name_nested"
+    end
+  end
+
+  describe ".method_missing" do
+    it "creates a nested element" do
+      group.html(:name)
+      expect(group.elements.first.class).to eq HungryForm::Html
+    end
+
+    it "concatenates nested element's name with the parent's one" do
+      group.html(:html)
+      expect(group.elements.first.name).to eq "parent_name_name_html"
+    end
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: hungryform
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey Bazhutkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: 
+email:
+- andrey.bazhutkin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- hungryform.gemspec
+- lib/hungryform.rb
+- lib/hungryform/elements.rb
+- lib/hungryform/elements/base_active_element.rb
+- lib/hungryform/elements/base_element.rb
+- lib/hungryform/elements/base_group.rb
+- lib/hungryform/elements/group.rb
+- lib/hungryform/elements/html.rb
+- lib/hungryform/elements/page.rb
+- lib/hungryform/elements/text_field.rb
+- lib/hungryform/resolver.rb
+- lib/hungryform/validator.rb
+- lib/hungryform/version.rb
+- spec/elements/group_spec.rb
+- spec/elements/html_spec.rb
+- spec/elements/page_spec.rb
+- spec/elements/text_field_spec.rb
+- spec/hungryform_spec.rb
+- spec/resolver_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_active_element.rb
+- spec/support/shared_element.rb
+- spec/support/shared_group.rb
+homepage: https://github.com/andrba/hungryform
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+signing_key: 
+specification_version: 4
+summary: A Ruby Library for working with multi page forms
+test_files:
+- spec/elements/group_spec.rb
+- spec/elements/html_spec.rb
+- spec/elements/page_spec.rb
+- spec/elements/text_field_spec.rb
+- spec/hungryform_spec.rb
+- spec/resolver_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_active_element.rb
+- spec/support/shared_element.rb
+- spec/support/shared_group.rb