hungryform 0.0.2 → 0.0.4

data/lib/hungryform/form.rb

@@ -0,0 +1,86 @@
+require 'json'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/class/attribute'
+require 'hungryform/version'
+require 'hungryform/resolver'
+require 'hungryform/validator'
+require 'hungryform/elements'
+
+module HungryForm
+  # HungryForm is an object that manages form creation and validation.
+  # A sample object could look like this:
+  #
+  # form = HungryForm::Form.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::Form is created, it uses
+  # attributes[: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 Form
+    attr_reader :pages
+
+    def initialize(attributes = {}, &block)
+      unless block_given?
+        fail HungryFormException, 'No form structure block given'
+      end
+
+      @resolver = Resolver.new(attributes.slice(:params))
+      @pages = []
+
+      instance_eval(&block)
+    end
+
+    # Create a form page
+    def page(name, attributes = {}, &block)
+      page = Elements::Page.new(name, nil, @resolver, attributes, &block)
+      pages << page if page.visible?
+    end
+
+    # Entire form validation. Loops through the form pages and
+    # validates each page individually.
+    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
+
+    # Get all the elements that the form consists of
+    def elements
+      @resolver.elements
+    end
+
+    # Get an entire hash of the form, including every element
+    # on every visible page
+    def to_hash
+      { pages: pages.map(&:to_hash) }
+    end
+
+    def to_json
+      JSON.generate(to_hash)
+    end
+  end
+end

data/lib/hungryform/resolver.rb

@@ -1,4 +1,4 @@
-class HungryForm
+module HungryForm
   # The class is responsible for dependency resolving.
   # It contains all form elements and params
   class Resolver
@@ -9,7 +9,7 @@ class HungryForm
       @elements = {}
     end
 
-    # Gets element value by element's name. 
+    # 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
@@ -17,18 +17,17 @@ class HungryForm
     def get_value(name, element = nil)
       return name.call(element) if name.respond_to? :call
 
+      # We don't want to mess up elements names
       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
+      element.placeholders.each { |k, v| name[k] &&= v } if element
 
-      return @elements[name].value if @elements.has_key?(name)
-      return @params[name] if @params.has_key?(name)
+      return @elements[name].value if @elements.key?(name)
+      return @params[name] if @params.key?(name)
 
       name
     end
@@ -39,29 +38,17 @@ class HungryForm
       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
+          return resolve_multi_dependency(:and, arguments)
         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
+          return resolve_multi_dependency(:or, arguments)
         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? }
+        arguments = arguments[0..1].map { |name| get_value(name) }
+        return false if arguments.any?(&:nil?)
 
         case operator
         when 'EQ'
@@ -75,5 +62,23 @@ class HungryForm
         end
       end
     end
+
+    private
+
+    # Helper method to resolve AND or OR conditions.
+    # Walks through the arguments and resolves their dependencies.
+    def resolve_multi_dependency(type, arguments)
+      if arguments.size == 0
+        fail HungryFormException, "No arguments for #{type.upcase} comparison: #{arguments}"
+      end
+
+      result = type == :and
+
+      arguments.each do |argument|
+        return !result unless resolve_dependency(argument)
+      end
+
+      result
+    end
   end
-end
+end

data/lib/hungryform/validator.rb

@@ -1,5 +1,5 @@
-class HungryForm
-  class Validator
+module HungryForm
+  module Validator
     class << self
       # Check if the element's value is not empty.
       # The rule argument can be a boolean or a callable object
@@ -7,16 +7,19 @@ class HungryForm
         if rule.respond_to? :call
           rule.call(element)
         else
-          "is required" if element.value.to_s.empty? && rule
+          'is required' if element.value.to_s.empty? && rule
         end
       end
 
       # Custom validation check
       # Use when you need to create a custom validation in the structure
       def validation(element, callable)
-        raise HungryFormError "Validation must respond to call" unless callable.respond_to? :call
+        unless callable.respond_to? :call
+          fail HungryFormError 'Validation must respond to call'
+        end
+
         callable.call(element)
       end
     end
   end
-end
+end

data/lib/hungryform/version.rb

@@ -1,3 +1,3 @@
-class HungryForm
-  VERSION = "0.0.2"
+module HungryForm
+  VERSION = "0.0.4"
 end

data/lib/hungryform.rb

@@ -1,81 +1,12 @@
 require 'json'
 require 'active_support/core_ext/string/inflections'
-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
+require 'active_support/core_ext/class/attribute'
+require 'hungryform/version'
+require 'hungryform/form'
+require 'hungryform/resolver'
+require 'hungryform/validator'
+require 'hungryform/elements'
+
+module HungryForm
   HungryFormException = Class.new(StandardError)
-
-  attr_reader :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
-
-  # Get all the elements that the form consists of
-  def elements
-    @resolver.elements
-  end
-
-  # Create a JSON string from the form elements (name => value)
-  def to_json
-    elements_hash = {}
-
-    self.elements.each do |name, el|
-      elements_hash[name] = el.value if el.is_a?(BaseActiveElement)
-    end
-    
-    JSON.generate(elements_hash)
-  end
 end

data/spec/elements/group_spec.rb

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

data/spec/elements/html_spec.rb

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

data/spec/elements/page_spec.rb

@@ -1,15 +1,15 @@
 require "spec_helper"
 
-describe HungryForm::Page do
+describe HungryForm::Elements::Page do
   let(:resolver) { HungryForm::Resolver.new() }
   let(:options) { {} }
-  let(:page) { HungryForm::Page.new(:pagename, nil, resolver, options) {} }
+  let(:page) { HungryForm::Elements::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
+      page = HungryForm::Elements::Page.new(:pagename, nil, resolver, options) do
         html :html_name, value: "<p>Test html block</p>"
       end
       expect(page.elements.size).to eq 1
@@ -19,7 +19,7 @@ describe HungryForm::Page do
   describe "#group" do 
     it "should contain a group" do
       page.group(:group_name, {}) {}
-      expect(page.elements.first.class).to eq HungryForm::Group
+      expect(page.elements.first.class).to eq HungryForm::Elements::Group
     end
   end
 end

data/spec/elements/radio_group_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe HungryForm::Elements::RadioGroup do
+  let(:resolver_options) { {} }
+  let(:resolver) { HungryForm::Resolver.new(resolver_options) }
+  let(:group) { HungryForm::Elements::Group.new(:group, nil, resolver, {}) {} }
+
+  let(:element_options) do 
+    {
+      :options => {
+        "1" => "First", 
+        "2" => "Second",
+        "3" => "Third"
+      }
+    } 
+  end
+  subject { HungryForm::Elements::RadioGroup.new(:element_name, group, resolver, element_options) {} }
+
+  it_behaves_like "an element with options" do
+    let(:options_element_options) do 
+      {
+        :options => {
+          "1" => "First", 
+          "element_value" => "Second" # element_value is checked in shared_active_element
+        }
+      } 
+    end
+  end
+end

data/spec/elements/select_field_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe HungryForm::Elements::SelectField do
+	let(:resolver_options) { {} }
+  let(:resolver) { HungryForm::Resolver.new(resolver_options) }
+  
+  let(:group_options) { {} }
+  let(:group) { HungryForm::Elements::Group.new(:group, nil, resolver, group_options) {} }
+
+  let(:element_options) do 
+		{
+			:options => {
+				"1" => "First", 
+				"2" => "Second",
+				"3" => "Third"
+			}
+		} 
+	end
+  subject { HungryForm::Elements::SelectField.new(:element_name, group, resolver, element_options) {} }
+
+	it_behaves_like "an element with options" do
+		let(:options_element_options) do 
+			{
+				:options => {
+					"1" => "First", 
+					"element_value" => "Second" # element_value is checked in shared_active_element
+				}
+			} 
+		end
+	end
+
+	describe "#set_value" do
+		context "when multiple enabled" do
+			it "assigns multiple values" do
+				resolver_options[:params] = {"group_element_name" => ["1", "2", "3"]}
+				element_options[:multiple] = true
+				expect(subject.value).to eq(["1", "2", "3"])
+			end
+		end
+	end
+
+	describe "#to_hash" do
+		it "should include multiple" do
+			expect(subject.to_hash).to include(:multiple)
+		end
+	end
+end

data/spec/elements/text_area_field_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe HungryForm::Elements::TextAreaField do
+  it_behaves_like "an active element" do
+    let(:active_element_options) { {} }
+  end
+end

data/spec/elements/text_field_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
-describe HungryForm::TextField do
+describe HungryForm::Elements::TextField do
   it_behaves_like "an active element" do
     let(:active_element_options) { {} }
   end
-end
+end

data/spec/{hungryform_spec.rb → form_spec.rb}

@@ -7,13 +7,13 @@ describe HungryForm do
         "first_first_name" => "John", 
         "first_last_name" => "Doe", 
         "second_email" => "john.doe@yahoo.com", 
-        "third_occupation" => "Software developer"
+        "third_occupation" => "programmer"
       } 
     } 
   end
 
-  subject(:form) do
-    HungryForm.new(options) do
+  subject do
+    HungryForm::Form.new(options) do
       page :first do
         text_field :first_name
         text_field :last_name
@@ -22,7 +22,7 @@ describe HungryForm do
         text_field :email
       end
       page :third do 
-        text_field :occupation
+        select_field :occupation, :options => {"programmer" => "Programmer", "other" => "Other"}
         group :employment_history do
           html :before, value: "Employment history over the last 5 years"
           text_field :history, value: "Default value"
@@ -38,18 +38,19 @@ describe HungryForm do
   end
 
   describe "#page" do 
-    subject(:form) { HungryForm.new() {} }
+    subject(:form) { HungryForm::Form.new() {} }
 
     it "should contain a page" do
       form.page(:page_name, {}) {}
-      expect(form.pages.first.class).to eq HungryForm::Page
+      expect(form.pages.first.class).to eq HungryForm::Elements::Page
     end
   end
 
   describe "#to_json" do
     it "should create a json string from the form objects" do
-      form_elements_hash = options[:params].merge({"third_employment_history_history" => "Default value"})
-      expect(form.to_json).to eq(JSON.generate(form_elements_hash))
+      hash = JSON.parse(subject.to_json)
+      expect(hash["pages"].size).to eq 2
+      expect(hash["pages"].first["elements"].size).to eq 2
     end
   end
 end

data/spec/resolver_spec.rb

@@ -16,7 +16,7 @@ describe HungryForm::Resolver do
   end
 
   describe "#get_value" do
-    let(:element) { HungryForm::Html.new(:html_name, nil, resolver, { value: "value" }) {} }
+    let(:element) { HungryForm::Elements::Html.new(:html_name, nil, resolver, { value: "value" }) {} }
 
     it "should get value from lambda param" do
       value = subject.get_value( ->(el){ "value" } )

data/spec/support/shared_active_element.rb

@@ -3,7 +3,7 @@ RSpec.shared_examples "an active element" do
   let(:resolver) { HungryForm::Resolver.new(resolver_options) }
   
   let(:group_options) { {} }
-  let(:group) { HungryForm::Group.new(:group, nil, resolver, group_options) {} }
+  let(:group) { HungryForm::Elements::Group.new(:group, nil, resolver, group_options) {} }
 
   let(:element) { described_class.new(:element_name, group, resolver, active_element_options) {} }
 
@@ -54,4 +54,12 @@ RSpec.shared_examples "an active element" do
       end
     end
   end
+
+  describe "#to_hash" do
+    it "should include required, value and error" do
+      active_element_options[:value] = ''
+      active_element_options[:required] = true
+      expect(element.to_hash).to include(:required, :value, :error)
+    end
+  end
 end

data/spec/support/shared_element.rb

@@ -1,7 +1,7 @@
 RSpec.shared_examples "an element" do
   let(:resolver) { HungryForm::Resolver.new() }
   
-  let(:group) { HungryForm::Group.new(:group, nil, resolver, {}) {} }
+  let(:group) { HungryForm::Elements::Group.new(:group, nil, resolver, {}) {} }
 
   let(:element) { described_class.new(:element_name, group, resolver, element_options) {} }
 
@@ -51,4 +51,12 @@ RSpec.shared_examples "an element" do
       expect(element.other_html_param?).to eq false
     end
   end
+
+  describe "#to_hash" do
+    it "should include visible, dependency, name and label" do
+      element_options[:dependency] = '{"EQ": [1, 1]}'
+      element_options[:name] = 'name'
+      expect(element.to_hash).to include(:visible, :dependency, :name, :label)
+    end
+  end
 end

data/spec/support/shared_group.rb

@@ -13,7 +13,7 @@ RSpec.shared_examples "a group" do
   describe "#group" do
     it "creates a nested group" do
       group.group(:nested, {}) {}
-      expect(group.elements.first.class).to eq HungryForm::Group
+      expect(group.elements.first.class).to eq HungryForm::Elements::Group
     end
 
     it "concatenates nested element's name with the parent's one" do
@@ -22,10 +22,16 @@ RSpec.shared_examples "a group" do
     end
   end
 
+  describe "#to_hash" do
+    it "should include group elements" do
+      expect(group.to_hash).to include(:elements)
+    end
+  end
+
   describe ".method_missing" do
     it "creates a nested element" do
       group.html(:name)
-      expect(group.elements.first.class).to eq HungryForm::Html
+      expect(group.elements.first.class).to eq HungryForm::Elements::Html
     end
 
     it "concatenates nested element's name with the parent's one" do

data/spec/support/shared_options_element.rb

@@ -0,0 +1,36 @@
+RSpec.shared_examples "an element with options" do
+  let(:resolver_options) { {} }
+  let(:resolver) { HungryForm::Resolver.new(resolver_options) }
+  
+  let(:group_options) { {} }
+  let(:group) { HungryForm::Elements::Group.new(:group, nil, resolver, group_options) {} }
+
+  let(:element) { described_class.new(:element_name, group, resolver, options_element_options) {} }
+
+  it_behaves_like "an active element" do
+    let(:active_element_options) { options_element_options }
+  end
+
+  describe ".new" do
+    it "should raise an exception if there is no options provided" do
+      options_element_options.delete(:options) if options_element_options[:options]
+      expect { described_class.new(:element_name, group, resolver, options_element_options) }.to raise_error(HungryForm::HungryFormException)
+    end
+
+    it "should have options" do
+      options_element_options[:options] = {"1" => "First", "2" => "Last"}
+      expect(element.options).to eq({"1" => "First", "2" => "Last"})
+    end
+
+    it "should convert options to hash" do
+      options_element_options[:options] = ->(el) {{"1" => "First", "2" => "Last"}}
+      expect(element.options).to eq({"1" => "First", "2" => "Last"})
+    end
+  end
+
+  describe "#to_hash" do
+    it "should include options" do
+      expect(element.to_hash).to include(:options)
+    end
+  end
+end

data/spec/validator_spec.rb

@@ -2,10 +2,10 @@ require "spec_helper"
 
 describe HungryForm::Validator do
   let(:resolver) { HungryForm::Resolver.new() }
-  let(:group) { HungryForm::Group.new(:group, nil, resolver, {}) {} }
+  let(:group) { HungryForm::Elements::Group.new(:group, nil, resolver, {}) {} }
 
   let(:element_options) { {} }
-  let(:element) { HungryForm::TextField.new(:element_name, group, resolver, element_options) {} }
+  let(:element) { HungryForm::Elements::TextField.new(:element_name, group, resolver, element_options) {} }
 
   describe "required" do
     it "should return nil when the element's value is present" do