Making rubocop happy (sort of)

adamruzicka · adamruzicka · commit 8fa3f05f5dfd · 2014-12-11T21:45:50.000+01:00
diff --git a/lib/concurrent/atomic/semaphore.rb b/lib/concurrent/atomic/semaphore.rb
@@ -1,9 +1,7 @@
 require 'concurrent/atomic/condition'
 
 module Concurrent
-
   class MutexSemaphore
-
     # @!macro [attach] semaphore_method_initialize
     #
     #   Create a new `Semaphore` with the initial `count`.
@@ -13,7 +11,7 @@ class MutexSemaphore
     #   @raise [ArgumentError] if `count` is not an integer or is less than zero
     def initialize(count)
       unless count.is_a?(Fixnum) && count >= 0
-        raise ArgumentError.new('count must be an non-negative integer')
+        fail ArgumentError, 'count must be an non-negative integer'
       end
       @mutex = Mutex.new
       @condition = Condition.new
@@ -22,16 +20,18 @@ def initialize(count)
 
     # @!macro [attach] semaphore_method_acquire
     #
-    #   Acquires the given number of permits from this semaphore, blocking until all are available.
+    #   Acquires the given number of permits from this semaphore,
+    #     blocking until all are available.
     #
     #   @param [Fixnum] permits Number of permits to acquire
     #
-    #   @raise [ArgumentError] if `permits` is not an integer or is less than one
+    #   @raise [ArgumentError] if `permits` is not an integer or is less than
+    #     one
     #
     #   @return [True]
     def acquire(permits = 1)
       unless permits.is_a?(Fixnum) && permits > 0
-        raise ArgumentError.new('permits must be an integer greater than zero')
+        fail ArgumentError, 'permits must be an integer greater than zero'
       end
       @mutex.synchronize do
         try_acquire_timed(permits, nil)
@@ -60,19 +60,23 @@ def drain_permits
 
     # @!macro [attach] semaphore_method_try_acquire
     #
-    #   Acquires the given number of permits from this semaphore, only if all are available at the time of invocation.
+    #   Acquires the given number of permits from this semaphore,
+    #     only if all are available at the time of invocation or within
+    #     `timeout` interval
     #
     #   @param [Fixnum] permits the number of permits to acquire
     #
-    #   @param [Fixnum] timeout the number of seconds to wait for the counter or `nil`
-    #     to return immediately
+    #   @param [Fixnum] timeout the number of seconds to wait for the counter
+    #     or `nil` to return immediately
     #
-    #   @raise [ArgumentError] if `permits` is not an integer or is less than one
+    #   @raise [ArgumentError] if `permits` is not an integer or is less than
+    #     one
     #
-    #   @return [Boolean] `false` if no permits are available, `true` when acquired a permit
+    #   @return [Boolean] `false` if no permits are available, `true` when
+    #     acquired a permit
     def try_acquire(permits = 1, timeout = nil)
       unless permits.is_a?(Fixnum) && permits > 0
-        raise ArgumentError.new('permits must be an integer greater than zero')
+        fail ArgumentError, 'permits must be an integer greater than zero'
       end
       @mutex.synchronize do
         if timeout.nil?
@@ -94,7 +98,7 @@ def try_acquire(permits = 1, timeout = nil)
     #   @return [True]
     def release(permits = 1)
       unless permits.is_a?(Fixnum) && permits > 0
-        raise ArgumentError.new('permits must be an integer greater than zero')
+        fail ArgumentError, 'permits must be an integer greater than zero'
       end
       @mutex.synchronize do
         @free += permits
@@ -116,14 +120,13 @@ def release(permits = 1)
     #   @return [True]
     def reduce_permits(reduction)
       unless reduction.is_a?(Fixnum) && reduction >= 0
-        raise ArgumentError.new('reduction must be an non-negative integer')
+        fail ArgumentError, 'reduction must be an non-negative integer'
       end
       unless @free - reduction >= 0
-        raise ArgumentError.new('cannot reduce number of available_permits below zero')
-      end
-      @mutex.synchronize do
-        @free -= reduction
+        fail(ArgumentError,
+             'cannot reduce number of available_permits below zero')
       end
+      @mutex.synchronize { @free -= reduction }
       true
     end
 
@@ -150,116 +153,78 @@ def try_acquire_timed(permits, timeout)
 
   if RUBY_PLATFORM == 'java'
 
-    # @!macro count_down_latch
+    # @!macro semaphore
     class JavaSemaphore
-
-      # @!macro count_down_latch_method_initialize
+      # @!macro semaphore_method_initialize
       def initialize(count)
         unless count.is_a?(Fixnum) && count >= 0
-          raise ArgumentError.new('count must be in integer greater than or equal zero')
+          fail(ArgumentError,
+               'count must be in integer greater than or equal zero')
         end
         @semaphore = java.util.concurrent.Semaphore.new(count)
       end
 
+      # @!macro semaphore_method_acquire
       def acquire(permits = 1)
         unless permits.is_a?(Fixnum) && permits > 0
-          raise ArgumentError.new('permits must be an integer greater than zero')
+          fail ArgumentError, 'permits must be an integer greater than zero'
         end
-        @semaphore.acquire(permits);
+        @semaphore.acquire(permits)
       end
 
-
-    # @!macro [attach] semaphore_method_available_permits
-    #
-    #   Returns the current number of permits available in this semaphore.
-    #
-    #   @return [Integer]
-    def available_permits
-      @semaphore.availablePermits
-    end
-
-    # @!macro [attach] semaphore_method_drain_permits
-    #
-    #   Acquires and returns all permits that are immediately available.
-    #
-    #   @return [Integer]
-    def drain_permits
-      @semaphore.drainPermits
-    end
-
-    # @!macro [attach] semaphore_method_try_acquire
-    #
-    #   Acquires the given number of permits from this semaphore, only if all are available at the time of invocation.
-    #
-    #   @param [Fixnum] permits the number of permits to acquire
-    #
-    #   @param [Fixnum] timeout the number of seconds to wait for the counter or `nil`
-    #     to return immediately
-    #
-    #   @raise [ArgumentError] if `permits` is not an integer or is less than one
-    #
-    #   @return [Boolean] `false` if no permits are available, `true` when acquired a permit
-    def try_acquire(permits = 1, timeout = nil)
-      unless permits.is_a?(Fixnum) && permits > 0
-        raise ArgumentError.new('permits must be an integer greater than zero')
+      # @!macro semaphore_method_available_permits
+      def available_permits
+        @semaphore.availablePermits
       end
-      if timeout.nil?
-        @semaphore.try_acquire(permits)
-      else
-        @semaphore.try_acquire(permits, timeout, java.util.concurrent.TimeUnit::SECONDS)
-      end
-    end
 
-    # @!macro [attach] semaphore_method_release
-    #
-    #   Releases the given number of permits, returning them to the semaphore.
-    #
-    #   @param [Fixnum] permits Number of permits to return to the semaphore.
-    #
-    #   @raise [ArgumentError] if `permits` is not a number or is less than one
-    #
-    #   @raise [ArgumentError] if `permits` + `@free` is larger than `@count`
-    #
-    #   @return [True]
-    def release(permits = 1)
-      unless permits.is_a?(Fixnum) && permits > 0
-        raise ArgumentError.new('permits must be an integer greater than zero')
+      # @!macro semaphore_method_drain_permits
+      def drain_permits
+        @semaphore.drainPermits
       end
-      @semaphore.release(permits)
-      true
-    end
 
-    # @!macro [attach] semaphore_method_reduce_permits
-    #
-    #   Shrinks the number of available permits by the indicated reduction.
-    #
-    #   @param [Fixnum] reduction Number of permits to remove.
-    #
-    #   @raise [ArgumentError] if `reduction` is not an integer or is negative
-    #
-    #   @raise [ArgumentError] if the operation would bring `@free` below zero
-    #
-    #   @return [True]
-    def reduce_permits(reduction)
-      unless reduction.is_a?(Fixnum) && reduction >= 0
-        raise ArgumentError.new('reduction must be an non-negative integer')
-      end
-      unless @free - reduction >= 0
-        raise ArgumentError.new('cannot reduce number of available_permits below zero')
+      # @!macro semaphore_method_try_acquire
+      def try_acquire(permits = 1, timeout = nil)
+        unless permits.is_a?(Fixnum) && permits > 0
+          fail ArgumentError, 'permits must be an integer greater than zero'
+        end
+        if timeout.nil?
+          @semaphore.try_acquire(permits)
+        else
+          @semaphore.try_acquire(permits,
+                                 timeout,
+                                 java.util.concurrent.TimeUnit::SECONDS)
+        end
       end
-      @semaphore.reducePermits(void)
-    end
 
+      # @!macro semaphore_method_release
+      def release(permits = 1)
+        unless permits.is_a?(Fixnum) && permits > 0
+          fail ArgumentError, 'permits must be an integer greater than zero'
+        end
+        @semaphore.release(permits)
+        true
+      end
 
+      # @!macro semaphore_method_reduce_permits
+      def reduce_permits(reduction)
+        unless reduction.is_a?(Fixnum) && reduction >= 0
+          fail ArgumentError, 'reduction must be an non-negative integer'
+        end
+        unless @free - reduction >= 0
+          fail(ArgumentError,
+               'cannot reduce number of available_permits below zero')
+        end
+        @semaphore.reducePermits(void)
+      end
     end
 
-    # @!macro count_down_latch
+    # @!macro semaphore
     class Semaphore < JavaSemaphore
     end
 
   else
 
-    # @!macro count_down_latch
+    # @!macro semaphore
     class Semaphore < MutexSemaphore
     end
   end
diff --git a/spec/concurrent/atomic/semaphore_spec.rb b/spec/concurrent/atomic/semaphore_spec.rb
@@ -1,11 +1,9 @@
 require 'spec_helper'
 
 shared_examples :semaphore do
-
   let(:semaphore) { described_class.new(3) }
 
   context '#initialize' do
-
     it 'raises an exception if the initial count is not an integer' do
       expect {
         described_class.new('foo')
@@ -14,7 +12,6 @@
   end
 
   describe '#acquire' do
-
     context 'permits available' do
       it 'should return true immediately' do
         result = semaphore.acquire
@@ -23,10 +20,9 @@
     end
 
     context 'not enough permits available' do
-
       it 'should block thread until permits are available' do
         semaphore.drain_permits
-        Thread.new { sleep(0.2); semaphore.release }
+        Thread.new { sleep(0.2) && semaphore.release }
 
         result = semaphore.acquire
         expect(result).to be_truthy
@@ -69,8 +65,8 @@
       end
 
       it 'acquires after if permits are available within timeout' do
-        x = semaphore.drain_permits
-        Thread.new { sleep 0.1; semaphore.release }
+        semaphore.drain_permits
+        Thread.new { sleep 0.1 && semaphore.release }
         result = semaphore.try_acquire(1, 0.2)
         expect(result).to be_truthy
       end
@@ -86,7 +82,7 @@
   describe '#reduce_permits' do
     it 'raises ArgumentError if reducing by negative number' do
       expect {
-        semaphore.reduce_permits -1
+        semaphore.reduce_permits(-1)
       }.to raise_error(ArgumentError)
     end
 
@@ -106,13 +102,10 @@
 end
 
 module Concurrent
-
   describe MutexSemaphore do
-
     it_should_behave_like :semaphore
 
     context 'spurious wake ups' do
-
       subject { described_class.new(1) }
 
       before(:each) do
@@ -127,7 +120,8 @@ def subject.simulate_spurious_wake_up
 
       it 'should resist to spurious wake ups without timeout' do
         @expected = true
-        Thread.new { @expected = subject.acquire } # would set @expected to false
+        # would set @expected to false
+        Thread.new { @expected = subject.acquire }
 
         sleep(0.1)
         subject.simulate_spurious_wake_up
@@ -138,24 +132,23 @@ def subject.simulate_spurious_wake_up
 
       it 'should resist to spurious wake ups with timeout' do
         @expected = true
-        t = Thread.new { @expected = subject.try_acquire(1, 0.3) } # sets @expected to false
+        # sets @expected to false in another thread
+        t = Thread.new { @expected = subject.try_acquire(1, 0.3) }
 
         sleep(0.1)
         subject.simulate_spurious_wake_up
 
         sleep(0.1)
         expect(@expected).to be_truthy
 
-        t.join()
+        t.join
         expect(@expected).to be_falsey
       end
     end
   end
 
   if TestHelpers.jruby?
-
     describe JavaSemaphore do
-
       it_should_behave_like :semaphore
     end
   end
