up_the_irons-immutable 0.1 → 0.2

data/README

@@ -14,7 +14,7 @@ Child classes, however, can still override the method.  So this is not like
 Java's "final" method modifier.
 
 One can argue that in OOP, if you want to reimplement or extend a method, a
-child class is the only place you should be doing that anyway.
+child class is the only place where you should be doing that anyway.
 
 Alpha
 -----
@@ -96,7 +96,6 @@ to immutable.rb and not mess with $RUBYLIB.
 If you installed ``Immutable`` from RubyGems, put::
 
   require 'rubygems'
-  gem 'up_the_irons-immutable'
   require 'immutable'
 
 at the top of your programs.
@@ -136,11 +135,41 @@ reimplementing them.  So the following:
     end
   end
 
+Will raise an error:
+
+::
+
+  Cannot override the immutable method: foo (Immutable::CannotOverrideMethod)
+
+There is one option to immutable_method() called :silent.  If :silent is true,
+no exception will be raised.  One can then do:
+
+::
+
+  module Foo
+    include Immutable
+
+    def foo
+      :foo
+    end
+
+    immutable_method :foo, :silent => true
+  end
+
+  module Foo
+    def foo
+      :baz
+    end
+  end
+
   include Foo
 
   foo          # => :foo
 
-Returns :foo, not :baz.
+foo() returns :foo, not :baz.  It did not allow itself to be overriden.  Using
+:silent can bring a great deal of confusion to other developers wondering why
+their method overrides aren't working.  I would consider using :silent bad
+practice in all but very limited cases.  Use with extreme caution.
 
 There is an alias for immutable_method() called immutable_methods() (plural).
 Use whichever style you prefer.
@@ -148,7 +177,7 @@ Use whichever style you prefer.
 To Do
 -----
 
-* Add option to raise exception if code tries to modify an immutable method.
+I finished my TODOs, cool.
 
 Author
 ------
@@ -177,17 +206,16 @@ Copyright
 
 Copyright (c) 2008 Garry C. Dolley
 
-eBay4R is free software; you can redistribute it and/or modify it under the
+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
 Foundation; either version 2 of the License, or (at your option) any later 
 version.
 
-eBay4R is distributed in the hope that it will be useful, but WITHOUT ANY
+Immutable is distributed in the hope that it will be useful, but WITHOUT ANY
 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 details.
 
 You should have received a copy of the GNU General Public License along with
-eBay4R; if not, write to the Free Software Foundation, Inc., 51 Franklin
+Immutable; if not, write to the Free Software Foundation, Inc., 51 Franklin
 Street, Fifth Floor, Boston, MA  02110-1301, USA
-

data/immutable.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name     = "immutable"
-  s.version  = "0.1"
+  s.version  = "0.2"
   s.author   = "Garry Dolley"
   s.email    = "gdolley@ucla.edu"
   s.homepage = "http://github.com/up_the_irons/immutable/tree/master"

data/lib/immutable.rb

@@ -1,30 +1,34 @@
 module Immutable
+  class CannotOverrideMethod < StandardError; end
+
   def self.included(mod)
     mod.extend(ClassMethods)
   end
 
   module ClassMethods
     def immutable_method(*args)
+      opts = args.last.is_a?(Hash) ? args.pop : {}
+      
       args.each do |method|
         alias_method "orig_#{method}", method
       end
 
-      @args = args
+      @args = args; @opts = opts
       module_eval do
         def self.method_added(sym)
           if @args
             @args.each do |method|
-              if method
-                if sym == method.to_sym 
-                  unless called_by_method_added
-                    self.module_eval <<-"end;"
-                      def #{method.to_s}(*args, &block)
-                        orig_#{method.to_s}(*args, &block)
-                      end
-                    end;
-                  end # called_by_method_added
-                end # method.to_sym
-              end # method
+              if method && sym == method.to_sym && !called_by_method_added
+                unless @opts[:silent]
+                  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;
+              end 
             end # @args.each
           end # @args
         end # def self.method_added()

data/spec/immutable_spec.rb

@@ -19,7 +19,7 @@ module Foo
     :fast
   end
 
-  immutable_method :foo, :bar
+  immutable_method :foo, :bar, :silent => true
 end
 
 # Other Foo modules we can screw with, so specs don't step on each other
@@ -37,69 +37,49 @@ describe "Module Foo" do
   end
  
   describe "after redefining" do
-    def redefine(method)
-      Foo.module_eval <<-"end;"
-        def #{method.to_s}
-          :slow
-        end
-      end;
-    end
-
     it "should not let foo() be redefined" do
-      redefine(:foo)
+      redefine(Foo, :foo)
       test_it(Foo, :foo)
     end
   
     it "should not let foo() be redefined even if we try twice" do
-      redefine(:foo)
-      redefine(:foo)
+      redefine(Foo, :foo)
+      redefine(Foo, :foo)
       test_it(Foo, :foo)
     end
 
     it "should not let bar() be redefined" do
-      redefine(:bar)
+      redefine(Foo, :bar)
       test_it(Foo, :bar)
     end
 
     it "should not let bar() be redefined even if we try twice" do
-      redefine(:bar)
-      redefine(:bar)
+      redefine(Foo, :bar)
+      redefine(Foo, :bar)
       test_it(Foo, :bar)
     end
   end
 
   describe "after undefining" do
-    def undefine(method)
-      Foo2.module_eval do
-        undef_method(method)
-      end
-    end
-
     it "should not let foo() be undefined" do
-      undefine(:foo)
+      undefine(Foo2, :foo)
       test_it(Foo2, :foo)
     end
 
     it "should not let bar() be undefined" do
-      undefine(:bar)
+      undefine(Foo2, :bar)
       test_it(Foo2, :bar)
     end
   end
 
   describe "after removing" do
-    def remove(method)
-      Foo3.module_eval do
-        remove_method(method)
-      end
-    end
-
     it "should not let foo() be removed" do
-      remove(:foo)
+      remove(Foo3, :foo)
       test_it(Foo3, :foo)
     end
 
     it "should not let bar() be removed" do
-      remove(:bar)
+      remove(Foo3, :bar)
       test_it(Foo3, :bar)
     end
   end
@@ -120,7 +100,7 @@ class Bar
     :fast
   end
 
-  immutable_method :foo, :bar
+  immutable_method :foo, :bar, :silent => true
 end
 
 # Other Bar modules we can screw with, so specs don't step on each other
@@ -140,69 +120,49 @@ describe "Class Bar" do
   end
  
   describe "after redefining" do
-    def redefine(method)
-      Bar.module_eval <<-"end;"
-        def #{method.to_s}
-          :slow
-        end
-      end;
-    end
-
     it "should not let foo() be redefined" do
-      redefine(:foo)
+      redefine(Bar, :foo)
       test_it(Bar, :foo)
     end
   
     it "should not let foo() be redefined even if we try twice" do
-      redefine(:foo)
-      redefine(:foo)
+      redefine(Bar, :foo)
+      redefine(Bar, :foo)
       test_it(Bar, :foo)
     end
 
     it "should not let bar() be redefined" do
-      redefine(:bar)
+      redefine(Bar, :bar)
       test_it(Bar, :bar)
     end
   
     it "should not let bar() be redefined even if we try twice" do
-      redefine(:bar)
-      redefine(:bar)
+      redefine(Bar, :bar)
+      redefine(Bar, :bar)
       test_it(Bar, :bar)
     end
   end
 
   describe "after undefining" do
-    def undefine(method)
-      Bar2.module_eval do
-        undef_method(method)
-      end
-    end
-
     it "should not let foo() be undefined" do
-      undefine(:foo)
+      undefine(Bar2, :foo)
       test_it(Bar2, :foo)
     end
 
     it "should not let bar() be undefined" do
-      undefine(:bar)
+      undefine(Bar2, :bar)
       test_it(Bar2, :bar)
     end
   end
 
   describe "after removing" do
-    def remove(method)
-      Bar3.module_eval do
-        remove_method(method)
-      end
-    end
-
     it "should not let foo() be removed" do
-      remove(:foo)
+      remove(Bar3, :foo)
       test_it(Bar3, :foo)
     end
 
     it "should not let bar() be removed" do
-      remove(:bar)
+      remove(Bar3, :bar)
       test_it(Bar3, :bar)
     end
   end
@@ -213,3 +173,51 @@ describe "Class Bar" do
     end
   end
 end
+
+##############
+# Exceptions #
+##############
+
+module Boo
+  include Immutable
+
+  def boo
+    :fast
+  end
+
+  immutable_method :boo
+end
+
+describe "Exceptions" do
+  describe "by default" do
+    it "should raise exception upon override" do
+      lambda do 
+        redefine(Boo, :boo)
+      end.should raise_error(Immutable::CannotOverrideMethod, /Cannot override the immutable method: boo$/)
+    end
+  end
+end
+
+##################
+# Helper methods #
+##################
+
+def redefine(mod, method)
+  mod.module_eval <<-"end;"
+    def #{method.to_s}
+      :slow
+    end
+  end;
+end
+
+def undefine(mod, method)
+  mod.module_eval do
+    undef_method(method)
+  end
+end
+
+def remove(mod, method)
+  mod.module_eval do
+    remove_method(method)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: up_the_irons-immutable
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - Garry Dolley