lib/hungryform/resolver.rb in hungryform-0.0.4 vs lib/hungryform/resolver.rb in hungryform-0.0.6

@@ -3,12 +3,13 @@
   # It contains all form elements and params
   class Resolver
     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.
     # If name is lambda - returns lambda's result
     # If name is present in the resolvers' elements hash - returns element's value
@@ -24,49 +25,46 @@
       # 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
       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
 
         arguments = [arguments] unless arguments.is_a?(Array)
 
         arguments = arguments[0..1].map { |name| get_value(name) }
         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
     end
 
     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
         fail HungryFormException, "No arguments for #{type.upcase} comparison: #{arguments}"
       end