resque_admin 0.2.0 → 1.0.2

data/lib/{resque_admin → resque}/errors.rb

@@ -1,4 +1,4 @@
-module ResqueAdmin
+module Resque
   # Raised whenever we need a queue but none is provided.
   class NoQueueError < RuntimeError; end
 

data/lib/{resque_admin → resque}/failure/airbrake.rb

@@ -4,19 +4,19 @@ rescue LoadError
   raise "Can't find 'airbrake' gem. Please add it to your Gemfile or install it."
 end
 
-module ResqueAdmin
+module Resque
   module Failure
     class Airbrake < Base
       def self.configure(&block)
-        ResqueAdmin.logger.warn "This actually sets global Airbrake configuration, " \
+        Resque.logger.warn "This actually sets global Airbrake configuration, " \
           "which is probably not what you want."
-        ResqueAdmin::Failure.backend = self
+        Resque::Failure.backend = self
         ::Airbrake.configure(&block)
       end
 
       def self.count(queue = nil, class_name = nil)
         # We can't get the total # of errors from Airbrake so we fake it
-        # by asking ResqueAdmin how many errors it has seen.
+        # by asking Resque how many errors it has seen.
         Stat[:failed]
       end
 

data/lib/{resque_admin → resque}/failure/base.rb

@@ -1,4 +1,4 @@
-module ResqueAdmin
+module Resque
   module Failure
     # All Failure classes are expected to subclass Base.
     #

data/lib/{resque_admin → resque}/failure/multiple.rb

@@ -1,4 +1,4 @@
-module ResqueAdmin
+module Resque
   module Failure
     # A Failure backend that uses multiple backends
     # delegates all queries to the first backend
@@ -10,7 +10,7 @@ module ResqueAdmin
 
       def self.configure
         yield self
-        ResqueAdmin::Failure.backend = self
+        Resque::Failure.backend = self
       end
 
       def initialize(*args)

data/lib/{resque_admin → resque}/failure/redis.rb

@@ -1,15 +1,15 @@
-module ResqueAdmin
+module Resque
   module Failure
     # A Failure backend that stores exceptions in Redis. Very simple but
-    # works out of the box, along with support in the ResqueAdmin web app.
+    # works out of the box, along with support in the Resque web app.
     class Redis < Base
 
       def data_store
-        ResqueAdmin.data_store
+        Resque.data_store
       end
 
       def self.data_store
-        ResqueAdmin.data_store
+        Resque.data_store
       end
 
       def save
@@ -22,7 +22,7 @@ module ResqueAdmin
           :worker    => worker.to_s,
           :queue     => queue
         }
-        data = ResqueAdmin.encode(data)
+        data = Resque.encode(data)
         data_store.push_to_failed_queue(data)
       end
 
@@ -44,7 +44,7 @@ module ResqueAdmin
 
       def self.all(offset = 0, limit = 1, queue = nil)
         check_queue(queue)
-        ResqueAdmin.list_range(:failed, offset, limit)
+        Resque.list_range(:failed, offset, limit)
       end
 
       def self.each(offset = 0, limit = self.count, queue = :failed, class_name = nil, order = 'desc')
@@ -79,7 +79,7 @@ module ResqueAdmin
         check_queue(queue)
         item = all(id)
         item['retried_at'] = Time.now.strftime("%Y/%m/%d %H:%M:%S")
-        data_store.update_item_in_failed_queue(id,ResqueAdmin.encode(item))
+        data_store.update_item_in_failed_queue(id,Resque.encode(item))
         Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
       end
 

data/lib/{resque_admin → resque}/failure/redis_multi_queue.rb

@@ -1,15 +1,15 @@
-module ResqueAdmin
+module Resque
   module Failure
     # A Failure backend that stores exceptions in Redis. Very simple but
-    # works out of the box, along with support in the ResqueAdmin web app.
+    # works out of the box, along with support in the Resque web app.
     class RedisMultiQueue < Base
 
       def data_store
-        ResqueAdmin.data_store
+        Resque.data_store
       end
 
       def self.data_store
-        ResqueAdmin.data_store
+        Resque.data_store
       end
 
       def save
@@ -22,8 +22,8 @@ module ResqueAdmin
           :worker    => worker.to_s,
           :queue     => queue
         }
-        data = ResqueAdmin.encode(data)
-        data_store.push_to_failed_queue(data,ResqueAdmin::Failure.failure_queue_name(queue))
+        data = Resque.encode(data)
+        data_store.push_to_failed_queue(data,Resque::Failure.failure_queue_name(queue))
       end
 
       def self.count(queue = nil, class_name = nil)
@@ -43,7 +43,7 @@ module ResqueAdmin
       end
 
       def self.all(offset = 0, limit = 1, queue = :failed)
-        ResqueAdmin.list_range(queue, offset, limit)
+        Resque.list_range(queue, offset, limit)
       end
 
       def self.queues
@@ -74,7 +74,7 @@ module ResqueAdmin
       def self.requeue(id, queue = :failed)
         item = all(id, 1, queue)
         item['retried_at'] = Time.now.strftime("%Y/%m/%d %H:%M:%S")
-        data_store.update_item_in_failed_queue(id,ResqueAdmin.encode(item),queue)
+        data_store.update_item_in_failed_queue(id,Resque.encode(item),queue)
         Job.create(item['queue'], item['payload']['class'], *item['payload']['args'])
       end
 
@@ -83,16 +83,16 @@ module ResqueAdmin
       end
 
       def self.requeue_queue(queue)
-        failure_queue = ResqueAdmin::Failure.failure_queue_name(queue)
+        failure_queue = Resque::Failure.failure_queue_name(queue)
         each(0, count(failure_queue), failure_queue) { |id, _| requeue(id, failure_queue) }
       end
 
       def self.requeue_all
-        queues.each { |queue| requeue_queue(ResqueAdmin::Failure.job_queue_name(queue)) }
+        queues.each { |queue| requeue_queue(Resque::Failure.job_queue_name(queue)) }
       end
 
       def self.remove_queue(queue)
-        data_store.remove_failed_queue(ResqueAdmin::Failure.failure_queue_name(queue))
+        data_store.remove_failed_queue(Resque::Failure.failure_queue_name(queue))
       end
 
       def filter_backtrace(backtrace)

data/lib/{resque_admin → resque}/failure.rb

@@ -1,9 +1,9 @@
-module ResqueAdmin
+module Resque
   # The Failure module provides an interface for working with different
   # failure backends.
   #
   # You can use it to query the failure backend without knowing which specific
-  # backend is being used. For instance, the ResqueAdmin web app uses it to display
+  # backend is being used. For instance, the Resque web app uses it to display
   # stats and other information.
   module Failure
     # Creates a new failure, which is delegated to the appropriate backend.
@@ -19,26 +19,26 @@ module ResqueAdmin
 
     #
     # Sets the current backend. Expects a class descendent of
-    # `ResqueAdmin::Failure::Base`.
+    # `Resque::Failure::Base`.
     #
     # Example use:
     #   require 'resque/failure/airbrake'
-    #   ResqueAdmin::Failure.backend = ResqueAdmin::Failure::Airbrake
+    #   Resque::Failure.backend = Resque::Failure::Airbrake
     def self.backend=(backend)
       @backend = backend
     end
 
     # Returns the current backend class. If none has been set, falls
-    # back to `ResqueAdmin::Failure::Redis`
+    # back to `Resque::Failure::Redis`
     def self.backend
       return @backend if @backend
 
       case ENV['FAILURE_BACKEND']
       when 'redis_multi_queue'
-        require 'resque_admin/failure/redis_multi_queue'
+        require 'resque/failure/redis_multi_queue'
         @backend = Failure::RedisMultiQueue
       when 'redis', nil
-        require 'resque_admin/failure/redis'
+        require 'resque/failure/redis'
         @backend = Failure::Redis
       else
         raise ArgumentError, "invalid failure backend: #{FAILURE_BACKEND}"
@@ -48,7 +48,7 @@ module ResqueAdmin
     # Obtain the failure queue name for a given job queue
     def self.failure_queue_name(job_queue_name)
       name = "#{job_queue_name}_failed"
-      ResqueAdmin.data_store.add_failed_queue(name)
+      Resque.data_store.add_failed_queue(name)
       name
     end
 

data/lib/{resque_admin → resque}/helpers.rb

@@ -8,41 +8,41 @@ elsif MultiJson.respond_to?(:engine)
   raise "Please install the yajl-ruby or json gem" if MultiJson.engine.to_s == 'MultiJson::Engines::OkJson'
 end
 
-module ResqueAdmin
-  # Methods used by various classes in ResqueAdmin.
+module Resque
+  # Methods used by various classes in Resque.
   module Helpers
     class DecodeException < StandardError; end
 
     # Direct access to the Redis instance.
     def redis
       # No infinite recursions, please.
-      # Some external libraries depend on ResqueAdmin::Helpers being mixed into
-      # ResqueAdmin, but this method causes recursions. If we have a super method,
+      # Some external libraries depend on Resque::Helpers being mixed into
+      # Resque, but this method causes recursions. If we have a super method,
       # assume it is canonical. (see #1150)
       return super if defined?(super)
 
-      ResqueAdmin.redis
+      Resque.redis
     end
 
     # Given a Ruby object, returns a string suitable for storage in a
     # queue.
     def encode(object)
-      ResqueAdmin.encode(object)
+      Resque.encode(object)
     end
 
     # Given a string, returns a Ruby object.
     def decode(object)
-      ResqueAdmin.decode(object)
+      Resque.decode(object)
     end
 
     # Given a word with dashes, returns a camel cased version of it.
     def classify(dashed_word)
-      ResqueAdmin.classify(dashed_word)
+      Resque.classify(dashed_word)
     end
 
     # Tries to find a constant with the name specified in the argument string
     def constantize(camel_cased_word)
-      ResqueAdmin.constantize(camel_cased_word)
+      Resque.constantize(camel_cased_word)
     end
   end
 end

data/lib/{resque_admin → resque}/job.rb

@@ -1,5 +1,5 @@
-module ResqueAdmin
-  # A ResqueAdmin::Job represents a unit of work. Each job lives on a
+module Resque
+  # A Resque::Job represents a unit of work. Each job lives on a
   # single queue and has an associated payload object. The payload
   # is a hash with two attributes: `class` and `args`. The `class` is
   # the name of the Ruby class which should be used to run the
@@ -8,19 +8,19 @@ module ResqueAdmin
   #
   # You can manually run a job using this code:
   #
-  #   job = ResqueAdmin::Job.reserve(:high)
-  #   klass = ResqueAdmin::Job.constantize(job.payload['class'])
+  #   job = Resque::Job.reserve(:high)
+  #   klass = Resque::Job.constantize(job.payload['class'])
   #   klass.perform(*job.payload['args'])
   class Job
     include Helpers
     extend Helpers
     def redis
-      ResqueAdmin.redis
+      Resque.redis
     end
     alias :data_store :redis
 
     def self.redis
-      ResqueAdmin.redis
+      Resque.redis
     end
 
     def self.data_store
@@ -30,36 +30,36 @@ module ResqueAdmin
     # Given a Ruby object, returns a string suitable for storage in a
     # queue.
     def encode(object)
-      ResqueAdmin.encode(object)
+      Resque.encode(object)
     end
 
     # Given a string, returns a Ruby object.
     def decode(object)
-      ResqueAdmin.decode(object)
+      Resque.decode(object)
     end
 
     # Given a Ruby object, returns a string suitable for storage in a
     # queue.
     def self.encode(object)
-      ResqueAdmin.encode(object)
+      Resque.encode(object)
     end
 
     # Given a string, returns a Ruby object.
     def self.decode(object)
-      ResqueAdmin.decode(object)
+      Resque.decode(object)
     end
     
     # Given a word with dashes, returns a camel cased version of it.
     def classify(dashed_word)
-      ResqueAdmin.classify(dashed_word)
+      Resque.classify(dashed_word)
     end
 
     # Tries to find a constant with the name specified in the argument string
     def constantize(camel_cased_word)
-      ResqueAdmin.constantize(camel_cased_word)
+      Resque.constantize(camel_cased_word)
     end
 
-    # Raise ResqueAdmin::Job::DontPerform from a before_perform hook to
+    # Raise Resque::Job::DontPerform from a before_perform hook to
     # abort the job.
     DontPerform = Class.new(StandardError)
 
@@ -85,14 +85,14 @@ module ResqueAdmin
     #
     # Raises an exception if no queue or class is given.
     def self.create(queue, klass, *args)
-      ResqueAdmin.validate(klass, queue)
+      Resque.validate(klass, queue)
 
-      if ResqueAdmin.inline?
-        # Instantiating a ResqueAdmin::Job and calling perform on it so callbacks run
+      if Resque.inline?
+        # Instantiating a Resque::Job and calling perform on it so callbacks run
         # decode(encode(args)) to ensure that args are normalized in the same manner as a non-inline job
         new(:inline, {'class' => klass, 'args' => decode(encode(args))}).perform
       else
-        ResqueAdmin.push(queue, :class => klass.to_s, :args => args)
+        Resque.push(queue, :class => klass.to_s, :args => args)
       end
     end
 
@@ -111,11 +111,11 @@ module ResqueAdmin
     #
     # The following call will remove both:
     #
-    #   ResqueAdmin::Job.destroy(queue, 'UpdateGraph')
+    #   Resque::Job.destroy(queue, 'UpdateGraph')
     #
     # Whereas specifying args will only remove the 2nd job:
     #
-    #   ResqueAdmin::Job.destroy(queue, 'UpdateGraph', 'mojombo')
+    #   Resque::Job.destroy(queue, 'UpdateGraph', 'mojombo')
     #
     # This method can be potentially very slow and memory intensive,
     # depending on the size of your queue, as it loads all jobs into
@@ -137,10 +137,10 @@ module ResqueAdmin
       destroyed
     end
 
-    # Given a string queue name, returns an instance of ResqueAdmin::Job
+    # Given a string queue name, returns an instance of Resque::Job
     # if any jobs are available. If not, returns nil.
     def self.reserve(queue)
-      return unless payload = ResqueAdmin.pop(queue)
+      return unless payload = Resque.pop(queue)
       new(queue, payload)
     end
 
@@ -154,7 +154,7 @@ module ResqueAdmin
 
       begin
         # Execute before_perform hook. Abort the job gracefully if
-        # ResqueAdmin::DontPerform is raised.
+        # Resque::DontPerform is raised.
         begin
           before_hooks.each do |hook|
             job.send(hook, *job_args)

data/lib/{resque_admin → resque}/log_formatters/quiet_formatter.rb

@@ -1,4 +1,4 @@
-module ResqueAdmin
+module Resque
   class QuietFormatter
     def call(serverity, datetime, progname, msg)
       ""

data/lib/{resque_admin → resque}/log_formatters/verbose_formatter.rb

@@ -1,4 +1,4 @@
-module ResqueAdmin
+module Resque
   class VerboseFormatter
     def call(serverity, datetime, progname, msg)
       "*** #{msg}\n"

data/lib/{resque_admin → resque}/log_formatters/very_verbose_formatter.rb

@@ -1,4 +1,4 @@
-module ResqueAdmin
+module Resque
   class VeryVerboseFormatter
     def call(serverity, datetime, progname, msg)
       time = Time.now.strftime('%H:%M:%S %Y-%m-%d')

data/lib/{resque_admin → resque}/logging.rb

@@ -1,11 +1,11 @@
-module ResqueAdmin
+module Resque
   # Include this module in classes you wish to have logging facilities
   module Logging
     module_function
 
     # Thunk to the logger's own log method (if configured)
     def self.log(severity, message)
-      ResqueAdmin.logger.__send__(severity, message) if ResqueAdmin.logger
+      Resque.logger.__send__(severity, message) if Resque.logger
     end
     
     # Log level aliases

data/lib/{resque_admin → resque}/plugin.rb

@@ -1,4 +1,4 @@
-module ResqueAdmin
+module Resque
   module Plugin
     extend self
 
@@ -6,7 +6,7 @@ module ResqueAdmin
 
     # Ensure that your plugin conforms to good hook naming conventions.
     #
-    #   ResqueAdmin::Plugin.lint(MyResquePlugin)
+    #   Resque::Plugin.lint(MyResquePlugin)
     def lint(plugin)
       hooks = before_hooks(plugin) + around_hooks(plugin) + after_hooks(plugin)
 

data/lib/{resque_admin → resque}/server/helpers.rb

@@ -1,4 +1,4 @@
-ResqueAdmin::Server.helpers do
+Resque::Server.helpers do
   ####################
   #failed.erb helpers#
   ####################
@@ -9,11 +9,11 @@ ResqueAdmin::Server.helpers do
 
   def failed_multiple_queues?
     return @multiple_failed_queues if defined?(@multiple_failed_queues)
-    @multiple_failed_queues = ResqueAdmin::Failure.queues.size > 1
+    @multiple_failed_queues = Resque::Failure.queues.size > 1
   end
 
   def failed_size
-    @failed_size ||= ResqueAdmin::Failure.count(params[:queue], params[:class])
+    @failed_size ||= Resque::Failure.count(params[:queue], params[:class])
   end
 
   def failed_per_page
@@ -42,7 +42,7 @@ ResqueAdmin::Server.helpers do
 
   def failed_class_counts(queue = params[:queue])
     classes = Hash.new(0)
-    ResqueAdmin::Failure.each(0, ResqueAdmin::Failure.count(queue), queue) do |_, item|
+    Resque::Failure.each(0, Resque::Failure.count(queue), queue) do |_, item|
       class_name = item['payload']['class'] if item['payload']
       class_name ||= "nil"
       classes[class_name] += 1

data/lib/{resque_admin → resque}/server/test_helper.rb

@@ -1,12 +1,12 @@
 require 'rack/test'
-require 'resque_admin/server'
+require 'resque/server'
 
-module ResqueAdmin
+module Resque
   module TestHelper
     class Test::Unit::TestCase
       include Rack::Test::Methods
       def app
-        ResqueAdmin::Server.new
+        Resque::Server.new
       end 
 
       def self.should_respond_with_success

data/lib/{resque_admin → resque}/server/views/failed.erb

@@ -1,5 +1,5 @@
 <% if failed_multiple_queues? && !params[:queue] %>
-<h1>All Failed Queues: <%= ResqueAdmin::Failure.queues.size %> total</h1>
+<h1>All Failed Queues: <%= Resque::Failure.queues.size %> total</h1>
 <% else %>
 <h1>Failed Jobs <%= "on '#{params[:queue]}'" if params[:queue] %> <%= "with class '#{params[:class]}'" if params[:class] %></h1>
 <% end %>
@@ -20,7 +20,7 @@
 
 
 <ul class='failed'>
-  <% ResqueAdmin::Failure.each(failed_start_at, failed_per_page, params[:queue], params[:class], failed_order) do |id, job| %>
+  <% Resque::Failure.each(failed_start_at, failed_per_page, params[:queue], params[:class], failed_order) do |id, job| %>
     <%= partial :failed_job, :id => id, :job => job, :queue => "failed#{'/' + params[:queue] if params[:queue]}" %>
   <% end %>
 </ul>

data/lib/{resque_admin → resque}/server/views/failed_queues_overview.erb

@@ -2,13 +2,13 @@
 <tbody>
   <tr class="total">
     <td class='queue'>Total Failed</td>
-    <td class='center'><%= ResqueAdmin::Failure.count %></td>
+    <td class='center'><%= Resque::Failure.count %></td>
   </tr>
 
-  <% ResqueAdmin::Failure.queues.sort.each do |queue| %>
+  <% Resque::Failure.queues.sort.each do |queue| %>
 	  <tr>
 	    <th><b class="queue-tag"><a href="<%= u "/failed/#{queue}" %>"><%= queue %></a></b></th>
-	    <th style="width:75px;" class="center"><%= ResqueAdmin::Failure.count(queue) %></th>
+	    <th style="width:75px;" class="center"><%= Resque::Failure.count(queue) %></th>
 	  </tr>
 
     <% failed_class_counts(queue).sort_by { |name,_| name }.each do |k, v| %>

data/lib/{resque_admin → resque}/server/views/layout.erb

@@ -2,7 +2,7 @@
 <html lang="en">
 <head>
   <meta charset="utf-8" />
-  <title>ResqueAdmin</title>
+  <title>Resque</title>
   <link href="<%=u 'reset.css' %>" media="screen" rel="stylesheet" type="text/css">
   <link href="<%=u 'style.css' %>" media="screen" rel="stylesheet" type="text/css">
   <script src="<%=u 'jquery-1.12.4.min.js' %>" type="text/javascript"></script>
@@ -16,9 +16,9 @@
         <%= tab tab_name %>
       <% end %>
     </ul>
-    <% if ResqueAdmin.redis.namespace != :resque %>
-      <abbr class="namespace" title="ResqueAdmin's Redis Namespace">
-       <%= ResqueAdmin.redis.namespace %>
+    <% if Resque.redis.namespace != :resque %>
+      <abbr class="namespace" title="Resque's Redis Namespace">
+       <%= Resque.redis.namespace %>
       </abbr>
     <% end %>
   </div>
@@ -36,8 +36,8 @@
 </div>
 
 <div id="footer">
-  <p>Powered by <a href="http://github.com/resque/resque">ResqueAdmin</a> v<%=ResqueAdmin::Version%></p>
-  <p>Connected to Redis namespace <%= ResqueAdmin.redis.namespace %> on <%=ResqueAdmin.redis_id%></p>
+  <p>Powered by <a href="http://github.com/resque/resque">Resque</a> v<%=Resque::Version%></p>
+  <p>Connected to Redis namespace <%= Resque.redis.namespace %> on <%=Resque.redis_id%></p>
 </div>
 
 </body>

data/lib/{resque_admin → resque}/server/views/queues.erb

@@ -41,16 +41,16 @@
     </tr>
     <% end %>
     <% if failed_multiple_queues? %>
-      <% ResqueAdmin::Failure.queues.sort_by { |q| q.to_s }.each_with_index do |queue, i| %>
-      <tr class="<%= ResqueAdmin::Failure.count(queue).zero? ? "failed" : "failure" %><%= " first_failure" if i.zero? %>">
+      <% Resque::Failure.queues.sort_by { |q| q.to_s }.each_with_index do |queue, i| %>
+      <tr class="<%= Resque::Failure.count(queue).zero? ? "failed" : "failure" %><%= " first_failure" if i.zero? %>">
         <td class='queue failed'><a class="queue" href="<%= u "failed/#{queue}" %>"><%= queue %></a></td>
-        <td class='size'><%= ResqueAdmin::Failure.count(queue) %></td>
+        <td class='size'><%= Resque::Failure.count(queue) %></td>
       </tr>
       <% end %>
     <% else %>
-      <tr class="<%= ResqueAdmin::Failure.count.zero? ? "failed" : "failure" %>">
+      <tr class="<%= Resque::Failure.count.zero? ? "failed" : "failure" %>">
         <td class='queue failed'><a class="queue" href="<%= u :failed %>">failed</a></td>
-        <td class='size'><%= ResqueAdmin::Failure.count %></td>
+        <td class='size'><%= Resque::Failure.count %></td>
       </tr>
     <% end %>
   </table>

data/lib/{resque_admin → resque}/server/views/stats.erb

@@ -39,7 +39,7 @@
 <% elsif params[:id] == 'keys' %>
 
   <h1>Keys owned by <%= resque %></h1>
-  <p class='sub'>(All keys are actually prefixed with "<%= ResqueAdmin.redis.namespace %>:")</p>
+  <p class='sub'>(All keys are actually prefixed with "<%= Resque.redis.namespace %>:")</p>
   <table class='stats'>
     <tr>
       <th>key</th>