unextendable 0.1.0 → 0.1.1

data/CHANGELOG.rdoc

@@ -1,5 +1,9 @@
 = Unextendable CHANGELOG
 
+== Version 0.1.1 (May 1, 2011)
+
+* Being able to pass a block to 'unextend' and only unextending a module when the block passes
+
 == Version 0.1.0 (May 1, 2011)
 
 * Initial release

data/README.textile

@@ -14,7 +14,7 @@ A gem that allows objects to effectively mixin and unmix modules. The downside i
 
 *Evil-ruby* - "Github repository":https://github.com/yugui/evil-ruby
 
-A gem that extends Ruby's semantics by accessing its internals from pure Ruby code. I do not want to mess with Ruby internals too much just for what I want to implement. As the name already, is it ethical or just evil? I will let you judge that. By the way, "evilr":https://github.com/jeremyevans/evilr is its brother written in C.
+A gem that extends Ruby's semantics by accessing its internals from pure Ruby code. I do not want to mess with Ruby internals too much just for what I want to implement. As the name already says, is it ethical or just evil? I will let you judge that. By the way, "evilr":https://github.com/jeremyevans/evilr is its brother written in C.
 
 *StatePattern* - "Github repository":https://github.com/dcadenas/state_pattern
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/unextendable/object.rb

@@ -26,12 +26,14 @@ class Object
     end
   end
 
-  def unextend(*modules)
+  def unextend(*modules, &block)
     if modules.empty?
-      meta_class.extended_modules.delete_if{|mod| mod.unextendable?}
+      meta_class.extended_modules.delete_if do |mod|
+        mod.unextendable? if !block_given? || block.call(mod)
+      end
     else
       modules.each do |mod|
-        meta_class.extended_modules.delete mod
+        meta_class.extended_modules.delete mod if !block_given? || block.call(mod)
       end
     end
   end

data/lib/unextendable/version.rb

@@ -1,3 +1,7 @@
 module Unextendable
-  VERSION = "0.1.0"
+  MAJOR = 0
+  MINOR = 1
+  TINY  = 1
+
+  VERSION = [MAJOR, MINOR, TINY].join(".")
 end

data/test/object_instance_test.rb

@@ -143,6 +143,23 @@ class ObjectInstanceTest < Test::Unit::TestCase
             assert !@c.meta_class.extended_modules.include?(U)
           end
 
+          should "remove the module but when passed a block only when it passes" do
+            assert_equal "Mr. C", @c.salutation
+
+            @c.extend U
+            assert_equal "Mr. U", @c.salutation
+
+            @c.unextend do |mod|
+              mod != U
+            end
+            assert_equal "Mr. U", @c.salutation
+
+            @c.unextend do |mod|
+              mod == U
+            end
+            assert_equal "Mr. C", @c.salutation
+          end
+
           context "when calling an unextendable method" do
             should "match the expected method" do
               assert_equal @c.method(:name), @c.send(:method_for, :name)
@@ -207,6 +224,17 @@ class ObjectInstanceTest < Test::Unit::TestCase
 
               @c.unextend
               assert_equal "Ms. A", @c.salutation
+
+              @c.extend U
+              @c.unextend do |mod|
+                mod != U
+              end
+              assert_equal "Ms. U", @c.salutation
+
+              @c.unextend do |mod|
+                mod == U
+              end
+              assert_equal "Ms. A", @c.salutation
             end
           end
         end

data/unextendable.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.email       = ["paul.engel@holder.nl"]
   s.homepage    = "https://github.com/archan937/unextendable"
   s.summary     = %q{A small gem making unextending extended module methods within object instances possible}
-  s.description = %q{Unextendable originated from the thought of being able to implement the "State pattern":http://tobyho.com/Design_Patterns_Revisited%3A_State within object instances using modules. In other words: I wanted object instances to behave dependent on their state using modules. I really want to use modules because they are commonly used to define a set of methods which you can extend within an object instance. Unfortunately, you cannot just unexclude a module. So after searching the web for solutions, I came across Mixology, evil-ruby and StatePattern. But they slightly did not fit the picture. So after doing some research, I came up with Unextendable.}
+  s.description = %q{Unextendable originated from the thought of being able to implement the State pattern within object instances using modules. In other words: I wanted object instances to behave dependent on their state using modules. I really want to use modules because they are commonly used to define a set of methods which you can extend within an object instance. Unfortunately, you cannot just unexclude a module. So after searching the web for solutions, I came across Mixology, evil-ruby and StatePattern. But they slightly did not fit the picture. So after doing some research, I came up with Unextendable.}
 
   s.rubyforge_project = "unextendable"
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: unextendable
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Paul Engel
@@ -46,7 +46,7 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id002
-description: "Unextendable originated from the thought of being able to implement the \"State pattern\":http://tobyho.com/Design_Patterns_Revisited%3A_State within object instances using modules. In other words: I wanted object instances to behave dependent on their state using modules. I really want to use modules because they are commonly used to define a set of methods which you can extend within an object instance. Unfortunately, you cannot just unexclude a module. So after searching the web for solutions, I came across Mixology, evil-ruby and StatePattern. But they slightly did not fit the picture. So after doing some research, I came up with Unextendable."
+description: "Unextendable originated from the thought of being able to implement the State pattern within object instances using modules. In other words: I wanted object instances to behave dependent on their state using modules. I really want to use modules because they are commonly used to define a set of methods which you can extend within an object instance. Unfortunately, you cannot just unexclude a module. So after searching the web for solutions, I came across Mixology, evil-ruby and StatePattern. But they slightly did not fit the picture. So after doing some research, I came up with Unextendable."
 email: 
 - paul.engel@holder.nl
 executables: []