adamtanner-terror 0.3.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+*.swp

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Adam Tanner
+ 
+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.markdown

@@ -0,0 +1,49 @@
+!! TERROR !!
+
+Terror allows you to define your errors/exceptions in a pretty run-of-the-mill style DSL.
+
+Reasons Terror exists:
+
+*  Because defining errors as subclasses of StandardError looks ugly.
+*  Also, because I wanted to make a pseudo-useful DSL.
+
+How to use Terror:
+
+For times where all you need is a pretty name to raise.
+
+    exceptions :exceptionally, "exceptional"
+
+
+If you need a little more control over your exceptions you can use a block.
+The methods inside the block become camel-cased exceptions where the method name
+is the exception name.
+
+    exceptions do
+      there_is_no_exception "You did wrong. There is no exception!"
+    end
+
+The argument passed to the method is the message you want to use when you raise the exception.
+For the example above you would do:
+
+    raise ThereIsNoException, ThereIsNoException.message
+
+If you need even more control over your exceptions and want to add custom functionality you can
+pass the method a block and insert whatever code you want available for the exception.
+
+    exceptions do
+      my_exception do   
+        def handle_my_exception()
+          return "Check that out, I can add my own methods!"
+        end
+      end
+    end
+
+And, of course, all of these can be done together in the same exceptions method if you need more, 
+or less, functionality for different exceptions.
+
+Things I'd Like to Get Around to Doing:
+
+*  Making this a gem.
+*  Writing tests. (In progress)
+
+That's all folks.

data/Rakefile

@@ -0,0 +1,13 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "terror"
+    gem.summary = "Because defining exceptions as subclasses of StandardError looks ugly."
+    gem.description = "Because defining exceptions as subclasses of StandardError looks ugly."
+    gem.email = "adam@adamtanner.org"
+    gem.homepage = "http://github.com/adamtanner/terror"
+    gem.authors = ["Adam Tanner"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/lib/terror.rb

@@ -0,0 +1,48 @@
+module Terror
+  def self.included(base)
+    base.send(:include, Terror::InstanceMethods)
+    base.send(:extend, Terror::ClassMethods)
+    Terror.base_class = base
+  end
+
+  class ErrorBuilder
+    def method_missing(method, *arguments, &block)
+      return Terror.base_class.new.send(method, *arguments) if Terror.base_class.new.respond_to?(method)
+      return Terror.base_class.send(method, *arguments) if Terror.base_class.respond_to?(method)
+      error_class = Terror.base_class.const_set(Terror.camelize(method), Class.new(StandardError))
+      error_class.class_eval(&block) if block_given?
+      message, arguments = arguments
+      if message
+        error_class.class_eval %{ class << self; self.send(:define_method, :message) { "#{message}" }; end }
+      end
+    end
+  end
+
+  module ClassMethods
+    def exceptions(*exceptions, &block) 
+      Terror::ErrorBuilder.new.instance_eval(&block) if block_given?
+
+      exceptions.each do |exception|
+        Terror.base_class.const_set(Terror.camelize(exception), Class.new(StandardError))
+      end
+    end
+  end  
+
+  module InstanceMethods
+
+  end
+
+  private
+    # @see Lifted from the Rails Inflector.
+    def self.camelize(string)
+      string.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
+
+    def self.base_class=(base)
+      @@base_class = base
+    end
+
+    def self.base_class
+      @@base_class
+    end
+end

data/spec/terror_spec.rb

@@ -0,0 +1,68 @@
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'terror'
+
+describe Terror do
+  before(:all) do
+    TestClass = Class.new
+    TestClass.send(:include, Terror)
+  end
+
+  it "should take a symbol and convert it to an exception" do
+    TestClass.exceptions :exception_from_symbol
+    TestClass.constants.should include("ExceptionFromSymbol")
+  end
+
+  it "should take a string and convert it to an exception" do
+    TestClass.exceptions "ExceptionFromString"
+    TestClass.constants.should include("ExceptionFromString")
+  end
+  
+  it "should convert the method in the block to an exception" do
+    TestClass.exceptions { exception_from_block }
+    TestClass.constants.should include("ExceptionFromBlock")
+  end
+
+  it "should assign the message from the method in the block" do
+    TestClass.exceptions { exception_from_block_with_message "Message from exception." }
+    TestClass::ExceptionFromBlockWithMessage.message.should match("Message from exception.")
+  end
+
+  it "should evaluate the block given to the method in the context of the exception" do
+    TestClass.exceptions do
+      exception_with_custom_code do
+        def custom_handle
+        end
+      end
+    end
+    TestClass::ExceptionWithCustomCode.new.should respond_to(:custom_handle)
+  end
+
+  it "should evaluate instance methods from the base class from within the block" do
+    TestClass.send(:define_method, :message_from_base_class) { return "This is a message from the base class!" }
+    TestClass.exceptions do
+      exception_with_message_from_helper message_from_base_class
+    end
+    TestClass::ExceptionWithMessageFromHelper.message.should match("This is a message from the base class!")
+  end
+
+  it "should evaluate singleton methods from the base class from within the block" do
+    TestClass.class_eval %{ def self.message_from_base_class; return "This is a message from the base class!"; end }
+    TestClass.exceptions do
+      exception_with_message_from_class_helper message_from_base_class
+    end
+    TestClass::ExceptionWithMessageFromClassHelper.message.should match("This is a message from the base class!")
+  end
+
+  it "should evaluate methods with arguments from the base class from within the block" do
+    TestClass.send(:define_method, :message_from_base_class_with_arguments) do |first, second, third|
+      "This is my message. I love #{first} #{second} #{third}!"
+    end
+    TestClass.exceptions do
+      exception_with_message_from_helper_with_arguments message_from_base_class_with_arguments("super", "long", "methods")
+    end
+    TestClass::ExceptionWithMessageFromHelperWithArguments.message.
+      should match("This is my message. I love super long methods!")
+  end
+end
+

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: adamtanner-terror
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Adam Tanner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-31 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Because defining exceptions as subclasses of StandardError looks ugly.
+email: adam@adamtanner.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- lib/terror.rb
+- spec/terror_spec.rb
+has_rdoc: true
+homepage: http://github.com/adamtanner/terror
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Because defining exceptions as subclasses of StandardError looks ugly.
+test_files: 
+- spec/terror_spec.rb