up_the_irons-immutable 0.2 → 0.3

data/README

@@ -3,8 +3,8 @@ Immutable
 =========
 
 :Author: Garry Dolley
-:Date: 09-17-2008
-:Version: v0.1
+:Date: 09-21-2008
+:Version: v0.2
 
 The ``Immutable`` module provides a method (immutable_method) that let's one
 declare method(s) as immutable.  That is, other code will not be able to
@@ -22,7 +22,12 @@ Alpha
 This code is very new and despite a pretty comprehensive spec, I'm sure there's
 cases where someone can figure out how to defeat this.  So be it. :)
 
-Additionally, I've tested this code on GNU/Linux with Ruby 1.8.6 only.
+This code has been tested on the following systems:
+
+* GNU/Linux (Ubuntu 8.04.1) with Ruby 1.8.6
+* FreeBSD 7.0 with Ruby 1.8.6
+* OpenBSD 4.3 with Ruby 1.8.6
+* Mac OS X 10.5 with Ruby 1.8.6
 
 Please see the Author section below and report any problems.
 
@@ -177,6 +182,9 @@ Use whichever style you prefer.
 To Do
 -----
 
+Make method_added immutable, as well as immutable_method.  Write tests to try
+to "defeat" an immutable method, see if we can prevent it.
+
 I finished my TODOs, cool.
 
 Author
@@ -204,7 +212,7 @@ look like markup, even though it is.
 Copyright
 ---------
 
-Copyright (c) 2008 Garry C. Dolley
+Copyright (c) 2008,2009 Garry C. Dolley
 
 Immutable is free software; you can redistribute it and/or modify it under the
 terms of the GNU General Public License as published by the Free Software

data/immutable.gemspec

@@ -1,12 +1,11 @@
 spec = Gem::Specification.new do |s|
-  s.name     = "immutable"
-  s.version  = "0.2"
-  s.author   = "Garry Dolley"
-  s.email    = "gdolley@ucla.edu"
-  s.homepage = "http://github.com/up_the_irons/immutable/tree/master"
-  s.platform = Gem::Platform::RUBY
-  s.summary  = "Declare methods as immutable, somewhat like Java's 'final' keyword but still allowing child classes to override."
-
-  s.files    = ['lib/immutable.rb', 'spec/immutable_spec.rb', 'immutable.gemspec', 'README', 'COPYING']
-  s.has_rdoc = false
+  s.name        = "immutable"
+  s.version     = "0.3"
+  s.authors     = ["Garry Dolley", "Lucas de Castro"]
+  s.email       = "gdolley@ucla.edu"
+  s.homepage    = "http://github.com/up_the_irons/immutable/tree/master"
+  s.description = "Declare methods as immutable."
+  s.summary     = "Declare methods as immutable, somewhat like Java's 'final' keyword but still allowing child classes to override."
+  s.files       = ['lib/immutable.rb', 'spec/immutable_spec.rb', 'immutable.gemspec', 'README', 'COPYING']
+  s.has_rdoc    = false
 end

data/lib/immutable.rb

@@ -1,36 +1,50 @@
 module Immutable
   class CannotOverrideMethod < StandardError; end
 
+  # Random ID changed at each interpreter load
+  UNIQ = "_#{object_id.abs}"
+
   def self.included(mod)
     mod.extend(ClassMethods)
   end
 
   module ClassMethods
     def immutable_method(*args)
+      # Initialize variables
+      @immutable_methods = [] if @immutable_methods.nil?
+      @silent_immutable_methods = [] if @silent_immutable_methods.nil?
+      instance_variable_set("@#{UNIQ}_in_method_added", false)
+
       opts = args.last.is_a?(Hash) ? args.pop : {}
       
       args.each do |method|
-        alias_method "orig_#{method}", method
+        alias_method "#{UNIQ}_old_#{method}", method
       end
+      
+      # Build list of immutable methods
+      @immutable_methods += args
+      @silent_immutable_methods += args if opts[:silent]
 
-      @args = args; @opts = opts
+      @opts = opts
       module_eval do
         def self.method_added(sym)
-          if @args
-            @args.each do |method|
-              if method && sym == method.to_sym && !called_by_method_added
-                unless @opts[:silent]
+          if @immutable_methods
+            @immutable_methods.each do |method|
+              if method && sym == method.to_sym && !in_method_added?
+                unless @silent_immutable_methods.include?(method)
                   raise CannotOverrideMethod, "Cannot override the immutable method: #{sym}"
                 end
-
-                self.module_eval <<-"end;"
-                  def #{method.to_s}(*args, &block)
-                    orig_#{method.to_s}(*args, &block)
-                  end
-                end;
+                
+                allow_method_override do
+                  self.module_eval <<-"end;"
+                    def #{method}(*args, &block)
+                      #{UNIQ}_old_#{method}(*args, &block)
+                    end
+                  end;
+                end
               end 
             end # @args.each
-          end # @args
+          end # @immutable_methods
         end # def self.method_added()
 
         def self.method_undefined(sym)
@@ -42,9 +56,15 @@ module Immutable
         end
       end # module_eval
 
-      def self.called_by_method_added
-        # This is a little brittle, suggestions?
-        caller[3] =~ /eval.*in.*method_added/
+      def self.allow_method_override
+        instance_variable_set("@#{UNIQ}_in_method_added", true)
+        yield
+      ensure
+        instance_variable_set("@#{UNIQ}_in_method_added", false)
+      end
+
+      def self.in_method_added?
+        instance_variable_get("@#{UNIQ}_in_method_added")
       end
     end # def immutable_method()
 

data/spec/immutable_spec.rb

@@ -27,15 +27,6 @@ Foo2 = Foo.clone
 Foo3 = Foo.clone
 
 describe "Module Foo" do
-  def test_it(mod, method)
-    @value = Object.instance_eval do
-      include mod
-      send(method)
-    end
-
-    @value.should == :fast
-  end
- 
   describe "after redefining" do
     it "should not let foo() be redefined" do
       redefine(Foo, :foo)
@@ -185,6 +176,11 @@ module Boo
     :fast
   end
 
+  def boofoo
+    :boofoo_fast
+  end
+
+  immutable_method :boofoo, :silent => true
   immutable_method :boo
 end
 
@@ -196,6 +192,66 @@ describe "Exceptions" do
       end.should raise_error(Immutable::CannotOverrideMethod, /Cannot override the immutable method: boo$/)
     end
   end
+
+  it "should not raise if :silent => true" do
+    redefine(Boo, :boofoo)
+    test_it(Boo, :boofoo, :boofoo_fast)
+  end
+end
+
+#########
+# Other #
+#########
+
+module Bear
+  include Immutable
+
+  def foo
+    :foo_fast
+  end
+
+  def bar
+    :bar_fast
+  end
+
+  def baz
+    :baz_fast
+  end
+
+  def boo
+    :boo_fast
+  end
+
+  # Make sure we can make independent calls to immutable_method
+  immutable_method :foo
+  immutable_method :bar
+  immutable_method :baz, :silent => true
+  immutable_method :boo
+end
+
+describe "Multiple independent calls to immutable_method()" do
+  it "should still recognize foo() is immutable" do
+    lambda do
+      redefine(Bear, :foo)
+    end.should raise_error(Immutable::CannotOverrideMethod, /Cannot override the immutable method: foo$/)
+  end
+
+  it "should still recognize bar() is immutable" do
+    lambda do
+      redefine(Bear, :bar)
+    end.should raise_error(Immutable::CannotOverrideMethod, /Cannot override the immutable method: bar$/)
+  end
+
+  it "should still recognize baz() is immutable" do
+    redefine(Bear, :baz)
+    test_it(Bear, :baz, :baz_fast)
+  end
+
+  it "should still recognize boo() is immutable" do
+    lambda do 
+      redefine(Bear, :boo)
+    end.should raise_error(Immutable::CannotOverrideMethod, /Cannot override the immutable method: boo$/)
+  end
 end
 
 ##################
@@ -221,3 +277,12 @@ def remove(mod, method)
     remove_method(method)
   end
 end
+
+def test_it(mod, method, value = :fast)
+  @value = Object.instance_eval do
+    include mod
+    send(method)
+  end
+
+  @value.should == value
+end

metadata

@@ -1,19 +1,20 @@
 --- !ruby/object:Gem::Specification 
 name: up_the_irons-immutable
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: "0.3"
 platform: ruby
 authors: 
 - Garry Dolley
+- Lucas de Castro
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 -07:00
+date: 2009-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
-description: 
+description: Declare methods as immutable.
 email: gdolley@ucla.edu
 executables: []
 
@@ -29,6 +30,7 @@ files:
 - COPYING
 has_rdoc: false
 homepage: http://github.com/up_the_irons/immutable/tree/master
+licenses: 
 post_install_message: 
 rdoc_options: []
 
@@ -49,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: Declare methods as immutable, somewhat like Java's 'final' keyword but still allowing child classes to override.