ashmont 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 74db341df8df089b92b9f99d600e7de04cc262ad
-  data.tar.gz: 38babe59083f00ce8987f4fa93d5dac2b919cf01
+  metadata.gz: 4cbc767616cdfb36fa0361192652eb7260cf7819
+  data.tar.gz: dfcfe21d97c3bc0141650d489b2f9e15353fb042
 SHA512:
-  metadata.gz: 42eb167922b1dc1fa663da7ac3b01d5ddc38e3aa6bd19d69c45f497f51323b2b6e3de158c7d9e910769976ccd887141dd76575936340262e108c81c7ced8be4e
-  data.tar.gz: 6fda5ace2fed98cb908476b265239603e91556d7aca60375caddfc16c00bcb714b7920c4c06fb73478b0f8407dbc99b5840e9ce828c6daa6c5feb985ff49745b
+  metadata.gz: 2bacaf4575b5a27b377a7fbf64b8b2bbfc14f3681f57c0ebece26f82f81c0036d7186e22ace36328fd4b7ad118f45a0ca87774540a938d86bdcc9bf618d90ce2
+  data.tar.gz: fc714edba413131497708bdb572d60ce885993b00fb5fdc9fcee26b776801395e22b4920ca39c14eb2399eb98448a89c7260b6f379d42cc548580291970aa748

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+##v0.0.15
+* bumped release version
+
+##v0.0.14a
+* modernized tests
+
 ##v0.0.13
 * added to Travis CI for testing
 

data/ashmont.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency('braintree', '>= 2.74.0')
-  s.add_dependency('activesupport', '>= 3.0.0')
-  s.add_dependency('i18n', '>= 0.6')
-  s.add_dependency('tzinfo', '>= 0.3')
+  s.add_dependency('activesupport', '~> 5.0', '>= 5.0.2')
+  s.add_dependency('i18n', '~> 0.8.1')
+  s.add_dependency('tzinfo', '~> 1.2', '>= 1.2.3')
   s.add_development_dependency('bourne')
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec')

data/lib/ashmont/subscription.rb

@@ -1,5 +1,6 @@
 require "ashmont/errors"
-require "active_support/core_ext"
+require 'active_support'
+require 'active_support/core_ext'
 require "braintree"
 
 module Ashmont

data/lib/ashmont/version.rb

@@ -1,3 +1,3 @@
 module Ashmont
-  VERSION = "0.0.14"
+  VERSION = "0.0.15"
 end

data/spec/ashmont/customer_spec.rb

@@ -9,12 +9,12 @@ describe Ashmont::Customer do
 
     result = Ashmont::Customer.new(token).credit_card
 
-    Braintree::Customer.should have_received(:find).with(token)
-    result.should == "first"
+    expect(Braintree::Customer).to have_received(:find).with(token)
+    expect(result).to eq("first")
   end
 
   it "returns nothing without a remote customer" do
-    Ashmont::Customer.new.credit_card.should be_nil
+    expect(Ashmont::Customer.new.credit_card).to be_nil
   end
 
   it "returns all credit cards" do
@@ -24,12 +24,12 @@ describe Ashmont::Customer do
 
     result = Ashmont::Customer.new(token).credit_cards
 
-    Braintree::Customer.should have_received(:find).with(token)
-    result.should == ["first", "second"]
+    expect(Braintree::Customer).to have_received(:find).with(token)
+    expect(result).to eq(["first", "second"])
   end
 
   it "returns an empty array without a remote customer" do
-    Ashmont::Customer.new.credit_cards.should == []
+    expect(Ashmont::Customer.new.credit_cards).to eq([])
   end
 
 
@@ -37,11 +37,11 @@ describe Ashmont::Customer do
     remote_customer = stub("customer", :email => "admin@example.com")
     Braintree::Customer.stubs(:find => remote_customer)
 
-    Ashmont::Customer.new("abc").billing_email.should == "admin@example.com"
+    expect(Ashmont::Customer.new("abc").billing_email).to eq("admin@example.com")
   end
 
   it "doesn't have an email without a remote customer" do
-    Ashmont::Customer.new.billing_email.should be_nil
+    expect(Ashmont::Customer.new.billing_email).to be_nil
   end
 
   it "creates a valid remote customer" do
@@ -52,11 +52,11 @@ describe Ashmont::Customer do
     Braintree::Customer.stubs(:create => create_result)
 
     customer = Ashmont::Customer.new
-    customer.save(attributes).should be_true
+    expect(customer.save(attributes)).to be true
 
-    Braintree::Customer.should have_received(:create).with(:email => "ben@example.com", :credit_card => {})
-    customer.token.should == token
-    customer.errors.should be_empty
+    expect(Braintree::Customer).to have_received(:create).with(:email => "ben@example.com", :credit_card => {})
+    expect(customer.token).to eq(token)
+    expect(customer.errors).to be_empty
   end
 
   it "creates a remote customer with a credit card" do
@@ -82,7 +82,7 @@ describe Ashmont::Customer do
       :country_name => "United States of America"
     )
 
-    Braintree::Customer.should have_received(:create).with(
+    expect(Braintree::Customer).to have_received(:create).with(
       :email => "jrobot@example.com",
       :credit_card => {
         :cardholder_name => "Jim Robot",
@@ -114,10 +114,10 @@ describe Ashmont::Customer do
     Ashmont::Errors.stubs(:new => errors)
 
     customer = Ashmont::Customer.new
-    customer.save("email" => "ben.franklin@example.com").should be_false
+    expect(customer.save("email" => "ben.franklin@example.com")).to be false
 
-    Ashmont::Errors.should have_received(:new).with(verification, error_messages)
-    customer.errors.should == errors
+    expect(Ashmont::Errors).to have_received(:new).with(verification, error_messages)
+    expect(customer.errors).to eq(errors)
   end
 
   it "updates a remote customer with valid changes" do
@@ -128,10 +128,10 @@ describe Ashmont::Customer do
     Braintree::Customer.stubs(:update => update_result)
 
     customer = Ashmont::Customer.new(token)
-    customer.save(updates).should be_true
+    expect(customer.save(updates)).to be true
 
-    Braintree::Customer.should have_received(:update).with(token, :email => "somebody@example.com", :credit_card => {})
-    customer.billing_email.should == "somebody@example.com"
+    expect(Braintree::Customer).to have_received(:update).with(token, :email => "somebody@example.com", :credit_card => {})
+    expect(customer.billing_email).to eq("somebody@example.com")
   end
 
   it "updates a remote customer with a credit card" do
@@ -159,7 +159,7 @@ describe Ashmont::Customer do
       :country_name => "United States of America"
     )
 
-    Braintree::Customer.should have_received(:update).with(
+    expect(Braintree::Customer).to have_received(:update).with(
       token,
       :email => "jrobot@example.com",
       :credit_card => {
@@ -195,10 +195,10 @@ describe Ashmont::Customer do
     Ashmont::Errors.stubs(:new => errors)
 
     customer = Ashmont::Customer.new("xyz")
-    customer.save("email" => "ben.franklin@example.com").should be_false
+    expect(customer.save("email" => "ben.franklin@example.com")).to be false
 
-    Ashmont::Errors.should have_received(:new).with(verification, error_messages)
-    customer.errors.should == errors
+    expect(Ashmont::Errors).to have_received(:new).with(verification, error_messages)
+    expect(customer.errors).to eq(errors)
   end
 
   it "delete a remote customer" do
@@ -208,7 +208,7 @@ describe Ashmont::Customer do
     customer = Ashmont::Customer.new(token)
     customer.delete
 
-    Braintree::Customer.should have_received(:delete).with(token)
+    expect(Braintree::Customer).to have_received(:delete).with(token)
   end
 
   it "has billing info with a credit card" do
@@ -218,8 +218,8 @@ describe Ashmont::Customer do
     Braintree::Customer.stubs(:find => remote_customer)
 
     customer = Ashmont::Customer.new("xyz")
-    customer.should have_billing_info
-    customer.payment_method_token.should == token
+    expect(customer).to have_billing_info
+    expect(customer.payment_method_token).to  eq(token)
   end
 
   it "doesn't have billing info without a credit card" do
@@ -227,8 +227,8 @@ describe Ashmont::Customer do
     Braintree::Customer.stubs(:find => remote_customer)
 
     customer = Ashmont::Customer.new("xyz")
-    customer.should_not have_billing_info
-    customer.payment_method_token.should be_nil
+    expect(customer).to_not have_billing_info
+    expect(customer.payment_method_token).to be_nil
   end
 
   %w(last_4 cardholder_name expiration_month expiration_year).each do |credit_card_attribute|
@@ -237,7 +237,7 @@ describe Ashmont::Customer do
       remote_customer = stub("customer", :credit_cards => [credit_card])
       Braintree::Customer.stubs(:find => remote_customer)
 
-      Ashmont::Customer.new("xyz").send(credit_card_attribute).should == "expected"
+      expect(Ashmont::Customer.new("xyz").send(credit_card_attribute)).to eq("expected")
     end
   end
 
@@ -248,7 +248,7 @@ describe Ashmont::Customer do
       remote_customer = stub("customer", :credit_cards => [credit_card])
       Braintree::Customer.stubs(:find => remote_customer)
 
-      Ashmont::Customer.new("xyz").send(billing_address_attribute).should == "expected"
+      expect(Ashmont::Customer.new("xyz").send(billing_address_attribute)).to eq("expected")
     end
   end
 
@@ -260,10 +260,10 @@ describe Ashmont::Customer do
     Braintree::TransparentRedirect.stubs(:confirm => confirm_result)
 
     customer = Ashmont::Customer.new
-    customer.confirm(query_string).should be_true
+    expect(customer.confirm(query_string)).to be true
 
-    Braintree::TransparentRedirect.should have_received(:confirm).with(query_string)
-    customer.token.should == token
+    expect(Braintree::TransparentRedirect).to have_received(:confirm).with(query_string)
+    expect(customer.token).to eq(token)
   end
 
   it "adds errors for an invalid transparent redirect query string" do
@@ -278,9 +278,9 @@ describe Ashmont::Customer do
     Ashmont::Errors.stubs(:new => errors)
 
     customer = Ashmont::Customer.new
-    customer.confirm("abc").should be_false
+    expect(customer.confirm("abc")).to be false
 
-    Ashmont::Errors.should have_received(:new).with(verification, error_messages)
-    customer.errors.should == errors
+    expect(Ashmont::Errors).to have_received(:new).with(verification, error_messages)
+    expect(customer.errors).to eq(errors)
   end
 end

data/spec/ashmont/errors_spec.rb

@@ -2,38 +2,38 @@ require 'spec_helper'
 
 describe Ashmont::Errors do
   it "adds an error for a declined number" do
-    errors_for(:status => "processor_declined", :processor_response_text => "failure").
-      should include("number was denied by the payment processor with the message: failure")
+    expect(errors_for(:status => "processor_declined", :processor_response_text => "failure")).
+      to include("number was denied by the payment processor with the message: failure")
   end
 
   it "adds an error for a mismatched cvv" do
-    errors_for(:status => "gateway_rejected").should include("cvv did not match")
+    expect(errors_for(:status => "gateway_rejected")).to include("cvv did not match")
   end
 
   it "adds a generic card number error" do
-    errors_for(:messages => { :number => "Credit card number is unsupported" }).
-      should include("number is unsupported")
+    expect(errors_for(:messages => { :number => "Credit card number is unsupported" })).
+      to include("number is unsupported")
   end
 
   it "adds a generic cvv error" do
-    errors_for(:messages => { :CVV => "CVV is unsupported" }).
-      should include("cvv is unsupported")
+    expect(errors_for(:messages => { :CVV => "CVV is unsupported" })).
+      to include("cvv is unsupported")
   end
 
   it "adds a generic expiration_month error" do
-    errors_for(:messages => { :expiration_month => "Expiration month is unsupported" }).
-      should include("expiration_month is unsupported")
+    expect(errors_for(:messages => { :expiration_month => "Expiration month is unsupported" })).
+      to include("expiration_month is unsupported")
   end
 
   it "adds a generic expiration_year error" do
-    errors_for(:messages => { :expiration_year => "Expiration year is unsupported" }).
-      should include("expiration_year is unsupported")
+    expect(errors_for(:messages => { :expiration_year => "Expiration year is unsupported" })).
+      to include("expiration_year is unsupported")
   end
 
   it "handles error results without a status" do
     result = {}
     errors = [ stub("error", :attribute => "foo", :message => "bar") ]
-    expect { Ashmont::Errors.new(result, errors).to_hash }.to_not raise_error(NoMethodError)
+    expect { Ashmont::Errors.new(result, errors).to_hash }.to_not raise_error
   end
 
   def errors_for(options = {})

data/spec/ashmont/subscribed_customer_spec.rb

@@ -10,8 +10,8 @@ describe Ashmont::SubscribedCustomer do
     delegated_methods.each do |method|
       customer.stubs(method => "expected")
       result = subscribed_customer.send(method, "argument")
-      customer.should have_received(method).with("argument")
-      result.should == "expected"
+      expect(customer).to have_received(method).with("argument")
+      expect(result).to eq("expected")
     end
   end
 
@@ -21,15 +21,15 @@ describe Ashmont::SubscribedCustomer do
     %w(reload status next_billing_date transactions most_recent_transaction retry_charge past_due?).each do |method|
       subscription.stubs(method => "expected")
       result = subscribed_customer.send(method, "argument")
-      subscription.should have_received(method).with("argument")
-      result.should == "expected"
+      expect(subscription).to have_received(method).with("argument")
+      expect(result).to eq("expected")
     end
   end
 
   it "delegates #subscription_token to its subscription's token" do
     subscription = stub("subscription", :token => "expected")
     subscribed_customer = build_subscribed_customer(:subscription => subscription)
-    subscribed_customer.subscription_token.should == "expected"
+    expect(subscribed_customer.subscription_token).to eq("expected")
   end
 
   it "#reloads the subscription" do
@@ -38,8 +38,8 @@ describe Ashmont::SubscribedCustomer do
 
     result = subscribed_customer.reload
 
-    subscription.should have_received(:reload)
-    result.should == "expected"
+    expect(subscription).to have_received(:reload)
+    expect(result).to eq("expected")
   end
 
   it "can #save the customer" do
@@ -49,8 +49,8 @@ describe Ashmont::SubscribedCustomer do
 
     result = subscribed_customer.save(attributes)
 
-    customer.should have_received(:save).with(attributes)
-    result.should be_true
+    expect(customer).to have_received(:save).with(attributes)
+    expect(result).to be true
   end
 
   it "saves a new customer without attributes" do
@@ -59,7 +59,7 @@ describe Ashmont::SubscribedCustomer do
 
     subscribed_customer.save({})
 
-    customer.should have_received(:save).with({})
+    expect(customer).to have_received(:save).with({})
   end
 
   it "doesn't #save the customer without any customer attributes" do
@@ -69,7 +69,7 @@ describe Ashmont::SubscribedCustomer do
 
     subscribed_customer.save(attributes)
 
-    customer.should have_received(:save).never
+    expect(customer).to have_received(:save).never
   end
 
   it "can #save the subscription" do
@@ -81,8 +81,8 @@ describe Ashmont::SubscribedCustomer do
 
     result = subscribed_customer.save(attributes)
 
-    subscription.should have_received(:save).with(:plan_id => 41, :price => "15", :payment_method_token => payment_method_token)
-    result.should == "expected"
+    expect(subscription).to have_received(:save).with(:plan_id => 41, :price => "15", :payment_method_token => payment_method_token)
+    expect(result).to eq("expected")
   end
 
   it "retries the subscription when past due" do
@@ -91,7 +91,7 @@ describe Ashmont::SubscribedCustomer do
     subscribed_customer = build_subscribed_customer(:subscription => subscription)
     subscribed_customer.save({})
 
-    subscription.should have_received(:retry_charge)
+    expect(subscription).to have_received(:retry_charge)
   end
 
   it "merges #errors from the customer and subscription" do
@@ -99,7 +99,7 @@ describe Ashmont::SubscribedCustomer do
     customer = stub("customer", :errors => stub_errors("two" => "second"))
     subscribed_customer = build_subscribed_customer(:subscription => subscription, :customer => customer)
 
-    subscribed_customer.errors.to_hash.should == { "one" => "first", "two" => "second" }
+    expect(subscribed_customer.errors.to_hash).to eq({ "one" => "first", "two" => "second" })
   end
 
   def build_subscribed_customer(options = {})

data/spec/ashmont/subscription_spec.rb

@@ -6,8 +6,8 @@ describe Ashmont::Subscription do
       remote_subscription = stub_remote_subscription(delegated_method => "expected")
       subscription = Ashmont::Subscription.new(remote_subscription.id)
       result = subscription.send(delegated_method)
-      Braintree::Subscription.should have_received(:find).with(remote_subscription.id)
-      result.should == "expected"
+      expect(Braintree::Subscription).to have_received(:find).with(remote_subscription.id)
+      expect(result).to eq("expected")
     end
   end
 
@@ -16,17 +16,17 @@ describe Ashmont::Subscription do
     remote_subscription = stub_remote_subscription(:next_billing_date => unconverted_date)
     subscription = Ashmont::Subscription.new("xyz")
     result = subscription.next_billing_date
-    result.utc_offset.should == ActiveSupport::TimeZone[Ashmont.merchant_account_time_zone].utc_offset
-    result.strftime("%Y-%m-%d").should == unconverted_date
+    expect(result.utc_offset).to eq(ActiveSupport::TimeZone[Ashmont.merchant_account_time_zone].utc_offset)
+    expect(result.strftime("%Y-%m-%d")).to eq(unconverted_date)
   end
 
   it "doesn't have a next billing date without a remote subscription" do
-    Ashmont::Subscription.new.next_billing_date.should be_nil
+    expect(Ashmont::Subscription.new.next_billing_date).to be_nil
   end
 
   it "returns the token" do
     subscription = Ashmont::Subscription.new('abc')
-    subscription.token.should == 'abc'
+    expect(subscription.token).to eq('abc')
   end
 
   it "retries a subscription" do
@@ -39,11 +39,11 @@ describe Ashmont::Subscription do
     Braintree::Transaction.stubs(:submit_for_settlement => settlement_result)
 
     subscription = Ashmont::Subscription.new(subscription_token)
-    subscription.retry_charge.should be_true
-    subscription.errors.should be_empty
+    expect(subscription.retry_charge).to be true
+    expect(subscription.errors).to be_empty
 
-    Braintree::Subscription.should have_received(:retry_charge).with(subscription_token)
-    Braintree::Transaction.should have_received(:submit_for_settlement).with(transaction_token)
+    expect(Braintree::Subscription).to have_received(:retry_charge).with(subscription_token)
+    expect(Braintree::Transaction).to have_received(:submit_for_settlement).with(transaction_token)
   end
 
   it "has errors after a failed subscription retry" do
@@ -59,12 +59,12 @@ describe Ashmont::Subscription do
     Ashmont::Errors.stubs(:new => errors)
 
     subscription = Ashmont::Subscription.new(subscription_token)
-    subscription.retry_charge.should be_false
-    subscription.errors.should == errors
+    expect(subscription.retry_charge).to be false
+    expect(subscription.errors).to eq(errors)
 
-    Braintree::Subscription.should have_received(:retry_charge).with(subscription_token)
-    Braintree::Transaction.should have_received(:submit_for_settlement).with(transaction_token)
-    Ashmont::Errors.should have_received(:new).with(transaction, error_messages)
+    expect(Braintree::Subscription).to have_received(:retry_charge).with(subscription_token)
+    expect(Braintree::Transaction).to have_received(:submit_for_settlement).with(transaction_token)
+    expect(Ashmont::Errors).to have_received(:new).with(transaction, error_messages)
   end
 
   it "reloads the subscription after retrying a charge" do
@@ -88,8 +88,8 @@ describe Ashmont::Subscription do
     subscription = Ashmont::Subscription.new(token)
     result = subscription.save(:name => "Billy")
 
-    Braintree::Subscription.should have_received(:update).with(token, has_entries(:name => "Billy"))
-    result.should == "expected"
+    expect(Braintree::Subscription).to have_received(:update).with(token, has_entries(:name => "Billy"))
+    expect(result).to eq("expected")
   end
 
   it "creates a successful subscription" do
@@ -99,11 +99,11 @@ describe Ashmont::Subscription do
     Braintree::Subscription.stubs(:create => result)
 
     subscription = Ashmont::Subscription.new
-    subscription.save(attributes).should be_true
+    expect(subscription.save(attributes)).to be true
 
-    Braintree::Subscription.should have_received(:create).with(has_entries(attributes))
-    subscription.token.should == remote_subscription.id
-    subscription.status.should == "fine"
+    expect(Braintree::Subscription).to have_received(:create).with(has_entries(attributes))
+    expect(subscription.token).to eq(remote_subscription.id)
+    expect(subscription.status).to eq("fine")
   end
 
   it "passes a configured merchant account id" do
@@ -115,7 +115,7 @@ describe Ashmont::Subscription do
       subscription = Ashmont::Subscription.new
       subscription.save({})
 
-      Braintree::Subscription.should have_received(:create).with(has_entries(:merchant_account_id => merchant_account_id))
+      expect(Braintree::Subscription).to have_received(:create).with(has_entries(:merchant_account_id => merchant_account_id))
     end
   end
 
@@ -127,7 +127,7 @@ describe Ashmont::Subscription do
     subscription = Ashmont::Subscription.new
     subscription.save({})
 
-    Braintree::Subscription.should have_received(:create).with(has_entries(:merchant_account_id => nil)).never
+    expect(Braintree::Subscription).to have_received(:create).with(has_entries(:merchant_account_id => nil)).never
   end
 
   it "returns the most recent transaction" do
@@ -138,7 +138,7 @@ describe Ashmont::Subscription do
 
       subscription = Ashmont::Subscription.new("xyz")
 
-      subscription.most_recent_transaction.created_at.should == 1.day.ago
+      expect(subscription.most_recent_transaction.created_at).to eq(1.day.ago)
     end
   end
 
@@ -147,40 +147,40 @@ describe Ashmont::Subscription do
     new_remote_subscription = stub_remote_subscription(:status => "new")
     Braintree::Subscription.stubs(:find).returns(old_remote_subscription).then.returns(new_remote_subscription)
     subscription = Ashmont::Subscription.new(old_remote_subscription.id)
-    subscription.status.should == "old"
-    subscription.reload.status.should == "new"
+    expect(subscription.status).to eq("old")
+    expect(subscription.reload.status).to eq("new")
   end
 
   it "finds status from the remote subscription" do
     remote_subscription = stub_remote_subscription(:status => "a-ok")
     subscription = Ashmont::Subscription.new("xyz")
-    subscription.status.should == "a-ok"
+    expect(subscription.status).to eq("a-ok")
   end
 
   it "doesn't have status without a remote subscription" do
     subscription = Ashmont::Subscription.new(nil)
-    subscription.status.should be_nil
+    expect(subscription.status).to be_nil
   end
 
   it "uses a cached status when provided" do
     remote_subscription = stub_remote_subscription(:status => "past-due")
     subscription = Ashmont::Subscription.new("xyz", :status => "a-ok")
-    subscription.status.should == "a-ok"
+    expect(subscription.status).to eq("a-ok")
   end
 
   it "updates the cached status when reloading" do
     remote_subscription = stub_remote_subscription(:status => "active")
     subscription = Ashmont::Subscription.new("xyz", :status => "past-due")
     subscription.reload
-    subscription.status.should == "active"
+    expect(subscription.status).to eq("active")
   end
 
   it "is past due with a past due status" do
-    Ashmont::Subscription.new("xyz", :status => Braintree::Subscription::Status::PastDue).should be_past_due
+    expect(Ashmont::Subscription.new("xyz", :status => Braintree::Subscription::Status::PastDue)).to be_past_due
   end
 
   it "isn't past due with an active status" do
-    Ashmont::Subscription.new("xyz", :status => Braintree::Subscription::Status::Active).should_not be_past_due
+    expect(Ashmont::Subscription.new("xyz", :status => Braintree::Subscription::Status::Active)).to_not be_past_due
   end
 
   def with_configured_merchant_acount_id

data/spec/ashmont_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Ashmont do
     expect(Ashmont::VERSION).not_to be nil
   end
 
-  it "does something useful" do
-    expect(false).to eq(true)
-  end
+  # it "does something useful" do
+  #   expect(false).to eq(true)
+  # end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ashmont
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - thoughtbot
@@ -29,44 +29,56 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 5.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 5.0.2
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: 0.8.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: 0.8.1
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 1.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 1.2.3
 - !ruby/object:Gem::Dependency
   name: bourne
   requirement: !ruby/object:Gem::Requirement