toe_tag 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ae4f2a77f06e19c9bf9aeebe69c27e70ea8aa65
+  data.tar.gz: 9f30f1da5507beed2d04a2b1e57091843f3ab443
+SHA512:
+  metadata.gz: 68e0d402a1ab16aa5c5d7e167f55b822947e82d9a91894c15433a1c74228a841a667b84e2e05e455d93664f9705bb5b92f274f56d511e648526bde96fc398830
+  data.tar.gz: 0833f0010a6ccbd1398f2f19b65011746272dfd3e2de6ad10ce2c561254c2e0fd8ffe198578fbc04e01669bb17f0315faba26afd1569d80f25c5051815585747

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.0
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+  - 1.8.7

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2014 CrowdCompass
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,76 @@
+[![Build Status](https://travis-ci.org/crowdcompass/toe_tag.svg?branch=master)](https://travis-ci.org/crowdcompass/toe_tag)
+
+# `toe_tag`
+
+Ruby's default exception handling is strictly based on module and class inheritance. `toe_tag` provides
+additional utilities for creating your own exception groups, narrowing exceptions based on message, and
+executing arbitrary blocks to determine whether an exception should be caught -- all within the familiar
+rescue syntax.
+
+## Usage
+
+    require 'toe_tag'
+
+    # Exception grouping:
+    # Note that not all of the constants have to be defined. Missing ones will be ignored.
+    DatabaseError = ToeTag.category %w[ActiveRecord::JDBCError PG::Error ActiveRecord::StatementInvalid]
+
+    begin
+      leaky_database_call
+    rescue DatabaseError => err
+      # err could be any of the listed classes
+    end
+
+    # Filtering by message:
+    SpuriousError = DatabaseError.with_message(/spurious|pointless|meaningless/)
+
+    begin
+      boring_database_call # ! raises PG::Error, "something spurious happened"
+    rescue SpuriousError
+      log "something spurious happened, ignore it"
+    rescue DatabaseError
+      log "watch out, something bad happened"
+    end
+
+    # Filtering by proc
+    class FancyError
+      attr_reader :error_code
+
+      def initialize(message, error_code)
+        super message
+        @error_code = error_code
+      end
+    end
+
+    FancierError = FancyError.with_proc{|e| e.error_code = 123 }
+
+    begin
+      fancy_api_call
+    rescue FancierError
+      log "it's one of those 123 errors again"
+    rescue FancyError
+      log "some unknown error, reraising"
+      raise
+    end
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'toe_tag'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install toe_tag
+
+## Contributing
+
+1. Fork it.
+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. Submit a pull request.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/toe_tag/version.rb

@@ -0,0 +1,3 @@
+module ToeTag
+  VERSION = "1.0.1"
+end

data/lib/toe_tag.rb

@@ -0,0 +1,157 @@
+require "toe_tag/version"
+
+module ToeTag
+
+  module Util
+    def self.try_constantize(name)
+      if RUBY_VERSION >= "2.0.0"
+        Object.const_get name
+      else
+        eval name
+      end
+    rescue NameError
+      # const doesn't exist, just return nil
+    end
+  end
+
+  module ExceptionBehavior
+    def with_message(message)
+      MessageSpec.new(message, self)
+    end
+  end
+
+  class ExceptionSpec < Module
+    include ExceptionBehavior
+  end
+
+  # Aggregates multiple exception classes into one single logical type. Intended
+  # to be used in rescue clauses, for cases where different underlying implementations
+  # may bubble up different exceptions meaning the same thing.
+  #
+  # The recommended usage is to assign these to constants and treat them as a sort of
+  # meta-exception. This may be useful in combination with ExceptionMessageCatcher.
+  # 
+  # @example
+  #   ErrorA = Class.new(StandardError)
+  #   ErrorB = Class.new(StandardError)
+  #   ErrorC = Class.new(StandardError)
+  #   
+  #   ErrorsABC = ToeTag.category ErrorA, ErrorB, ErrorC
+  #
+  #   begin
+  #     # some stuff
+  #   rescue ErrorsABC => err
+  #     # err is either ErrorA, ErrorB, or ErrorC
+  #   end
+  #
+  class CategorySpec < ExceptionSpec
+    attr_reader :exceptions
+
+    def initialize(*exceptions)
+      self.exceptions = exceptions.flatten.freeze
+    end
+
+    def ===(except)
+      exceptions.any?{|exc| exc === except }
+    end
+
+    # Accepts a list of exception classes or names of exception classes and returns
+    # an ExceptionCategory covering those exception classes. If a name is provided,
+    # it is converted to a constant. If the constant doesn't exist, the name is ignored.
+    # This allows the creation of an ExceptionCategory covering multiple exception
+    # types that may not all be loaded in a given environment.
+    #
+    # @example
+    #   DatabaseError = ExceptionCategory.category %w[ActiveRecord::JDBCError PG::Error]
+    def self.category(*names)
+      names = names.flatten.map{|except_name|
+        if except_name.kind_of?(String)
+          Util.try_constantize(except_name)
+        else
+          except_name
+        end
+      }.compact
+      new(*names)
+    end
+
+    private
+
+    attr_writer :exceptions
+  end
+
+  def self.category(*names)
+    CategorySpec.category(*names)
+  end
+
+  # Wraps a proc to allow arbitrary logic when matching an exception.
+  class ProcSpec < ExceptionSpec
+
+    def initialize(blk, exception = StandardError)
+      self.exception = exception
+      self.block = blk
+    end
+
+    def ===(except)
+      exception === except && block[except]
+    end
+
+    private
+
+    attr_accessor :exception, :block
+  end
+
+  def self.with_proc(&blk)
+    ProcSpec.new(&blk)
+  end
+
+  # Wraps an exception class to allow matching against the message, too. Intended
+  # to be used in rescue clauses, for cases where one exception class 
+  # (ActiveRecord::StatementInvalid, I'm looking at you) represents a host of 
+  # underlying issues.
+  #
+  # The recommended usage is to assign these to constants and treat them as a sort
+  # of meta-exception. This may be useful in combination with ExceptionCategory.
+  #
+  # @example
+  #   BogusError = StandardError.with_message(/bogus/)
+  #
+  #   begin
+  #     raise "bogus error man"
+  #   rescue BogusError => err
+  #     p err
+  #   end
+  #
+  class MessageSpec < ExceptionSpec
+    
+    def initialize(message, exception = StandardError)
+      self.exception = exception
+      self.message   = message
+    end
+
+    def ===(except)
+      exception === except && message === except.message
+    end
+
+    private
+
+    attr_accessor :exception, :message
+
+    def message=(val)
+      if val.kind_of?(String)
+        @message = /#{val}/
+      else
+        @message = val
+      end
+    end
+
+  end
+
+  def self.with_message(message)
+    MessageSpec.new(message)
+  end
+
+end
+
+class Exception
+  extend ToeTag::ExceptionBehavior
+end

data/spec/toe_tag_spec.rb

@@ -0,0 +1,135 @@
+require 'toe_tag'
+
+describe ToeTag do
+  
+  let(:error_a) { Class.new StandardError }
+  let(:error_b) { Class.new StandardError }
+  let(:error_c) { Class.new StandardError }
+  let(:error_oddball) { Class.new StandardError }
+
+  let(:error_group) { ToeTag::CategorySpec.new(error_a, error_b, error_c) }
+  
+  describe ToeTag::CategorySpec do
+
+    it "should capture exceptions from any class it is composed from" do
+      expect {
+        begin 
+          raise error_a
+        rescue error_group
+        end
+        begin
+          raise error_b
+        rescue error_group
+        end
+        begin
+          raise error_c
+        rescue error_group
+        end
+      }.not_to raise_error
+      expect {
+        begin
+          raise error_oddball
+        rescue error_group
+        end
+      }.to raise_error(error_oddball)
+    end
+
+    context ".category" do
+
+      it "should look up exception types by name, skipping nonexistent ones" do
+        grouping = ToeTag.category %w[IndexError StandardError BogusError]
+        expect(grouping.exceptions.length).to eql 2
+        expect(grouping === NameError.new).to eql true
+      end
+
+    end
+
+  end
+
+  describe ToeTag::ProcSpec do
+    
+    it "should capture exceptions that return true from a given proc" do
+      catcher = ToeTag::ProcSpec.new(lambda{|e| e.message == "not spurious" })
+      expect {
+        begin
+          raise error_a, "not spurious"
+        rescue catcher
+        end
+      }.not_to raise_error
+      expect {
+        begin
+          raise error_a, "totally spurious"
+        rescue catcher
+        end
+      }.to raise_error(error_a)
+    end
+
+  end
+
+  describe ToeTag::MessageSpec do
+    
+    it "should capture exceptions with a given message substring" do
+      catcher = ToeTag::MessageSpec.new("spurious")
+      expect {
+        begin
+          raise error_a, "a spurious error"
+        rescue catcher
+        end
+      }.not_to raise_error
+      expect {
+        begin
+          raise error_a, "a serious error"
+        rescue catcher
+        end
+      }.to raise_error
+    end
+
+    context "combined with ExceptionCategory" do
+      
+      it "should capture exceptions within a set with a given message substring" do
+        catcher = ToeTag.category(error_group).with_message("spurious")
+        expect {
+          begin
+            raise error_a, "a spurious error"
+          rescue catcher
+          end
+        }.not_to raise_error
+        expect {
+          begin
+            raise error_oddball, "a spurious error, outside the group"
+          rescue catcher
+          end
+        }.to raise_error(error_oddball)
+        expect {
+          begin
+            raise error_b, "a serious error"
+          rescue catcher
+          end
+        }.to raise_error(error_b)
+      end
+
+    end
+
+    context "using the Exception extensions" do
+
+      it "should catch errors by message" do
+        catcher = StandardError.with_message(/catch|retrieve|fetch/)
+        expect {
+          begin
+            raise "catch me if you can"
+          rescue catcher
+          end
+        }.not_to raise_error
+        expect {
+          begin
+            raise "fail"
+          rescue catcher
+          end
+        }.to raise_error(StandardError)
+      end
+
+    end
+
+  end
+
+end

data/toe_tag.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'toe_tag/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "toe_tag"
+  spec.version       = ToeTag::VERSION
+  spec.authors       = ["Matthew Boeh"]
+  spec.email         = ["matt@crowdcompass.com"]
+  spec.description   = %q{Utilities for catching and handling exceptions.}
+  spec.summary       = %q{Utilities for catching and handling exceptions.}
+  spec.homepage      = "https://github.com/crowdcompass/toetag"
+  spec.license       = "Apache-2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: toe_tag
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Matthew Boeh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Utilities for catching and handling exceptions.
+email:
+- matt@crowdcompass.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/toe_tag.rb
+- lib/toe_tag/version.rb
+- spec/toe_tag_spec.rb
+- toe_tag.gemspec
+homepage: https://github.com/crowdcompass/toetag
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0.rc.2
+signing_key: 
+specification_version: 4
+summary: Utilities for catching and handling exceptions.
+test_files:
+- spec/toe_tag_spec.rb
+has_rdoc: