hydra_attribute 0.2.0 → 0.3.0.beta1

data/features/query_methods/where.feature

@@ -1,29 +1,28 @@
 Feature: hydra attribute where conditions
   When filter by hydra attribute and this value is not nil
-  Then the correct hydra attribute table should be joined and filter by this value should be added
+  Then records with this attribute should be selected
 
   When filter by hydra attribute and this value is nil
-  Then records with nil value should be selected  or records which don't have this hydra attribute
+  Then records with nil and blank value should be selected
 
-  Background: create models and describe hydra attributes
-    Given create model class "Product"
-    And create model class "SimpleProduct" as "Product" with hydra attributes:
-      | type    | name    |
-      | string  | code    |
-      | string  | summary |
-      | string  | title   |
-      | float   | price   |
-      | boolean | active  |
-      | integer | state   |
+  Background: create hydra attributes
+    Given create "HydraAttribute::HydraAttribute" models with attributes as "hashes":
+      | entity_type | name    | backend_type |
+      | Product     | code    | string       |
+      | Product     | summary | string       |
+      | Product     | title   | string       |
+      | Product     | price   | float        |
+      | Product     | active  | boolean      |
+      | Product     | state   | integer      |
 
-  Scenario: add filter by one hydra attribute
-    Given create models:
-      | model         | attributes                         |
-      | SimpleProduct | code=[string:1] price=[float:2.75] |
-      | SimpleProduct | code=[string:2] price=[float:2.75] |
-      | SimpleProduct | code=[string:3] price=[float:2.76] |
-      | SimpleProduct | code=[string:4] price=[nil:]       |
-    When filter "SimpleProduct" by:
+  Scenario: filter by one hydra attribute
+    Given create "Product" model with attributes as "hashes":
+      | code       | price        |
+      | [string:1] | [float:2.75] |
+      | [string:2] | [float:2.75] |
+      | [string:3] | [float:2.76] |
+      | [string:4] | [nil:]       |
+    When filter "Product" by:
       | field | value         |
       | price | [string:2.75] |
     Then total records should be "2"
@@ -32,13 +31,13 @@ Feature: hydra attribute where conditions
       | code  | [string:1] |
       | code  | [string:2] |
 
-  Scenario: add nil filter by one hydra attribute
-    Given create models:
-      | model         | attributes                      |
-      | SimpleProduct | code=[string:1] price=[nil:]    |
-      | SimpleProduct | code=[string:2] price=[float:0] |
-      | SimpleProduct | code=[string:3]                 |
-    When filter "SimpleProduct" by:
+  Scenario: filter by one hydra attribute with nil value
+    Given create "Product" model with attributes as "hashes":
+      | code       | price     |
+      | [string:1] | [nil:]    |
+      | [string:2] | [float:0] |
+      | [string:3] |           |
+    When filter "Product" by:
       | field | value  |
       | price | [nil:] |
     Then total records should be "2"
@@ -47,23 +46,22 @@ Feature: hydra attribute where conditions
       | code  | [string:1] |
       | code  | [string:3] |
 
-  Scenario: add filter by several fields including both the hydra and general attributes
-    Given create models:
-      | model         | attributes                                                                                                                                   |
-      | SimpleProduct | name=[string:toy] code=[string:1] title=[string:story] price=[float:2.45] active=[boolean:true]               info=[string:]                 |
-      | SimpleProduct | name=[string:toy] code=[string:2] title=[string:story] price=[float:2.45] active=[boolean:true]               info=[string:a] summary=[nil:] |
-      | SimpleProduct | name=[string:toy] code=[string:3] title=[string:story] price=[float:2.45] active=[boolean:true]  state=[nil:] info=[string:a] summary=[nil:] |
-      | SimpleProduct | name=[string:toy] code=[string:4]                      price=[float:2.45] active=[boolean:false] state=[nil:] info=[string:a] summary=[nil:] |
-      | SimpleProduct |                   code=[string:5]                      price=[float:2.45] active=[boolean:true]  state=[nil:] info=[string:a] summary=[nil:] |
-      | SimpleProduct | name=[string:toy] code=[string:6]                      price=[float:2.46] active=[boolean:true]  state=[nil:] info=[string:a] summary=[nil:] |
-    When filter "SimpleProduct" by:
+  Scenario: filter by several fields including both the hydra and general attributes
+    Given create "Product" model with attributes as "hashes":
+      | name         | code       | title          | price        | active          | state  | summary |
+      | [string:toy] | [string:1] | [string:story] | [float:2.40] | [boolean:true]  |        |         |
+      | [string:toy] | [string:2] | [string:story] | [float:2.45] | [boolean:true]  |        | [nil:]  |
+      | [string:toy] | [string:3] | [string:story] | [float:2.45] | [boolean:true]  | [nil:] | [nil:]  |
+      | [string:toy] | [string:4] |                | [float:2.45] | [boolean:false] | [nil:] | [nil:]  |
+      |              | [string:5] |                | [float:2.45] | [boolean:true]  | [nil:] | [nil:]  |
+      | [string:toy] | [string:6] |                | [float:2.46] | [boolean:true]  | [nil:] | [nil:]  |
+    When filter "Product" by:
       | field   | value          |
       | name    | [string:toy]   |
       | title   | [string:story] |
       | summary | [nil:]         |
       | price   | [string:2.45]  |
       | active  | [boolean:true] |
-      | info    | [string:a]     |
       | state   | [nil:]         |
     Then total records should be "2"
     And records should have the following attributes:

data/features/step_definitions/model_steps.rb

@@ -1,31 +1,35 @@
-Given /^create models:$/ do |table|
-  table.hashes.each do |hash|
-    attributes = typecast_attributes(hash[:attributes])
-    Object.const_get(hash[:model]).create!(attributes)
+Given /^create "([^"]+)" model$/ do |klass|
+  klass.constantize.create!
+end
+
+Given /^(load and )?(save|create|update(?: all| attributes)?|destroy(?: all)?|delete(?: all)?)(?: for)? "([^"]+)" models? with attributes as "([^"]+)":$/ do |load, action, klass, format, table|
+  action = action.gsub(' ', '_')
+  klass  = klass.constantize
+  models = load.present? ? klass.all : [klass]
+
+  Array.wrap(table.send(format)).each do |hash|
+    models.each do |model|
+      model.send(action, type_cast_hash(hash))
+    end
   end
 end
 
-Given /^create model "([^"]+)" with attributes "([^"]+)"$/ do |klass, attributes|
-  attrs  = typecast_attributes(attributes)
-  @model = Object.const_get(klass).create!(attrs)
+Given /^create "([^"]+)" association for "([^"]+)" with attributes as "([^"]+)":$/ do |association, klass, format, table|
+  Array.wrap(table.send(format)).each do |hash|
+    klass.constantize.send(association).create(hash)
+  end
 end
 
-Then /^model "([^"]+)" should "(should|should_not)" to "([^"]+)"$/ do |klass, method, attributes|
-  model = Object.const_get(klass).new
+Then /^model "([^"]+)" (should(?:\snot)?) respond to "([^"]+)"$/ do |klass, method, attributes|
+  model  = klass.constantize.new
+  method = method.gsub(/\s+/, '_')
   attributes.split.each do |attribute|
     model.send(method, respond_to(attribute))
   end
 end
 
-Then /^it should have typecast attributes "([^"]+)"$/ do |attributes|
-  @model.reload # ensure that all attributes have correct type
-  typecast_attributes(attributes).each do |name, value|
-    @model.send(name).should == value
+Then /^(last|first) created "([^"]+)" (should|should not) have the following attributes:$/ do |method, klass, match, table|
+  table.rows_hash.each_with_object(klass.constantize.send(method)) do |(attribute, value), model|
+    model.send(attribute).send(match) == type_cast_value(value)
   end
-end
-
-Then /^model "([^"]+)" should have only the following ((?:hydra )?attributes(?: before type cast)?) "([^"]+)"$/ do |klass, method, attributes|
-  model  = Object.const_get(klass).new
-  method = method.gsub(/\s+/, '_')
-  model.send(method).keys.should =~ attributes.split(/\s+/)
 end

data/features/step_definitions/query_methods.rb

@@ -1,5 +1,5 @@
 When /^filter "([^"]+)" by:$/ do |klass, table|
-  condition = table.hashes.each_with_object({}) { |item, hash| hash[item[:field].to_sym] = typecast_value(item[:value]) }
+  condition = table.hashes.each_with_object({}) { |item, hash| hash[item[:field].to_sym] = type_cast_value(item[:value]) }
   @records  = Object.const_get(klass).where(condition)
 end
 
@@ -9,7 +9,7 @@ When /^filter "([^"]+)" records by "([^"]+)"$/ do |klass, attribute|
 end
 
 When /^filter records by "([^"]+)"$/ do |attribute|
-  name, value = typecast_attribute(attribute)
+  name, value = type_cast_attribute(attribute)
   @records = @records.where(name => value)
 end
 
@@ -39,6 +39,10 @@ When /^(order|reorder) records by "([^"]+)"$/ do |sort_method, attributes|
   @records = @records.reverse_order if reverse
 end
 
+When /^reverse order records$/ do
+  @records = @records.reverse_order
+end
+
 When /^"([^"]+)" select only the following columns "([^"]+)"$/ do |klass, columns|
   @records = Object.const_get(klass).select(columns.split(/\s+/).map(&:to_sym))
 end

data/features/step_definitions/record_steps.rb

@@ -2,38 +2,51 @@ When /^load all "([^"]+)" records$/ do |klass|
   @records = Object.const_get(klass).all
 end
 
-When /^select "(first|last)" "([^"]+)" record$/ do |method, klass|
+When /^select (first|last) "([^"]+)" record$/ do |method, klass|
   @record = Object.const_get(klass).send(method)
 end
 
-Then /^record should have the following ((?:hydra )?attributes(?: before type cast)?) "([^"]+)" in attribute hash$/ do |method, attributes|
-  method = method.gsub(/\s+/, '_')
-  typecast_attributes(attributes).each do |(name, value)|
-    @record.send(method)[name.to_s].should == value
+When /^assign attributes as "([^"]+)":$/ do |format, table|
+  Array.wrap(table.send(format)).each do |hash|
+    @record.assign_attributes(type_cast_hash(hash))
   end
 end
 
+When /^(save|destroy) record$/ do |action|
+  @record.send(action)
+end
+
+When /^keep "([^"]+)" attribute$/ do |attribute|
+  @keep ||= {}
+  @keep[attribute] = @record.send(attribute)
+end
+
+Then /^attribute "([^"]+)" (should(?:\snot)?) be the same$/ do |attribute, behavior|
+  method = behavior.sub(/\s/, '_')
+  @keep[attribute].send(method) == @record.send(attribute)
+end
+
 Then /^record (read attribute(?: before type cast)?) "([^"]+)" and value should be "([^"]+)"$/ do |method, attribute, value|
   method = method.gsub(/\s+/, '_')
-  @record.send(method, attribute).should == typecast_value(value)
+  @record.send(method, attribute).should == type_cast_value(value)
 end
 
 Then /^"(first|last)" record should have "([^"]+)"$/ do |method, attribute|
-  typecast_attributes(attribute).each do |(name, value)|
+  type_cast_attributes(attribute).each do |(name, value)|
     @records.send(method).send(name).should == value
   end
 end
 
 Then /^records should have the following attributes:$/ do |table|
   table.hashes.each do |hash|
-    record = @records.detect { |r| r.send(hash[:field]) == typecast_value(hash[:value]) }
+    record = @records.detect { |r| r.send(hash[:field]) == type_cast_value(hash[:value]) }
     record.should_not be_nil
   end
 end
 
 Then /^records should have only the following "([^"]+)" names$/ do |attributes|
   @records.each do |record|
-    record.attributes.keys.should == attributes.split(/\s+/)
+    record.attributes.keys.should =~ attributes.split(/\s+/)
   end
 end
 
@@ -47,7 +60,12 @@ Then /^records should raise "([^"]+)" when call the following "([^"]+)"$/ do |er
 end
 
 Then /^total records should be "([^"]+)"$/ do |count|
-  @records.to_a.should have(count.to_i).items
+  @records.to_a.should have(count.to_i).records
+end
+
+Then /^total "([^"]+)" records should be "([^"]+)"$/ do |klass, count|
+  @records = klass.constantize.scoped
+  step %Q(total records should be "#{count}")
 end
 
 Then /^records "(should|should_not)" have loaded associations:$/ do |should, table|

data/features/support/env.rb

@@ -11,15 +11,21 @@ ActiveRecord::Base.extend(HydraAttribute::ActiveRecord)
 DatabaseCleaner.strategy = :truncation
 
 Before do
-  HydraAttribute::SUPPORT_TYPES.each do |type|
-    const = HydraAttribute.config.associated_const_name(type)
-    HydraAttribute.send(:remove_const, const) if HydraAttribute.const_defined?(const)
-  end
-  [:Product, :SimpleProduct, :GroupProduct].each do |const|
-    Object.send(:remove_const, const) if Object.const_defined?(const)
+  if Object.const_defined?(:Product)
+    HydraAttribute::SUPPORT_TYPES.each do |type|
+      assoc_model = HydraAttribute::AssociationBuilder.new(Product, type).model_name
+      HydraAttribute.send(:remove_const, assoc_model)
+    end
+
+    Object.send(:remove_const, :Product)
   end
+
   ActiveSupport::Dependencies::Reference.clear!
   DatabaseCleaner.start
+
+  class Product < ActiveRecord::Base
+    use_hydra_attributes
+  end
 end
 
 After do

data/features/support/schema.rb

@@ -1,51 +1,78 @@
 ActiveRecord::Schema.define do
   create_table "products", :force => true do |t|
-    t.string   "type"
-    t.string   "name"
-    t.string   "info"
-    t.datetime "created_at", :null => false
-    t.datetime "updated_at", :null => false
+    t.string  "name"
+    t.datetime "created_at",                :null => false
+    t.datetime "updated_at",                :null => false
   end
 
-  create_table "hydra_string_attributes", :force => true do |t|
-    t.integer "entity_id"
-    t.string  "entity_type"
-    t.string  "name"
-    t.string  "value"
+  create_table "hydra_attributes", :force => true do |t|
+    t.string   "entity_type",   :limit => 32, :null => false
+    t.string   "name",          :limit => 32, :null => false
+    t.string   "backend_type",  :limit => 16, :null => false
+    t.string   "default_value"
+    t.datetime "created_at",                  :null => false
+    t.datetime "updated_at",                  :null => false
   end
 
-  create_table "hydra_float_attributes", :force => true do |t|
-    t.integer "entity_id"
-    t.string  "entity_type"
-    t.string  "name"
-    t.float   "value"
+  add_index "hydra_attributes", ["entity_type", "name"], :name => "hydra_attributes_index", :unique => true
+
+  create_table "hydra_boolean_products", :force => true do |t|
+    t.integer  "entity_id",          :null => false
+    t.integer  "hydra_attribute_id", :null => false
+    t.boolean  "value"
+    t.datetime "created_at",         :null => false
+    t.datetime "updated_at",         :null => false
   end
 
-  create_table "hydra_boolean_attributes", :force => true do |t|
-    t.integer "entity_id"
-    t.string  "entity_type"
-    t.string  "name"
-    t.boolean "value"
+  add_index "hydra_boolean_products", ["entity_id", "hydra_attribute_id"], :name => "hydra_boolean_products_index", :unique => true
+
+  create_table "hydra_datetime_products", :force => true do |t|
+    t.integer  "entity_id",          :null => false
+    t.integer  "hydra_attribute_id", :null => false
+    t.datetime "value"
+    t.datetime "created_at",         :null => false
+    t.datetime "updated_at",         :null => false
   end
 
-  create_table "hydra_integer_attributes", :force => true do |t|
-    t.integer "entity_id"
-    t.string  "entity_type"
-    t.string  "name"
-    t.integer "value"
+  add_index "hydra_datetime_products", ["entity_id", "hydra_attribute_id"], :name => "hydra_datetime_products_index", :unique => true
+
+  create_table "hydra_float_products", :force => true do |t|
+    t.integer  "entity_id",          :null => false
+    t.integer  "hydra_attribute_id", :null => false
+    t.float    "value"
+    t.datetime "created_at",         :null => false
+    t.datetime "updated_at",         :null => false
   end
 
-  create_table "hydra_text_attributes", :force => true do |t|
-    t.integer "entity_id"
-    t.string  "entity_type"
-    t.string  "name"
-    t.text    "value"
+  add_index "hydra_float_products", ["entity_id", "hydra_attribute_id"], :name => "hydra_float_products_index", :unique => true
+
+  create_table "hydra_integer_products", :force => true do |t|
+    t.integer  "entity_id",          :null => false
+    t.integer  "hydra_attribute_id", :null => false
+    t.integer  "value"
+    t.datetime "created_at",         :null => false
+    t.datetime "updated_at",         :null => false
   end
 
-  create_table "hydra_datetime_attributes", :force => true do |t|
-    t.integer  "entity_id"
-    t.string   "entity_type"
-    t.string   "name"
-    t.datetime "value"
+  add_index "hydra_integer_products", ["entity_id", "hydra_attribute_id"], :name => "hydra_integer_products_index", :unique => true
+
+  create_table "hydra_string_products", :force => true do |t|
+    t.integer  "entity_id",          :null => false
+    t.integer  "hydra_attribute_id", :null => false
+    t.string   "value"
+    t.datetime "created_at",         :null => false
+    t.datetime "updated_at",         :null => false
   end
+
+  add_index "hydra_string_products", ["entity_id", "hydra_attribute_id"], :name => "hydra_string_products_index", :unique => true
+
+  create_table "hydra_text_products", :force => true do |t|
+    t.integer  "entity_id",          :null => false
+    t.integer  "hydra_attribute_id", :null => false
+    t.text     "value"
+    t.datetime "created_at",         :null => false
+    t.datetime "updated_at",         :null => false
+  end
+
+  add_index "hydra_text_products", ["entity_id", "hydra_attribute_id"], :name => "hydra_text_products_index", :unique => true
 end

data/features/support/world.rb

@@ -1,8 +1,11 @@
 module HydraAttribute
   module Cucumber
     module World
-      def typecast_value(schema)
+      def type_cast_value(schema)
+        return schema unless schema.is_a?(String)
         type, value = schema.gsub(/\[|\]/, '').split(':', 2)
+        return schema if schema == type && value.nil?
+
         case type
         when 'integer'  then value.to_i
         when 'float'    then value.to_f
@@ -13,17 +16,23 @@ module HydraAttribute
         end
       end
 
-      def typecast_attribute(attribute)
+      def type_cast_attribute(attribute)
         name, schema = attribute.split('=')
-        [name.to_sym, typecast_value(schema)]
+        [name, type_cast_value(schema)]
       end
 
-      def typecast_attributes(attributes)
+      def type_cast_attributes(attributes)
         attributes.split(/(?<=\])\s+/).flatten.each_with_object({}) do |attribute, hash|
-          name, value = typecast_attribute(attribute)
+          name, value = type_cast_attribute(attribute)
           hash[name]  = value
         end
       end
+
+      def type_cast_hash(hash)
+        hash.delete_if{ |_, v| v.blank? }.each do |key, value|
+          hash[key] = type_cast_value(value)
+        end
+      end
     end
   end
 end

data/features/update.feature

@@ -0,0 +1,114 @@
+Feature: update hydra attributes
+  When update attribute
+  Then entity should be touched
+
+  Background: create hydra attributes
+    Given create "HydraAttribute::HydraAttribute" models with attributes as "hashes":
+      | entity_type | name  | backend_type | default_value |
+      | Product     | code  | string       | [string:###]  |
+      | Product     | title | string       |               |
+      | Product     | total | integer      | [integer:1]   |
+    And create "Product" model
+
+  Scenario Outline: update attributes
+    Given select last "Product" record
+    When  assign attributes as "rows_hash":
+      | code  | <set code>  |
+      | title | <set title> |
+      | total | <set total> |
+    And save record
+    Then last created "Product" should have the following attributes:
+      | code  | <code>  |
+      | title | <title> |
+      | total | <total> |
+
+    Scenarios: attributes
+      | set code   | set title  | set total   | code         | title      | total       |
+      | [string:a] | [string:b] | [integer:2] | [string:a]   | [string:b] | [integer:2] |
+      | [string:]  | [string:]  | [nil:]      | [string:]    | [string:]  | [nil:]      |
+      |            |            | [string:3]  | [string:###] | [nil:]     | [integer:3] |
+
+  # Is a better solution to call several scenarios but don't call hooks and backgrounds before?
+  Scenario: update the same model several times
+    Given select first "Product" record
+    And save record
+    Then last created "Product" should have the following attributes:
+      | code  | [string:###] |
+      | title | [nil:]       |
+      | total | [integer:1]  |
+
+    When assign attributes as "rows_hash":
+      | title | [string:] |
+      | total | [nil:]    |
+    And save record
+    Then last created "Product" should have the following attributes:
+      | code  | [string:###] |
+      | title | [string:]    |
+      | total | [nil:]       |
+
+    When assign attributes as "rows_hash":
+      | code  | [string:a] |
+      | total | [string:2] |
+    And save record
+    Then last created "Product" should have the following attributes:
+      | code  | [string:a]  |
+      | title | [string:]   |
+      | total | [integer:2] |
+
+    When assign attributes as "rows_hash":
+      | title | [string:b] |
+    And save record
+    Then last created "Product" should have the following attributes:
+      | code  | [string:a]  |
+      | title | [string:b]  |
+      | total | [integer:2] |
+
+  Scenario: touch entity when attribute is updated
+    Given select last "Product" record
+    And keep "updated_at" attribute
+    And save record
+    Then attribute "updated_at" should be the same
+
+    Given select last "Product" record
+    And keep "updated_at" attribute
+    When assign attributes as "rows_hash":
+      | code  | [string:###] |
+      | total | [integer:1]  |
+    And save record
+    Then attribute "updated_at" should be the same
+
+    Given select last "Product" record
+    And keep "updated_at" attribute
+    When assign attributes as "rows_hash":
+      | code | [nil:] |
+    And save record
+    Then attribute "updated_at" should not be the same
+
+    Given select last "Product" record
+    And keep "updated_at" attribute
+    When assign attributes as "rows_hash":
+      | code | [nil:] |
+    And save record
+    Then attribute "updated_at" should be the same
+
+    Given select last "Product" record
+    And keep "updated_at" attribute
+    When assign attributes as "rows_hash":
+      | total | [nil:] |
+    And save record
+    Then attribute "updated_at" should not be the same
+
+    Given select last "Product" record
+    And keep "updated_at" attribute
+    When assign attributes as "rows_hash":
+      | code | [string:] |
+    And save record
+    Then attribute "updated_at" should not be the same
+
+    Given select last "Product" record
+    And keep "updated_at" attribute
+    When assign attributes as "rows_hash":
+      | title | [string:]   |
+      | total | [integer:0] |
+    And save record
+    Then attribute "updated_at" should not be the same

data/gemfiles/3.1.gemfile.lock

@@ -1,36 +1,36 @@
 PATH
   remote: /Users/kostyantyn/Sites/github/gems/hydra_attribute
   specs:
-    hydra_attribute (0.2.0.beta1)
+    hydra_attribute (0.3.0.beta2)
       activerecord (>= 3.1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.1.5)
-      activesupport (= 3.1.5)
+    activemodel (3.1.6)
+      activesupport (= 3.1.6)
       builder (~> 3.0.0)
       i18n (~> 0.6)
-    activerecord (3.1.5)
-      activemodel (= 3.1.5)
-      activesupport (= 3.1.5)
+    activerecord (3.1.6)
+      activemodel (= 3.1.6)
+      activesupport (= 3.1.6)
       arel (~> 2.2.3)
       tzinfo (~> 0.3.29)
-    activesupport (3.1.5)
+    activesupport (3.1.6)
       multi_json (>= 1.0, < 1.3)
     appraisal (0.4.1)
       bundler
       rake
     arel (2.2.3)
     builder (3.0.0)
-    cucumber (1.2.0)
+    cucumber (1.2.1)
       builder (>= 2.1.2)
       diff-lcs (>= 1.1.3)
-      gherkin (~> 2.10.0)
+      gherkin (~> 2.11.0)
       json (>= 1.4.6)
     database_cleaner (0.8.0)
     diff-lcs (1.1.3)
-    gherkin (2.10.0)
+    gherkin (2.11.1)
       json (>= 1.4.6)
     i18n (0.6.0)
     json (1.7.3)

data/gemfiles/3.2.gemfile.lock

@@ -1,21 +1,21 @@
 PATH
   remote: /Users/kostyantyn/Sites/github/gems/hydra_attribute
   specs:
-    hydra_attribute (0.2.0.beta1)
+    hydra_attribute (0.3.0.beta2)
       activerecord (>= 3.1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.2.5)
-      activesupport (= 3.2.5)
+    activemodel (3.2.6)
+      activesupport (= 3.2.6)
       builder (~> 3.0.0)
-    activerecord (3.2.5)
-      activemodel (= 3.2.5)
-      activesupport (= 3.2.5)
+    activerecord (3.2.6)
+      activemodel (= 3.2.6)
+      activesupport (= 3.2.6)
       arel (~> 3.0.2)
       tzinfo (~> 0.3.29)
-    activesupport (3.2.5)
+    activesupport (3.2.6)
       i18n (~> 0.6)
       multi_json (~> 1.0)
     appraisal (0.4.1)
@@ -23,14 +23,14 @@ GEM
       rake
     arel (3.0.2)
     builder (3.0.0)
-    cucumber (1.2.0)
+    cucumber (1.2.1)
       builder (>= 2.1.2)
       diff-lcs (>= 1.1.3)
-      gherkin (~> 2.10.0)
+      gherkin (~> 2.11.0)
       json (>= 1.4.6)
     database_cleaner (0.8.0)
     diff-lcs (1.1.3)
-    gherkin (2.10.0)
+    gherkin (2.11.1)
       json (>= 1.4.6)
     i18n (0.6.0)
     json (1.7.3)