interrobang 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6095e5897bbea3cff7301fdc71e9957fb8780eab
-  data.tar.gz: d1832778b017ca518c234006241e5bbd8406e17b
+  metadata.gz: 9712141ae193c892d33886ad593382b6be6074d6
+  data.tar.gz: 0f4f1cf059e7626d5ecbfc19ec8e65e0582d1a21
 SHA512:
-  metadata.gz: 60c8312652570cad7ae79b0a0388f84b040bcd4d4cdb0bb9083d3c0283a2a9bd4991eea28f2c4d68cb5eedf3b4b157acdf6f25c93fc9f2fc94bf95a90bf1f3fe
-  data.tar.gz: 622daee4c4311256827dea66f1b6251e2f9ddc27129be4e0143e33c409b46ecb0e75eb7d2e480bdce36bceb48a7a5fb2963610e52358026486e799672a6ccd4e
+  metadata.gz: 8592a7b828d2494581650bd18d475f907411c98530bbf359204c07a2f64637d4bb888dc7009bcbb716353725d437e4674fad7778b5b5e3a67f073aaec5d024ea
+  data.tar.gz: 89518dacacc502943491ea52a5a69b812f68ac87f7a6bcedb78f943b8b17075350f305a88805dcf6f75f62cbc00671d9be929b26a051c0c2ccc9b8c17be77b92

data/.travis.yml

@@ -9,4 +9,4 @@ rvm:
   - rbx-2
 addons:
   code_climate:
-    repo_token: 240d93328887c5936b3af5aadca1900358cb12bdc227831b0577be2e9a89d817
+    repo_token: 6f4b7c1f44b29f414ffb9b243b1f83cf5fa40eb297b4cd0c7761bf960487a8eb

data/README.md

@@ -1,7 +1,9 @@
 # Interrobang :interrobang:
 
+[![Gem Version](https://badge.fury.io/rb/interrobang.svg)](http://badge.fury.io/rb/interrobang)
 [![Build Status](https://travis-ci.org/fny/interrobang.svg?branch=master)](https://travis-ci.org/fny/interrobang)
 [![Test Coverage](https://codeclimate.com/github/fny/interrobang/badges/coverage.svg)](https://codeclimate.com/github/fny/interrobang)
+[![Inline docs](http://inch-ci.org/github/fny/interrobang.svg?branch=master)](http://inch-ci.org/github/fny/interrobang)
 
 Convert your `predicate_methods?` into `bang_methods!` without abusing `method_missing`.
 
@@ -24,8 +26,12 @@ end
 `Interrobang` automagically adds corresponding bang methods for any predicate methods that end in a `?`. The bang methods explode when the predicate method returns a falsey value.
 
 ```ruby
-Interrobang.bangify(Answer)
-answer = Answer.new # => [:correct!]
+# Pick your poison...
+Interrobang(Answer) # => [:correct!]
+Interrobang.bangify(Answer) # => [:correct!]
+Interrobang.bangify_class(Answer) # => [:correct!]
+
+answer = Answer.new 
 answer.respond_to?(:correct!) # => true (no method missing shenanigans!)
 Answer.new.correct! # => Raises Interrobang::FalsePredicate if `#correct?` is false
 ```
@@ -33,7 +39,7 @@ Answer.new.correct! # => Raises Interrobang::FalsePredicate if `#correct?` is fa
 You can add prefixes and suffixes to the generated bang method.
 
 ```ruby
-Interrobang.bangify(Answer, prefix: 'ensure_', suffix: '_or_else')
+Interrobang(Answer, prefix: 'ensure_', suffix: '_or_else')
 # => [:ensure_correct_or_else!]
 Answer.new.ensure_correct_or_else!
 # => Raises Interrobang::FalsePredicate if `#correct?` is false
@@ -42,7 +48,7 @@ Answer.new.ensure_correct_or_else!
 Provide your own blocks to execute on failure. You can optionally access the symbol of the predicate method as an argument.
 
 ```ruby
-Interrobang.bangify(Answer, prefix: 'ensure_') do |predicate_method|
+Interrobang(Answer, prefix: 'ensure_') do |predicate_method|
   raise StandardError, predicate_method
 end # => [:ensure_correct!]
 Answer.new.ensure_correct! # => Raises StandardError if `#correct?` is false
@@ -51,13 +57,20 @@ Answer.new.ensure_correct! # => Raises StandardError if `#correct?` is false
 Need to convert a single method? No problem.
 
 ```ruby
-Interrobang.bangify_method(Answer, :correct?, prefix: 'ensure_', suffix: '_on_saturday') do
+# Pick your poison...
+Interrobang(Answer, :correct?) # => :correct!
+Interrobang.bangify(Answer, :correct?) # => :correct!
+Interrobang.bangify_method(Answer, :correct?) # => :correct!
+
+Interrobang(Answer, :correct?, prefix: 'ensure_', suffix: '_on_saturday') do
   if Time.now.saturday?
     raise WeekendLaziness
   else
     true
   end
 end # => :ensure_correct_on_saturday!
+
+
 ```
 
 ### Filters
@@ -65,14 +78,14 @@ end # => :ensure_correct_on_saturday!
 Perhaps you'd like to convert methods that match a different pattern?
 
 ```ruby
-Interrobang.bangify(Answer, matching: %r{\Ais_.*\z})
+Interrobang(Answer, matching: %r{\Ais_.*\z})
 # => [:is_correct!, :is_factual!, :is_right!]
 ```
 
 You can exclude methods that match the pattern with `except`.
 
 ```ruby
-Interrobang.bangify(Answer, matching: %r{\Ais_.*\z},
+Interrobang(Answer, matching: %r{\Ais_.*\z},
                               except: [:is_factual,  :is_right])
 # => [:is_correct!]
 ```
@@ -80,24 +93,24 @@ Interrobang.bangify(Answer, matching: %r{\Ais_.*\z},
 Maybe you'd like to state the methods to convert explicitly?
 
 ```ruby
-Interrobang.bangify(Answer, only: :is_correct) # => [:is_correct!]
+Interrobang(Answer, only: :is_correct) # => [:is_correct!]
 ```
 
 You can opt to include methods from parent classes, but proceed with caution...
 
 ```ruby
-Interrobang.bangify(Answer, include_super: true,  prefix: 'ensure_')
+Interrobang(Answer, include_super: true,  prefix: 'ensure_')
 # => [:ensure_correct!, :ensure_nil!, :ensure_eql!, :ensure_tainted!, :ensure_untrusted!, :ensure_frozen!, :ensure_instance_variable_defined!, :ensure_instance_of!, :ensure_kind_of!, :ensure_is_a!, :ensure_respond_to!, :ensure_equal!] 
 Answer.new.ensure_nil! # => Raises Interrobang::FalsePredicate
 ```
 
-Too lazy to type `Interrobang`? Just `extend` it. It's methods are `module_function`s!
+Too lazy to type `Interrobang` a few timews? Just `extend` it. It's methods are `module_function`s.
 
 ```ruby
 class Answer
   extend Interrobang
-  bangify self
-  bangify_method self, :is_special
+  bangify_method self, :is_correct
+  bangify_method self, :is_correct, prefix: 'ensure_'
 end
 ```
 
@@ -145,11 +158,11 @@ class Protector
     @user && (@user.is_admin || @user.id == other_user.id)
   end
 
-  Interrobang.bangify(self, prefix: 'ensure_') do |predicate_method|
+  Interrobang(self, prefix: 'ensure_') do |predicate_method|
     raise Unauthorized, "#{predicate_method} failed"
   end
 
-  Interrobang.bangify_method(self, :signed_in?, prefix: 'ensure_') do |predicate_method|
+  Interrobang(self, :signed_in?, prefix: 'ensure_') do |predicate_method|
     raise NotSignedIn, "#{predicate_method} failed"
   end
 end

data/lib/interrobang.rb

@@ -10,6 +10,24 @@ module Interrobang
 
   module_function
 
+  # Wrapper method for `bangify_class` and `bangify_method`. The appropriate
+  # method will be called depending on the method signature.
+  #
+  # Examples
+  #
+  #     Interrobang.bangify(Answer) # => [:correct!]
+  #     Interrobang.bangify(Answer, :is_correct) # => :is_correct!
+  #
+  # Returns either a Symbol or Symbol Array of bangified method names.
+  def bangify(*args, **keywords, &block)
+    klass, method = args
+    if method
+      bangify_method(klass, method, **keywords, &block)
+    else
+      bangify_class(klass, **keywords, &block)
+    end
+  end
+
   # Converts the specified predicate methods in a class to bang methods.
   #
   # klass - The Class to target for bangification
@@ -25,7 +43,7 @@ module Interrobang
   #   inlcude_super - The Boolean specifying whether to bangify parent methods
   #
   # Returns the Symbol Array of bangified method names.
-  def bangify(klass, matching: DEFAULT_PATTERN, only: [], except: [], prefix: '', suffix: '', include_super: false)
+  def bangify_class(klass, matching: DEFAULT_PATTERN, only: [], except: [], prefix: '', suffix: '', include_super: false)
     method_keys = klass.instance_methods(include_super)
     only = [only] unless only.is_a?(Array)
     except = [except] unless except.is_a?(Array)
@@ -101,3 +119,8 @@ module Interrobang
     bang_method
   end
 end
+
+# Alias for `Interrobang.bangify`
+def Interrobang(*args, &block)
+  Interrobang.bangify(*args, &block)
+end

data/lib/interrobang/version.rb

@@ -1,3 +1,3 @@
 module Interrobang
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/test/lib/predicate_bang_test.rb

@@ -17,173 +17,205 @@ def test_class
 end
 
 describe Interrobang do
-  describe '.bangify_method' do
-    describe "with a method that ends in a ?" do
-      it "adds a ! method dropping the ?" do
+  bangify_class_signatures = {
+    '#Interrobang' =>
+      -> (*args, &block) { Interrobang(*args, &block) },
+    '.bangify' =>
+      -> (*args, &block) { Interrobang.bangify(*args, &block) },
+    '.bangify_class' =>
+      -> (*args, &block) { Interrobang.bangify_class(*args, &block) }
+  }
+  bangify_class_signatures.each do |method_call, method_block|
+    describe method_call do
+      it "converts all predicate? methods by default" do
         klass = test_class
-        Interrobang.bangify_method(klass, :true?)
+        method_block.call klass
         assert klass.new.true!
+        assert klass.new.veritable!
       end
-      it "has no method missing shenanigans" do
+
+      it "returns an array of symbols of the bangified methods" do
         klass = test_class
-        Interrobang.bangify_method(klass, :true?)
-        assert klass.new.respond_to?(:true!)
+        assert_equal method_block.call(klass).sort, [:true!, :veritable!, :false!, :with_argument!].sort
       end
-    end
 
-    describe "with a method that does not end in a ?" do
-      it "adds a ! method" do
+      it "converts all methods according to the provided prefix and suffix" do
         klass = test_class
-        Interrobang.bangify_method(klass, :so_true)
+        method_block.call(klass, prefix: 'prefix_', suffix: '_suffix')
+        assert klass.new.prefix_true_suffix!
+        assert klass.new.prefix_veritable_suffix!
       end
-    end
 
-    it "returns the symbol of the bangified method" do
-      klass = test_class
-      assert_equal Interrobang.bangify_method(klass, :true?), :true!
-    end
+      it "converts all methods that match the provided pattern" do
+        klass = test_class
+        method_block.call(klass, matching: %r{\Aso_.*\z})
+        assert klass.new.so_true!
+        assert klass.new.so_very_true!
+        -> { klass.new.true! }.must_raise NoMethodError
+      end
 
-    it "works on methods with arguments" do
-      klass = test_class
-      Interrobang.bangify_method(klass, :with_argument?)
-      assert klass.new.with_argument!(true)
-      -> { klass.new.with_argument!(false) }.must_raise Interrobang::FalsePredicate
-    end
+      it "converts all methods that match the provided pattern respected except" do
+        klass = test_class
+        method_block.call(klass, matching: %r{\Aso_.*\z}, except: [:so_very_true])
+        assert klass.new.so_true!
+        -> { klass.new.so_very_true! }.must_raise NoMethodError
+        -> { klass.new.true! }.must_raise NoMethodError
+      end
 
-    it "does not convert assignment methods" do
-      klass = test_class
-      Interrobang.bangify_method klass, :assignment_=
-      -> { klass.new.assignment_! }.must_raise NoMethodError
-    end
+      it "except option accepts a singular symbol" do
+        klass = test_class
+        method_block.call(klass, matching: %r{\Aso_.*\z}, except: :so_very_true)
+        assert klass.new.so_true!
+        -> { klass.new.so_very_true! }.must_raise NoMethodError
+        -> { klass.new.true! }.must_raise NoMethodError
+      end
 
-    it "does not convert bang methods" do
-      klass = test_class
-      Interrobang.bangify_method klass, :bang!
-      assert_equal klass.new.bang!, '!'
-    end
+      it "converts only the methods specified in the only option" do
+        klass = test_class
+        method_block.call(klass, only: [:so_true])
+        assert klass.new.so_true!
+        -> { klass.new.so_very_true! }.must_raise NoMethodError
+        -> { klass.new.true! }.must_raise NoMethodError
+      end
 
-    describe "options" do
-      it "adds any provided prefix or suffix to the bang method" do
+      it "except option accepts a singular symbol" do
         klass = test_class
-        Interrobang.bangify_method(klass, :true?, prefix: 'prefix_', suffix: '_suffix')
-        assert klass.new.prefix_true_suffix!
+        method_block.call(klass, only: :so_true)
+        assert klass.new.so_true!
+        -> { klass.new.so_very_true! }.must_raise NoMethodError
+        -> { klass.new.true! }.must_raise NoMethodError
       end
-    end
 
-    describe "falsey predicates" do
-      describe "without a custom block" do
-        it "raises a FalsePredicate error" do
-          klass = test_class
-          Interrobang.bangify_method klass, :false?
-          err = -> { klass.new.false! }.must_raise Interrobang::FalsePredicate
-          assert_equal err.message, 'false? is false'
+      it "converts only the methods specified in the only option with a block" do
+        klass = test_class
+        method_block.call(klass, only: [:so_false]) do
+          raise SomeError
         end
+        -> { klass.new.so_false! }.must_raise SomeError
+        -> { klass.new.so_true! }.must_raise NoMethodError
+        -> { klass.new.true! }.must_raise NoMethodError
       end
 
-      describe "with a provided block" do
-        it "performs the provided block for the bang method" do
-          klass = test_class
-          Interrobang.bangify_method klass, :false? do
-            raise SomeError
-          end
-          -> { klass.new.false! }.must_raise SomeError
+      it "performs the provided block for the bang method" do
+        klass = test_class
+        method_block.call(klass) do
+          raise SomeError
         end
+        assert klass.new.true!
+        -> { klass.new.false! }.must_raise SomeError
+      end
 
-        it "allows the provided block to take the predicate method as an argument" do
-          klass = test_class
-          Interrobang.bangify_method klass, :false? do |predicate_method|
-            raise SomeError, "#{predicate_method} isn't true"
-          end
-          err = -> { klass.new.false! }.must_raise SomeError
-          assert_equal err.message, "false? isn't true"
-        end
+      it "converts super methods when specified" do
+        klass = test_class
+        method_block.call(klass, include_super: true, prefix: 'ensure_')
+        -> { klass.new.ensure_nil! }.must_raise Interrobang::FalsePredicate
       end
     end
   end
 
-  describe '.bangify' do
-    it "converts all predicate? methods by default" do
-      klass = test_class
-      Interrobang.bangify klass
-      assert klass.new.true!
-      assert klass.new.veritable!
-    end
+  bangify_method_signatures = {
+    '#Interrobang' =>
+      -> (*args, &block) { Interrobang(*args, &block) },
+    '.bangify' =>
+      -> (*args, &block) { Interrobang.bangify(*args, &block) },
+    '.bangify_method' =>
+      -> (*args, &block) { Interrobang.bangify_method(*args, &block) }
+  }
+  bangify_method_signatures.each do |method_call, method_block|
+    describe method_call do
+      describe "with a method that ends in a ?" do
+        it "adds a ! method dropping the ?" do
+          klass = test_class
+          method_block.call(klass, :true?)
+          assert klass.new.true!
+        end
+        it "has no method missing shenanigans" do
+          klass = test_class
+          method_block.call(klass, :true?)
+          assert klass.new.respond_to?(:true!)
+        end
+      end
 
-    it "returns an array of symbols of the bangified methods" do
-      klass = test_class
-      assert_equal Interrobang.bangify(klass), [:true!, :veritable!, :false!, :with_argument!]
-    end
+      describe "with a method that does not end in a ?" do
+        it "adds a ! method" do
+          klass = test_class
+          method_block.call(klass, :so_true)
+        end
+      end
 
-    it "converts all methods according to the provided prefix and suffix" do
-      klass = test_class
-      Interrobang.bangify klass, prefix: 'prefix_', suffix: '_suffix'
-      assert klass.new.prefix_true_suffix!
-      assert klass.new.prefix_veritable_suffix!
-    end
+      it "returns the symbol of the bangified method" do
+        klass = test_class
+        assert_equal method_block.call(klass, :true?), :true!
+      end
 
-    it "converts all methods that match the provided pattern" do
-      klass = test_class
-      Interrobang.bangify klass, matching: %r{\Aso_.*\z}
-      assert klass.new.so_true!
-      assert klass.new.so_very_true!
-      -> { klass.new.true! }.must_raise NoMethodError
-    end
+      it "works on methods with arguments" do
+        klass = test_class
+        method_block.call(klass, :with_argument?)
+        assert klass.new.with_argument!(true)
+        -> { klass.new.with_argument!(false) }.must_raise Interrobang::FalsePredicate
+      end
 
-    it "converts all methods that match the provided pattern respected except" do
-      klass = test_class
-      Interrobang.bangify klass, matching: %r{\Aso_.*\z}, except: [:so_very_true]
-      assert klass.new.so_true!
-      -> { klass.new.so_very_true! }.must_raise NoMethodError
-      -> { klass.new.true! }.must_raise NoMethodError
-    end
+      it "does not convert assignment methods" do
+        klass = test_class
+        method_block.call(klass, :assignment_=)
+        -> { klass.new.assignment_! }.must_raise NoMethodError
+      end
 
-    it "except option accepts a singular symbol" do
-      klass = test_class
-      Interrobang.bangify klass, matching: %r{\Aso_.*\z}, except: :so_very_true
-      assert klass.new.so_true!
-      -> { klass.new.so_very_true! }.must_raise NoMethodError
-      -> { klass.new.true! }.must_raise NoMethodError
-    end
+      it "does not convert bang methods" do
+        klass = test_class
+        method_block.call(klass, :bang!)
+        assert_equal klass.new.bang!, '!'
+      end
 
-    it "converts only the methods specified in the only option" do
-      klass = test_class
-      Interrobang.bangify klass, only: [:so_true]
-      assert klass.new.so_true!
-      -> { klass.new.so_very_true! }.must_raise NoMethodError
-      -> { klass.new.true! }.must_raise NoMethodError
-    end
+      describe "options" do
+        it "adds any provided prefix or suffix to the bang method" do
+          klass = test_class
+          method_block.call(klass, :true?, prefix: 'prefix_', suffix: '_suffix')
+          assert klass.new.prefix_true_suffix!
+        end
+      end
 
-    it "except option accepts a singular symbol" do
-      klass = test_class
-      Interrobang.bangify klass, only: :so_true
-      assert klass.new.so_true!
-      -> { klass.new.so_very_true! }.must_raise NoMethodError
-      -> { klass.new.true! }.must_raise NoMethodError
-    end
+      describe "falsey predicates" do
+        describe "without a custom block" do
+          it "raises a FalsePredicate error" do
+            klass = test_class
+            method_block.call(klass, :false?)
+            err = -> { klass.new.false! }.must_raise Interrobang::FalsePredicate
+            assert_equal err.message, 'false? is false'
+          end
+        end
 
-    it "converts only the methods specified in the only option with a block" do
-      klass = test_class
-      Interrobang.bangify klass, only: [:so_false] do
-        raise SomeError
-      end
-      -> { klass.new.so_false! }.must_raise SomeError
-      -> { klass.new.so_true! }.must_raise NoMethodError
-      -> { klass.new.true! }.must_raise NoMethodError
-    end
+        describe "with a provided block" do
+          it "performs the provided block for the bang method" do
+            klass = test_class
+            method_block.call(klass, :false?) do
+              raise SomeError
+            end
+            -> { klass.new.false! }.must_raise SomeError
+          end
 
-    it "performs the provided block for the bang method" do
-      klass = test_class
-      Interrobang.bangify klass do
-        raise SomeError
+          it "allows the provided block to take the predicate method as an argument" do
+            klass = test_class
+            method_block.call(klass, :false?) do |predicate_method|
+              raise SomeError, "#{predicate_method} isn't true"
+            end
+            err = -> { klass.new.false! }.must_raise SomeError
+            assert_equal err.message, "false? isn't true"
+          end
+        end
       end
-      assert klass.new.true!
-      -> { klass.new.false! }.must_raise SomeError
     end
+  end
 
-    it "converts super methods when specified" do
-      klass = test_class
-      Interrobang.bangify klass, include_super: true, prefix: 'ensure_'
-      -> { klass.new.ensure_nil! }.must_raise Interrobang::FalsePredicate
+  it "is extendable" do
+    class Answer
+      extend Interrobang
+      def correct?; end
+      bangify(self)
+      bangify_class(self)
+      bangify_method(self, :correct?)
     end
+    -> { Answer.new.correct! }.must_raise(Interrobang::FalsePredicate)
   end
-end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: interrobang
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Faraz Yashar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-27 00:00:00.000000000 Z
+date: 2015-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler