abstract_method 1.0.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 SUSE
+
+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,83 @@
+Abstract Method
+===============
+
+Abstract Method is a tiny library enabling you to define abstract methods in Ruby classes and modules.
+
+Example
+-------
+
+```ruby
+class AbstractClass
+  abstract_method :foo
+end
+
+class ConcreteClass < AbstractClass
+  def foo
+    42
+  end
+end
+
+AbstractClass.new.foo # raises AbstractMethodCalled
+ConcreteClass.new.foo # => 42
+```
+
+Installation
+------------
+
+    $ gem install abstract_method
+
+Usage
+-----
+
+First, require the library:
+
+```ruby
+require "abstract_method"
+```
+
+You can now use the `abstract_method` method to define abstract methods in classes and modules.
+
+```ruby
+class AbstractClass
+  abstract_method :foo
+end
+
+class AbstractModule
+  abstract_method :bar
+end
+```
+
+When called, the abstract method will raise an `AbstractMethodCalled` exception with a helpful message:
+
+```ruby
+AbstractClass.new.foo # => raises AbstractMethodCalled with the following message:
+                      #      Called unimplemented abstract method AbstractClass#foo
+                      #      (defined in class AbstractClass).
+```
+
+Abstract methods can be overridden as usual:
+
+```ruby
+class ConcreteClass < AbstractClass
+  def foo
+    42
+  end
+end
+
+ConcreteClass.new.foo # => 42
+```
+
+For more information, see the [API documentation](http://rubydoc.info/github/openSUSE/abstract_method/frames).
+
+FAQ
+---
+
+**Why define abstract methods? In a dynamic language like Ruby this isn't needed.**
+
+Mainly for documentation purposes.
+
+Imagine writing a plugin system where the plugins are classes derived from one superclass. For a plugin author it would be great to see what methods plugins need to implement directly from the superclass code. The abstract method definition is also a great place to put documentation describing what the method should do.
+
+**Why create a new library? There is already the [abstract](http://rubygems.org/gems/abstract) gem.**
+
+With the abstract gem you have to specify the abstract method parameter list in a string when you define it. This is ugly and in Ruby the parameter list often does not say much about the method anyway. The parameters should should rather be described using a code documentation system (such as [YARD](http://yardoc.org/)).

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/lib/abstract_method.rb

@@ -0,0 +1,43 @@
+# Tiny library enabling you to define abstract methods in Ruby classes and
+# modules.
+module AbstractMethod
+  # Abstract Method version (uses [semantic versioning](http://semver.org/)).
+  VERSION = File.read(File.dirname(__FILE__) + "/../VERSION").strip
+end
+
+# Exception raised when an abstract method is called.
+class AbstractMethodCalled < StandardError
+end
+
+class Module
+  # Defines one or more abstract methods with given names in a class or module.
+  # When called, the abstract method will raise an `AbstractMethodCalled`
+  # exception with a helpful message.
+  #
+  # @example
+  #   class AbstractClass
+  #     abstract_method :foo
+  #   end
+  #
+  #   class ConcreteClass < AbstractClass
+  #     def foo
+  #       42
+  #     end
+  #   end
+  #
+  #   AbstractClass.new.foo # raises AbstractMethodCalled
+  #   ConcreteClass.new.foo # => 42
+  #
+  # @param [Array<Symbol>] names the names of defined abstract methods
+  def abstract_method(*names)
+    definitor = self
+
+    names.each do |name|
+      define_method name do
+        raise AbstractMethodCalled,
+              "Called unimplemented abstract method #{self.class}##{name} " +
+              "(defined in #{definitor.class.name.downcase} #{definitor})."
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: abstract_method
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- David Majda
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-25 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: redcarpet
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Abstract Method is a tiny library enabling you to define abstract methods in Ruby classes and modules.
+email: dmajda@suse.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.md
+- VERSION
+- lib/abstract_method.rb
+has_rdoc: true
+homepage: https://github.com/openSUSE/abstract_method
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Tiny library enabling you to define abstract methods in Ruby classes and modules
+test_files: []
+