ayl 0.3.0 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b3b09c825346a151c1ee66241ddb9f8f803fb663
+  data.tar.gz: a18dc857d326a0b310cfc2c6fc8b1b4aa1a5afec
+SHA512:
+  metadata.gz: 4733517f005acbae5f5c668810bd33fb1fcfe3076892abd4540438a3f1721fb5be3a900f23cd8620169d705806d2c51264d2679d48a302317b23ae39715c15a6
+  data.tar.gz: 94529875c0b7971d76a6503b85f5befab221cb775826588717b2f59566b6cd27c35f87ffdc628e512c2e12f59f84db11867330abb691afb1727b4b5cd6483e31

data/Gemfile

@@ -6,13 +6,11 @@ source "http://rubygems.org"
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rspec", ">= 2.3.0"
-  gem "bundler", ">= 1.0.0"
-  gem "jeweler", ">= 1.6.4"
-  gem "rcov", ">= 0"
-  gem 'pry'
+  gem "rspec", "~> 2.14"
+  gem "bundler", "~> 1.10"
+  gem "jeweler", "~> 2.0"
 end
 
-group :test do
-  gem 'pry'
+group :test, :development do
+  gem 'pry', "~> 0.9"
 end

data/Gemfile.lock

@@ -1,41 +1,79 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    addressable (2.3.8)
+    builder (3.2.2)
     coderay (0.9.8)
-    diff-lcs (1.1.3)
-    git (1.2.5)
-    jeweler (1.6.4)
-      bundler (~> 1.0)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    diff-lcs (1.2.5)
+    faraday (0.9.1)
+      multipart-post (>= 1.2, < 3)
+    git (1.2.9.1)
+    github_api (0.12.3)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.4)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 3.3)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.3)
+      oauth2
+    hashie (3.4.2)
+    highline (1.7.2)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
       git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
       rake
+      rdoc
+    jwt (1.5.0)
     method_source (0.6.7)
       ruby_parser (>= 2.3.1)
+    mini_portile (0.6.2)
+    multi_json (1.11.0)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    oauth2 (1.0.0)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 1.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
     pry (0.9.7.4)
       coderay (~> 0.9.8)
       method_source (~> 0.6.7)
       ruby_parser (>= 2.3.1)
       slop (~> 2.1.0)
-    rake (0.9.2.2)
-    rcov (0.9.11)
-    rspec (2.7.0)
-      rspec-core (~> 2.7.0)
-      rspec-expectations (~> 2.7.0)
-      rspec-mocks (~> 2.7.0)
-    rspec-core (2.7.1)
-    rspec-expectations (2.7.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.7.0)
+    rack (1.6.1)
+    rake (10.4.2)
+    rdoc (4.2.0)
+    rspec (2.99.0)
+      rspec-core (~> 2.99.0)
+      rspec-expectations (~> 2.99.0)
+      rspec-mocks (~> 2.99.0)
+    rspec-core (2.99.2)
+    rspec-expectations (2.99.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.99.3)
     ruby_parser (2.3.1)
       sexp_processor (~> 3.0)
     sexp_processor (3.0.8)
     slop (2.1.0)
+    thread_safe (0.3.5)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (>= 1.0.0)
-  jeweler (>= 1.6.4)
-  pry
-  rcov
-  rspec (>= 2.3.0)
+  bundler (~> 1.10)
+  jeweler (~> 2.0)
+  pry (~> 0.9)
+  rspec (~> 2.14)
+
+BUNDLED WITH
+   1.10.3

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2011 j0hnds@gmail.com
+Copyright (c) 2011-2015 j0hnds@gmail.com
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -13,7 +13,7 @@ been abstracted away from the general framework. You can implement any
 "Engine" you like to provide the asynchronous functionality. A
 reference implementation of an engine using beanstalk
 ({beanstalkd}[http://kr.github.com/beanstalkd/],
-{beanstalk-client}[http://beanstalk.rubyforge.org/]) as a queuing
+{beaneater}[https://github.com/beanstalkd/beaneater]) as a queuing
 mechanism is provided to give you a leg up:
 {ayl-beanstalk}[https://github.com/j0hnds/ayl-beanstalk]. If you
 decide to use a different mechanism, you can simply provide an
@@ -39,6 +39,6 @@ See the {wiki}[https://github.com/j0hnds/ayl/wiki/ayl-Home] for more detailed do
 
 == Copyright
 
-Copyright (c) 2011 j0hnds@gmail.com. See LICENSE.txt for
+Copyright (c) 2011-2015 j0hnds@gmail.com. See LICENSE.txt for
 further details.
 

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/ayl.gemspec

@@ -2,14 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
+# stub: ayl 0.4.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "ayl"
-  s.version = "0.3.0"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
   s.authors = ["Dave Sieh"]
-  s.date = "2013-08-07"
+  s.date = "2015-06-15"
   s.description = "Invoke code At Your Leisure. ayl is a small framework that simplifies the process of implementing asynchronous method calls in Ruby."
   s.email = "j0hnds@gmail.com"
   s.extra_rdoc_files = [
@@ -47,32 +49,28 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/j0hnds/ayl"
   s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.23"
+  s.rubygems_version = "2.4.6"
   s.summary = "Invoke code At Your Leisure"
 
   if s.respond_to? :specification_version then
-    s.specification_version = 3
+    s.specification_version = 4
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, [">= 2.3.0"])
-      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, [">= 1.6.4"])
-      s.add_development_dependency(%q<rcov>, [">= 0"])
-      s.add_development_dependency(%q<pry>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.14"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.10"])
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0"])
+      s.add_development_dependency(%q<pry>, ["~> 0.9"])
     else
-      s.add_dependency(%q<rspec>, [">= 2.3.0"])
-      s.add_dependency(%q<bundler>, [">= 1.0.0"])
-      s.add_dependency(%q<jeweler>, [">= 1.6.4"])
-      s.add_dependency(%q<rcov>, [">= 0"])
-      s.add_dependency(%q<pry>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.14"])
+      s.add_dependency(%q<bundler>, ["~> 1.10"])
+      s.add_dependency(%q<jeweler>, ["~> 2.0"])
+      s.add_dependency(%q<pry>, ["~> 0.9"])
     end
   else
-    s.add_dependency(%q<rspec>, [">= 2.3.0"])
-    s.add_dependency(%q<bundler>, [">= 1.0.0"])
-    s.add_dependency(%q<jeweler>, [">= 1.6.4"])
-    s.add_dependency(%q<rcov>, [">= 0"])
-    s.add_dependency(%q<pry>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.14"])
+    s.add_dependency(%q<bundler>, ["~> 1.10"])
+    s.add_dependency(%q<jeweler>, ["~> 2.0"])
+    s.add_dependency(%q<pry>, ["~> 0.9"])
   end
 end
 

data/lib/ayl/mailer.rb

@@ -6,7 +6,8 @@ module Ayl
     attr_reader :mailer
 
     def mailer=(mailer)
-      raise "Mailer implement the 'ayl_message(message, exception)' method" if mailer && !mailer.respond_to?(:ayl_message)
+      raise "Mailer must implement the 'ayl_message(message, exception)' method" if mailer && !mailer.respond_to?(:ayl_message)
+      raise "Mailer must implement the 'burying_job(code)' method" if mailer && !mailer.respond_to?(:burying_job)
       @mailer = mailer
     end
 
@@ -16,6 +17,12 @@ module Ayl
       Ayl::Logger.instance.error("Error sending ayl email message: #{ex.backtrace.join("\n")}")
     end
 
+    def burying_job(code)
+      mailer.burying_job(code).deliver if mailer && mailer.respond_to?(:burying_job)
+    rescue Exception => ex
+      Ayl::Logger.instance.error("Error sending burying_job email message: #{ex.backtrace.join("\n")}")
+    end
+
   end
 
 end

data/lib/ayl/message.rb

@@ -3,6 +3,7 @@ module Ayl
   class Message
 
     attr_accessor :object, :selector, :options, :arguments
+    attr_reader :code
 
     def initialize(object, selector, opts, *args)
       @object = object
@@ -13,15 +14,20 @@ module Ayl
 
     def self.from_hash(message_hash)
       raise Ayl::UnrecoverableMessageException, "parameter must be a hash" unless message_hash.is_a?(Hash)
-      raise Ayl::UnrecoverableMessageException, "not a valid message hash" if message_hash[:type] != :ayl || message_hash[:code].nil?
-      raise Ayl::UnrecoverableMessageException, "No code provided in job: #{job.body}" if message_hash[:code].nil?
+      raise Ayl::UnrecoverableMessageException, "not a valid message hash" if message_hash['type'] != 'ayl' || message_hash['code'].nil?
+      raise Ayl::UnrecoverableMessageException, "No code provided in job: #{job.body}" if message_hash['code'].nil?
 
-      code = message_hash[:code]
+      code = message_hash['code']
 
       Message.new(nil, nil, MessageOptions.new).tap do | m |
         m.send(:message_hash=, message_hash)
         m.send(:code=, code)
-        m.options.failed_job_handler = message_hash[:failed_job_handler] if message_hash[:failed_job_handler]
+        m.options.failed_job_handler = 
+          message_hash['failed_job_handler'] if message_hash['failed_job_handler']
+        m.options.failed_job_count = 
+          message_hash['failed_job_count'] if message_hash['failed_job_handler'] == 'decay' && message_hash['failed_job_count']
+        m.options.failed_job_delay = 
+          message_hash['failed_job_delay'] if message_hash['failed_job_handler'] == 'decay' && message_hash['failed_job_delay']
       end
       
     end
@@ -31,11 +37,20 @@ module Ayl
     end
 
     def to_hash
-      @message_hash ||= {
+      @message_hash ||= new_message_hash
+    end
+
+    def new_message_hash
+      {
         :type => :ayl,
         :failed_job_handler => options.failed_job_handler,
         :code => to_rrepr
-      }
+      }.tap do | h |
+        if options.failed_job_handler == 'decay'
+          h[:failed_job_count] = options.failed_job_count
+          h[:failed_job_delay] = options.failed_job_delay
+        end
+      end
     end
 
     def evaluate(top_binding)

data/lib/ayl/message_options.rb

@@ -2,14 +2,23 @@ module Ayl
 
   class MessageOptions
 
-    OPTIONS = [ :priority, :fuzz, :delay, :time_to_run, :queue_name, :failed_job_handler ]
+    OPTIONS = [ 
+      :priority, 
+      :fuzz, 
+      :delay, 
+      :time_to_run, 
+      :queue_name, 
+      :failed_job_handler,
+      :failed_job_delay,
+      :failed_job_count ]
 
     VALID_FAILED_JOB_HANDLERS = %W{ bury decay delete }
 
     attr_accessor *OPTIONS
 
     class << self
-      attr_accessor :default_priority, :default_fuzz, :default_delay, :default_time_to_run, :default_queue_name, :default_failed_job_handler
+      attr_accessor :default_priority, :default_fuzz, :default_delay, :default_time_to_run, :default_queue_name 
+      attr_accessor :default_failed_job_handler, :default_failed_job_delay, :default_failed_job_count 
     end
 
     # Set the default options
@@ -19,6 +28,8 @@ module Ayl
     self.default_time_to_run = 120
     self.default_queue_name = 'default'
     self.default_failed_job_handler = 'delete'
+    self.default_failed_job_delay = 60
+    self.default_failed_job_count = 3
 
     def initialize(opts=nil)
       opts ||= {}

data/spec/engine_spec.rb

@@ -7,47 +7,47 @@ describe Ayl::Engine do
     it "should return the default (synchronous) engine if no other engines are configured" do
       engine = Ayl::Engine.get_active_engine
 
-      engine.should_not be_nil
-      engine.should be_an_instance_of(Ayl::Engine)
+      expect(engine).not_to be_nil
+      expect(engine).to be_an_instance_of(Ayl::Engine)
     end
 
     it "should allow a different engine to be configured and selected if active" do
-      mock_engine = mock("FakeEngine")
-      mock_engine.should_receive(:respond_to?).with(:asynchronous?).and_return(true)
-      mock_engine.should_receive(:respond_to?).with(:is_connected?).and_return(true)
-      mock_engine.should_receive(:is_connected?).and_return(true)
+      mock_engine = double("FakeEngine")
+      expect(mock_engine).to receive(:respond_to?).with(:asynchronous?).and_return(true)
+      expect(mock_engine).to receive(:respond_to?).with(:is_connected?).and_return(true)
+      expect(mock_engine).to receive(:is_connected?).and_return(true)
       
       Ayl::Engine.clear_engines
       Ayl::Engine.add_engine(mock_engine)
 
-      Ayl::Engine.get_active_engine.should == mock_engine
+      expect(Ayl::Engine.get_active_engine).to eq(mock_engine)
     end
 
     it "should allow a different engine to be configured but select the default if the new one is not active" do
-      mock_engine = mock("FakeEngine")
-      mock_engine.should_receive(:respond_to?).with(:asynchronous?).and_return(true)
-      mock_engine.should_receive(:respond_to?).with(:is_connected?).and_return(true)
-      mock_engine.should_receive(:is_connected?).and_return(false)
+      mock_engine = double("FakeEngine")
+      expect(mock_engine).to receive(:respond_to?).with(:asynchronous?).and_return(true)
+      expect(mock_engine).to receive(:respond_to?).with(:is_connected?).and_return(true)
+      expect(mock_engine).to receive(:is_connected?).and_return(false)
 
       Ayl::Engine.clear_engines
       Ayl::Engine.add_engine(mock_engine)
 
-      Ayl::Engine.get_active_engine.should == Ayl::Engine.instance
+      expect(Ayl::Engine.get_active_engine).to eq(Ayl::Engine.instance)
     end
 
     it "should raise an exception if a new engine is added that doesn't respond to :asynchronous" do
-      mock_engine = mock("FakeEngine")
-      mock_engine.should_receive(:respond_to?).with(:asynchronous?).and_return(false)
+      mock_engine = double("FakeEngine")
+      expect(mock_engine).to receive(:respond_to?).with(:asynchronous?).and_return(false)
       
-      lambda { Ayl::Engine.add_engine(mock_engine) }.should raise_error
+      expect { Ayl::Engine.add_engine(mock_engine) }.to raise_error
     end
 
     it "should raise an exception if a new engine is added that doesn't respond to :is_connected" do
-      mock_engine = mock("FakeEngine")
-      mock_engine.should_receive(:respond_to?).with(:asynchronous?).and_return(true)
-      mock_engine.should_receive(:respond_to?).with(:is_connected?).and_return(false)
+      mock_engine = double("FakeEngine")
+      expect(mock_engine).to receive(:respond_to?).with(:asynchronous?).and_return(true)
+      expect(mock_engine).to receive(:respond_to?).with(:is_connected?).and_return(false)
       
-      lambda { Ayl::Engine.add_engine(mock_engine) }.should raise_error
+      expect { Ayl::Engine.add_engine(mock_engine) }.to raise_error
     end
 
   end
@@ -59,26 +59,26 @@ describe Ayl::Engine do
     end
 
     it "should identify itself as synchronous" do
-      @default_engine.asynchronous?.should be_false
+      expect(@default_engine.asynchronous?).to be false
     end
 
     it "should respond that it is connected" do
-      @default_engine.is_connected?.should be_true
+      expect(@default_engine.is_connected?).to be true
     end
 
     it "should simply execute the code provided in the message submission" do
-      mock_logger = mock("Ayl::Logger")
+      mock_logger = double("Ayl::Logger")
       mock_logger.stub(:debug)
       
       Ayl::Logger.instance.logger = mock_logger
 
-      mock_message = mock("Ayl::Message")
+      mock_message = double("Ayl::Message")
 
-      mock_worker = mock("Ayl::Worker")
-      mock_worker.should_receive(:process_message).with(mock_message).and_return(8)
-      Ayl::Worker.should_receive(:new).and_return(mock_worker)
+      mock_worker = double("Ayl::Worker")
+      expect(mock_worker).to receive(:process_message).with(mock_message).and_return(8)
+      expect(Ayl::Worker).to receive(:new).and_return(mock_worker)
 
-      @default_engine.submit(mock_message).should == 8
+      expect(@default_engine.submit(mock_message)).to eq(8)
     end
 
   end

data/spec/extensions_spec.rb

@@ -13,30 +13,32 @@ describe Ayl::Extensions do
     end
 
     it "should delegate the call to ayl_send to ayl_send_opts" do
-      @cut.should_receive(:ayl_send_opts).with(:something, {}, "arg1", "arg2")
+      expect(@cut).to receive(:ayl_send_opts).with(:something, {}, "arg1", "arg2")
       @cut.ayl_send(:something, "arg1", "arg2")
     end
 
     it "should have the message submit the call from ayl_send_opts" do
-      mock_engine = mock("Ayl::Engine")
+      mock_engine = double("Ayl::Engine")
 
-      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_engine)
+      expect(Ayl::Engine).to receive(:get_active_engine).and_return(mock_engine)
       
-      mock_message_opts = mock("Ayl::MessageOptions")
-      Ayl::MessageOptions.should_receive(:new).with({}).and_return(mock_message_opts)
+      mock_message_opts = double("Ayl::MessageOptions")
+      expect(Ayl::MessageOptions).to receive(:new).with({}).and_return(mock_message_opts)
       
-      mock_message = mock("Ayl::Message")
+      mock_message = double("Ayl::Message")
 
-      Ayl::Message.should_receive(:new).with(@cut, :something, mock_message_opts, "arg1", "arg2").and_return(mock_message)
-      mock_engine.should_receive(:submit).with(mock_message)
+      expect(Ayl::Message).to receive(:new).
+        with(@cut, :something, mock_message_opts, "arg1", "arg2").
+        and_return(mock_message)
+      expect(mock_engine).to receive(:submit).with(mock_message)
 
       @cut.ayl_send_opts(:something, {}, "arg1", "arg2")
     end
 
     it "should extend a common set up classes" do
       [ Array, Hash, Module, Numeric, Range, String, Symbol ].each do |c|
-        c.should respond_to :ayl_send
-        c.should respond_to :ayl_send_opts
+        expect(c).to respond_to :ayl_send
+        expect(c).to respond_to :ayl_send_opts
       end
     end
 

data/spec/logger_spec.rb

@@ -9,14 +9,14 @@ describe Ayl::Logger do
   context "Logger Configuration" do
 
     it "should respond with nil if a logger isn't configured" do
-      Ayl::Logger.instance.logger.should be_nil
+      expect(Ayl::Logger.instance.logger).to be_nil
     end
 
     it "should respond with the logger set if the logger is configured" do
-      mock_logger = mock("Logger")
+      mock_logger = double("Logger")
 
       Ayl::Logger.instance.logger = mock_logger
-      Ayl::Logger.instance.logger.should == mock_logger
+      expect(Ayl::Logger.instance.logger).to be mock_logger
     end
 
   end
@@ -24,11 +24,11 @@ describe Ayl::Logger do
   context "Logging" do
 
     it "should log calls to the logger through std out when no logger is configured" do
-      Kernel.should_receive(:puts).with("DEBUG: Debug message")
-      Kernel.should_receive(:puts).with("ERROR: Error message")
-      Kernel.should_receive(:puts).with("FATAL: Fatal message")
-      Kernel.should_receive(:puts).with("INFO: Info message")
-      Kernel.should_receive(:puts).with("WARN: Warn message")
+      expect(Kernel).to receive(:puts).with("DEBUG: Debug message")
+      expect(Kernel).to receive(:puts).with("ERROR: Error message")
+      expect(Kernel).to receive(:puts).with("FATAL: Fatal message")
+      expect(Kernel).to receive(:puts).with("INFO: Info message")
+      expect(Kernel).to receive(:puts).with("WARN: Warn message")
       
       Ayl::Logger.instance.logger = nil
 
@@ -38,12 +38,12 @@ describe Ayl::Logger do
     end
 
     it "should log calls to the configured logger" do
-      mock_logger = mock("Logger")
-      mock_logger.should_receive(:debug).with("Debug message")
-      mock_logger.should_receive(:error).with("Error message")
-      mock_logger.should_receive(:fatal).with("Fatal message")
-      mock_logger.should_receive(:info).with("Info message")
-      mock_logger.should_receive(:warn).with("Warn message")
+      mock_logger = double("Logger")
+      expect(mock_logger).to receive(:debug).with("Debug message")
+      expect(mock_logger).to receive(:error).with("Error message")
+      expect(mock_logger).to receive(:fatal).with("Fatal message")
+      expect(mock_logger).to receive(:info).with("Info message")
+      expect(mock_logger).to receive(:warn).with("Warn message")
 
       Ayl::Logger.instance.logger = mock_logger
       

data/spec/mailer_spec.rb

@@ -8,22 +8,23 @@ describe Ayl::Mailer do
 
   context 'Mailer configuration' do
 
-    context "#logger" do
+    context "#deliver_message" do
 
       it "should respond with nil if a mailer isn't configured" do
-        Ayl::Mailer.instance.mailer.should be_nil
+        expect(Ayl::Mailer.instance.mailer).to be_nil
       end
 
       it "should raise an error if an attempt is made to configure the mailer with an invalid object" do
-        lambda { Ayl::Mailer.instance.mailer = Object.new }.should raise_error
+        expect { Ayl::Mailer.instance.mailer = Object.new }.to raise_error
       end
 
       it "should allow a valid mailer to be configured" do
-        mock_mailer = mock("MyMailer")
+        mock_mailer = double("MyMailer")
         mock_mailer.stub(:ayl_message)
+        mock_mailer.stub(:burying_job)
 
-        lambda { Ayl::Mailer.instance.mailer = mock_mailer }.should_not raise_error
-        Ayl::Mailer.instance.mailer.should == mock_mailer
+        expect { Ayl::Mailer.instance.mailer = mock_mailer }.not_to raise_error
+        expect(Ayl::Mailer.instance.mailer).to be mock_mailer
       end
 
     end
@@ -39,12 +40,13 @@ describe Ayl::Mailer do
       end
 
       it "should deliver a message and no stack trace if a valid mailer is configured" do
-        mock_mailer = mock("MyMailer")
-        mock_mailer.should_receive(:ayl_message).with('The Message', nil).and_return do
-          mock("MailMessage").tap do | mail_message |
-            mail_message.should_receive(:deliver)
-          end
-        end
+        mock_mailer = double("MyMailer")
+        mock_message = double("MailMessage")
+        expect(mock_message).to receive(:deliver)
+        expect(mock_mailer).to receive(:ayl_message).
+          with('The Message', nil).
+          and_return(mock_message)
+        mock_mailer.stub(:burying_job)
 
         Ayl::Mailer.instance.mailer = mock_mailer
 
@@ -52,12 +54,13 @@ describe Ayl::Mailer do
       end
 
       it "should deliver a message and a stack trace if a valid mailer is configured" do
-        mock_mailer = mock("MyMailer")
-        mock_mailer.should_receive(:ayl_message).with('The Message', 'StackTrace').and_return do
-          mock("MailMessage").tap do | mail_message |
-            mail_message.should_receive(:deliver)
-          end
-        end
+        mock_mailer = double("MyMailer")
+        mock_message = double("MailMessage")
+        expect(mock_message).to receive(:deliver)
+        expect(mock_mailer).to receive(:ayl_message).
+          with('The Message', 'StackTrace').
+          and_return(mock_message)
+        mock_mailer.stub(:burying_job)
 
         Ayl::Mailer.instance.mailer = mock_mailer
 
@@ -66,6 +69,23 @@ describe Ayl::Mailer do
 
     end
 
+    context '#burying_job' do
+
+      it "should deliver a message if a valid mailer is configured" do
+        mock_mailer = double("MyMailer")
+        mock_message = double("MailMessage")
+        expect(mock_message).to receive(:deliver)
+        expect(mock_mailer).to receive(:burying_job).
+          with('1 + 2').
+          and_return(mock_message)
+        mock_mailer.stub(:ayl_message)
+
+        Ayl::Mailer.instance.mailer = mock_mailer
+
+        Ayl::Mailer.instance.burying_job('1 + 2')
+      end
+    end
+
   end
 
 end

data/spec/message_options_spec.rb

@@ -5,12 +5,14 @@ describe Ayl::MessageOptions do
   context "Option Default Accessors" do
 
     it "should have the correct defaults" do
-      Ayl::MessageOptions.default_priority.should == 512
-      Ayl::MessageOptions.default_fuzz.should == 0
-      Ayl::MessageOptions.default_delay.should == 0
-      Ayl::MessageOptions.default_time_to_run.should == 120
-      Ayl::MessageOptions.default_queue_name.should == 'default'
-      Ayl::MessageOptions.default_failed_job_handler.should == 'delete'
+      expect(Ayl::MessageOptions.default_priority).to eq(512)
+      expect(Ayl::MessageOptions.default_fuzz).to eq(0)
+      expect(Ayl::MessageOptions.default_delay).to eq(0)
+      expect(Ayl::MessageOptions.default_time_to_run).to eq(120)
+      expect(Ayl::MessageOptions.default_queue_name).to eq('default')
+      expect(Ayl::MessageOptions.default_failed_job_handler).to eq('delete')
+      expect(Ayl::MessageOptions.default_failed_job_count).to eq(3)
+      expect(Ayl::MessageOptions.default_failed_job_delay).to eq(60)
     end
 
     it "should reflect the changes if changes have been made" do
@@ -20,13 +22,17 @@ describe Ayl::MessageOptions do
       Ayl::MessageOptions.default_time_to_run = 1
       Ayl::MessageOptions.default_queue_name = 'different'
       Ayl::MessageOptions.default_failed_job_handler = 'bury'
-
-      Ayl::MessageOptions.default_priority.should == 256
-      Ayl::MessageOptions.default_fuzz.should == 18
-      Ayl::MessageOptions.default_delay.should == 2300
-      Ayl::MessageOptions.default_time_to_run.should == 1
-      Ayl::MessageOptions.default_queue_name.should == 'different'
-      Ayl::MessageOptions.default_failed_job_handler.should == 'bury'
+      Ayl::MessageOptions.default_failed_job_count = 8
+      Ayl::MessageOptions.default_failed_job_delay = 3600
+
+      expect(Ayl::MessageOptions.default_priority).to eq(256)
+      expect(Ayl::MessageOptions.default_fuzz).to eq(18)
+      expect(Ayl::MessageOptions.default_delay).to eq(2300)
+      expect(Ayl::MessageOptions.default_time_to_run).to eq(1)
+      expect(Ayl::MessageOptions.default_queue_name).to eq('different')
+      expect(Ayl::MessageOptions.default_failed_job_handler).to eq('bury')
+      expect(Ayl::MessageOptions.default_failed_job_count).to eq(8)
+      expect(Ayl::MessageOptions.default_failed_job_delay).to eq(3600)
     end
 
   end
@@ -36,66 +42,77 @@ describe Ayl::MessageOptions do
     it "should respond with the correct defaults when initialized with an empty hash" do
       mo = Ayl::MessageOptions.new({})
 
-      mo.priority.should == Ayl::MessageOptions.default_priority
-      mo.fuzz.should == Ayl::MessageOptions.default_fuzz
-      mo.delay.should == Ayl::MessageOptions.default_delay
-      mo.time_to_run.should == Ayl::MessageOptions.default_time_to_run
-      mo.queue_name.should == Ayl::MessageOptions.default_queue_name
-      mo.failed_job_handler.should == Ayl::MessageOptions.default_failed_job_handler
+      expect(mo.priority).to eq(Ayl::MessageOptions.default_priority)
+      expect(mo.fuzz).to eq(Ayl::MessageOptions.default_fuzz)
+      expect(mo.delay).to eq(Ayl::MessageOptions.default_delay)
+      expect(mo.time_to_run).to eq(Ayl::MessageOptions.default_time_to_run)
+      expect(mo.queue_name).to eq(Ayl::MessageOptions.default_queue_name)
+      expect(mo.failed_job_handler).to eq(Ayl::MessageOptions.default_failed_job_handler)
+      expect(mo.failed_job_count).to eq(Ayl::MessageOptions.default_failed_job_count)
+      expect(mo.failed_job_delay).to eq(Ayl::MessageOptions.default_failed_job_delay)
     end
 
     it "should respond with the correct defaults when initialized with nil" do
       mo = Ayl::MessageOptions.new(nil)
 
-      mo.priority.should == Ayl::MessageOptions.default_priority
-      mo.fuzz.should == Ayl::MessageOptions.default_fuzz
-      mo.delay.should == Ayl::MessageOptions.default_delay
-      mo.time_to_run.should == Ayl::MessageOptions.default_time_to_run
-      mo.queue_name.should == Ayl::MessageOptions.default_queue_name
-      mo.failed_job_handler.should == Ayl::MessageOptions.default_failed_job_handler
+      expect(mo.priority).to eq(Ayl::MessageOptions.default_priority)
+      expect(mo.fuzz).to eq(Ayl::MessageOptions.default_fuzz)
+      expect(mo.delay).to eq(Ayl::MessageOptions.default_delay)
+      expect(mo.time_to_run).to eq(Ayl::MessageOptions.default_time_to_run)
+      expect(mo.queue_name).to eq(Ayl::MessageOptions.default_queue_name)
+      expect(mo.failed_job_handler).to eq(Ayl::MessageOptions.default_failed_job_handler)
+      expect(mo.failed_job_count).to eq(Ayl::MessageOptions.default_failed_job_count)
+      expect(mo.failed_job_delay).to eq(Ayl::MessageOptions.default_failed_job_delay)
     end
 
     it "should respond with the correct defaults when initialized with no parameter" do
       mo = Ayl::MessageOptions.new()
 
-      mo.priority.should == Ayl::MessageOptions.default_priority
-      mo.fuzz.should == Ayl::MessageOptions.default_fuzz
-      mo.delay.should == Ayl::MessageOptions.default_delay
-      mo.time_to_run.should == Ayl::MessageOptions.default_time_to_run
-      mo.queue_name.should == Ayl::MessageOptions.default_queue_name
-      mo.failed_job_handler.should == Ayl::MessageOptions.default_failed_job_handler
+      expect(mo.priority).to eq(Ayl::MessageOptions.default_priority)
+      expect(mo.fuzz).to eq(Ayl::MessageOptions.default_fuzz)
+      expect(mo.delay).to eq(Ayl::MessageOptions.default_delay)
+      expect(mo.time_to_run).to eq(Ayl::MessageOptions.default_time_to_run)
+      expect(mo.queue_name).to eq(Ayl::MessageOptions.default_queue_name)
+      expect(mo.failed_job_handler).to eq(Ayl::MessageOptions.default_failed_job_handler)
+      expect(mo.failed_job_count).to eq(Ayl::MessageOptions.default_failed_job_count)
+      expect(mo.failed_job_delay).to eq(Ayl::MessageOptions.default_failed_job_delay)
     end
 
     it "should respond with the correct values when all are specified in the options" do
-      opts = { :priority => 22, :fuzz => 88, :delay => 99, :time_to_run => 11, :queue_name => 'stub', :failed_job_handler => 'decay' }
+      opts = { priority: 22, fuzz: 88, delay: 99, time_to_run: 11, queue_name: 'stub', 
+        failed_job_handler: 'decay', failed_job_count: 12, failed_job_delay: 14 }
       mo = Ayl::MessageOptions.new(opts)
 
-      mo.priority.should == opts[:priority]
-      mo.fuzz.should == opts[:fuzz]
-      mo.delay.should == opts[:delay]
-      mo.time_to_run.should == opts[:time_to_run]
-      mo.queue_name.should == opts[:queue_name]
-      mo.failed_job_handler.should == opts[:failed_job_handler]
+      expect(mo.priority).to eq(opts[:priority])
+      expect(mo.fuzz).to eq(opts[:fuzz])
+      expect(mo.delay).to eq(opts[:delay])
+      expect(mo.time_to_run).to eq(opts[:time_to_run])
+      expect(mo.queue_name).to eq(opts[:queue_name])
+      expect(mo.failed_job_handler).to eq(opts[:failed_job_handler])
+      expect(mo.failed_job_count).to eq(opts[:failed_job_count])
+      expect(mo.failed_job_delay).to eq(opts[:failed_job_delay])
     end
 
     it "should respond with the correct values when some values are specified in the options" do
       opts = { :priority => 22, :fuzz => 88, :delay => 99 }
       mo = Ayl::MessageOptions.new(opts)
 
-      mo.priority.should == opts[:priority]
-      mo.fuzz.should == opts[:fuzz]
-      mo.delay.should == opts[:delay]
-      mo.time_to_run.should == Ayl::MessageOptions.default_time_to_run
-      mo.queue_name.should == Ayl::MessageOptions.default_queue_name
-      mo.failed_job_handler.should == Ayl::MessageOptions.default_failed_job_handler
+      expect(mo.priority).to eq(opts[:priority])
+      expect(mo.fuzz).to eq(opts[:fuzz])
+      expect(mo.delay).to eq(opts[:delay])
+      expect(mo.time_to_run).to eq(Ayl::MessageOptions.default_time_to_run)
+      expect(mo.queue_name).to eq(Ayl::MessageOptions.default_queue_name)
+      expect(mo.failed_job_handler).to eq(Ayl::MessageOptions.default_failed_job_handler)
+      expect(mo.failed_job_count).to eq(Ayl::MessageOptions.default_failed_job_count)
+      expect(mo.failed_job_delay).to eq(Ayl::MessageOptions.default_failed_job_delay)
     end
 
     it "should raise an exception when an invalid option is provided in the hash" do
-      lambda { Ayl::MessageOptions.new({:bob => 'something' }) }.should raise_error
+      expect { Ayl::MessageOptions.new({:bob => 'something' }) }.to raise_error
     end
 
     it "should raise an exception when a non-hash is provided as a parameter" do
-      lambda { Ayl::MessageOptions.new(14) }.should raise_error
+      expect { Ayl::MessageOptions.new(14) }.to raise_error
     end
 
   end

data/spec/message_spec.rb

@@ -10,6 +10,8 @@ describe Ayl::Message do
     Ayl::MessageOptions.default_time_to_run = 120
     Ayl::MessageOptions.default_queue_name = 'default'
     Ayl::MessageOptions.default_failed_job_handler = 'decay'
+    Ayl::MessageOptions.default_failed_job_count = 3 
+    Ayl::MessageOptions.default_failed_job_delay = 60 
   end
 
   context "Initialization" do
@@ -18,20 +20,20 @@ describe Ayl::Message do
       options = Ayl::MessageOptions.new
       m = Ayl::Message.new("object", :method_name, options, "arg1", "arg2")
       
-      m.object.should == "object"
-      m.selector.should == :method_name
-      m.options.should == options
-      m.arguments.should == [ "arg1", "arg2" ]
+      expect(m.object).to eq "object"
+      expect(m.selector).to eq :method_name
+      expect(m.options).to eq options
+      expect(m.arguments).to eq [ "arg1", "arg2" ]
     end
 
     it "should accept an object, selector options and no arguments" do
       options = Ayl::MessageOptions.new
       m = Ayl::Message.new("object", :method_name, options)
       
-      m.object.should == "object"
-      m.selector.should == :method_name
-      m.options.should == options
-      m.arguments.should == [ ]
+      expect(m.object).to eq "object"
+      expect(m.selector).to eq :method_name
+      expect(m.options).to eq options
+      expect(m.arguments).to eq [ ]
     end
 
   end
@@ -41,13 +43,13 @@ describe Ayl::Message do
     it "should generate code when arguments are present" do
       options = Ayl::MessageOptions.new
       m = Ayl::Message.new("object", :method_name, options, "arg1", "arg2")
-      m.to_rrepr.should == "\"object\".method_name(\"arg1\", \"arg2\")"
+      expect(m.to_rrepr).to eq "\"object\".method_name(\"arg1\", \"arg2\")"
     end
 
     it "should generate code when no arguments are present" do
       options = Ayl::MessageOptions.new
       m = Ayl::Message.new("object", :method_name, options)
-      m.to_rrepr.should == "\"object\".method_name()"
+      expect(m.to_rrepr).to eq "\"object\".method_name()"
     end
 
   end
@@ -57,75 +59,81 @@ describe Ayl::Message do
     it "should package up the message into a hash" do
       options = Ayl::MessageOptions.new
       m = Ayl::Message.new("object", :method_name, options, "arg1", "arg2")
-      m.to_hash.should == { :type => :ayl, :failed_job_handler => 'decay', :code => "\"object\".method_name(\"arg1\", \"arg2\")" }
+      expect(m.to_hash).to eq({ :type => :ayl, :failed_job_handler => 'decay', :failed_job_count => 3, :failed_job_delay => 60, :code => "\"object\".method_name(\"arg1\", \"arg2\")" })
+    end
+
+    it "should package up the message into a hash but not with decay" do
+      options = Ayl::MessageOptions.new({failed_job_handler: 'delete'})
+      m = Ayl::Message.new("object", :method_name, options, "arg1", "arg2")
+      expect(m.to_hash).to eq({ :type => :ayl, :failed_job_handler => 'delete', :code => "\"object\".method_name(\"arg1\", \"arg2\")" })
     end
 
     it "should package up the message into a hash when the decay failed job has been set" do
       options = Ayl::MessageOptions.new
       options.failed_job_handler = 'decay'
       m = Ayl::Message.new("object", :method_name, options, "arg1", "arg2")
-      m.to_hash.should == { :type => :ayl, :failed_job_handler => 'decay', :code => "\"object\".method_name(\"arg1\", \"arg2\")" }
+      expect(m.to_hash).to eq({ :type => :ayl, :failed_job_handler => 'decay', :failed_job_count => 3, :failed_job_delay => 60, :code => "\"object\".method_name(\"arg1\", \"arg2\")" })
     end
 
     it "should be able to create a message from a hash with code that has arguments" do
-      m_hash = { :type => :ayl, :code => "\"object\".method_name(\"arg1\", \"arg2\")" }
+      m_hash = { 'type' => 'ayl', 'code' => "\"object\".method_name(\"arg1\", \"arg2\")" }
       m = Ayl::Message.from_hash(m_hash)
-      m.options.is_a?(Ayl::MessageOptions).should be_true
-      m.to_hash.should === m_hash
+      expect(m.options.is_a?(Ayl::MessageOptions)).to be true
+      expect(m.to_hash).to eq m_hash
     end
 
     it "should be able to create a message from a hash with code that has no arguments" do
-      m_hash = { :type => :ayl, :code => "\"object\".method_name()" }
+      m_hash = { 'type' => 'ayl', 'code' => "\"object\".method_name()" }
       m = Ayl::Message.from_hash(m_hash)
-      m.options.is_a?(Ayl::MessageOptions).should be_true
-      m.to_hash.should === m_hash
+      expect(m.options.is_a?(Ayl::MessageOptions)).to be true
+      expect(m.to_hash).to eq m_hash
     end
 
     it "should be able to create a message from a hash with code that has no arguments and no parens" do
-      m_hash = { :type => :ayl, :code => "\"object\".method_name" }
+      m_hash = { 'type' => 'ayl', 'code' => "\"object\".method_name" }
       m = Ayl::Message.from_hash(m_hash)
-      m.options.is_a?(Ayl::MessageOptions).should be_true
-      m.to_hash.should === m_hash
+      expect(m.options.is_a?(Ayl::MessageOptions)).to be true
+      expect(m.to_hash).to eq m_hash
     end
 
     it "should be able to create a message from a hash with code that has one arguments with multiple parens" do
-      m_hash = { :type => :ayl, :code => "\"object\".method_name('string'.length())" }
+      m_hash = { 'type' => 'ayl', 'code' => "\"object\".method_name('string'.length())" }
       m = Ayl::Message.from_hash(m_hash)
-      m.options.is_a?(Ayl::MessageOptions).should be_true
-      m.to_hash.should === m_hash
+      expect(m.options.is_a?(Ayl::MessageOptions)).to be true
+      expect(m.to_hash).to be m_hash
     end
 
     # Sample._ayl_after_create(Sample.find(106))
     it "should be able to create a message from a hash with code that has one arguments with multiple parens" do
-      m_hash = { :type => :ayl, :code => "String._ayl_after_create(2.to_s(2))" }
+      m_hash = { 'type' => 'ayl', 'code' => "String._ayl_after_create(2.to_s(2))" }
       m = Ayl::Message.from_hash(m_hash)
-      m.options.is_a?(Ayl::MessageOptions).should be_true
-      m.to_hash.should === m_hash
+      expect(m.options.is_a?(Ayl::MessageOptions)).to be true
+      expect(m.to_hash).to be m_hash
     end
 
     it "should create a message with decay_failed job set to false if not in the original hash" do
       Ayl::MessageOptions.default_failed_job_handler = 'delete'
-      m_hash = { :type => :ayl, :code => "String._ayl_after_create(2.to_s(2))" }
+      m_hash = { 'type' => 'ayl', 'code' => "String._ayl_after_create(2.to_s(2))" }
       m = Ayl::Message.from_hash(m_hash)
-      m.options.is_a?(Ayl::MessageOptions).should be_true
-      m.to_hash.should === m_hash
-      m.options.failed_job_handler.should == 'delete'
+      expect(m.options.is_a?(Ayl::MessageOptions)).to be true
+      expect(m.to_hash).to be m_hash
+      expect(m.options.failed_job_handler).to eq 'delete'
     end
 
     it "should create a message with decay_failed job set to false if in the original hash as false" do
-      m_hash = { :type => :ayl, :failed_job_handler => 'delete', :code => "String._ayl_after_create(2.to_s(2))" }
+      m_hash = { 'type' => 'ayl', 'failed_job_handler' => 'delete', 'code' => "String._ayl_after_create(2.to_s(2))" }
       m = Ayl::Message.from_hash(m_hash)
-      m.options.is_a?(Ayl::MessageOptions).should be_true
-      m.to_hash.should === m_hash
-      m.options.failed_job_handler.should == 'delete'
+      expect(m.options.is_a?(Ayl::MessageOptions)).to be true
+      expect(m.to_hash).to be m_hash
+      expect(m.options.failed_job_handler).to eq 'delete'
     end
 
     it "should create a message with decay_failed job set to true if in the original hash as true" do
-      m_hash = { :type => :ayl, :failed_job_handler => 'decay', :code => "String._ayl_after_create(2.to_s(2))" }
+      m_hash = { 'type' => 'ayl', 'failed_job_handler' => 'decay', 'code' => "String._ayl_after_create(2.to_s(2))" }
       m = Ayl::Message.from_hash(m_hash)
-      m.options.is_a?(Ayl::MessageOptions).should be_true
-      m.to_hash.should === m_hash
-      m.options.failed_job_handler.should == 'decay'
+      expect(m.options.is_a?(Ayl::MessageOptions)).to be true
+      expect(m.to_hash).to be m_hash
+      expect(m.options.failed_job_handler).to eq 'decay'
     end
 
 
@@ -136,7 +144,7 @@ describe Ayl::Message do
     it "should evaluate the code associated with the message" do
       array_of_nums = [ 3, 2, 8, 1 ]
       m = Ayl::Message.new(array_of_nums, :length, Ayl::MessageOptions.new)
-      m.evaluate(binding).should == 4
+      expect(m.evaluate(binding)).to be 4
     end
 
   end

data/spec/worker_spec.rb

@@ -11,7 +11,7 @@ describe Ayl::Worker do
 
     it "should raise an exception if receive is called on an engine that is not asynchronous" do
       Kernel.stub(:puts)
-      lambda { @worker.process_messages }.should raise_error(RuntimeError, "synchronous worker cannot receive messages")
+      expect { @worker.process_messages }.to raise_error(RuntimeError, "synchronous worker cannot receive messages")
     end
 
   end

metadata

@@ -1,96 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: ayl
 version: !ruby/object:Gem::Version
-  version: 0.3.0
-  prerelease: 
+  version: 0.4.0
 platform: ruby
 authors:
 - Dave Sieh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-07 00:00:00.000000000 Z
+date: 2015-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.3.0
+        version: '2.14'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.4
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.4
-- !ruby/object:Gem::Dependency
-  name: rcov
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.9'
 description: Invoke code At Your Leisure. ayl is a small framework that simplifies
   the process of implementing asynchronous method calls in Ruby.
 email: j0hnds@gmail.com
@@ -100,8 +75,8 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.rdoc
 files:
-- .document
-- .rspec
+- ".document"
+- ".rspec"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -130,29 +105,25 @@ files:
 homepage: http://github.com/j0hnds/ayl
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 831016271210020708
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.4.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Invoke code At Your Leisure
 test_files: []