lucasdecastro-immutable 0.3

data/COPYING

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program 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.
+
+    This program 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 this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

data/README

@@ -0,0 +1,226 @@
+=========
+Immutable
+=========
+
+:Author: Garry Dolley
+: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
+open your class and replace your method with one of the same name.
+
+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 where you should be doing that anyway.
+
+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. :)
+
+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.
+
+Motivation
+----------
+
+My motivation for writing something that provides what some may call "evil"
+functionality of closed methods/classes came from my trials of trying to
+improve Rails loading time by reimplementing some ActiveSupport methods in C
+(Ruby extension).  I absolutely needed my C versions of certain methods to be
+present, and not clobbered by ActiveSupport.  
+
+So why didn't I just load my extension after ActiveSupport?  Because by then it
+is too late.  Rails is already loaded, along with slow running methods that get
+called over 10,000 times.  Run the profiler and see for yourself:
+
+::
+
+  ./script/performance/profiler "require 'config/environment'"
+
+Releases
+--------
+
+The latest code is in git::
+
+  * git://github.com/up_the_irons/immutable.git
+
+Requirements
+------------
+
+* None
+
+Optionals
+---------
+
+* RubyGems 1.2.0 or higher
+
+Installation
+------------
+
+git
+~~~
+
+::
+
+  git clone git://github.com/up_the_irons/immutable.git
+
+Add the path where the repo was cloned on your filesystem to $RUBYLIB, or just
+use the full path when you "require".  See "Getting Started" section.
+
+RubyGems
+~~~~~~~~
+
+::
+
+  gem sources -a http://gems.github.com
+  sudo gem install up_the_irons-immutable
+
+
+Getting Started
+---------------
+
+If you installed ``Immutable`` by cloning the git repo, put the path to the repo in
+$RUBYLIB, then put::
+
+  require 'lib/immutable'
+
+at the top of your programs.  Alternatively, you can just require the full path
+to immutable.rb and not mess with $RUBYLIB.
+
+If you installed ``Immutable`` from RubyGems, put::
+
+  require 'rubygems'
+  require 'immutable'
+
+at the top of your programs.
+
+Using
+-----
+
+There's not much to say, so let me present a fully working example:
+
+::
+
+  require 'rubygems'
+  require 'immutable'
+  
+  module Foo
+    include Immutable
+  
+    def foo
+      :foo
+    end
+  
+    def bar
+      :bar
+    end
+  
+    immutable_method :foo, :bar
+  end
+  
+Now methods foo() and bar() cannot be overridden by other code opening Foo and
+reimplementing them.  So the following:
+
+::
+
+  module Foo
+    def foo
+      :baz
+    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
+
+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.
+  
+To Do
+-----
+
+I finished my TODOs, cool.
+
+Author
+------
+
+Garry C. Dolley
+
+gdolley [at] NOSPAM- ucla.edu
+
+AIM: garry97531
+
+IRC: up_the_irons in #git and #caboose on Freenode (and usually many other
+channels)
+
+Formatting
+----------
+
+This README is formatted in reStructredText [RST]_.  It has the best
+correlation between what a document looks like as plain text vs. its
+formatted output (HTML, LaTeX, etc...).  What I like best is, markup doesn't
+look like markup, even though it is.
+
+.. [RST] http://docutils.sourceforge.net/rst.html
+
+Copyright
+---------
+
+Copyright (c) 2008 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
+Foundation; either version 2 of the License, or (at your option) any later 
+version.
+
+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
+Immutable; if not, write to the Free Software Foundation, Inc., 51 Franklin
+Street, Fifth Floor, Boston, MA  02110-1301, USA

data/immutable.gemspec

@@ -0,0 +1,11 @@
+spec = Gem::Specification.new do |s|
+  s.name        = "immutable"
+  s.version     = "0.3"
+  s.authors     = ["Garry Dolley", "Lucas de Castro"]
+  s.email       = "email@dolucas.com"
+  s.homepage    = "http://github.com/lucasdecastro/immutable"
+  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

@@ -0,0 +1,74 @@
+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 "#{UNIQ}_old_#{method}", method
+      end
+      
+      # Build list of immutable methods
+      @immutable_methods += args
+      @silent_immutable_methods += args if opts[:silent]
+
+      @opts = opts
+      module_eval do
+        def self.method_added(sym)
+          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
+                
+                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 # @immutable_methods
+        end # def self.method_added()
+
+        def self.method_undefined(sym)
+          method_added(sym)
+        end
+
+        def self.method_removed(sym)
+          method_added(sym)
+        end
+      end # module_eval
+
+      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()
+
+    alias immutable_methods immutable_method
+
+  end # module ClassMethods
+end # module Immutable

data/spec/immutable_spec.rb

@@ -0,0 +1,288 @@
+require 'rubygems'
+require 'spec'
+require 'ruby-debug'
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'immutable')
+
+##################
+# Module version #
+##################
+
+module Foo
+  include Immutable
+
+  def foo
+    :fast
+  end
+
+  def bar
+    :fast
+  end
+
+  immutable_method :foo, :bar, :silent => true
+end
+
+# Other Foo modules we can screw with, so specs don't step on each other
+Foo2 = Foo.clone
+Foo3 = Foo.clone
+
+describe "Module Foo" do
+  describe "after redefining" do
+    it "should not let foo() be redefined" do
+      redefine(Foo, :foo)
+      test_it(Foo, :foo)
+    end
+  
+    it "should not let foo() be redefined even if we try twice" do
+      redefine(Foo, :foo)
+      redefine(Foo, :foo)
+      test_it(Foo, :foo)
+    end
+
+    it "should not let bar() be redefined" do
+      redefine(Foo, :bar)
+      test_it(Foo, :bar)
+    end
+
+    it "should not let bar() be redefined even if we try twice" do
+      redefine(Foo, :bar)
+      redefine(Foo, :bar)
+      test_it(Foo, :bar)
+    end
+  end
+
+  describe "after undefining" do
+    it "should not let foo() be undefined" do
+      undefine(Foo2, :foo)
+      test_it(Foo2, :foo)
+    end
+
+    it "should not let bar() be undefined" do
+      undefine(Foo2, :bar)
+      test_it(Foo2, :bar)
+    end
+  end
+
+  describe "after removing" do
+    it "should not let foo() be removed" do
+      remove(Foo3, :foo)
+      test_it(Foo3, :foo)
+    end
+
+    it "should not let bar() be removed" do
+      remove(Foo3, :bar)
+      test_it(Foo3, :bar)
+    end
+  end
+end
+
+#################
+# Class version #
+#################
+
+class Bar
+  include Immutable
+
+  def foo
+    :fast
+  end
+
+  def bar
+    :fast
+  end
+
+  immutable_method :foo, :bar, :silent => true
+end
+
+# Other Bar modules we can screw with, so specs don't step on each other
+Bar2 = Bar.clone
+Bar3 = Bar.clone
+
+class ChildOfBar < Bar
+  def foo
+    :slow
+  end
+end
+
+describe "Class Bar" do
+  def test_it(klass, method)
+    @value = klass.new.send(method)
+    @value.should == :fast
+  end
+ 
+  describe "after redefining" do
+    it "should not let foo() be redefined" do
+      redefine(Bar, :foo)
+      test_it(Bar, :foo)
+    end
+  
+    it "should not let foo() be redefined even if we try twice" do
+      redefine(Bar, :foo)
+      redefine(Bar, :foo)
+      test_it(Bar, :foo)
+    end
+
+    it "should not let bar() be redefined" do
+      redefine(Bar, :bar)
+      test_it(Bar, :bar)
+    end
+  
+    it "should not let bar() be redefined even if we try twice" do
+      redefine(Bar, :bar)
+      redefine(Bar, :bar)
+      test_it(Bar, :bar)
+    end
+  end
+
+  describe "after undefining" do
+    it "should not let foo() be undefined" do
+      undefine(Bar2, :foo)
+      test_it(Bar2, :foo)
+    end
+
+    it "should not let bar() be undefined" do
+      undefine(Bar2, :bar)
+      test_it(Bar2, :bar)
+    end
+  end
+
+  describe "after removing" do
+    it "should not let foo() be removed" do
+      remove(Bar3, :foo)
+      test_it(Bar3, :foo)
+    end
+
+    it "should not let bar() be removed" do
+      remove(Bar3, :bar)
+      test_it(Bar3, :bar)
+    end
+  end
+
+  describe "child classes" do
+    it "should still be able to override method" do
+      ChildOfBar.new.foo.should == :slow
+    end
+  end
+end
+
+##############
+# Exceptions #
+##############
+
+module Boo
+  include Immutable
+
+  def boo
+    :fast
+  end
+
+  def boofoo
+    :boofoo_fast
+  end
+
+  immutable_method :boofoo, :silent => true
+  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
+
+  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
+
+##################
+# 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
+
+def test_it(mod, method, value = :fast)
+  @value = Object.instance_eval do
+    include mod
+    send(method)
+  end
+
+  @value.should == value
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: lucasdecastro-immutable
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- Garry Dolley
+- Lucas de Castro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Declare methods as immutable.
+email: email@dolucas.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/immutable.rb
+- spec/immutable_spec.rb
+- immutable.gemspec
+- README
+- COPYING
+has_rdoc: false
+homepage: http://github.com/lucasdecastro/immutable
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Declare methods as immutable, somewhat like Java's 'final' keyword but still allowing child classes to override.
+test_files: []
+