hungryform 0.0.4 → 0.0.6

data/lib/hungryform/elements/base/hashable.rb

@@ -1,37 +1,39 @@
 module HungryForm
-  module Elements::Base
-    # This module adds hashing capabilities to form elements.
-    # Do not include this module in your classes. It is already
-    # included in the base_element class.
-    #
-    # Sample usage:
-    #
-    # class MyField
-    #   attr_accessor :param1, :param2
-    #   hashable :param1, :param2
-    #   ...
-    # end
-    #
-    # Any instance of MyField class will have the "to_hash" method
-    # that will contain only the accessor/reader params defined in
-    # the hashable macro.
-    module Hashable
-      def self.included(base)
-        base.extend ClassMethods
-        base.class_attribute :hashable_attributes
-        base.hashable_attributes = []
-      end
+  module Elements
+    module Base
+      # This module adds hashing capabilities to form elements.
+      # Do not include this module in your classes. It is already
+      # included in the base_element class.
+      #
+      # Sample usage:
+      #
+      # class MyField
+      #   attr_accessor :param1, :param2
+      #   hashable :param1, :param2
+      #   ...
+      # end
+      #
+      # Any instance of MyField class will have the "to_hash" method
+      # that will contain only the accessor/reader params defined in
+      # the hashable macro.
+      module Hashable
+        def self.included(base)
+          base.extend ClassMethods
+          base.class_attribute :hashable_attributes
+          base.hashable_attributes = []
+        end
 
-      def to_hash
-        hash = self.class.hashable_attributes.each_with_object({}) do |param, h|
-          h[param] = send(param) unless send(param).nil?
+        def to_hash
+          hash = self.class.hashable_attributes.each_with_object({}) do |param, h|
+            h[param] = send(param) unless send(param).nil?
+          end
+          hash.merge(_type: self.class.name.demodulize)
         end
-        hash.merge(_type: self.class.name.demodulize)
-      end
 
-      module ClassMethods
-        def hashable(*params)
-          self.hashable_attributes = hashable_attributes.dup.concat params
+        module ClassMethods
+          def hashable(*params)
+            self.hashable_attributes = hashable_attributes.dup.concat params
+          end
         end
       end
     end

data/lib/hungryform/elements/base/options_element.rb

@@ -1,33 +1,37 @@
 module HungryForm
-  module Elements::Base
-    # The BaseOptionsElement class can be used as a base class for
-    # fields with options, such as select or radio
-    class OptionsElement < ActiveElement
-      attr_accessor :options
+  module Elements
+    module Base
+      # The BaseOptionsElement class can be used as a base class for
+      # fields with options, such as select or radio
+      class OptionsElement < ActiveElement
+        attr_accessor :options
 
-      hashable :options
+        hashable :options
 
-      def initialize(name, parent, resolver, attributes = {}, &block)
-        if attributes.key?(:options)
-          self.options = attributes[:options].dup
-        else
-          fail HungryFormException, "No options provided for #{name}"
-        end
+        def initialize(name, parent, resolver, attributes = {}, &block)
+          if attributes.key?(:options)
+            self.options = attributes.delete(:options)
+          else
+            fail HungryFormException, "No options provided for #{name}"
+          end
 
-        unless options.is_a?(Hash)
-          self.options = resolver.get_value(options, self)
-        end
+          unless options.is_a?(Hash)
+            self.options = resolver.get_value(options, self)
+          end
 
-        super
-      end
+          self.options = ActiveSupport::HashWithIndifferentAccess.new(options)
+
+          super
+        end
 
-      # Sets a value of the element
-      # Checks the value from the resolver params against the available options
-      def set_value
-        if resolver.params.key?(name) && options.key?(resolver.params[name])
-          self.value = resolver.params[name]
-        else
-          self.value = @attributes[:value]
+        # Sets a value of the element
+        # Checks the value from the resolver params against the available options
+        def set_value
+          if resolver.params.key?(name) && options.key?(resolver.params[name])
+            self.value = resolver.params[name]
+          else
+            self.value = attributes.delete(:value)
+          end
         end
       end
     end

data/lib/hungryform/elements/html.rb

@@ -6,7 +6,7 @@ module HungryForm
 
       def initialize(name, parent, resolver, attributes = {}, &block)
         super
-        self.value = @attributes[:value] || ''
+        self.value = @attributes.delete(:value) || ''
       end
     end
   end

data/lib/hungryform/elements/page.rb

@@ -26,6 +26,10 @@ module HungryForm
         super
         self.title ||= label
       end
+
+      def to_s
+        self.name
+      end
     end
   end
 end

data/lib/hungryform/elements/radio_group.rb

@@ -9,7 +9,7 @@ module HungryForm
             self.value = resolver.params[name]
           end
         else
-          self.value = @attributes[:value]
+          self.value = attributes.delete(:value)
         end
       end
     end

data/lib/hungryform/elements/select_field.rb

@@ -1,31 +1,27 @@
 module HungryForm
   module Elements
     class SelectField < Base::OptionsElement
-      attr_accessor :multiple
-      alias_method :multiple?, :multiple
-
-      hashable :multiple
-
-      def initialize(name, parent, resolver, attributes = {}, &block)
-        self.multiple = attributes[:multiple] || false
-        super
-      end
-
       # Sets a value of the element
       # Checks the value from the resolver params against the available options
       def set_value
         if resolver.params.key?(name)
+          self.value = resolver.params[name] if acceptable_values?
+        else
+          self.value = attributes.delete(:value)
+        end
+      end
+
+      private
 
-          # Check if all values present in the options
-          if multiple?
-            acceptable_values = (resolver.params[name] - options.keys).empty?
-          else
-            acceptable_values = options.keys.include?(resolver.params[name])
-          end
+      # Check if all of the values from the resolver params are present
+      # in the options.
+      def acceptable_values?
+        options_sym_keys = options.keys.map(&:to_sym)
 
-          self.value = resolver.params[name] if acceptable_values
+        if @attributes[:multiple] && resolver.params[name].respond_to?(:map)
+          (resolver.params[name].map(&:to_sym) - options_sym_keys).empty?
         else
-          self.value = @attributes[:value]
+          options_sym_keys.include?(resolver.params[name].to_sym)
         end
       end
     end

data/lib/hungryform/elements/{text_area_field.rb → text_area.rb}

@@ -1,6 +1,6 @@
 module HungryForm
   module Elements
-    class TextAreaField < Base::ActiveElement
+    class TextArea < Base::ActiveElement
     end
   end
 end

data/lib/hungryform/elements.rb

@@ -1,5 +1,13 @@
 module HungryForm
   module Elements
+    # Find a class of the Elements module by name
+    def self.find_class(name)
+      constants.find { |c| Class === const_get(c) && c.to_s.underscore.to_sym == name }
+    end
+
+    def self.all_classes
+      constants.select { |c| Class === const_get(c) }
+    end
   end
 end
 
@@ -13,5 +21,5 @@ require_relative 'elements/group'
 require_relative 'elements/html'
 require_relative 'elements/text_field'
 require_relative 'elements/select_field'
-require_relative 'elements/text_area_field'
+require_relative 'elements/text_area'
 require_relative 'elements/radio_group'

data/lib/hungryform/exceptions.rb

@@ -0,0 +1,3 @@
+module HungryForm
+  HungryFormException = Class.new(StandardError)
+end

data/lib/hungryform/form.rb

@@ -1,6 +1,7 @@
 require 'json'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/hash/indifferent_access'
 require 'hungryform/version'
 require 'hungryform/resolver'
 require 'hungryform/validator'
@@ -32,7 +33,7 @@ module HungryForm
   # 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
+    attr_reader :pages, :current_page
 
     def initialize(attributes = {}, &block)
       unless block_given?
@@ -43,6 +44,12 @@ module HungryForm
       @pages = []
 
       instance_eval(&block)
+
+      if @resolver.params[:page]
+        @current_page = pages.find { |p| p.name.to_s == @resolver.params[:page] }
+      end
+
+      @current_page ||= pages.first
     end
 
     # Create a form page
@@ -68,7 +75,7 @@ module HungryForm
       !valid?
     end
 
-    # Get all the elements that the form consists of
+    # Get all the elements the form consists of
     def elements
       @resolver.elements
     end
@@ -82,5 +89,28 @@ module HungryForm
     def to_json
       JSON.generate(to_hash)
     end
+
+    # Create a hash of form elements values
+    def values
+      active_elements = elements.select do |name, el|
+        el.is_a? Elements::Base::ActiveElement
+      end
+
+      active_elements.each_with_object({}) do |(name, el), o| 
+        o[name.to_sym] = el.value 
+      end
+    end
+
+    def next_page
+      pages.each_cons(2) do |page, next_page|
+        return next_page if page == current_page
+      end
+    end
+
+    def prev_page
+      pages.each_cons(2) do |prev_page, page|
+        return prev_page if page == current_page
+      end
+    end
   end
 end

data/lib/hungryform/resolver.rb

@@ -5,8 +5,9 @@ module HungryForm
     attr_accessor :elements, :params
 
     def initialize(options = {})
-      @params = options[:params] || {}
-      @elements = {}
+      self.params = ActiveSupport::HashWithIndifferentAccess.new(options[:params] || {})
+
+      self.elements = {}
     end
 
     # Gets element value by element's name.
@@ -26,22 +27,19 @@ module HungryForm
       # we get its placeholders and replace substrings in the name argument
       element.placeholders.each { |k, v| name[k] &&= v } if element
 
-      return @elements[name].value if @elements.key?(name)
-      return @params[name] if @params.key?(name)
-
-      name
+      elements[name].try(:value) || params[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|
+        operator = operator.to_sym
+
         case operator
-        when 'AND'
-          return resolve_multi_dependency(:and, arguments)
-        when 'OR'
-          return resolve_multi_dependency(:or, arguments)
-        when 'NOT'
+        when :and, :or
+          return resolve_multi_dependency(operator, arguments)
+        when :not
           return !resolve_dependency(arguments)
         end
 
@@ -51,13 +49,13 @@ module HungryForm
         return false if arguments.any?(&:nil?)
 
         case operator
-        when 'EQ'
+        when :eq
           return arguments[0].to_s == arguments[1].to_s
-        when 'LT'
+        when :lt
           return arguments[0].to_f < arguments[1].to_f
-        when 'GT'
+        when :gt
           return arguments[0].to_f > arguments[1].to_f
-        when 'SET'
+        when :set
           return !arguments[0].empty?
         end
       end
@@ -65,7 +63,7 @@ module HungryForm
 
     private
 
-    # Helper method to resolve AND or OR conditions.
+    # Method resolves AND or OR conditions.
     # Walks through the arguments and resolves their dependencies.
     def resolve_multi_dependency(type, arguments)
       if arguments.size == 0

data/lib/hungryform/version.rb

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

data/lib/hungryform.rb

@@ -1,12 +1,29 @@
+module HungryForm
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_config
+      @configuration = Configuration.new
+    end
+  end
+end
+
 require 'json'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object'
 require 'hungryform/version'
 require 'hungryform/form'
+require 'hungryform/exceptions'
 require 'hungryform/resolver'
+require 'hungryform/configuration'
 require 'hungryform/validator'
-require 'hungryform/elements'
-
-module HungryForm
-  HungryFormException = Class.new(StandardError)
-end
+require 'hungryform/elements'

data/spec/elements/group_spec.rb

@@ -1,5 +1,14 @@
 require "spec_helper"
 
 describe HungryForm::Elements::Group do
-  it_behaves_like "a group"
+  let(:resolver_options) { {} }
+  let(:resolver) { HungryForm::Resolver.new(resolver_options) }
+  let(:group_options) { {} }
+  let(:group) { HungryForm::Elements::Group.new(:parent_name, nil, resolver, group_options) {} }
+  let(:options) { {} }
+  
+  subject { HungryForm::Elements::Group.new(:element_name, group, resolver, options) {} }
+
+  it_behaves_like 'an element'
+  it_behaves_like 'a group'
 end

data/spec/elements/html_spec.rb

@@ -1,17 +1,19 @@
 require "spec_helper"
 
 describe HungryForm::Elements::Html do
-  it_behaves_like "an element" do
-    let(:element_options) { {} }
-  end
+  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(:options) { { value: 'body text' } }
+
+  subject { HungryForm::Elements::Html.new(:element_name, nil, resolver, options) {} }
 
-  let(:resolver) { HungryForm::Resolver.new() }
-  let(:options) { {value: "body text"} }
-  subject { HungryForm::Elements::Html.new(:html, nil, resolver, options) {} }
+  it_behaves_like 'an element'
 
-  describe ".new" do
-    it "should have a value" do
-      expect(subject.value).to eq "body text"
+  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,25 +1,28 @@
 require "spec_helper"
 
 describe HungryForm::Elements::Page do
-  let(:resolver) { HungryForm::Resolver.new() }
+  let(:resolver_options) { {} }
+  let(:resolver) { HungryForm::Resolver.new(resolver_options) }
+
   let(:options) { {} }
-  let(:page) { HungryForm::Elements::Page.new(:pagename, nil, resolver, options) {} }
+  subject { HungryForm::Elements::Page.new(:element_name, nil, resolver, options) {} }
 
-  it_behaves_like "a group"
+  it_behaves_like 'an element'
+  it_behaves_like 'a group'
 
   describe ".new" do
     it "should have one element" do
-      page = HungryForm::Elements::Page.new(:pagename, nil, resolver, options) do
+      subject = HungryForm::Elements::Page.new(:element_name, nil, resolver, options) do
         html :html_name, value: "<p>Test html block</p>"
       end
-      expect(page.elements.size).to eq 1
+      expect(subject.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::Elements::Group
+      subject.group(:group_name, {}) {}
+      expect(subject.elements.first.class).to eq HungryForm::Elements::Group
     end
   end
 end

data/spec/elements/radio_group_spec.rb

@@ -3,27 +3,21 @@ 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(:group_options) { {} }
+  let(:group) { HungryForm::Elements::Group.new(:group, nil, resolver, group_options) {} }
 
-  let(:element_options) do 
+  let(:options) do 
     {
       :options => {
         "1" => "First", 
-        "2" => "Second",
-        "3" => "Third"
+        "element_value" => "Second" # element_value is checked in shared_active_element
       }
     } 
   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
+  subject { HungryForm::Elements::RadioGroup.new(:element_name, group, resolver, options) {} }
+
+  it_behaves_like 'an element'
+  it_behaves_like 'an active element'
+  it_behaves_like 'an element with options'
 end

data/spec/elements/select_field_spec.rb

@@ -3,45 +3,31 @@ 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) {} }
+  let(:options) do 
+    {
+      :options => {
+        '1' => 'First', 
+        'element_value' => 'Second' # element_value is checked in shared_active_element
+      }
+    } 
+  end
 
-	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
+  subject { HungryForm::Elements::SelectField.new(:element_name, group, resolver, options) {} }
 
-	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"])
+  it_behaves_like 'an element'
+  it_behaves_like 'an active element'
+	it_behaves_like 'an element with options'
+		
+	describe '#set_value' do
+		context 'when multiple enabled' do
+			it 'assigns multiple values' do
+				resolver_options[:params] = {"group_element_name" => ["1", "element_value"]}
+				options[:multiple] = true
+				expect(subject.value).to eq(["1", "element_value"])
 			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/shared_examples/active_element.rb

@@ -0,0 +1,52 @@
+RSpec.shared_examples "an active element" do
+  describe ".new" do
+    it "should have empty error" do
+      expect(subject.error).to eq ""
+    end
+
+    it "should not be required if its parent is not visible" do
+      group_options[:visible] = false
+      options[:required] = true
+      expect(subject.required?).to eq false
+    end
+
+    it "should have a nil value" do
+      expect(subject.value).to be nil
+    end
+
+    it "should have a value from form params" do
+      resolver_options[:params]= {"group_element_name" => "element_value" }
+      expect(subject.value).to eq "element_value"
+    end
+
+    it "should have a value from element structure" do
+      options[:value] = "element_value"
+      expect(subject.value).to eq "element_value"
+    end
+  end
+
+  describe "#valid?" do
+    context "when required" do
+      before(:each) { options[:required] = true }
+
+      it "is valid" do
+        subject.value = "value"
+        expect(subject.valid?).to eq true
+        expect(subject.error).to eq ''
+      end
+
+      it "is invalid" do
+        subject.value = ''
+        expect(subject.valid?).to eq false
+        expect(subject.error).to eq 'This field is required'
+      end
+    end
+  end
+
+  describe "#to_hash" do
+    it 'should include required, value and error' do
+      options.merge!(value: '', required: true)
+      expect(subject.to_hash).to include(:required, :value, :error)
+    end
+  end
+end