nanoboy 1.0.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/nbproject
+.rvmrc

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Bernat Foj Capell
+
+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,39 @@
+# Nanoboy
+
+nanoboy is a little ruby gem that allows you to extend classes and/or modules with several advantages over the usual ruby include/extend:
+
+ * lazy extension  -- the extended class is not loaded if it's not already in the memory. The extension will be applied once the class is loaded.
+ * persistent on class reloading -- if you are developing in Rails, where classes are reloaded on each request, use nanoboy and forget about reloading problems and callbacks.
+
+Due to the lazy extension feature, this gem is specially useful when you have loading order problems. For example, if you are extending a lib that is extending another lib. Yes, these things happen.
+
+
+Syntax
+------
+
+There are two possible syntaxes:
+
+* Explicit
+
+```ruby
+Nanoboy.include! :ClassToExtend, MyAwesomeModule
+```
+
+* Sugared
+
+```ruby
+:ClassToExtend.include! MyAwesomeModule
+```
+
+Note that the class to be extended is named with its symbol, not the constant. If you use the constant, it gets loaded and you lose.
+
+And yes it works with namespaces too:
+
+```ruby
+:"CrazyModule::ClassToExtend".include! MyAwesomeModule
+```
+
+About the name
+--------------
+
+As @jondeandres said, if there is a well-known gem called FactoryGirl, what's the problem with Nanoboy?

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rake'
+require 'rake/testtask'
+require "bundler/gem_tasks"
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test nanoboy'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+def update_version(function, name)
+  major, minor, tiny = File.read("VERSION").strip.split(".").map { |i| i.to_i }
+  eval "#{name} #{function}= 1"
+  File.open("VERSION", "w") { |f| f.puts [major, minor, tiny].join(".") }
+  puts `cat VERSION`
+end
+
+{ :bump => "+", :debump => "-"}.each do |key, value|
+  namespace key do
+    [ :major, :minor, :tiny].each do |position|
+      eval <<-CODE
+      desc "#{key.to_s.capitalize} #{position} number by 1"
+      task :#{position} do
+        update_version("#{value}", "#{position}")
+      end
+    CODE
+    end
+  end
+end

data/VERSION

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

data/lib/nanoboy.rb

@@ -0,0 +1,63 @@
+require 'nanoboy/hook'
+
+module Nanoboy
+  class << self
+    attr_accessor :extensions, :methods
+  end
+
+  self.extensions ||= {}
+  self.methods = %w{include extend helper}
+
+  # Returns true if the +sym+ class has scheduled extensions to be included
+  def self.has_extensions?(sym)
+    extensions[sym.to_s]
+  end
+
+  # Returns a Module that, when included, will provide all the scheduled funcionality for +sym+
+  def self.extensions_for(sym)
+    Module.new{
+      block = ::Proc.new{|recipient|
+        Nanoboy.methods.each do |method|
+          Array(Nanoboy.extensions[sym.to_s][method]).each do |k|
+            recipient.send(method, k)
+          end
+        end
+      }
+      define_method :included, block
+      module_function :included
+    }
+  end
+
+  def self.load_extensions_for klass, recipient = klass
+    if has_extensions?(klass.name)
+      recipient.send :include, extensions_for(klass.name)
+    end
+  end
+
+  methods.each do |method|
+
+    self.class_eval <<-EOS
+      # Schedules the inclusion of +klass+ inside +recipient+
+      # Use this instead of sending direct includes, extends or helpers
+      def self.#{method}!(recipient, klass)                  # def self.append_include('ClassToExtend', MyModule)
+        extensions[recipient.to_s] ||= {}                    #   extensions['ClassToExtend'.to_s] ||= {}
+        extensions[recipient.to_s]["#{method}"] ||= []       #   extensions['ClassToExtend'.to_s]["include"] ||= []
+        extensions[recipient.to_s]["#{method}"] << klass     #   extensions['ClassToExtend'.to_s]["include"] << klass
+        # use class_eval to avoid evaluation of recipient    #   # use class_eval to avoid evaluation of ClassToExtend
+        class_eval <<-EOCONSTANTIZE                          #   class_eval <<-EOCONSTANTIZE
+          if defined?(\#{recipient})                         #     if defined?(ClassToExtend)
+            \#{recipient}.send("#{method}", klass)           #       ClassToExtend.send("include", MyModule)
+          end                                                #     end
+        EOCONSTANTIZE
+      end                                                    # end
+    EOS
+  end
+
+  def self.enable
+    Nanoboy::Hook.activate
+  end
+
+end
+
+# Go!
+Nanoboy.enable

data/lib/nanoboy/hook.rb

@@ -0,0 +1,72 @@
+module Nanoboy
+  # This module acts as a hook to enable Nanoboy in the class that includes it
+  module Hook
+
+    # This is the main Nanoboy hook, that is fired in the usual class creation
+    # class MyClass (< MyParent); end
+    module InheritedHook
+      def inherited_with_nanoboy(subclass)
+        inherited_without_nanoboy(subclass)
+        Nanoboy.load_extensions_for subclass
+      end
+
+      def self.included klass
+        Hook.nanoboy_alias klass, :inherited
+      end
+    end
+
+    # This module allows to also fire Nanoboy when defining new classes using
+    # the Module#const_set method
+    module ConstSetHook
+      def const_set_with_nanoboy(name, klass)
+        set_object = const_set_without_nanoboy(name, klass)
+        if set_object.is_a? Class
+          Nanoboy.load_extensions_for set_object
+        end
+        set_object
+      end
+
+      def self.included klass
+        Hook.nanoboy_alias klass, :const_set
+      end
+    end
+
+    # This is the module that allows the sugared syntax: :ClassToExtend.include!
+    module SymbolHook
+      def self.included(klass)
+        klass.class_eval do
+          Nanoboy.methods.each do |method|
+            define_method "#{method}!" do |extension|
+              Nanoboy.send("#{method}!", self, extension)
+            end
+          end
+        end
+      end
+    end
+
+    # You can include Nanoboy::Hook manually in your classes.
+    # Useful if it's activated too late for you
+    def self.included(klass)
+      klass.singleton_class.instance_eval { include InheritedHook, ConstSetHook }
+    end
+
+    # Similar to ActiveSupport alias_method_chain, but ensuring the alias
+    # is created only once
+    def self.nanoboy_alias klass, name
+      klass.class_eval do
+        unless (instance_methods + private_methods).include? :"#{name}_without_nanoboy"
+          alias_method "#{name}_without_nanoboy", name
+          alias_method name, "#{name}_with_nanoboy"
+        end
+      end
+    end
+
+    # Performs the hooking into the system that will make Nanoboy work
+    def self.activate
+      # Modules do not have Class#inherited since it is only defined for classes
+      Class.instance_eval  { include InheritedHook }
+      Module.instance_eval { include ConstSetHook  }
+      Symbol.instance_eval { include SymbolHook    }
+    end
+  end
+end

data/lib/nanoboy/version.rb

@@ -0,0 +1,13 @@
+module Nanoboy
+  def self.version
+    VERSION::STRING
+  end
+  module VERSION #:nodoc:
+    file    = File.join(File.dirname(__FILE__), "..", "..", "VERSION")
+    version = File.read(file).strip.split(".")
+
+    MAJOR, MINOR, *TINY = version
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/nanoboy.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "nanoboy/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nanoboy"
+  s.version     = Nanoboy.version
+  s.authors     = ["Bernat Foj"]
+  s.homepage    = "http://www.github.com/bfcapell/nanoboy"
+  s.summary     = %q{Lazy extend ruby classes and modules}
+  s.description = %q{Lazy extend ruby classes and modules}
+
+  s.rubyforge_project = "nanoboy"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "mocha", "~> 0.10.0"
+end

data/test/nanoboy_test.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'test/unit'
+require 'nanoboy'
+require 'mocha'
+
+class NanoboyTest < Test::Unit::TestCase
+
+  # Mock classes, with namespace to test the general case
+  class Test::MyClass; end
+  class Test::OtherClass; end
+  module Test::MyModule
+    def my_method; end
+  end
+
+  def test_load_methods_should_trigger_include_when_defined
+    Nanoboy.methods.each do |method|
+      Test::MyClass.expects(method).with(Test::MyModule)
+      Nanoboy.send("#{method}!", 'Test::MyClass', Test::MyModule)
+    end
+  end
+
+  def test_load_methods_should_trigger_include_with_sugared_syntax
+    Nanoboy.methods.each do |method|
+      Test::MyClass.expects(method).with(Test::MyModule)
+      :'Test::MyClass'.send("#{method}!", Test::MyModule)
+    end
+  end
+
+  def test_load_methods_should_schedule_automatic_inclusion_when_defined_after_with_const_set
+    Test.send('remove_const', 'MyClass')
+    Nanoboy.include!('Test::MyClass', Test::MyModule)
+    Test.const_set('MyClass', Class.new)
+    assert Test::MyClass.instance_methods.map(&:to_sym).include?(:my_method)
+  end
+
+  def test_load_methods_should_schedule_automatic_inclusion_when_defined_after_with_normal_def
+    Test.send('remove_const', 'MyClass')
+    Nanoboy.include!('Test::MyClass', Test::MyModule)
+    Test.class_eval "class MyClass; end"
+    assert Test::MyClass.instance_methods.map(&:to_sym).include?(:my_method)
+  end
+
+  def test_load_methods_should_allow_inclusion_in_other_classes
+    Nanoboy.include!('Test::MyClass', Test::MyModule)
+    Test::OtherClass.class_eval do
+      Nanoboy.load_extensions_for Test::MyClass, self
+    end
+    assert Test::OtherClass.instance_methods.map(&:to_sym).include?(:my_method)
+  end
+
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: nanoboy
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Bernat Foj
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-18 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 55
+        segments: 
+        - 0
+        - 10
+        - 0
+        version: 0.10.0
+  type: :development
+  version_requirements: *id001
+description: Lazy extend ruby classes and modules
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/nanoboy.rb
+- lib/nanoboy/hook.rb
+- lib/nanoboy/version.rb
+- nanoboy.gemspec
+- test/nanoboy_test.rb
+homepage: http://www.github.com/bfcapell/nanoboy
+licenses: []
+
+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: nanoboy
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Lazy extend ruby classes and modules
+test_files: []
+