base 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# base Changelog
+
+### 0.0.1 / 2011-09-01
+
+* Project Created

data/Manifest.txt

@@ -0,0 +1,6 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+lib/base.rb
+spec/base_spec.rb

data/README.md

@@ -0,0 +1,39 @@
+# Base
+
+* http://github.com/garybernhardt/base
+
+## DESCRIPTION:
+
+People love Base classes! They have tons of methods waiting to be used. Just check out ActiveRecord::Base's method list:
+
+    >> ActiveRecord::Base.methods.length
+    => 530 
+
+But why stop there? Why not have even more methods? In fact, let's put EVERY METHOD on one Base class!
+
+So I did. It's called Base. Just subclass it and feel free to directly reference any class method, instance method, or constant defined on any module or class in the system. Like this:
+
+    class Cantaloupe < Base
+      def embiggen
+        encode64(deflate(SEPARATOR))
+      end
+    end
+
+    >> Cantaloupe.new.embiggen
+    => "eJzTBwAAMAAw\n" 
+
+See that `embiggen` method calling encode64 and deflate methods? Those come from the `Base64` and `Zlib` modules. And the `SEPARATOR` constant is defined in `File`. Base don't care where it's defined! Base will call it!
+
+By the way, remember those 530 ActiveRecord methods? That's amateur stuff. Check out Base loaded inside a Rails app:
+
+    >> Base.new.methods.count
+    => 6947 
+
+It's so badass that it takes FIVE SECONDS just to answer that question!
+
+## SHOULD I USE THIS IN MY SYSTEM?
+
+Yes. I am being completely serious. You should.
+
+Definitely.
+

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugin :git, :doofus, :seattlerb
+
+Hoe.spec 'base' do
+  developer 'Gary Bernhardt', 'gary.bernhardt@gmail.com'
+
+  ### Use markdown for changelog and readme
+  self.history_file = 'CHANGELOG.md'
+  self.readme_file  = 'README.md'
+
+  ### Test with rspec
+  self.extra_dev_deps << [ 'rspec', '>= 2.1.0' ]
+  self.testlib = :rspec
+
+  ### build zip files too
+  self.need_zip = true
+end
+
+# add pointer so gem test works. bleh.
+task :test => [:spec]
+

data/lib/base.rb

@@ -0,0 +1,95 @@
+class Base
+  VERSION = "0.0.1"
+
+  def initialize *args, &block
+    super *args, &block
+  end
+
+  def self.const_missing name
+    name = name.to_s
+    all_modules.each do |mod|
+      mod.constants.each do |constant|
+        return mod.const_get(constant) if constant == name
+      end
+    end
+    super
+  end
+
+  def self.all_modules
+    modules = []
+    ObjectSpace.each_object(Module) do |mod|
+      modules << mod if should_extract_from?(mod)
+    end
+    modules << Kernel
+    modules
+  end
+
+  def self.should_extract_from?(mod)
+    return false if (mod < Base || mod == Base || mod.is_a?(Base))
+    return mod.is_a?(Module) && mod != Kernel
+  end
+
+  def self.method_missing name, *args, &block
+    call_method(self, name, args, block)
+  end
+
+  def method_missing name, *args, &block
+    self.class.call_method(self, name, args, block)
+  end
+
+  def self.call_method(object, name, args, block)
+    name_string = name.to_s
+
+    all_modules.each do |mod|
+      if mod.respond_to?(name)
+        return mod.send name, *args, &block
+      elsif mod.instance_methods.include?(name_string)
+        return call_instance_method(mod, name, args, block)
+      end
+    end
+
+    # 1. The world is all that is the case.
+    # 2. We failed to find a method to call.
+    #   2.1. So we need to call method_missing.
+    #     2.1.1. We can't just super it because we're not in method_missing.
+    #       2.1.1.1. We're not in method_missing because there are two of them
+    #                (self and instance) that need to share this code.
+    #       2.1.1.2. We need to call the method that would be called if we said
+    #                "super" in the object's method_missing.
+    #         2.1.1.2.1. Which is its class's superclass's method_missing method
+    #                    object.
+    Object.instance_method(:method_missing).bind(object).call(name, *args, &block)
+  end
+
+  def self.call_instance_method(mod, name, args, block)
+    if mod.is_a? Class
+      klass = Class.new(mod)
+    else
+      klass = Class.new { include mod }
+    end
+    return klass.new.send name, *args, &block
+  end
+
+  def self.methods
+    (giant_method_list_including_object(self) + super).uniq
+  end
+
+  def methods
+    (self.class.giant_method_list_including_object(self) + super).uniq
+  end
+
+  # INHERIT ALL THE METHODS!
+  def self.giant_method_list_including_object(object)
+    methods = []
+    all_modules.each_with_index do |m, i|
+      # Don't recurse into other Base objects' "methods" method
+      if m.is_a?(Base) || m < Base || m == Base
+        []
+      else
+        methods += m.methods + m.instance_methods
+      end
+    end
+    methods
+  end
+end
+

data/spec/base_spec.rb

@@ -0,0 +1,77 @@
+require 'lib/base'
+
+module NormalModule
+  Something = 5
+
+  def self.a_class_method; 6; end
+  def a_module_method; 7; end
+end
+
+class NormalClass
+  def an_instance_method; 8; end
+end
+
+class InheritsFromBase < Base
+end
+
+describe Base do
+  it "should have other modules' constants" do
+    InheritsFromBase::Something.should == NormalModule::Something
+  end
+
+  it "still throws NameError if the constant doesn't exist" do
+    expect do
+      InheritsFromBase::SomethingElse
+    end.to raise_error NameError
+  end
+
+  it "should have other modules' class methods" do
+    InheritsFromBase.a_class_method.should == 6
+  end
+
+  it "should have other modules' instance methods" do
+    InheritsFromBase.a_module_method.should == 7
+  end
+
+  it "should have other classes' instance methods" do
+    InheritsFromBase.an_instance_method.should == 8
+  end
+
+  it "still throws NoMethodError if the method doesn't exist" do
+    expect do
+      InheritsFromBase.not_a_method
+    end.to raise_error NoMethodError
+  end
+
+  it "should have other modules' methods as instance methods" do
+    InheritsFromBase.new.a_class_method.should == 6
+  end
+
+  it "includes methods from the standard library" do
+    InheritsFromBase.inflate(InheritsFromBase.deflate("x")).should == "x"
+  end
+
+  it "checks Kernel last" do
+    InheritsFromBase.all_modules.last.should == Kernel
+  end
+
+  its "instance NoMethodErrors should reference the instance" do
+    expect do
+      InheritsFromBase.new.not_a_method
+    end.to raise_error(NoMethodError, /undefined method `not_a_method' for #<InheritsFromBase/)
+  end
+
+  it "lists a lot of class methods" do
+    InheritsFromBase.methods.count.should > 1500
+  end
+
+  it "lists a lot of instance methods" do
+    InheritsFromBase.new.methods.count.should > 1500
+  end
+
+  it "doesn't list duplicate methods" do
+    methods = InheritsFromBase.methods
+    methods.uniq.should == methods
+  end
+end
+

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: base
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Gary Bernhardt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 12
+        version: "2.12"
+  type: :development
+  version_requirements: *id002
+description: |-
+  People love Base classes! They have tons of methods waiting to be used. Just check out ActiveRecord::Base's method list:
+  
+      >> ActiveRecord::Base.methods.length
+      => 530 
+  
+  But why stop there? Why not have even more methods? In fact, let's put EVERY METHOD on one Base class!
+  
+  So I did. It's called Base. Just subclass it and feel free to directly reference any class method, instance method, or constant defined on any module or class in the system. Like this:
+  
+      class Cantaloupe < Base
+        def embiggen
+          encode64(deflate(SEPARATOR))
+        end
+      end
+  
+      >> Cantaloupe.new.embiggen
+      => "eJzTBwAAMAAw\n" 
+  
+  See that `embiggen` method calling encode64 and deflate methods? Those come from the `Base64` and `Zlib` modules. And the `SEPARATOR` constant is defined in `File`. Base don't care where it's defined! Base will call it!
+  
+  By the way, remember those 530 ActiveRecord methods? That's amateur stuff. Check out Base loaded inside a Rails app:
+  
+      >> Base.new.methods.count
+      => 6947 
+  
+  It's so badass that it takes FIVE SECONDS just to answer that question!
+email: 
+- gary.bernhardt@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+files: 
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- lib/base.rb
+- spec/base_spec.rb
+- .gemtest
+homepage: http://github.com/garybernhardt/base
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.md
+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: base
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: People love Base classes! They have tons of methods waiting to be used
+test_files: []
+