hungryform 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 301fe1318d8aec9203be048d49946604a9c90826
-  data.tar.gz: 58eed16ad2bf95ffd8453d6225c32e79234beaf1
+  metadata.gz: 366185c77f738aac57f059664729402272c35d18
+  data.tar.gz: 4368d143b24f7eec28af6ca428de93eebabbd6fd
 SHA512:
-  metadata.gz: d4da2b5138ddbbad90956b0bd0fbbbfa885f7ae3d25518951629d8d98c46518d1e81f759f523222e52075c89e69312f6d9417ec5cdd2ff55c2f105c5ef624fb0
-  data.tar.gz: 7a443c26c7fe85572cb9a15f70df473f59ccdca5f02aab2ed676ea49f98eebe01cbe428603ea0560ac39edeb73a4e2a7ac24ff82772ee69de471a31c5a7379ca
+  metadata.gz: 19bdd1d7bdad63873e2386fe74e0fe8efd184b7eb5d295acf79899093d57ee71a66bc7b36f380fa32b0555917a703ef0f5a6376df5f16df29065bee6d876420e
+  data.tar.gz: db49ba35e648b857964f43fb82569f270521c196d8153f02337aed5ee47fd9e819233bf5eec81464b9aa42cf64252a6b0aa89191a4d208ac40d5ec53d762b0c1

data/.gitignore

@@ -1 +1,6 @@
-*.gem
+*.gem
+*.log
+
+Gemfile.lock
+gemfiles/*.lock
+spec/app/tmp

data/.rspec

@@ -1,2 +1 @@
---format documentation
 --color

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/.travis.yml

@@ -0,0 +1,5 @@
+install:
+  - 'travis_retry bundle install'
+language:
+  - ruby
+script: 'bundle exec rspec spec'

data/README.md

@@ -1,8 +1,6 @@
-# HungryForm
+# HungryForm [![Build Status](https://travis-ci.org/andrba/hungryform.svg?branch=master)](https://travis-ci.org/andrba/hungryform) [![Code Climate](https://codeclimate.com/github/andrba/hungryform/badges/gpa.svg)](https://codeclimate.com/github/andrba/hungryform)
 
-[![Build Status](https://travis-ci.org/andrba/hungryform.svg?branch=master)](https://travis-ci.org/andrba/hungryform)
-
-HungryForm is a gem for managing multiple page forms. The main purpose of this gem is to give developers an easy DSL to build complex forms.
+HungryForm is a gem for managing multiple page forms. The main purpose of this gem is to give developers an easy DSL to build complex forms. 
 
 ## Usage
 
@@ -20,81 +18,112 @@ form = HungryForm::Form.new do
     text_field :occupation
     
     # Show this group only when the occupation field is not empty
-    group :employment_history, dependency: '{"SET": "third_occupation"}' do
+    group :employment_history, dependency: { set: "third_occupation" } do
       html :before, value: "Employment history over the last 5 years"
       text_area :history, value: "Default value"
     end
   end 
 end
-```
-
-To assign values to the form elements pass them as a hash on form initialization. The params hash must consist of elements names and their values. Please note, that the elements names must contain the full path to the element, starting from the page name.
-
-```ruby
-params = {
-  "first_first_name" => "John",
-  "first_last_name" => "Doe",
-  "second_address" => "John's address",
-  "third_occupation" => "Software engineer",
-  "third_employment_history_history" => "John's employment hisotory"
-}
 
-form = HungryForm::Form.new :params => params do
-...
+if form.valid?
+  form.to_json
 end
-
 ```
+## Field Dependencies
 
-You can assign default value to a form element:
+Each element of HungryForm, including pages and groups, can have a ```dependency``` parameter. This parameter must be a hash, containing a tree of basic operations. The dependency tree eventually resolves into to a boolean result. Within this tree you can use and combine the following operators, creating complex dependencies that can involve multiple elements:
 
 ```ruby
-text_field :email, value: "john.doe@yahoo.com"
-```
-## Dependencies
-
-Each element of HungryForm, including pages and groups, can have a dependency parameter. This parameter must be a json string with an expression, that resolves to a boolean result. Within this expression you can use and combine the following operators, creating complex dependencies that can involve multiple elements:
-
-```json
 # val1 == val2
-{"EQ": ["val1", "val2"]}
+{ eq: ["val1", "val2"] }
 
 # val1 > val2
-{"GT": ["val1", "val2"]}
+{ gt: ["val1", "val2"] }
 
 # val1 < val2
-{"LT": ["val1", "val2"]}
+{ lt: ["val1", "val2"] }
 
 # val1 is not empty
-{"SET": "val1"}
+{ set: "val1" }
 
 # Get the opposite result of the expression
-{"NOT": {"EQ": ["1", "1"]}}
+{ not: { eq: [1, 1] } }
 
 # Check if all the expressions are true
-{"AND": [
-  {"EQ": ["1", "1"]},
-  {"EQ": ["2", "2"]}
-]}
+{ 
+  and: [
+    { eq: [1, 1] },
+    { eq: [2, 2] }
+  ] 
+}
 
 # Check if any of the expressions is true
-{"OR": [
-  {"NOT": {"EQ": ["1", "1"]}},
-  {"EQ": ["2", "2"]}
-]}
+{ 
+  or: [
+    { not: { eq: [1, 1] } },
+    { eq: [2, 2] }
+  ] 
+}
 ```
 
-If the dependency is resolved positively it makes the element visible. Otherwise the element will be hidden and not required. It is allowed to use element names or params keys as parameters inside expressions.
+If the dependency is resolved positively it makes the element visible. Otherwise the element will be hidden with all its validation rules omited. It is allowed to use element names or params keys as parameters inside expressions.
 
 ```ruby
 HungryForm::Form.new do
   page :about do
     text_field :age
-    text_field :favourite_alcohol, required: true, dependency: '{"GT": ["about_age", "18"]}'
+    text_field :favourite_alcohol, required: true, dependency: { gt: ["about_age", 18] }
   end
 end
     
 ```
 
+## Assigning values
+
+To assign values to form fields pass them as a hash on form initialization. The params hash must consist of field names and their values. Please note, that the field names must contain the full path to the field, starting from the page name.
+
+```ruby
+params = {
+  "first_first_name" => "John",
+  "first_last_name" => "Doe",
+  "second_address" => "John's address",
+  "third_occupation" => "Software engineer",
+  "third_employment_history_history" => "John's employment history"
+}
+
+form = HungryForm::Form.new :params => params do
+...
+end
+
+```
+
+Assign a default value to a form field:
+
+```ruby
+text_field :email, value: "john.doe@yahoo.com"
+```
+
+You can assign any attribute to the field and it will be included into the field attributes during rendering:
+
+```ruby
+text_field :email, my_attribute: "attribute value"
+```
+
+## Configuration
+
+To configure the gem use the configuration block:
+
+```ruby
+HungryForm.configure do |config|
+  config.views_prefix = 'myform'
+  config.text_field maxlength: 100
+end
+```
+
+```views_prefix```: Set this option in case you want to override the standard elements templates with your own ones. The prefix must match the folder name in your views folder where you keep the elements partials.
+
+```text_field``` (or any other element name): Assign an attribute to all elements of this type
+
 ## Validation
 
 Each active element of a form can be assigned with validation rules.

data/Rakefile

@@ -1,4 +1,3 @@
-require "bundler/gem_tasks"
-require 'rspec/core/rake_task'
-task :default => :spec
-RSpec::Core::RakeTask.new
+# encoding: utf-8
+
+require "bundler/gem_tasks"

data/hungryform.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 1.9.2'
   
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency 'pry'
   spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler", ['>= 1.0.0']
+  spec.add_development_dependency "rake", ['>= 0']
+  spec.add_development_dependency "rspec", ['>= 3.0']
 end

data/lib/hungryform/configuration.rb

@@ -0,0 +1,31 @@
+module HungryForm
+  class Configuration
+    attr_accessor :views_prefix
+
+    def initialize
+      @views_prefix = 'hungryform'
+
+      init_element_default_attributes
+    end
+
+    private
+
+    def init_element_default_attributes
+      @elements_default_attributes = {}
+
+      HungryForm::Elements.all_classes.each do |klass|
+        klass_name = klass.to_s.underscore.to_sym
+        @elements_default_attributes[klass_name] = {}
+
+        # Assign a default attribute to an element
+        define_singleton_method klass_name do |attributes = {}|
+          if attributes.any?
+            @elements_default_attributes[klass_name].merge!(attributes)
+          end
+
+          @elements_default_attributes[klass_name]
+        end
+      end
+    end
+  end
+end

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

@@ -1,52 +1,60 @@
 module HungryForm
-  module Elements::Base
-    # The ActiveElement class is used as a base class for all
-    # form fields that can contain values and be validated
-    class ActiveElement < Element
-      attr_accessor :error, :value, :required
-      alias_method :required?, :required
+  module Elements
+    module Base
+      # The ActiveElement class is used as a base class for all
+      # form fields that can contain values and be validated
+      class ActiveElement < Element
+        attr_accessor :error, :value, :required
+        alias_method :required?, :required
 
-      hashable :required, :value, :error
+        hashable :required, :value, :error
 
-      def initialize(name, parent, resolver, attributes = {}, &block)
-        super
+        def initialize(name, parent, resolver, attributes = {}, &block)
+          super
 
-        clear_error
+          clear_error
 
-        # Leave only the attributes that are being methods of the HungryForm::Validator class
-        @validation_rules = @attributes.select { |key, _| HungryForm::Validator.respond_to?(key) }
-
-        if parent.visible?
-          self.required = @attributes[:required] || false
-        else
-          self.required = false
-        end
+          if parent.visible?
+            self.required = @attributes[:required] || false
+          else
+            self.required = false
+          end
 
-        set_value
-      end
+          # Leave only the attributes that are being methods of the HungryForm::Validator class
+          @validation_rules = @attributes.select { |key, _| HungryForm::Validator.singleton_class.instance_methods(false).include?(key) }
+          @attributes.delete_if { |key, _| @validation_rules.key?(key) }
 
-      def valid?
-        clear_error
-        is_valid = true
-        return true unless visible?
+          set_value
+        end
 
-        @validation_rules.each do |key, rule|
-          error = HungryForm::Validator.send(key, self, rule) || ''
-          unless error.empty?
-            is_valid = false
-            break
+        def valid?
+          clear_error
+          is_valid = true
+          return true unless visible?
+
+          @validation_rules.each do |key, rule|
+            self.error = HungryForm::Validator.send(key, self, rule) || ''
+            unless error.empty?
+              self.error = "This field #{error}"
+              is_valid = false
+              break
+            end
           end
+
+          is_valid
         end
 
-        is_valid
-      end
+        def invalid?
+          !valid?
+        end
 
-      def set_value
-        self.value = resolver.params.key?(name) ? resolver.params[name] : @attributes[:value]
-      end
+        def set_value
+          self.value = resolver.params[name] || attributes.delete(:value)
+        end
 
-      def clear_error
-        self.error = ''
+        def clear_error
+          self.error = ''
+        end
       end
     end
   end

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

@@ -1,57 +1,48 @@
 module HungryForm
-  module Elements::Base
-    # The Element class is used in every form element. It contains the attrs
-    # and methods used by all form elements, such as name, visible, dependency etc
-    class Element
-      include HungryForm::Elements::Base::Hashable
-      attr_accessor :name, :placeholders, :resolver, :visible, :label, :dependency
-      alias_method :visible?, :visible
-
-      hashable :visible, :dependency, :name, :label
-
-      def initialize(name, parent, resolver, attributes = {})
-        @attributes = attributes.dup
-
-        @placeholders ||= {}
-        @resolver = resolver
-
-        self.dependency ||= @attributes[:dependency]
-
-        # The element is visible if no visible parameter passed or
-        # visible param equals true and the dependency is resolved positively
-        self.visible = @attributes.key?(:visible) ? @attributes[:visible] : true
-
-        if dependency
-          json_dependency = ::JSON.parse(dependency)
-          self.visible &&= resolver.resolve_dependency(json_dependency)
+  module Elements
+    module Base
+      # The Element class is used in every form element. It contains the attrs
+      # and methods used by all form elements, such as name, visible, dependency etc
+      class Element
+        include HungryForm::Elements::Base::Hashable
+        attr_accessor :name, :placeholders, :resolver, :visible, :label, :dependency, :attributes
+        alias_method :visible?, :visible
+
+        hashable :visible, :dependency, :name, :label
+
+        def initialize(name, parent, resolver, attributes = {})
+          @attributes = HungryForm.configuration.send(self.class.name.demodulize.underscore).dup
+          @attributes.merge!(attributes)
+
+          @placeholders ||= {}
+          @resolver = resolver
+
+          self.dependency ||= @attributes.delete(:dependency)
+
+          # The element is visible if no visible parameter passed or
+          # visible param equals true and the dependency is resolved positively
+          self.visible = @attributes.key?(:visible) ? @attributes.delete(:visible) : true
+
+          if dependency
+            self.visible &&= resolver.resolve_dependency(dependency)
+          end
+
+          # An element's name is prefixed with all parents names up to the page
+          self.name = resolver.get_value(name, self)
+          self.name = "#{parent.name}_#{name}" unless parent.nil?
+          
+          # Label can be created from name if there is no label given
+          if @attributes[:label]
+            self.label = resolver.get_value(@attributes.delete(:label), self)
+          else
+            self.label = resolver.get_value(name, self).humanize
+          end
         end
 
-        # An element's name is prefixed with all parents names up to the page
-        self.name = resolver.get_value(name, self)
-        self.name = "#{parent.name}_#{name}" unless parent.nil?
-
-        # Label can be created from name if there is no label given
-        if @attributes[:label]
-          self.label = resolver.get_value(@attributes[:label], self)
-        else
-          self.label = resolver.get_value(name, self).humanize
+        def dependency_json
+          JSON.generate(dependency) if dependency
         end
       end
-
-      def method_missing(method_name, *args, &block)
-        # Check if an option exists
-        if method_name.to_s[-1] == '?'
-          return @attributes.key?(method_name.to_s[0..-2].to_sym)
-        end
-
-        # Return an attribute
-        return @attributes[method_name] if @attributes.key?(method_name)
-        super
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        @attributes.key?(method_name) || super
-      end
     end
   end
 end

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

@@ -1,88 +1,91 @@
 module HungryForm
-  module Elements::Base
-    # 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
-    class Group < Element
-      attr_accessor :elements, :errors
-
-      hashable :elements
-
-      def initialize(name, parent, resolver, attributes = {}, &block)
-        unless block_given?
-          fail HungryFormException, 'No group structure block given'
-        end
-
-        super
-
-        @elements = []
-        @errors = {}
+  module Elements
+    module Base
+      # 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
+      class Group < Element
+        attr_accessor :elements, :errors
+
+        hashable :elements
+
+        def initialize(name, parent, resolver, attributes = {}, &block)
+          unless block_given?
+            fail HungryFormException, 'No group structure block given'
+          end
 
-        instance_eval(&block)
-      end
+          super
 
-      # Validates an entire group. If a group consists of nested groups
-      # they will be validated recursively
-      def valid?
-        errors.clear
-        is_valid = true
+          @elements = []
+          @errors = {}
 
-        elements.each do |el|
-          next if el.valid?
+          instance_eval(&block)
+        end
 
-          is_valid = false
-          case el
-          when BaseActiveElement
-            errors[el.name] = el.error
-          when BaseGroupObject
-            errors.merge!(el.errors)
+        # Validates an entire group. If a group consists of nested groups
+        # they will be validated recursively
+        def valid?
+          errors.clear
+          is_valid = true
+          return true unless visible?
+          
+          elements.each do |el|
+            next if !el.respond_to?(:valid?) || el.valid?
+
+            is_valid = false
+            case el
+            when Base::ActiveElement
+              errors[el.name] = el.error
+            when Base::Group
+              errors.merge!(el.errors)
+            end
           end
-        end
 
-        is_valid
-      end
+          is_valid
+        end
 
-      def invalid?
-        !valid?
-      end
+        def invalid?
+          !valid?
+        end
 
-      def to_hash
-        super.merge(elements: elements.map(&:to_hash))
-      end
+        def to_hash
+          super.merge(elements: elements.map(&:to_hash))
+        end
 
-      def method_missing(method_name, *args, &block)
-        # Find a matching class
-        klass = HungryForm::Elements.constants.find { |c| Class === HungryForm::Elements.const_get(c) && c.to_s.underscore.to_sym == method_name }
-        return super if klass.nil?
+        def method_missing(method_name, *args, &block)
+          # Find a matching class
+          klass = HungryForm::Elements.find_class(method_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::Elements.const_get(klass).send(:new, args[0], self, @resolver, *(args[1..-1]), &block)
-        elements << element
+          # Create a new element based on a symbol provided and push it into the group elements array
+          element = HungryForm::Elements.const_get(klass).send(:new, args[0], self, @resolver, *(args[1..-1]), &block)
+          elements << element
 
-        # Resolver keeps a hash of all elements of the form
-        @resolver.elements[element.name] = element
+          # Resolver keeps a hash of all elements of the form
+          @resolver.elements[element.name] = element
 
-        element
-      end
+          element
+        end
 
-      def respond_to_missing?(method_name, include_private = false)
-        HungryForm::Elements.constants.any? { |c| Class === HungryForm::Elements.const_get(c) && c.to_s.underscore.to_sym == method_name } || super
+        def respond_to_missing?(method_name, include_private = false)
+          HungryForm::Elements.find_class(method_name) || super
+        end
       end
     end
   end