line_up 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 893ebb96aa6db1f8b61b41954630d0f3a7922da6
-  data.tar.gz: 82cd227d22fd25c02785675164a263fefd841ba1
+SHA256:
+  metadata.gz: ce18ce8d73e695503b1817970a0f7c134a716f9bfc6c040e0572f9ef5df9a26f
+  data.tar.gz: b6ffe2e2f83caef827038c9b2d0015a0c9561f03f711ba008105116605d6560c
 SHA512:
-  metadata.gz: 010f5577b11b26d98d93c7dedd378cbc196525a1b300cfcaed0834f62fe591a29aa044f60cc3210de4478fb45c3ff8e1932fe33cc00d8dff3f919ad3a1ef5e28
-  data.tar.gz: 46c76b54b0932de54d07828a0ffb1c0b260a07e5b0132cee83c28b745adebe378fb5ace719944c13ab27cb17044b62ef4ca1c7af398231759f0f82ccc327d5cd
+  metadata.gz: 278311aa84959ea1d7fd8148c273eef5420494699070a9dd80ec42498d27ab2157ea63c5a73b436d016b0e7a3e38082e3ab11d3b0a18e65a937d8de2c13901e3
+  data.tar.gz: 9fcd63dd92472f090fe8e168b36442daf14cd673d617ea2aa2c4d8f5a75989256594776d633d9c2c464e007d8bc9c5fa1d746888b220f99f2b4d407e414f5627

data/README.md

@@ -41,11 +41,7 @@ With the setup above, Resque lies in the `myapp:resque`-namespace. So you can en
 This is how you can enqueue a job for another applications:
 
 ```ruby
-if LineUp.push :otherApp, :SomeJob, 12345, some: thing
-# Yey, everything went well
-else
-# The "Trouble"-gem, has been notified and I can process the failure if I like
-end
+LineUp.push :otherApp, :SomeJob, 12345, some: thing
 ```
 
 This will enqueue to `other_app:resque:some_job` with arguments `[12345, { 'some' => 'thing' }]` and make sure that the `other_app:resque:queues` Set references the queue List.

data/lib/line_up/version.rb

@@ -2,7 +2,7 @@ module LineUp
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 2
+    TINY  = 4
 
     STRING = [MAJOR, MINOR, TINY].compact.join('.')
   end

data/lib/line_up.rb

@@ -1,5 +1,3 @@
-require 'trouble'
-
 require 'line_up/configuration'
 require 'line_up/job'
 
@@ -13,10 +11,6 @@ module LineUp
       redis.rpush "queue:#{job.queue_name}", job.encode
     end
     log caller, application, jobclass, *args
-    true
-  rescue Exception => exception
-    Trouble.notify exception, caller: caller[1], message: "LineUp could not enqueue a Job", code: :enqueue_failed, redis: config.redis.inspect, application: application.inspect, job: jobclass.inspect, args: args.inspect
-    false
   end
 
   def self.ensure(application, jobclass, *args)
@@ -25,39 +19,15 @@ module LineUp
     end
   end
 
-  def self.push_throttled(application, jobclass, *args)
-    job = Job.new jobclass, *args
-    unless recent? application, job
-      push(application, jobclass, *args)
-      recent! application, job
-    end
-  end
-
   def self.queue_length(application, jobclass)
     redis_for application do |r|
       job = Job.new jobclass
       return r.llen "queue:#{job.queue_name}"
     end
-  rescue Exception => e
-    Trouble.notify e, caller: caller[1], message: "LineUp could not get the queue length", code: :getting_queue_length_failed, redis: config.redis.inspect, application: application.inspect, job: jobclass.inspect
-    false
   end
 
   private
 
-  def self.recent?(application, job)
-    redis_for application do |r|
-      return true if r.exists "throttled:#{job.checksum}"
-    end
-    false
-  end
-
-  def self.recent!(application, job)
-    redis_for application do |r|
-      r.setex "throttled:#{job.checksum}", config.recency_ttl, "true"
-    end
-  end
-
   def self.redis_for(application, &block)
     config.redis.namespace [StringExtensions.underscore(application), :resque].compact.join(':'), &block
   end
@@ -66,5 +36,4 @@ module LineUp
     return unless config.logger
     config.logger.debug "LINEUP ENQUEUED JOB #{jobclass.inspect} for #{application.inspect} at #{caller.first} with arguments #{args.inspect}"
   end
-
 end

data/spec/lib/line_up/configuration_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe LineUp do
 
-  let(:logger)      { mock(:logger) }
-
+  let(:rails)  { Module.new }
+  let(:logger) { double(:logger) }
   let(:lineup) { LineUp }
 
   describe '.config' do
@@ -12,22 +12,18 @@ describe LineUp do
     end
 
     it 'is an STDOUT logger' do
-      Logger.should_receive(:new).with(STDOUT).and_return logger
-      lineup.config.logger.should be logger
+      expect(Logger).to receive(:new).with(STDOUT).and_return logger
+      expect(lineup.config.logger).to eq(logger)
     end
 
     context 'with Rails' do
       before do
-        ensure_module :Rails
-        Rails.stub!(:logger).and_return(logger)
-      end
-
-      after do
-        Object.send(:remove_const, :Rails)
+        allow(rails).to receive(:logger).and_return(logger)
+        stub_const("Rails", rails)
       end
 
       it 'is the Rails logger' do
-        lineup.config.logger.should be Rails.logger
+        expect(lineup.config.logger).to eq(Rails.logger)
       end
     end
   end

data/spec/lib/line_up_spec.rb

@@ -6,26 +6,22 @@ describe LineUp do
   let(:job)         { :SendEmail }
   let(:args)        { [123, some: :thing] }
   let(:redis)       { $raw_redis }
-  let(:logger)      { mock(:logger) }
+  let(:logger)      { double(:logger) }
   let(:lineup_job)  { LineUp::Job.new job, *args }
 
   let(:lineup) { LineUp }
 
   describe '.push' do
-    it 'returns true if successful' do
-      lineup.push(application, job, *args).should be_true
-    end
-
     it 'registers the queue' do
       lineup.push application, job, *args
-      queues = redis.smembers('other_app:resque:queues').should == %w{ send_email }
+      expect(redis.smembers('other_app:resque:queues')).to eq(%w{ send_email })
     end
 
     it 'enqueues the job' do
       lineup.push application, job, *args
       jobs = redis.lrange('other_app:resque:queue:send_email', 0, -1)
-      jobs.size.should == 1
-      MultiJson.load(jobs.first).should == { 'class' => 'SendEmail', 'args' => [123, 'some' => 'thing'] }
+      expect(jobs.size).to eq(1)
+      expect(MultiJson.load(jobs.first)).to eq({ 'class' => 'SendEmail', 'args' => [123, 'some' => 'thing'] })
     end
 
     context 'with a Logger' do
@@ -34,120 +30,36 @@ describe LineUp do
       end
 
       it 'logs the enqueueing and returns true' do
-        logger.should_receive(:debug) do |string|
-          string.should include('LINEUP ENQUEUED')
-          string.should include('line_up_spec.rb')
-          string.should include(':otherApp')
-          string.should include(':SendEmail')
-          string.should include('[123, {:some=>:thing}]')
-        end
-        lineup.push(application, job, *args).should be_true
-      end
-    end
-
-    context 'when the key for the Queue Set is occupied by the wrong data format' do
-      before do
-        redis.set 'other_app:resque:queues', :anything_but_a_list
-      end
-
-      it 'catches the error and returns false' do
-        Trouble.should_receive(:notify) do |exception, metadata|
-          exception.should be_instance_of Redis::CommandError
-          metadata[:code].should == :enqueue_failed
-          metadata[:application].should == ':otherApp'
-          metadata[:job].should == ':SendEmail'
-          metadata[:args].should == '[123, {:some=>:thing}]'
-          metadata[:caller].should include('line_up_spec.rb')
+        expect(logger).to receive(:debug) do |string|
+          expect(string).to include('LINEUP ENQUEUED')
+          expect(string).to include('line_up_spec.rb')
+          expect(string).to include(':otherApp')
+          expect(string).to include(':SendEmail')
+          expect(string).to include('[123, {:some=>:thing}]')
         end
-        lineup.push(application, job, *args).should be_false
-      end
-    end
-
-    context 'when the key for the List Job Queue is occupied by the wrong data format' do
-      before do
-        redis.set 'other_app:resque:queue:send_email', :anything_but_a_list
-      end
-
-      it 'catches the error and returns false' do
-        Trouble.should_receive(:notify) do |exception, metadata|
-          exception.should be_instance_of Redis::CommandError
-          metadata[:code].should == :enqueue_failed
-          metadata[:application].should == ':otherApp'
-          metadata[:job].should == ':SendEmail'
-          metadata[:args].should == '[123, {:some=>:thing}]'
-          metadata[:caller].should include('line_up_spec.rb')
-        end
-        lineup.push(application, job, *args).should be_false
+        lineup.push application, job, *args
       end
     end
   end
 
   describe ".queue_length" do
-
     it "returns the length of the given queue in the given application" do
       lineup.push(application, job, 1)
       lineup.push(application, job, 2)
-      lineup.queue_length(application, job).should == 2
-    end
-
-    context 'when the key for the List Job Queue is occupied by the wrong data format' do
-      before do
-        redis.set 'other_app:resque:queue:send_email', :anything_but_a_list
-      end
-
-      it 'logs the error' do
-        Trouble.should_receive(:notify) do |exception, metadata|
-          exception.should be_instance_of Redis::CommandError
-          metadata[:code].should == :getting_queue_length_failed
-          metadata[:application].should == ':otherApp'
-          metadata[:job].should == ':SendEmail'
-          metadata[:caller].should include('line_up_spec.rb')
-        end
-        lineup.queue_length(application, job)
-      end
-
-      it "returns false" do
-        lineup.queue_length(application, job).should be_false
-      end
+      expect(lineup.queue_length(application, job)).to eq(2)
     end
   end
 
   describe ".ensure" do
-
     it "pushes the job if the queue is empty" do
-      lineup.should_receive(:push).with(application, job, *args)
+      expect(lineup).to receive(:push).with(application, job, *args)
       lineup.ensure application, job, *args
     end
 
     it "does not push the job if the queue already has a job with the same name" do
       lineup.push application, job, *args
-      lineup.should_not_receive(:push)
+      expect(lineup).not_to receive(:push)
       lineup.ensure application, job, *args
     end
   end
-
-  describe ".push_throttled" do
-
-    it "pushes same consecutive job just once" do
-      lineup.should_receive(:push).once
-      lineup.push_throttled application, job, *args
-      lineup.push_throttled application, job, *args
-    end
-
-    it "pushes again when previous identical job has expired" do
-      lineup.should_receive(:push).twice
-
-      lineup.push_throttled application, job, *args
-      redis.del "other_app:resque:throttled:#{lineup_job.checksum}"
-      lineup.push_throttled application, job, *args
-    end
-
-    it "stores throttle with configured ttl" do
-      lineup.push_throttled application, job, *args
-      ttl = redis.ttl "other_app:resque:throttled:#{lineup_job.checksum}"
-      ttl.should == lineup.config.recency_ttl
-    end
-
-  end
-
 end

data/spec/spec_helper.rb

@@ -1,40 +1,16 @@
 require 'redis-namespace'
 require 'line_up'
 
-def ensure_class_or_module(full_name, class_or_module)
-  full_name.to_s.split(/::/).inject(Object) do |context, name|
-    begin
-      context.const_get(name)
-    rescue NameError
-      if class_or_module == :class
-        context.const_set(name, Class.new)
-      else
-        context.const_set(name, Module.new)
-      end
-    end
-  end
-end
-
-def ensure_module(name)
-  ensure_class_or_module(name, :module)
-end
-
-def ensure_class(name)
-  ensure_class_or_module(name, :class)
-end
-
 RSpec.configure do |config|
 
   config.before do
     $raw_redis = Redis.new(db: 14)
     LineUp.config.redis = Redis::Namespace.new :myapp, redis: $raw_redis
     LineUp.config.logger = nil
-    Trouble.stub!(:notify)
   end
 
   config.after do
     $raw_redis.flushdb
     LineUp.reset!
   end
-
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: line_up
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - bukowskis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2023-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: trouble
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -66,34 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: guard-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rb-fsevent
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: No more need to maintain two separate redis connections when using namespaces.
   LineUp does not even need Resque itself.
 email: 
@@ -132,8 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Enqueue Resque Jobs directly via Redis so that you can choose the namespace