abstractable 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8bd935180782c9239522ca5b1620e0df57ed3711
+  data.tar.gz: 783fb41773e04a0dab097fe83b1f3917c46d2dba
+SHA512:
+  metadata.gz: 4961394ef67b57d5844633e51b9c152dbe47cb6d1dc4ddad9f150ec853676be4a0f353b4b7e7ac6009119422f121c56ff3324861d262a4cd936bc8e318b30117
+  data.tar.gz: c71bf70ef9481d8e9786d3471c806c98c4ed856f21df818d89f088b2b4ab5d72ccd99cdd2f7174f78f48184b59f5f4291c51bc32d3ab3a400111dd8a49e45cb6

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,41 @@
+HashSyntax:
+  EnforcedStyle: ruby19
+  SupportedStyles:
+    - ruby19
+    - hash_rockets
+
+Documentation:
+  Enabled: false
+
+LineLength:
+  Enabled: false
+
+ClassLength:
+  Enabled: false
+
+RegexpLiteral:
+  MaxSlashes: 0
+
+GuardClause:
+  MinBodyLength: 3
+
+TrivialAccessors:
+  AllowPredicates: true
+
+RedundantReturn:
+  AllowMultipleReturnValues: true
+
+RedundantBegin:
+  Enabled: false
+
+SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Style/Lambda:
+  Enabled: false
+
+Style/Proc:
+  Enabled: false
+
+StringLiterals:
+  EnforcedStyle: double_quotes

data/.travis.yml

@@ -0,0 +1,10 @@
+bundler_args: --without development
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+script:  bundle exec rspec
+branches:
+  only:
+    - master

data/Gemfile

@@ -0,0 +1,20 @@
+source "https://rubygems.org"
+
+gem "rake", ">= 0.9"
+gem "rdoc", ">= 3.9"
+
+group :development do
+  gem "guard-rubocop"
+  gem "terminal-notifier-guard"
+  gem "flay"
+  gem "flog"
+end
+
+group :test do
+  gem "coveralls", require: false
+  gem "rubocop", ">= 0.19"
+  gem "rspec", ">= 3"
+  gem "simplecov", ">= 0.9"
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 pujoheadsoft
+
+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,235 @@
+# Abstractable
+
+[![Build Status](http://img.shields.io/travis/pujoheadsoft/abstractable.svg)][travis]
+[![Coverage Status](http://img.shields.io/coveralls/pujoheadsoft/abstractable.svg)][coveralls]
+[![Code Climate](http://img.shields.io/codeclimate/github/pujoheadsoft/abstractable.svg)][codeclimate]
+
+[travis]: http://travis-ci.org/pujoheadsoft/abstractable
+[coveralls]: https://coveralls.io/r/pujoheadsoft/abstractable
+[codeclimate]: https://codeclimate.com/github/pujoheadsoft/abstractable
+
+## Overview
+Abstractable is Library for define abstract method.  
+Can know unimplemented abstract methods by fail fast as possible.  
+This mechanism is very useful for prevent the implementation leakage.
+```ruby
+require "abstractable"
+class AbstractDriver
+  extend Abstractable
+  abstract :open, :close
+end
+
+class AbstractIODriver < AbstractDriver
+  abstract :read, :write
+end
+
+class NotImplIODriver < AbstractIODriver; end
+
+NotImplIODriver.new
+# => following abstract methods are not implemented. (NotImplementedError)
+#    [:open, :close] defined in AbstractDriver
+#    [:read, :write] defined in AbstractIODriver
+```
+See sample above. error occurred at call *new* method.  
+Info of unimplemented abstract method have been included in the error message.
+
+## Installation
+    gem install abstractable
+
+## How to use
+First, call *require "abstractable"*.  
+Then, *extend Abstractable*.
+```ruby
+require "abstractable"
+class AbstractClass
+  extend Abstractable
+end
+```
+**Note:** This document omit the *require "abstractable"* from now on.
+
+### Define abstract method
+
+1. **Specify *Symbol* (can specify multiple)**
+    ```ruby
+    class AbstractList
+      extend Abstractable
+
+      abstract :add, :insert, :empty?
+    end
+    ```
+    If want to express the arguments then can write be as follows.
+    ```ruby
+    class AbstractList
+      extend Abstractable
+
+      def add(value); end
+      def insert(index, value); end
+      def empty?; end
+
+      abstract :add, :insert, :empty?
+    end
+    ```
+2. **In block**  
+    Defined methods in block is all treated as an abstract method.
+    ```ruby
+    class AbstractList
+      extend Abstractable
+
+      abstract do
+        def add(value); end
+        def insert(index, value); end
+        def empty?; end
+      end
+    end
+    ```
+    Can also be written as follows.
+    ```ruby
+    class AbstractList
+      extend Abstractable
+
+      abstract { def add(value); end }
+      abstract { def insert(index, value); end }
+      abstract { def empty?; end }
+    end
+    ```
+
+### Get defined abstract methods
+*abstract_methods* returns an array containing the names of abstract methods in the receiver.  
+ if set *true* to args include ancestors abstract methods (default *true*).
+```ruby
+class AbstractDriver
+  extend Abstractable
+  abstract :open, :close
+end
+
+class AbstractIODriver < AbstractDriver
+  abstract :read, :write
+end
+
+AbstractIODriver.abstract_methods # => [:read, :write, :open, :close]
+```
+If specify *false* for the argument, only abstract methods defined in the receiver is returned.
+```ruby
+AbstractIODriver.abstract_methods(false) # => [:read, :write]
+```
+### Undefine of abstract method
+Can undefine and if you call *Module#undef_method*.  
+However, the receiver must be a class that defines an abstract method.  
+(Can't be undefine of the abstract methods of the parent class from a subclass.)
+```ruby
+class Parent
+  extend Abstractable
+  abstract :greet
+end
+
+class Child < Parent
+  undef_method :greet
+end
+
+begin
+  Child.new # => NotImplementedError
+rescue NotImplementedError
+end
+
+class Parent
+  undef_method :greet
+end
+
+Child.new # => OK
+```
+### Validation of unimplemented abstract method do always called?
+Once you have confirmed that the unimplemented methods do not exist, validation does not take place.  
+if defined abstract method later, then perform validation once more.  
+*required_validate?* returns true if required unimplemented abstract methods validation.
+```ruby
+class AbstractParent
+  extend Abstractable
+  abstract :greet
+end
+
+class Child < AbstractParent
+  def greet; end
+end
+
+Child.required_validate? # => true
+Child.new
+Child.required_validate? # => false
+
+# define abstract method
+AbstractParent.abstract :execute
+
+Child.required_validate? # => true
+```
+#### If define environment variable *ABSTRACTABLE_IGNORE_VALIDATE*
+This case is *required_validate?* returns true always.  
+*ABSTRACTABLE_IGNORE_VALIDATE* value allow any value.
+```
+# Linux
+export ABSTRACTABLE_IGNORE_VALIDATE=true
+# windows
+set ABSTRACTABLE_IGNORE_VALIDATE=true
+```
+### Abstract method of singleton class
+Abstract method of singleton class can't validation at new.  
+Therefore throw error at abstract method call.  
+But can find unimplemented abstract methods.
+```ruby
+class AbstractParent
+  class << self
+    extend Abstractable
+    abstract :greet
+  end
+end
+
+class Child < AbstractParent
+end
+
+Child.greet # => greet is abstract method defined in
+            # #<Class:AbstractParent>, and must implement.
+            # (NotImplementedError)
+```
+### Do explicitly validation
+if call *validate_not_implemented_abstract_methods* then can do explicitly validation.
+```ruby
+class AbstractParent
+  extend Abstractable
+  abstract :greet
+end
+
+class Child < AbstractParent; end
+
+# explicitly validation
+Child.validate_not_implemented_abstract_methods
+# => following abstract methods are not implemented. (NotImplementedError)
+#    [:greet] defined in AbstractParent
+```
+### Find unimplemented abstract methods
+*abstractable#find_not_implemented_info* returns a following format Hash
+```ruby
+{abstract_class => array of unimplemented abstract methods, ...}
+```
+```ruby
+class AbstractParent
+  extend Abstractable
+  abstract :greet
+end
+
+class Child < AbstractParent; end
+
+Abstractable.find_not_implemented_info(Child) # => {AbstractParent=>[:greet]}
+```
+If call *find_not_implemented_info_from_singleton*,  
+Then can find unimplemented abstract methods of singleton class.
+```ruby
+class AbstractParent
+  class << self
+    extend Abstractable
+    abstract :greet
+  end
+end
+
+class Child < AbstractParent; end
+
+Abstractable.find_not_implemented_info_from_singleton(Child)
+# => {#<Class:AbstractParent>=>[:greet]}
+```

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+task default: :spec
+
+task quality: [:flog, :flay]
+
+Dir.glob("tasks/*.rake").each { |each| import each }

data/abstractable.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "abstractable/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "abstractable"
+  spec.version       = Abstractable::VERSION
+  spec.authors       = ["Kenji Suzuki"]
+  spec.email         = ["pujoheadsoft@gmail.com"]
+  spec.summary       = "Library for define abstract method."
+  spec.description   = "Library for define abstract method. Can know unimplemented abstract methods by fail fast as possible. This mechanism is very useful for prevent the implementation leakage."
+  spec.homepage      = ""
+  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 "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/lib/abstractable/not_implemented_info_finder.rb

@@ -0,0 +1,49 @@
+require "abstractable"
+require "abstractable/pedigree_stream"
+
+module Abstractable
+  # this class can find to information of unimplemented abstract method
+  class NotImplementedInfoFinder
+    # find(klass) -> hash
+    #
+    # Returns an hash as information of unimplemented abstract method.
+    # hash format is {class => array of unimplemented method in class, ... }
+    def find(klass)
+      find_from_pedigree_stream(PedigreeStream.new(klass))
+    end
+
+    # find_from_singleton(klass) -> hash
+    # singleton_class version find.
+    def find_from_singleton(klass)
+      find_from_pedigree_stream(SingletonPedigreeStream.new(klass))
+    end
+
+    private
+
+    def find_from_pedigree_stream(pedigree_stream)
+      pedigree_stream.each_with_descendants_and_object(create_deny_empty_array_hash) do |klass, descendants, hash|
+        hash[klass] = find_from_ancestor_and_descendants(klass, descendants) if need_find?(klass, descendants)
+      end
+    end
+
+    def create_deny_empty_array_hash
+      hash = {}
+      def hash.[]=(key, value)
+        super(key, value) unless value.empty?
+      end
+      hash
+    end
+
+    def need_find?(ancestor, descendants)
+      ancestor.is_a?(Abstractable) && 0 < descendants.size
+    end
+
+    def find_from_ancestor_and_descendants(ancestor, descendants)
+      ancestor.abstract_methods(false).reject { |method| descendants.any?(&individual_method_defined?(method)) }
+    end
+
+    def individual_method_defined?(method)
+      lambda { |klass| klass.instance_methods(false).include? method }
+    end
+  end
+end

data/lib/abstractable/pedigree_stream.rb

@@ -0,0 +1,63 @@
+module Abstractable
+  # this class represent stream of pedigree to myself from an ancestor.
+  class PedigreeStream
+    include Enumerable
+
+    def initialize(klass)
+      fail ArgumentError, "wrong type argument #{klass} (should be Class) " unless klass.is_a? Class
+      self.pedigree_stream = pedigree_stream_of(klass)
+    end
+
+    # each for Enumerable.
+    def each
+      pedigree_stream.each { |klass| yield klass }
+    end
+
+    # each with descendants
+    #
+    # Example of use:
+    # each_with_descendants do |klass, descendants_of_klass|
+    #   your code...
+    # end
+    def each_with_descendants
+      each do |klass|
+        yield(klass, descendants_of(klass))
+      end
+    end
+
+    # each_with_object with descendants.
+    #
+    # Example of use:
+    # each_with_descendants_and_object([]) do |klass, descendants_of_klass, array|
+    #   your code...
+    # end
+    def each_with_descendants_and_object(object)
+      each_with_descendants do |klass, descendants_of_klass|
+        yield(klass, descendants_of_klass, object)
+      end
+      object
+    end
+
+    # descendants_of(klass) -> array
+    # Returns an array of descendants name of class.
+    def descendants_of(klass)
+      i = pedigree_stream.index(klass)
+      i ? pedigree_stream.drop(i + 1) : []
+    end
+
+    protected
+
+    attr_accessor :pedigree_stream
+
+    def pedigree_stream_of(klass)
+      klass.ancestors.reverse
+    end
+  end
+
+  # PedigreeStream of Singleton Class.
+  class SingletonPedigreeStream < PedigreeStream
+    def pedigree_stream_of(klass)
+      klass.ancestors.reverse.map(&:singleton_class)
+    end
+  end
+end

data/lib/abstractable/version.rb

@@ -0,0 +1,3 @@
+module Abstractable
+  VERSION = "1.0.0"
+end

data/lib/abstractable.rb

@@ -0,0 +1,128 @@
+require "abstractable/version"
+require "abstractable/not_implemented_info_finder"
+
+# abstract method support module.
+module Abstractable
+  class WrongOperationError < StandardError; end
+
+  def included(base)
+    base.extend(Abstractable)
+  end
+
+  # new after unimplemented abstract methods validation.
+  def new(*args, &block)
+    validate_on_create(:new)
+    super(*args, &block)
+  end
+
+  # allocate after unimplemented abstract methods validation.
+  def allocate(*args, &block)
+    validate_on_create(:allocate)
+    super(*args, &block)
+  end
+
+  # Define abstract methods.
+  #
+  # Example:
+  #   abstract :execute           # one symbol
+  #   abstract :method1, :method2 # multiple symbol
+  #   # in block
+  #   abstract do
+  #     def method3; end
+  #     def method4; end
+  #   end
+  def abstract(*names, &block)
+    add_abstract_methods(*names.compact)
+    add_abstract_methods_by_block(&block) if block_given?
+  end
+
+  # abstract_methods(all=true)   -> array
+  #
+  # Returns an array containing the names of abstract methods in the receiver.
+  # if set true to args include ancestors abstract methods.
+  # (default true)
+  #
+  def abstract_methods(all = true)
+    return individual_abstract_methods unless all
+    collect = lambda { |klass, array| array.push(*klass.abstract_methods(false)) if klass.is_a? Abstractable }
+    individual_abstract_methods + (ancestors - [self]).each_with_object([], &collect)
+  end
+
+  # Unimplemented abstract methods validation.
+  #
+  # if found unimplemented methods then throw NotImplementedError.
+  def validate_not_implemented_abstract_methods
+    not_impl_info = Abstractable.find_not_implemented_info(self)
+    fail NotImplementedError, build_error_message(not_impl_info) unless not_impl_info.empty?
+    @implemented_abstract_methods = abstract_methods
+  end
+
+  # required_validate? -> true or false
+  #
+  # Returns <code>true</code> if required unimplemented abstract methods validation.
+  #
+  # if validated or if defined environment variable  <code>ABSTRACTABLE_IGNORE_VALIDATE</code>
+  # then always return true.
+  def required_validate?
+    !ENV["ABSTRACTABLE_IGNORE_VALIDATE"] && @implemented_abstract_methods != abstract_methods
+  end
+
+  # called when the method is undef.
+  def method_undefined(method)
+    individual_abstract_methods.delete(method)
+  end
+
+  # Shortcut to NotImplementedInfoFinder.new.find(klass)
+  def self.find_not_implemented_info(klass)
+    NotImplementedInfoFinder.new.find(klass)
+  end
+
+  # Shortcut to NotImplementedInfoFinder.new.find_from_singleton(klass)
+  def self.find_not_implemented_info_from_singleton(klass)
+    NotImplementedInfoFinder.new.find_from_singleton(klass)
+  end
+
+  private
+
+  def individual_abstract_methods
+    @individual_abstract_methods ||= []
+  end
+
+  def validate_on_create(create_method_name)
+    validate_not_implemented_abstract_methods if required_validate?
+    if is_a?(Abstractable) && 0 < abstract_methods(false).size
+      fail WrongOperationError, "#{self} has abstract methods. and therefore can't call #{create_method_name}."
+    end
+  end
+
+  def build_error_message(not_implemented_infos)
+    messages = ["following abstract methods are not implemented."]
+    formatter = Proc.new { |klass, methods| "#{methods} defined in #{klass}" }
+    messages.push(*not_implemented_infos.map(&formatter)).join("\n")
+  end
+
+  def define_abstract_skeleton(method)
+    this = self
+    class_eval do
+      define_method method do |*_|
+        fail NotImplementedError, "#{method} is abstract method defined in #{this}, and must implement."
+      end
+    end
+  end
+
+  def add_abstract_methods_by_block(&block)
+    old_instance_methods = instance_methods(false)
+    block.call
+    add_abstract_methods(*(instance_methods(false) - old_instance_methods))
+  end
+
+  def add_abstract_methods(*methods)
+    methods.each { |method| add_abstract_method(method) }
+  end
+
+  def add_abstract_method(method)
+    fail ArgumentError, "wrong type argument #{method} (should be Symbol) " unless method.is_a? Symbol
+    individual_abstract_methods << method
+    define_abstract_skeleton(method)
+  end
+end

data/spec/abstractable_spec.rb

@@ -0,0 +1,310 @@
+require "spec_helper"
+
+describe Abstractable, "Simple" do
+
+  before(:context) do
+
+    class AbstractList
+      extend Abstractable
+      abstract :size, :empty?, :add
+    end
+
+    class NotImplList < AbstractList; end
+
+    class OneImplList < AbstractList
+      def size; end
+    end
+
+    class AllImplList < OneImplList
+      def empty?; end
+
+      def add; end
+    end
+
+  end
+
+  it "all implemented abstract methods" do
+    expect { AllImplList.new }.not_to raise_error
+    expect { AllImplList.allocate }.not_to raise_error
+  end
+
+  it "not implemented abstract methods" do
+    expect do
+      NotImplList.new
+    end.to raise_error(NotImplementedError, <<-EOF.gsub(/^\s+|\n$/, ""))
+      following abstract methods are not implemented.
+      [:size, :empty?, :add] defined in AbstractList
+    EOF
+  end
+
+  it "1 implemented abstract methods" do
+    expect do
+      OneImplList.new
+    end.to raise_error(NotImplementedError, <<-EOF.gsub(/^\s+|\n$/, ""))
+      following abstract methods are not implemented.
+      [:empty?, :add] defined in AbstractList
+    EOF
+  end
+
+  it "new abstract" do
+    error_message = "#{AbstractList} has abstract methods. and therefore can't call new."
+    expect do
+      AbstractList.new
+    end.to raise_error(Abstractable::WrongOperationError, error_message)
+  end
+
+  it "allocate abstract" do
+    error_message = "#{AbstractList} has abstract methods. and therefore can't call allocate."
+    expect do
+      AbstractList.allocate
+    end.to raise_error(Abstractable::WrongOperationError, error_message)
+  end
+
+end
+
+describe Abstractable, "Complex class hierarchy" do
+
+  before(:context) do
+
+    module AbstractAddressHolder
+      extend Abstractable
+      abstract :city
+      abstract :state, :zip
+    end
+
+    module AbstractNameHolder
+      extend Abstractable
+      abstract do
+        def last_name; end
+
+        def first_name; end
+      end
+    end
+
+    class OneImplAddressHolder
+      include AbstractAddressHolder
+      def state; end
+    end
+
+    class TwoImplAdressAndNameHolder < OneImplAddressHolder
+      include AbstractNameHolder
+      def first_name; end
+    end
+
+    class AllImplAdressAndNameHolder
+      include AbstractAddressHolder
+      include AbstractNameHolder
+
+      def last_name; end
+
+      def first_name; end
+
+      def city; end
+
+      def state; end
+
+      def zip; end
+    end
+  end
+
+  it "all implemented abstract methods" do
+    expect { AllImplAdressAndNameHolder.new }.not_to raise_error
+  end
+
+  it "1 implemented abstract methods" do
+    expect do
+      OneImplAddressHolder.new
+    end.to raise_error(NotImplementedError, <<-EOF.gsub(/^\s+|\n$/, ""))
+      following abstract methods are not implemented.
+      [:city, :zip] defined in AbstractAddressHolder
+    EOF
+  end
+
+  it "2 implemented abstract methods" do
+    expect do
+      TwoImplAdressAndNameHolder.new
+    end.to raise_error(NotImplementedError, <<-EOF.gsub(/^\s+|\n$/, ""))
+      following abstract methods are not implemented.
+      [:city, :zip] defined in AbstractAddressHolder
+      [:last_name] defined in AbstractNameHolder
+    EOF
+  end
+
+end
+
+describe Abstractable, "Independency" do
+
+  before(:context) do
+    class AbstractFormatter
+      extend Abstractable
+      abstract :format
+    end
+
+    class AFormatter < AbstractFormatter
+      def format; end
+    end
+
+    class BFormatter < AbstractFormatter
+      def format; end
+    end
+
+  end
+
+  it "AFormatter & BFormatter validation is independent" do
+    expect(AFormatter.required_validate?).to be_truthy
+    expect(BFormatter.required_validate?).to be_truthy
+
+    AFormatter.new
+    expect(AFormatter.required_validate?).to be_falsey
+    expect(BFormatter.required_validate?).to be_truthy
+
+    BFormatter.new
+    expect(AFormatter.required_validate?).to be_falsey
+    expect(BFormatter.required_validate?).to be_falsey
+  end
+
+  it "Add later abstract method" do
+    AbstractFormatter.abstract :close
+
+    expect { AFormatter.new }.to raise_error(NotImplementedError)
+    expect { BFormatter.new }.to raise_error(NotImplementedError)
+
+    class AFormatter
+      def close; end
+    end
+    expect { AFormatter.new }.not_to raise_error
+    expect { BFormatter.new }.to raise_error(NotImplementedError)
+
+    class BFormatter
+      def close; end
+    end
+    expect { AFormatter.new }.not_to raise_error
+    expect { BFormatter.new }.not_to raise_error
+  end
+
+end
+
+describe Abstractable, "delete  abstract" do
+
+  it "delete by undef_method & undef_abstract" do
+    class AbstractWriter
+      extend Abstractable
+      abstract :write, :open, :close
+    end
+
+    class AbstractDocumentWriter < AbstractWriter
+      abstract :write_document
+    end
+
+    class AbstractXMLDocumentWriter < AbstractDocumentWriter
+      abstract :to_xml
+    end
+
+    class XMLDocumentWriter < AbstractXMLDocumentWriter; end
+
+    expect { XMLDocumentWriter.new }.to raise_error(NotImplementedError)
+
+    class AbstractXMLDocumentWriter
+      undef_method :to_xml
+    end
+
+    expect(XMLDocumentWriter.abstract_methods).to eq([:write_document, :write, :open, :close])
+    expect(AbstractXMLDocumentWriter.abstract_methods).to eq([:write_document, :write, :open, :close])
+    expect(AbstractWriter.abstract_methods).to eq([:write, :open, :close])
+
+    class AbstractDocumentWriter
+      undef_method :write_document, :open, :close
+    end
+
+    expect(XMLDocumentWriter.abstract_methods).to eq([:write, :open, :close])
+    expect(AbstractXMLDocumentWriter.abstract_methods).to eq([:write, :open, :close])
+    expect(AbstractWriter.abstract_methods).to eq([:write, :open, :close])
+
+    class AbstractWriter
+      undef_method :write, :open, :close
+    end
+
+    expect(XMLDocumentWriter.abstract_methods).to eq([])
+    expect(AbstractXMLDocumentWriter.abstract_methods).to eq([])
+    expect(AbstractWriter.abstract_methods).to eq([])
+  end
+
+end
+
+describe Abstractable, "Class method" do
+
+  before(:context) do
+    class AbstractApplication
+      class << self
+        extend Abstractable
+        abstract :name
+      end
+    end
+
+    class NotImplApplication < AbstractApplication; end
+
+    class Application < AbstractApplication
+      def self.name; end
+    end
+
+  end
+
+  it "not implemented class method" do
+    message = "name is abstract method defined in #{AbstractApplication.singleton_class}, and must implement."
+    expect do
+      NotImplApplication.name
+    end.to raise_error(NotImplementedError, message)
+  end
+
+  it "implemented class method" do
+    expect { Application.new }.not_to raise_error
+  end
+
+  it "find not implemented info from singleton class" do
+    h = {AbstractApplication.singleton_class => [:name]}
+    expect(Abstractable.find_not_implemented_info_from_singleton(NotImplApplication)).to eq(h)
+    expect(Abstractable.find_not_implemented_info_from_singleton(Application)).to eq({})
+  end
+
+end
+
+describe Abstractable, "Use environment variable: ABSTRACTABLE_IGNORE_VALIDATE" do
+
+  before(:context) do
+    class AbstractPerson
+      extend Abstractable
+      abstract :say
+    end
+
+    class NotImplPerson < AbstractPerson; end
+  end
+
+  it "if defined ABSTRACTABLE_IGNORE_VALIDATE then ignore validation." do
+    expect(ENV).to receive(:[]).with("ABSTRACTABLE_IGNORE_VALIDATE").and_return(true)
+    expect { NotImplPerson.new }.not_to raise_error
+  end
+
+end
+
+describe Abstractable::NotImplementedInfoFinder do
+
+  it "find" do
+    class AbstractCollection
+      extend Abstractable
+      abstract :add, :remove
+    end
+
+    class AbstractQueue < AbstractCollection
+      abstract :clear
+    end
+
+    class PriorityQueue < AbstractQueue; end
+
+    abst_info1 = {AbstractCollection => [:add, :remove]}
+    abst_info2 = {AbstractQueue => [:clear]}
+    expect(Abstractable::NotImplementedInfoFinder.new.find(PriorityQueue)).to eq(abst_info1.merge(abst_info2))
+    expect(Abstractable::NotImplementedInfoFinder.new.find(AbstractQueue)).to eq(abst_info1)
+    expect(Abstractable::NotImplementedInfoFinder.new.find(AbstractCollection)).to eq({})
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require "simplecov"
+require "coveralls"
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter ".bundle/"
+end
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "abstractable"

data/tasks/flay.rake

@@ -0,0 +1,11 @@
+require "rake/tasklib"
+require "flay"
+require "flay_task"
+
+FlayTask.new do |t|
+  t.dirs = FileList["lib/**/*.rb"].map do |each|
+    each[%r{[^/]+}]
+  end.uniq
+  t.threshold = 0
+  t.verbose = true
+end

data/tasks/flog.rake

@@ -0,0 +1,18 @@
+require "flog"
+
+desc "Analyze for code complexity"
+task :flog do
+  flog = Flog.new(continue: true)
+  flog.flog(*FileList["lib/**/*.rb"])
+  threshold = 28
+
+  bad_methods = flog.totals.select do |name, score|
+    !(/##{flog.no_method}$/ =~ name) && score > threshold
+  end
+  bad_methods.sort { |a, b| a[1] <=> b[1] }.reverse.each do |name, score|
+    printf "%8.1f: %s\n", score, name
+  end
+  unless bad_methods.empty?
+    $stderr.puts "#{bad_methods.size} methods have a complexity > #{threshold}"
+  end
+end

data/tasks/rspec.rake

@@ -0,0 +1,3 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: abstractable
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kenji Suzuki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-20 00:00:00.000000000 Z
+dependencies:
+- !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: rspec
+  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'
+description: Library for define abstract method. Can know unimplemented abstract methods
+  by fail fast as possible. This mechanism is very useful for prevent the implementation
+  leakage.
+email:
+- pujoheadsoft@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- abstractable.gemspec
+- lib/abstractable.rb
+- lib/abstractable/not_implemented_info_finder.rb
+- lib/abstractable/pedigree_stream.rb
+- lib/abstractable/version.rb
+- spec/abstractable_spec.rb
+- spec/spec_helper.rb
+- tasks/flay.rake
+- tasks/flog.rake
+- tasks/rspec.rake
+homepage: ''
+licenses:
+- MIT
+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.4.1
+signing_key: 
+specification_version: 4
+summary: Library for define abstract method.
+test_files:
+- spec/abstractable_spec.rb
+- spec/spec_helper.rb