meta_programming 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+pkg
+nbproject
+TODO.txt
+*.gemspec
+*.gem

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006-2009 Jeff Patmon
+
+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.rdoc

@@ -0,0 +1,28 @@
+= MetaProgramming
+
+Various meta-programming methods and 'spells' for Ruby
+
+== Resources
+
+Install
+
+* sudo gem install meta_programming
+
+Use
+
+* require 'meta_programming'
+
+	
+== Description
+
+Current Methods
+* eigenclass (or metaclass)
+* safe_alias_method_chain
+* define_chained_method
+* blank_slate
+* clean_room
+
+
+== Dependencies
+
+none

data/Rakefile

@@ -0,0 +1,66 @@
+#require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+gem 'gem_version', '>= 0.0.1'
+require 'gem_version'
+#require 'rake/contrib/sshpublisher'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'meta_programming'
+  s.version = GemVersion.next_version
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.8.7'
+  s.description = 'Collection of meta-programming methods for Ruby'
+  s.summary = 'Collection of meta-programming methods for Ruby'
+
+ 
+  exclude_folders = '' # 'spec/rails/{doc,lib,log,nbproject,tmp,vendor,test}'
+  exclude_files = [] # FileList['**/*.log'] + FileList[exclude_folders+'/**/*'] + FileList[exclude_folders]
+  s.files = FileList['{lib,spec}/**/*'] + %w(init.rb LICENSE Rakefile README.rdoc .gitignore) - exclude_files
+  s.require_path = 'lib'
+  s.has_rdoc = true
+  s.test_files = Dir['spec/*_spec.rb']
+  
+  s.author = 'Jeff Patmon'
+  s.email = 'jpatmon@gmail.com'
+  s.homepage = 'http://github.com/jeffp/meta_programming/tree/master'
+end
+ 
+require 'spec/version'
+require 'spec/rake/spectask'
+
+desc "Run specs"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+  t.libs << 'lib' << 'spec'
+  t.rcov = false
+  t.spec_opts = ['--options', 'spec/spec.opts']
+  #t.rcov_dir = 'coverage'
+  #t.rcov_opts = ['--exclude', "kernel,load-diff-lcs\.rb,instance_exec\.rb,lib/spec.rb,lib/spec/runner.rb,^spec/*,bin/spec,examples,/gems,/Library/Ruby,\.autotest,#{ENV['GEM_HOME']}"]
+end
+
+desc "Generate documentation for the #{spec.name} gem."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = spec.name
+  #rdoc.template = '../rdoc_template.rb'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc', 'LICENSE', 'lib/**/*.rb')
+end
+ 
+desc 'Generate a gemspec file.'
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+  GemVersion.increment_version
+  GemVersion.commit_and_push
+end
+ 
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = RUBY_PLATFORM =~ /mswin/ ? false : true
+  p.need_zip = true
+end
+
+Dir['tasks/**/*.rake'].each {|rake| load rake}

data/init.rb

@@ -0,0 +1 @@
+require 'arspy'

data/lib/meta_programming.rb

@@ -0,0 +1,8 @@
+require 'meta_programming/object'
+require 'meta_programming/class'
+
+module MetaProgramming
+end
+
+Object.send :include, MetaProgramming::Object
+Class.send :include, MetaProgramming::Class

data/lib/meta_programming/class.rb

@@ -0,0 +1,17 @@
+module MetaProgramming
+  module Class
+    def self.included(base)
+      raise 'This module may only be included in class Class' unless base.name == 'Class'
+    end
+
+    def blank_slate(opts={})
+      opts[:except] = opts[:except] ? (opts[:except].is_a?(Array) ? opts[:except] : [opts[:except]]) : []
+      exceptions = ['method_missing', 'respond_to\?', '^__'] + opts[:except].map{|ex| ex.to_s}
+      regexp = Regexp.new(exceptions.join('|'))
+      instance_methods.each do |m|
+        undef_method m unless regexp.match(m.to_s)
+      end
+    end
+    alias_method :clean_room, :blank_slate
+  end
+end

data/lib/meta_programming/object.rb

@@ -0,0 +1,48 @@
+module MetaProgramming
+  module Object
+    def self.included(base)
+      raise 'This module may only be included in class Object' unless base.name == 'Object'
+      base.extend(ClassMethods)
+      base.class_eval do
+        alias_method :metaclass, :eigenclass
+      end
+    end
+
+    def eigenclass
+      class << self; self; end
+    end
+    
+    module ClassMethods
+      def safe_alias_method_chain(method_name, ext)
+        class_eval do
+          stripped_method_name, punctuation = method_name.to_s.sub(/([?!=])$/, ''), $1
+          method_name_with_ext = "#{stripped_method_name}_with_#{ext}#{punctuation}".to_sym
+          method_name_without_ext = "#{stripped_method_name}_without_#{ext}#{punctuation}".to_sym
+          instance_variable = "#{stripped_method_name}_#{ext}_#{{'?'=>'questmark', '!'=>'bang', '='=>'equals'}[punctuation]}"
+          if (method_defined?(method_name_with_ext) && !(eigenclass.instance_variable_defined?("@#{instance_variable}")))
+            if method_defined?(method_name.to_sym)
+              #alias_method_chain(method_name.to_sym, ext.to_sym)
+              alias_method method_name_without_ext, method_name.to_sym
+              alias_method method_name.to_sym, method_name_with_ext
+              case
+              when public_method_defined?(method_name_without_ext) then public(method_name.to_sym)
+              when protected_method_defined?(method_name_without_ext) then protected(without_method.to_sym)
+              when private_method_defined?(method_name_without_ext) then private(without_method.to_sym)
+              end
+            else
+              alias_method method_name.to_sym, method_name_with_ext
+              define_method(method_name_without_ext) {|*args| }
+            end
+            eigenclass.instance_variable_set("@#{instance_variable}", true)
+          end
+        end
+      end
+
+      def define_chained_method(method_name, ext, &block)
+        define_method("#{method_name}_with_#{ext}".to_sym, block)
+        safe_alias_method_chain(method_name.to_sym, ext)
+      end
+
+    end
+  end
+end

data/spec/meta_programming_spec.rb

@@ -0,0 +1,159 @@
+require 'lib/meta_programming'
+
+describe "MetaProgramming" do
+  describe "eigenclass and metaclass methods" do
+    it "should return the eigen class of a class" do
+      class A
+        class << self; self; end.should == self.eigenclass
+        class << self; self; end.should == self.metaclass
+      end
+      class << A; self; end.should == A.eigenclass
+      class << A; self; end.should == A.metaclass
+    end
+    it "should return the eigen class of an object" do
+      class A; def return_eigenclass; eigenclass; end; end
+      a = A.new
+      class << a; self; end.should == a.eigenclass
+      class << a; self; end.should == a.metaclass
+    end
+  end
+  describe "define_chained_method" do
+    it "should complain if there is no block" do
+      lambda {
+        class B1
+          def target; end
+          define_chained_method(:target, :chain)
+        end
+      }.should raise_exception
+    end
+    it "should define and chain a method" do
+      class B2; def target(array); array << 'target'; end; end
+      B2.new.target(['init']).should == ['init', 'target']
+      class B2
+        define_chained_method(:target, :chain) do |array|
+          array << 'chain'
+          target_without_chain(array)
+        end
+      end
+      B2.new.target(['init']).should == ['init', 'chain', 'target']
+    end
+#    it "should complain if block has wrong arity" do
+#      lambda {
+#        class B3
+#          def target(array); array << 'target'; end
+#          define_chained_method(:target, :chain) do
+#            target_without_chain(['chain'])
+#          end
+#        end
+#        B3.new.target(['init'])
+#      }.should raise_exception
+#    end
+    it "should define and chain a method safely if there is no target method" do
+      class B4
+        define_chained_method(:target, :chain) do |array|
+          array << 'chain'
+          target_without_chain(array)
+        end
+        B4.new.target(['init']).should == ['init', 'chain']
+      end
+    end
+  end
+  describe "safe_alias_method_chain method" do
+    it "should not chain for non-existent chaining method" do
+      class A
+        def primary(array); array << 'primary'; end
+        #do not define :primary_with_ext
+        safe_alias_method_chain :primary, :ext
+      end
+      a=A.new
+      a.primary(['init']).should == ['init', 'primary']
+    end
+    it "should not raise NoMethod error when chaining for non-existing primary method" do
+      lambda {
+        class A0
+          def primary_with_ext(array)
+            array << 'chaining'
+            primary_without_ext(array)
+          end
+          safe_alias_method_chain :primary, :ext
+        end
+        a=A0.new
+        a.primary(['init']).should == ['init', 'chaining']
+      }.should_not raise_exception(NoMethodError)
+    end
+    it "should chain for two methods" do
+      class A1
+        def primary(array)
+          array << 'primary'
+        end
+
+        def primary_with_ext(array)
+          array << 'chaining_in'
+          primary_without_ext(array)
+          array << 'chaining_out'
+        end
+        safe_alias_method_chain :primary, :ext
+      end
+      A1.new.primary(['init']).should == ['init', 'chaining_in', 'primary', 'chaining_out']
+    end
+    it "should chain for three methods" do
+      class A2 
+        def primary(array); array << 'primary'; end
+        
+        def primary_with_one(array); array << 'one'; primary_without_one(array); end
+        
+        def primary_with_two(array); array << 'two'; primary_without_two(array); end
+        
+        safe_alias_method_chain :primary, :one
+        safe_alias_method_chain :primary, :two
+      end
+      A2.new.primary(['init']).should == ['init', 'two', 'one', 'primary']
+    end
+    it "should not cause endless loop when called twice" do
+      lambda {
+        class A3
+          def primary(array); array << 'primary'; end
+          def primary_with_one(array); array << 'one'; primary_without_one(array); end
+
+          safe_alias_method_chain :primary, :one
+          safe_alias_method_chain :primary, :one
+        end
+        A3.new.primary(['init']).should == ['init', 'one', 'primary']
+      }.should_not raise_exception
+    end
+    it "should chain with = punctuation" do
+      class A5
+        def primary=(array); array << 'primary'; end
+        def primary_with_one=(array); array << 'one'; self.primary_without_one=(array); end
+
+        safe_alias_method_chain :primary=, :one
+      end
+      lambda {
+        a = A5.new.primary=(['init'])
+        a.should == ['init', 'one', 'primary']
+      }.should_not raise_exception
+    end
+    it "should chain with ? punctuation" do
+      class A6
+        def primary?(array); array << 'primary'; end
+        def primary_with_one?(array); array << 'one'; primary_without_one?(array); end
+
+        safe_alias_method_chain :primary?, :one
+      end
+      lambda {
+        A6.new.primary?(['init']).should == ['init', 'one', 'primary']
+      }.should_not raise_exception
+    end
+    it "should chain with ! punctuation" do
+      class A7
+        def primary!(array); array << 'primary'; end
+        def primary_with_one!(array); array << 'one'; primary_without_one!(array); end
+
+        safe_alias_method_chain :primary!, :one
+      end
+      lambda {
+        A7.new.primary!(['init']).should == ['init', 'one', 'primary']
+      }.should_not raise_exception
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: meta_programming
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jeff Patmon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-29 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Collection of meta-programming methods for Ruby
+email: jpatmon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/meta_programming/class.rb
+- lib/meta_programming/object.rb
+- lib/meta_programming.rb
+- spec/meta_programming_spec.rb
+- spec/spec.opts
+- init.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+- .gitignore
+has_rdoc: true
+homepage: http://github.com/jeffp/meta_programming/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Collection of meta-programming methods for Ruby
+test_files: 
+- spec/meta_programming_spec.rb