object-in-enumerable 1.1.0

data/README

@@ -0,0 +1,24 @@
+Gives the more-readable `foo.in?(some_list)` and `foo.not_in?(some_list)` rather than having to revert to the more backward `some_list.include?(foo)` and `!some_list.include?(foo)`. This leads to more-readable conditions, like: `if foo.is_awesome? and foo.in?(allowed_values)`.
+
+Examples:
+
+  "abc".in?("abcdef")         # true
+  "abc".not_in?("abcdef")     # false
+  "ABC".in?("abcdef")         # false
+  "ABC".not_in?("abcdef")     # true
+  "a".in(%w(a b c d e))       # true
+  "a".not_in(%w(a b c d e))   # false
+  1.in?(0..10)                # true
+  1.not_in?(0..10)            # false
+  1.in?(10..20)               # false
+  1.not_in?(10..20)           # true
+  1.in?(10)                   # nil, as 10 doesn't respond to :include?
+  1.not_in?(10)               # nil, as 10 doesn't respond to :include?
+
+Install:
+
+    # From the command line
+    gem install pbyrne-object-in-enumerable --source=http://gems.github.com
+    
+    # In your Rails project's environment.rb
+    config.gem "pbyrne-object-in-enumerable", :source => "http://gems.github.com", :lib => "object-in-enumerable"

data/lib/object-in-enumerable.rb

@@ -0,0 +1,10 @@
+class Object
+  # Uses the given enum's include? method to determine whether the object is included in it. If the given method doesn't respond to include?, returns nil.
+  def in?(enum)
+    enum.respond_to?(:include?) ? enum.include?(self) : nil
+  end
+  
+  def not_in?(enum)
+    enum.respond_to?(:include?) ? !enum.include?(self) : nil
+  end
+end

data/spec/object-in-enumerable_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), "/spec_helper")
+
+describe Object do
+  context "knowing whether it is in the given object" do
+    before(:each) do
+      @enum = [1, "B", Date.today, {:foo => "bar"}, nil]
+      @string = "abcdefg"
+    end
+    
+    it "should know when it is in the given array" do
+      1.in?(@enum).should be_true
+      "B".in?(@enum).should be_true
+      Date.today.in?(@enum).should be_true
+      {:foo => "bar"}.in?(@enum).should be_true
+      nil.in?(@enum).should be_true
+      
+      1.not_in?(@enum).should be_false
+      "B".not_in?(@enum).should be_false
+      Date.today.not_in?(@enum).should be_false
+      {:foo => "bar"}.not_in?(@enum).should be_false
+      nil.not_in?(@enum).should be_false
+    end
+    
+    it "should know when it is not in the given array" do
+      2.in?(@enum).should be_false
+      "C".in?(@enum).should be_false
+      Date.new(2000, 01, 01).in?(@enum).should be_false
+      {:bing => "bang"}.in?(@enum).should be_false
+      
+      2.not_in?(@enum).should be_true
+      "C".not_in?(@enum).should be_true
+      Date.new(2000, 01, 01).not_in?(@enum).should be_true
+      {:bing => "bang"}.not_in?(@enum).should be_true
+    end
+
+    it "should know when it is in a non-enumerable object" do
+      "a".in?("abc").should be_true
+      "ABC".in?("ABCDEFG").should be_true
+      1.in?(1..5).should be_true
+      
+      "a".not_in?("abc").should be_false
+      "ABC".not_in?("ABCDEFG").should be_false
+      1.not_in?(1..5).should be_false
+    end
+    
+    it "should know when it is not in a non-enumerable object" do
+      "d".in?("abc").should be_false
+      "Z".in?("xyz").should be_false
+      1.in?(5..10).should be_false
+      
+      "d".not_in?("abc").should be_true
+      "Z".not_in?("xyz").should be_true
+      1.not_in?(5..10).should be_true
+    end
+    
+    it "should return nil if the given enumerable doesn't respond to include?" do
+      1.in?(1).should be_nil
+      "foo".in?(nil).should be_nil
+      
+      1.not_in?(1).should be_nil
+      "foo".not_in?(nil).should be_nil
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: object-in-enumerable
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
+platform: ruby
+authors: 
+- Patrick Byrne
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-21 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: code@patrickbyrne.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/object-in-enumerable.rb
+- README
+- spec/object-in-enumerable_spec.rb
+has_rdoc: true
+homepage: http://github.com/pbyrne/object-in-enumerable/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Gives the more-readable `foo.in?(some_list)` rather than having to revert to the more backward `some_list.include?(foo)`.
+test_files: 
+- spec/object-in-enumerable_spec.rb