cucumber-rest-bdd 0.5.3 → 0.6.0.pre.183

data/lib/cucumber-rest-bdd/steps/response.rb

@@ -1,170 +1,145 @@
 require 'cucumber-rest-bdd/steps/resource'
 require 'cucumber-rest-bdd/types'
+require 'cucumber-rest-bdd/list'
+require 'cucumber-rest-bdd/data'
 
-Then(/^print the response$/) do
+ParameterType(
+    name: 'item_name',
+    regexp: /([\w\s]+?)/,
+    transformer: -> (s) { s },
+    use_for_snippets: false
+)
+
+Then("print the response") do
     puts %/The response:\n#{@response.to_json_s}/
 end
 
-# response interrogation
+# SIMPLE VALUE RESPONSE
+
+# response is a string with the specified value
+Then("the response #{HAVE_ALTERNATION} (the )(following )value {string}") do |value|
+    expected = value
+    data = @response.get get_root_data_key()
+    raise %/Response did not match: #{expected}\n#{data}/ if data.empty? || !data.include?(expected)
+end
+
+# OBJECT RESPONSE
+
+# response is an object with a field that is validated by a pre-defined regex
+Then("the response #{HAVE_ALTERNATION} {field_name} of type {word}") do |field, type|
+    regex = case type
+        when 'datetime' then /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:[+|-]\d{2}:\d{2})?$/i
+        when 'guid' then /^[{(]?[0-9A-F]{8}[-]?([0-9A-F]{4}[-]?){3}[0-9A-F]{12}[)}]?$/i
+        else nil
+    end
+
+    type = 'string' if regex.nil?
+    value = field.get_value(@response, type)
+    field.validate_value(@response, value.to_s, Regexp.new(regex))
+end
+
+# response is an object with a field that is validated by a custom regex
+Then("the response #{HAVE_ALTERNATION} {field_name} of type {word} that matches {string}") do |field, type, regex|
+    value = field.get_value(@response, type)
+    field.validate_value(@response, value.to_s, Regexp.new(regex))
+end
 
-Then(/^the response is a list (?:of|containing) (#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) .*?$/) do |count_mod, count|
+# response is an object with specific attributes having defined values
+Then("the response #{HAVE_ALTERNATION} (the )(following )attributes:") do |attributes|
+    expected = get_attributes(attributes.hashes)
+    data = @response.get get_root_data_key()
+    raise %/Response did not match:\n#{expected.inspect}\n#{data}/ if data.empty? || !data.deep_include?(expected)
+end
+
+# ARRAY RESPONSE
+
+# response is an array of objects
+Then("the response is a list of/containing {list_has_count} {field_name}") do |list_comparison, item|
     list = @response.get_as_type get_root_data_key(), 'array'
-    raise %/Expected at least #{count} items in array for path '#{get_root_data_key()}', found: #{list.count}\n#{@response.to_json_s}/ if !num_compare(count_mod, list.count, count.to_i)
+    raise %/Expected #{list_comparison.to_string()} items in array for path '#{get_root_data_key()}', found: #{list.count}\n#{@response.to_json_s}/ if !list_comparison.compare(list.count)
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:\w+) )*)#{HAVE_SYNONYM} (?:the )?(?:following )?(?:data|error )?attributes:$/) do |nesting, attributes|
+# response is an array of objects where the specified number of entries match the defined data attributes
+Then("(the response is a list with ){list_has_count} {word} #{HAVE_ALTERNATION} (the )(following )(data )attributes:") do |list_comparison, item_name, attributes|
     expected = get_attributes(attributes.hashes)
-    groups = nesting
-    grouping = get_grouping(groups)
-    grouping.push({
-        root: true,
-        type: 'single'
-    })
-    data = @response.get get_key(grouping)
-    raise %/Could not find a match for: #{nesting}\n#{expected.inspect}\n#{@response.to_json_s}/ if data.empty? || !nest_match(data, grouping, expected)
+    data = @response.get_as_type get_root_data_key(), 'array'
+    matched = data.select { |item| !item.empty? && item.deep_include?(expected) }
+    raise %/Expected #{list_comparison.to_string()} items in array that matched:\n#{expected.inspect}\n#{data}/ if !list_comparison.compare(matched.count)
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:\w+)\s?)+)$/) do |nesting|
-    groups = nesting
-    grouping = get_grouping(groups)
-    grouping.push({
+# response is an array of objects where the specified number of entries match the defined data attributes
+Then("(the response is a list with ){list_has_count} {item_name} {list_nesting}") do |list_comparison, item_name, nesting|
+    nesting.push({
         root: true,
-        type: 'single'
+        type: 'multiple',
+        comparison: list_comparison
     })
-    data = @response.get get_key(grouping)
-    raise %/Could not find a match for: #{nesting}\n#{@response.to_json_s}/ if data.empty? || !nest_match(data, grouping, {})
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, {}, false)
 end
 
-Then(/^(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) (?:.*?) ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:\w+) )*)#{HAVE_SYNONYM} (?:the )?(?:following )?(?:data )?attributes:$/) do |count_mod, count, nesting, attributes|
+# response is an array of objects where the specified number of entries match the defined data attributes
+Then("(the response is a list with ){list_has_count} {item_name} {list_nesting} #{HAVE_ALTERNATION} (the )(following )(data )attributes:") do |list_comparison, item_name, nesting, attributes|
     expected = get_attributes(attributes.hashes)
-    groups = nesting
-    grouping = get_grouping(groups)
-    grouping.push({
+    nesting.push({
         root: true,
         type: 'multiple',
-        count: count.to_i,
-        count_mod: count_mod
+        comparison: list_comparison
     })
-    data = @response.get get_key(grouping)
-    raise %/Expected #{compare_to_string(count_mod)}#{count} items in array with attributes for: #{nesting}\n#{expected.inspect}\n#{@response.to_json_s}/ if !nest_match(data, grouping, expected)
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{expected.inspect}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, false)
 end
 
-Then(/^(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) (?:.*?) ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:\w+)\s?)+)$/) do |count_mod, count, nesting|
-    groups = nesting
-    grouping = get_grouping(groups)
-    grouping.push({
+# response is an array of objects where the specified number of entries match the defined string value
+Then("(the response is a list with ){list_has_count} {item_name} having/containing/with (the )(following )value {string}") do |list_comparison, item_name, value|
+    expected = value
+    data = @response.get_as_type get_root_data_key(), 'array'
+    matched = data.select { |item| !item.empty? && item.include?(expected) }
+    raise %/Expected #{list_comparison.to_string()} items in array that matched:\n#{expected}\n#{data}/ if !list_comparison.compare(matched.count)
+end
+
+# response is an array of objects where the specified number of entries match the defined string value
+Then("(the response is a list with ){list_has_count} {item_name} {list_nesting} #{HAVE_ALTERNATION} (the )(following )value {string}") do |list_comparison, item_name, nesting, value|
+    expected = value
+    nesting.push({
         root: true,
         type: 'multiple',
-        count: count.to_i,
-        count_mod: count_mod
+        comparison: list_comparison
     })
-    data = @response.get get_key(grouping)
-    raise %/Expected #{compare_to_string(count_mod)}#{count} items in array with: #{nesting}\n#{@response.to_json_s}/ if !nest_match(data, grouping, {})
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{expected}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, true)
 end
 
-Then(/^the response ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:\w+) )*)#{HAVE_SYNONYM} a list of (#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT} |\d+ )?(\w+)$/) do |nesting, num_mod, num, item|
-    groups = nesting
-    list = {
-        type: 'list',
-        key: get_resource(item)
-    }
-    if (num) then
-        list[:count] = num.to_i
-        list[:count_mod] = num_mod
-    end
-    grouping = [list]
-    grouping.concat(get_grouping(groups))
-    grouping.push({
+# HIERARCHICAL RESPONSE
+
+# response has the specified hierarchy of objects / lists where the specified number of leaf items match the defined data attributes
+Then("the response {list_nesting} #{HAVE_ALTERNATION} (the )(following )attributes:") do |nesting, attributes|
+    expected = get_attributes(attributes.hashes)
+    nesting.push({
         root: true,
         type: 'single'
     })
-    data = @response.get get_key(grouping)
-    raise %/Could not find a match for #{nesting}#{compare_to_string(num_mod)}#{num} #{item}\n#{@response.to_json_s}/ if !nest_match(data, grouping, {})
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{expected.inspect}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, false)
 end
 
-Then(/^(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+) (?:.*?) ((?:#{HAVE_SYNONYM} (?:a|an|(?:(?:#{FEWER_MORE_THAN})?\s*#{CAPTURE_INT}|\d+)) (?:\w+) )*)#{HAVE_SYNONYM} a list of (#{FEWER_MORE_THAN})?\s*(?:(#{CAPTURE_INT}|\d+) )?(\w+)$/) do |count_mod, count, nesting, num_mod, num, item|
-    groups = nesting
-    list = {
-        type: 'list',
-        key: get_resource(item)
-    }
-    if (num) then
-        list[:count] = num.to_i
-        list[:count_mod] = num_mod
-    end
-    grouping = [list]
-    grouping.concat(get_grouping(groups))
-    grouping.push({
+# response has the specified hierarchy of objects / lists where the specified number of leaf items match the defined string value
+Then("the response {list_nesting} #{HAVE_ALTERNATION} (the )(following )value {string}") do |nesting, value|
+    expected = value
+    nesting.push({
         root: true,
-        type: 'multiple',
-        count: count.to_i,
-        count_mod: count_mod
+        type: 'single'
     })
-    data = @response.get get_key(grouping)
-    raise %/Expected #{compare_to_string(count_mod)}#{count} items with #{nesting}#{compare_to_string(num_mod)}#{num}#{item}\n#{@response.to_json_s}/ if !nest_match(data, grouping, {})
-end
-
-# gets the relevant key for the response based on the first key element
-def get_key(grouping)
-    if ENV['error_key'] && !ENV['error_key'].empty? && grouping.count > 1 && grouping[-2][:key].singularize == ENV['error_key'] then
-        get_root_error_key()
-    else
-        get_root_data_key()
-    end
-end
-
-# gets an array in the nesting format that nest_match understands to interrogate nested object and array data
-def get_grouping(nesting)
-    grouping = []
-    while matches = /^#{HAVE_SYNONYM} (?:a|an|(?:(#{FEWER_MORE_THAN})?\s*(#{CAPTURE_INT}|\d+))) (\w+)\s?+/.match(nesting)
-        nesting = nesting[matches[0].length, nesting.length]
-        if matches[2].nil? then
-            level = {
-                type: 'single',
-                key: get_parameter(matches[3]),
-                root: false
-            }
-        else
-            level = {
-                type: 'multiple',
-                key: get_parameter(matches[3]),
-                count: to_num(matches[2]),
-                root: false,
-                count_mod: to_compare(matches[1])
-            }
-        end
-        grouping.push(level)
-    end
-    grouping.reverse
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{expected}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, expected, true)
 end
 
-# top level has 2 children with an item containing at most three fish with attributes:
-#
-# nesting = [{key=fish,count=3,count_mod='<=',type=multiple},{key=item,type=single},{key=children,type=multiple,count=2,count_mod='='},{root=true,type=single}]
-#
-# returns true if the expected data is contained within the data based on the nesting information
-def nest_match(data, nesting, expected)
-    return false if !data
-    return data.deep_include?(expected) if nesting.size == 0
-
-    local_nesting = nesting.dup
-    level = local_nesting.pop
-    case level[:type]
-    when 'single' then
-        child_data = level[:root] ? data.dup : data[get_parameter(level[:key])]
-        return nest_match(child_data, local_nesting, expected)
-    when 'multiple' then
-        child_data = level[:root] ? data.dup : data[get_resource(level[:key])]
-        matched = child_data.select { |item| nest_match(item, local_nesting, expected) }
-        return num_compare(level[:count_mod], matched.count, level[:count])
-    when 'list' then
-        child_data = level[:root] ? data.dup : data[get_resource(level[:key])]
-        return false if !child_data.is_a?(Array)
-        if level.has_key?(:count) then
-            return num_compare(level[:count_mod], child_data.count, level[:count])
-        end
-        return true
-    else
-        raise %/Unknown nested data type: #{level[:type]}/
-    end
+# response has the specified hierarchy of objects / lists where the specified number of leaf items is as expected only (no data checked)
+Then("the response {list_nesting}") do |nesting|
+    nesting.push({
+        root: true,
+        type: 'single'
+    })
+    data = @response.get get_key(nesting.grouping)
+    raise %/Could not find a match for: #{nesting.match}\n#{@response.to_json_s}/ if data.empty? || !nest_match_attributes(data, nesting.grouping, {}, false)
 end

data/lib/cucumber-rest-bdd/steps/status.rb

@@ -1,63 +1,102 @@
 require 'cucumber-api/response'
 require 'cucumber-api/steps'
 
-Then(/^the request (?:is|was) successful$/) do
+ParameterType(
+    name: 'item_type',
+    regexp: /([\w\s]+)/,
+    transformer: -> (s) { s },
+    use_for_snippets: false
+)
+
+Then("the request is/was successful") do
     raise %/Expected Successful response code 2xx but was #{@response.code}/ if @response.code < 200 || @response.code >= 300
 end
 
-Then(/^the request (?:is|was) redirected$/) do
+Then("the request is/was redirected") do
     raise %/Expected redirected response code 3xx but was #{@response.code}/ if @response.code < 300 || @response.code >= 400
 end
 
-Then(/^(?:it|the request) fail(?:s|ed)$/) do
+Then("the request fail(s/ed)") do
     raise %/Expected failed response code 4xx\/5xx but was #{@response.code}/ if @response.code < 400 || @response.code >= 600
 end
 
-Then(/^the (?!request)(?:.+?) (?:is|was) created$/) do
+Then("the request is/was successful and a/the resource is/was created") do
     steps %Q{Then the response status should be "201"}
 end
 
-Then(/^the request (?:is|was) successful and (?:a resource|.+) (?:is|was) created$/) do
+Then("(the request is/was successful and )a/the {item_type} is/was created") do | item_type |
     steps %Q{Then the response status should be "201"}
 end
 
-Then(/^the request (?:is|was) successfully accepted$/) do
+Then("the request is/was successfully accepted") do
   steps %Q{Then the response status should be "202"}
 end
 
-Then(/^the request (?:is|was) successful and (?:no|an empty) response body is returned$/) do
+Then("the request is/was successful and (an )empty/blank/no response body is/was returned") do
   steps %Q{Then the response status should be "204"}
   raise %/Expected the request body to be empty/ if !@response.body.empty?
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because it (?:is|was) invalid$/) do
+Then("the request fail(s/ed) because (the )it/resource is/was invalid") do
+    steps %Q{Then the response status should be "400"}
+end
+
+Then("the request fail(s/ed) because (the ){item_type} is/was invalid") do | item_type |
     steps %Q{Then the response status should be "400"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because (?:.+) (?:is|was|am|are) unauthori[sz]ed$/) do
+Then("the request fail(s/ed) because (the )it/resource is/was/am/are unauthorised/unauthorized") do
+    steps %Q{Then the response status should be "401"}
+end
+
+Then("the request fail(s/ed) because (the ){item_type} is/was/am/are unauthorised/unauthorized") do | item_type |
     steps %Q{Then the response status should be "401"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because (?:.+) (?:is|was) forbidden$/) do
+Then("the request fail(s/ed) because (the )it/resource is/was forbidden") do
     steps %Q{Then the response status should be "403"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was) not found$/) do
+Then("the request fail(s/ed) because (the ){item_type} is/was forbidden") do | item_type |
+    steps %Q{Then the response status should be "403"}
+end
+
+Then("the request fail(s/ed) because (the )it/resource is/was not found") do
+    steps %Q{Then the response status should be "404"}
+end
+
+Then("the request fail(s/ed) because (the ){item_type} is/was not found") do | item_type |
     steps %Q{Then the response status should be "404"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because it (?:is|was) not allowed$/) do
+Then("the request fail(s/ed) because (the )it/resource is/was not allowed") do
     steps %Q{Then the response status should be "405"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because there (?:is|was|has) a conflict(?: with .+)?$/) do
+Then("the request fail(s/ed) because (the ){item_type} is/was not allowed") do  | item_type |
+    steps %Q{Then the response status should be "405"}
+end
+
+Then("the request fail(s/ed) because there is/was/has a conflict") do
+    steps %Q{Then the response status should be "409"}
+end
+
+Then("the request fail(s/ed) because there is/was/has a conflict with {item_type}") do | item_type |
     steps %Q{Then the response status should be "409"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was|has) gone$/) do
+Then("the request fail(s/ed) because (the )it/resource is/was/has gone") do
     steps %Q{Then the response status should be "410"}
 end
 
-Then(/^(?:it|the request) fail(?:s|ed) because the (?:.+) (?:is|was) not implemented$/) do
+Then("the request fail(s/ed) because (the ){item_type} is/was/has gone") do | item_type |
+    steps %Q{Then the response status should be "410"}
+end
+
+Then("the request fail(s/ed) because (the )it/resource is/was not implemented") do
+    steps %Q{Then the response status should be "501"}
+end
+
+Then("the request fail(s/ed) because (the ){item_type} is/was not implemented") do | item_type |
     steps %Q{Then the response status should be "501"}
 end

data/lib/cucumber-rest-bdd/types.rb

@@ -1,85 +1,69 @@
 require 'active_support/inflector'
 
-CAPTURE_INT = Transform(/^(?:zero|one|two|three|four|five|six|seven|eight|nine|ten)$/) do |v|
-    %w(zero one two three four five six seven eight nine ten).index(v)
-end
+HAVE_ALTERNATION = "has/have/having/contain/contains/containing/with"
+RESOURCE_NAME_SYNONYM = '\w+\b(?:\s+\w+\b)*?|`[^`]*`'
+FIELD_NAME_SYNONYM = '\w+\b(?:(?:\s+:)?\s+\w+\b)*?|`[^`]*`'
+MAXIMAL_FIELD_NAME_SYNONYM = '\w+\b(?:(?:\s+:)?\s+\w+\b)*|`[^`]*`'
+
+ParameterType(
+    name: 'resource_name',
+    regexp: /#{RESOURCE_NAME_SYNONYM}/,
+    transformer: -> (s) { get_resource(s) },
+    use_for_snippets: false
+)
+
+ParameterType(
+    name: 'field_name',
+    regexp: /#{FIELD_NAME_SYNONYM}/,
+    transformer: -> (s) { ResponseField.new(s) },
+    use_for_snippets: false
+)
 
-FEWER_MORE_THAN = Transform(/^(?:(?:fewer|less|more) than|at (?:least|most))$/) do |v|
-    to_compare(v)
-end
+module Boolean; end
+class TrueClass; include Boolean; end
+class FalseClass; include Boolean; end
 
-HAVE_SYNONYM = %{(?:has|have|having|contain|contains|containing|with)}
-
-CMP_LESS_THAN = '<'
-CMP_MORE_THAN = '>'
-CMP_AT_LEAST = '>='
-CMP_AT_MOST = '<='
-CMP_EQUALS = '='
-
-# take a number modifier string (fewer than, less than, etc) and return an operator '<', etc
-def to_compare(compare)
-    return case compare
-    when 'fewer than' then CMP_LESS_THAN
-    when 'less than' then CMP_LESS_THAN
-    when 'more than' then CMP_MORE_THAN
-    when 'at least' then CMP_AT_LEAST
-    when 'at most' then CMP_AT_MOST
-    else CMP_EQUALS
-    end
-end
+module Enum; end
+class String; include Enum; end
 
-# turn a comparison into a string
-def compare_to_string(compare)
-    case compare
-    when CMP_LESS_THAN then 'fewer than '
-    when CMP_MORE_THAN then 'more than '
-    when CMP_AT_LEAST then 'at least '
-    when CMP_AT_MOST then 'at most '
-    when CMP_EQUALS then ''
-    else ''
+class ResponseField
+    def initialize(names)
+        @fields = get_fields(names)
     end
-end
 
-# compare two numbers using the FEWER_MORE_THAN optional modifier
-def num_compare(type, left, right)
-    case type
-    when CMP_LESS_THAN then left < right
-    when CMP_MORE_THAN then left > right
-    when CMP_AT_MOST then left <= right
-    when CMP_AT_LEAST then left >= right
-    when CMP_EQUALS then left == right
-    else left == right
+    def to_json_path()
+        return "#{get_root_data_key()}#{@fields.join('.')}"
     end
-end
 
-def to_num(num)
-    if /^(?:zero|one|two|three|four|five|six|seven|eight|nine|ten)$/.match(num)
-        return %w(zero one two three four five six seven eight nine ten).index(num)
+    def get_value(response, type)
+        return response.get_as_type to_json_path(), parse_type(type)
     end
-    return num.to_i
-end
 
-module Boolean; end
-class TrueClass; include Boolean; end
-class FalseClass; include Boolean; end
-
-module Enum; end
-class String; include Enum; end
-
-class String
-  def to_type(type)
-    # cannot use 'case type' which checks for instances of a type rather than type equality
-    if type == Boolean then !(self =~ /true|yes/i).nil?
-    elsif type == Enum then self.upcase.tr(" ", "_")
-    elsif type == Float then self.to_f
-    elsif type == Integer then self.to_i
-    elsif type == NilClass then nil
-    else self
+    def validate_value(response, value, regex)
+        raise %/Expected #{json_path} value '#{value}' to match regex: #{regex}\n#{response.to_json_s}/ if (regex =~ value).nil?
     end
-  end
 end
 
 def parse_type(type)
+    replacements = {
+        /^numeric$/i => 'numeric',
+        /^int$/i => 'numeric',
+        /^long$/i => 'numeric',
+        /^number$/i => 'numeric',
+        /^decimal$/i => 'numeric',
+        /^double$/i => 'numeric',
+        /^bool$/i => 'boolean',
+        /^null$/i => 'nil_class',
+        /^nil$/i => 'nil_class',
+        /^string$/i => 'string',
+        /^text$/i => 'string'
+    }
+    type.tr(' ', '_')
+    replacements.each { |k,v| type.gsub!(k, v) }
+    type
+end
+
+def string_to_type(value, type)
     replacements = {
         /^numeric$/i => 'integer',
         /^int$/i => 'integer',
@@ -90,53 +74,115 @@ def parse_type(type)
         /^bool$/i => 'boolean',
         /^null$/i => 'nil_class',
         /^nil$/i => 'nil_class',
+        /^string$/i => 'string',
         /^text$/i => 'string'
     }
     type.tr(' ', '_')
     replacements.each { |k,v| type.gsub!(k, v) }
-    type
+    type = type.camelize.constantize
+    # cannot use 'case type' which checks for instances of a type rather than type equality
+    if type == Boolean then !(value =~ /true|yes/i).nil?
+    elsif type == Enum then value.upcase.tr(" ", "_")
+    elsif type == Float then value.to_f
+    elsif type == Integer then value.to_i
+    elsif type == NilClass then nil
+    else value
+    end
 end
 
 def get_resource(name)
-    resource = name.parameterize
-    resource = (ENV.has_key?('resource_single') && ENV['resource_single'] == 'true') ? resource.singularize : resource.pluralize
+    if name[0] == '`' && name[-1] == '`'
+        name = name[1..-2]
+    else
+        name = name.parameterize
+        name = (ENV.has_key?('resource_single') && ENV['resource_single'] == 'true') ? name.singularize : name.pluralize
+    end
+    return name
 end
 
 def get_root_data_key()
     return ENV.has_key?('data_key') && !ENV['data_key'].empty? ? "$.#{ENV['data_key']}." : "$."
 end
 
-def get_root_error_key()
-    return "$."
+def get_json_path(names)
+    return "#{get_root_data_key()}#{get_fields(names).join('.')}"
 end
 
-def get_json_path(names)
-    return "#{get_root_data_key()}#{get_parameters(names).join('.')}"
+def get_fields(names)
+    return names.split(':').map { |n| get_field(n.strip) }
 end
 
-def get_parameters(names)
-    names.split(':').map { |n| get_parameter(n) }
+def get_field(name)
+    if name[0] == '`' && name[-1] == '`'
+        name = name[1..-2]
+    elsif name[0] != '[' || name[-1] != ']'
+        separator = ENV.has_key?('field_separator') ? ENV['field_separator'] : '_'
+        name = name.parameterize(separator: separator)
+        name = name.camelize(:lower) if (ENV.has_key?('field_camel') && ENV['field_camel'] == 'true')
+    end
+    return name
 end
 
-def get_parameter(name)
+def get_list_field(name)
     if name[0] == '`' && name[-1] == '`'
         name = name[1..-2]
-    else
+    elsif name[0] != '[' || name[-1] != ']'
         separator = ENV.has_key?('field_separator') ? ENV['field_separator'] : '_'
         name = name.parameterize(separator: separator)
+        name = name.pluralize
         name = name.camelize(:lower) if (ENV.has_key?('field_camel') && ENV['field_camel'] == 'true')
     end
-    name
+    return name
 end
 
 def get_attributes(hashes)
     attributes = hashes.each_with_object({}) do |row, hash|
       name, value, type = row["attribute"], row["value"], row["type"]
+      value = resolve_functions(value)
       value = resolve(value)
       value.gsub!(/\\n/, "\n")
-      type = parse_type(type)
-      names = get_parameters(name)
-      new_hash = names.reverse.inject(value.to_type(type.camelize.constantize)) { |a, n| { n => a } }
-      hash.deep_merge!(new_hash)
+      names = get_fields(name)
+      new_hash = names.reverse.inject(string_to_type(value, type)) { |a, n| add_to_hash(a, n) }
+      hash.deep_merge!(new_hash) { |key, old, new| new.kind_of?(Array) ? merge_arrays(old, new) : new }
+    end
+end
+
+def resolve_functions(value)
+    value.gsub!(/\[([a-zA-Z0-9_]+)\]/) do |s|
+        s.gsub!(/[\[\]]/, '')
+        case s.downcase
+        when "datetime"
+            Time.now.strftime("%Y%m%d%H%M%S")
+        else
+            raise 'Unrecognised function ' + s + '?'
+        end
+    end
+    value
+end
+
+def add_to_hash(a, n)
+    result = nil
+    if (n[0] == '[' && n[-1] == ']') then
+        array = Array.new(n[1..-2].to_i() + 1)
+        array[n[1..-2].to_i()] = a
+        result = array
+    end
+    result != nil ? result : { n => a };
+end
+
+def merge_arrays(a, b)
+    new_length = [a.length, b.length].max
+    new_array = Array.new(new_length)
+    new_length.times do |n|
+        if b[n].nil? then
+            new_array[n] = a[n]
+        else
+            if a[n].nil? then
+                new_array[n] = b[n]
+            else
+                new_array[n] = a[n].merge(b[n])
+            end
+        end
     end
+    return new_array
 end