interrobang 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6095e5897bbea3cff7301fdc71e9957fb8780eab
+  data.tar.gz: d1832778b017ca518c234006241e5bbd8406e17b
+SHA512:
+  metadata.gz: 60c8312652570cad7ae79b0a0388f84b040bcd4d4cdb0bb9083d3c0283a2a9bd4991eea28f2c4d68cb5eedf3b4b157acdf6f25c93fc9f2fc94bf95a90bf1f3fe
+  data.tar.gz: 622daee4c4311256827dea66f1b6251e2f9ddc27129be4e0143e33c409b46ecb0e75eb7d2e480bdce36bceb48a7a5fb2963610e52358026486e799672a6ccd4e

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+script: bundle exec rake test
+rvm:
+  - 2.2
+  - 2.1
+  - 2.0.0
+  - ruby-head
+  - jruby-head
+  - rbx-2
+addons:
+  code_climate:
+    repo_token: 240d93328887c5936b3af5aadca1900358cb12bdc227831b0577be2e9a89d817

data/.yardopts

@@ -0,0 +1,6 @@
+--readme README.md
+--plugin tomdoc
+lib
+-
+*.md
+*.txt

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in interrobang.gemspec
+gemspec
+
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Faraz Yashar
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,266 @@
+# Interrobang :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)
+
+Convert your `predicate_methods?` into `bang_methods!` without abusing `method_missing`.
+
+`Interrobang` currently only works with Ruby versions that support keyword arguments.
+
+## Overview
+
+Say we have the following class:
+
+```ruby
+class Answer
+  # Say these return a boolean.
+  def correct?; end
+  def is_correct; end
+  def is_factual; end
+  def is_right; end
+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!]
+answer.respond_to?(:correct!) # => true (no method missing shenanigans!)
+Answer.new.correct! # => Raises Interrobang::FalsePredicate if `#correct?` is false
+```
+
+You can add prefixes and suffixes to the generated bang method.
+
+```ruby
+Interrobang.bangify(Answer, prefix: 'ensure_', suffix: '_or_else')
+# => [:ensure_correct_or_else!]
+Answer.new.ensure_correct_or_else!
+# => Raises Interrobang::FalsePredicate if `#correct?` is false
+```
+
+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|
+  raise StandardError, predicate_method
+end # => [:ensure_correct!]
+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
+  if Time.now.saturday?
+    raise WeekendLaziness
+  else
+    true
+  end
+end # => :ensure_correct_on_saturday!
+```
+
+### Filters
+
+Perhaps you'd like to convert methods that match a different pattern?
+
+```ruby
+Interrobang.bangify(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},
+                              except: [:is_factual,  :is_right])
+# => [:is_correct!]
+```
+
+Maybe you'd like to state the methods to convert explicitly?
+
+```ruby
+Interrobang.bangify(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_')
+# => [: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!
+
+```ruby
+class Answer
+  extend Interrobang
+  bangify self
+  bangify_method self, :is_special
+end
+```
+
+See `lib/interrobang.rb` for complete documentation and the tests for details.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'interrobang'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install interrobang
+
+
+## Example Use Case with Rails
+
+`Interrobang` works wonderfully with permission-related objects. Say we have a bangified `Protector` class that defines user permissions in our application:
+
+```ruby
+class Protector
+  NotSignedIn = Class.new(Exception)
+  Unauthorized = Class.new(Exception)
+
+  def initialize(user)
+    @user = user
+  end
+
+  def signed_in?
+    @user.is_a?(User)
+  end
+
+  def admin?
+    @user && @user.is_admin
+  end
+
+  def can_edit_user?(other_user)
+    @user && (@user.is_admin || @user.id == other_user.id)
+  end
+
+  Interrobang.bangify(self, prefix: 'ensure_') do |predicate_method|
+    raise Unauthorized, "#{predicate_method} failed"
+  end
+
+  Interrobang.bangify_method(self, :signed_in?, prefix: 'ensure_') do |predicate_method|
+    raise NotSignedIn, "#{predicate_method} failed"
+  end
+end
+```
+
+In our controller, we can then define rescue handlers for the those exceptions, and add a method to access a `Protector` instance.
+
+```ruby
+class ApplicationController < ActionController::Base
+  def protector
+    @protector ||= Protector.new(current_user)
+  end
+
+  rescue_from Protector::NotSignedIn do
+    redirect_to sign_in_path, alert: "Please sign in to continue."
+  end
+
+  rescue_from Protector::Unauthorized do
+    # Handle as you will
+  end
+end
+```
+
+Now we can call `protector.ensure_signed_in!`, `protector.ensure_admin!`, `protector.ensure_can_edit!(other_user)!` from any controller and trigger the errors defined with `Interrobang`.
+
+### Aside: Testing Tricks with Rescue Handlers
+
+For tests, we can stub the rescue handlers with methods that expose the original errors so we can check for them directly.
+
+```ruby
+# spec/support/helpers.rb
+def raise_handled_rescues(controller = ApplicationController)
+  stubbed_handlers = controller.rescue_handlers.map { |rescue_handler|
+    name, proc = rescue_handler
+    [ name, -> { raise Kernel.const_get(name) } ]
+  }
+  allow(controller).to receive(:rescue_handlers).and_return(stubbed_handlers)
+end
+```
+
+This allows us to test that proper errors are being raised independently from testing each error's particular handling.
+
+```ruby
+# spec/controllers/users_controller_spec.rb
+RSpec.describe UsersController, type: :controller do
+  before { raise_handled_rescues }
+  after { reset_handled_rescues }
+  describe "GET index" do
+    context "unauthenticated user" do
+      it "raises Protector::NotSignedIn" do
+        expect { get :index }.to raise_error(Protector::NotSignedIn)
+      end
+    end
+  end
+end
+
+# spec/controllers/application_controller_spec.rb
+RSpec.describe ApplicationController, type: :controller do
+  describe "Protector::NotSignedIn rescue handler" do
+    controller { def index; raise Protector::NotSignedIn; end }
+    it "redirects to the sign in page" do
+      get :index
+      expect(response).to redirect_to sign_in_path
+    end
+  end
+end
+```
+
+## What are these predicate methods and bang methods?
+
+**Predicate methods** return a Boolean. By Ruby convention, these methods typically end in a `?`. Other languages like [Scheme][scheme-conventions], [C#][csharp-predicates], [Java][java-predicates], support this interface too.
+
+**Bang methods** are "dangerous" or modify the receiver. By convention, these methods typically end with a `!`. In the case of `Interrobang`, these methods are considered "dangerous" because they may raise an exception.
+
+### Fun Fact
+
+The Ruby conventions for `?` and `!`  are borrowed from [Scheme][scheme-conventions]:
+
+> 1.3.5  Naming conventions
+>
+>
+> By convention, the names of procedures that always return a boolean value usually end in ``?''. Such procedures are called predicates.
+>
+> By convention, the names of procedures that store values into previously
+> allocated locations (see section 3.4) usually end in ``!''. Such procedures
+> are called mutation procedures. By convention, the value returned by a 
+> mutation procedure is unspecified.
+
+## Development
+
+Be sure to test all the things. Just `rake test`. You can use `bundle console` to play with things in an IRB session.
+
+## Contributing
+
+1. Fork it ( https://github.com/fny/interrobang/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Special Thanks To...
+
+ - [Discourse][discourse] for inspiring me to find a `method_missing`-free alternative to its [EnsureMagic][discourse-ensure]
+ - [Michael Josephson][josephson] for [pointing me in the right direction][so-question]
+ - To all [contributers][github-contributers]! :beers:
+
+[csharp-predicates]: https://msdn.microsoft.com/en-us/library/bfcke1bz%28v=vs.110%29.aspx "Predicate<T> Delegate"
+[java-predicates]: https://docs.oracle.com/javase/8/docs/api/java/util/function/Predicate.html "Interface Predicate<T>"
+[scheme-conventions]: http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-4.html#%_sec_1.3.5 "Scheme Naming Conventions"
+[discourse]: http://discourse.org "Discourse"
+[discourse-ensure]: https://github.com/discourse/discourse/blob/ba0084edee8ace004855b987e1661a7eaff60122/lib/guardian/ensure_magic.rb "module EnsureMagic"
+[josephson]: http://www.josephson.org/ "Michael Josephson"
+[so-question]: http://stackoverflow.com/questions/28818193/define-method-based-on-existing-method-in-ruby "Define Method Based on Existing Method in Ruby - Stack Overflow"
+[github-contributers]: https://github.com/fny/interrobang/graphs/contributors "Predicate Bang Contributers - GitHub"

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib/interrobang'
+  t.test_files = FileList['test/lib/**/*_test.rb']
+  t.verbose = true
+end

data/interrobang.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'interrobang/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'interrobang'
+  spec.version       = Interrobang::VERSION
+  spec.authors       = ["Faraz Yashar"]
+  spec.email         = ["faraz.yashar@gmail.com"]
+  spec.summary       = "Convert your predicate_methods? into bang_methods! without
+abusing method_missing"
+  spec.description   = "Convert your predicate_methods? into bang_methods! without
+abusing method_missing."
+  spec.homepage      = 'https://github.com/fny/interrobang'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.5'
+
+  spec.required_ruby_version = '>= 2.0.0'
+end

data/lib/interrobang.rb

@@ -0,0 +1,103 @@
+require 'interrobang/version'
+
+# Convert your `#predicate_methods?` to `#bang_methods!`
+module Interrobang
+  # Exception to raise when no block is provided for bangified falsey methods
+  FalsePredicate = Class.new(Exception)
+
+  # Regexp that matches methods that end in question marks.
+  DEFAULT_PATTERN = %r{\A[^?]+\?\z}
+
+  module_function
+
+  # Converts the specified predicate methods in a class to bang methods.
+  #
+  # klass - The Class to target for bangification
+  # block - An optional block to run if a predicate method returns something falsey
+  #
+  # Options
+  #
+  #   matching - The Regexp used to match methods that should be bangified; defaults to DEFAULT_PATTERN
+  #   only - The Symbol or Symbol Array of methods to bangify exclusively
+  #   except - The Symbol or Symbol Array of methods to ignore when pattern matching
+  #   prefix - The String prefix to add to front of the bangified method
+  #   suffix - The String suffix to add to end of the bangified method
+  #   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)
+    method_keys = klass.instance_methods(include_super)
+    only = [only] unless only.is_a?(Array)
+    except = [except] unless except.is_a?(Array)
+    if only.empty?
+      method_keys.map do |method_key|
+        if method_key.to_s =~ matching && !except.include?(method_key)
+          if block_given?
+            bangify_method(klass, method_key, prefix: prefix, suffix: suffix, &Proc.new)
+          else
+            bangify_method(klass, method_key, prefix: prefix, suffix: suffix)
+          end
+        end
+      end.compact
+    else
+      method_keys.map do |method_key|
+        if only.include?(method_key)
+          if block_given?
+            bangify_method(klass, method_key, prefix: prefix, suffix: suffix, &Proc.new)
+          else
+            bangify_method(klass, method_key, prefix: prefix, suffix: suffix)
+          end
+        end
+      end.compact
+    end
+  end
+
+  # Converts the specified predicate method to a bang method.
+  #
+  # klass - The Class to target for bangification
+  # predicate_method - The Symbol of the predicate method
+  # block - An optional block to run if a predicate method returns something falsey
+  #
+  # Options
+  #
+  #   matching - The Regexp used to match methods that should be bangified
+  #   prefix - The String prefix to add to front of the bangified method
+  #   suffix - The String suffix to add to end of the bangified method
+  #
+  # Returns the Symbol name of the bang method created.
+  def bangify_method(klass, predicate_method, prefix: '', suffix: '')
+    predicate_method_string = predicate_method.to_s
+    method_name_base =
+      case predicate_method_string[-1]
+      when '=', '!'
+        return
+      when '?'
+        predicate_method.to_s[0..-2]
+      else
+        predicate_method.to_s
+      end
+
+    bang_method = :"#{prefix}#{method_name_base}#{suffix}!"
+
+    klass.class_eval do
+      if block_given?
+        define_method(bang_method) do |*args, &block|
+          if send(predicate_method, *args, &block)
+            true
+          else
+            yield(predicate_method)
+          end
+        end
+      else
+        define_method(bang_method) do |*args, &block|
+          if send(predicate_method, *args, &block)
+            true
+          else
+            raise(Interrobang::FalsePredicate, "#{predicate_method} is false")
+          end
+        end
+      end
+    end
+    bang_method
+  end
+end

data/lib/interrobang/version.rb

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

data/test/lib/predicate_bang_test.rb

@@ -0,0 +1,189 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+SomeError = Class.new(Exception)
+
+def test_class
+  Class.new {
+    def true?; true; end
+    def veritable?; true; end
+    def so_true; true; end
+    def so_very_true; true; end
+    def false?; false; end
+    def so_false; false; end
+    def assignment=; end
+    def bang!; '!'; end
+    def with_argument?(bool); bool; end
+  }
+end
+
+describe Interrobang do
+  describe '.bangify_method' do
+    describe "with a method that ends in a ?" do
+      it "adds a ! method dropping the ?" do
+        klass = test_class
+        Interrobang.bangify_method(klass, :true?)
+        assert klass.new.true!
+      end
+      it "has no method missing shenanigans" do
+        klass = test_class
+        Interrobang.bangify_method(klass, :true?)
+        assert klass.new.respond_to?(:true!)
+      end
+    end
+
+    describe "with a method that does not end in a ?" do
+      it "adds a ! method" do
+        klass = test_class
+        Interrobang.bangify_method(klass, :so_true)
+      end
+    end
+
+    it "returns the symbol of the bangified method" do
+      klass = test_class
+      assert_equal Interrobang.bangify_method(klass, :true?), :true!
+    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 "does not convert assignment methods" do
+      klass = test_class
+      Interrobang.bangify_method klass, :assignment_=
+      -> { klass.new.assignment_! }.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
+
+    describe "options" do
+      it "adds any provided prefix or suffix to the bang method" do
+        klass = test_class
+        Interrobang.bangify_method(klass, :true?, prefix: 'prefix_', suffix: '_suffix')
+        assert klass.new.prefix_true_suffix!
+      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'
+        end
+      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
+        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
+      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
+
+    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
+
+    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 "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 "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 "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 "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
+
+    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
+
+    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
+
+    it "performs the provided block for the bang method" do
+      klass = test_class
+      Interrobang.bangify klass do
+        raise SomeError
+      end
+      assert klass.new.true!
+      -> { klass.new.false! }.must_raise SomeError
+    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
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require File.expand_path('../../lib/interrobang', __FILE__)

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: interrobang
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Faraz Yashar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+description: |-
+  Convert your predicate_methods? into bang_methods! without
+  abusing method_missing.
+email:
+- faraz.yashar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- interrobang.gemspec
+- lib/interrobang.rb
+- lib/interrobang/version.rb
+- test/lib/predicate_bang_test.rb
+- test/test_helper.rb
+homepage: https://github.com/fny/interrobang
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Convert your predicate_methods? into bang_methods! without abusing method_missing
+test_files:
+- test/lib/predicate_bang_test.rb
+- test/test_helper.rb
+has_rdoc: