case 0.5 → 0.5.1

data/README.rdoc

@@ -0,0 +1,241 @@
+= case
+
+The case gem is a power-up for Ruby's case-matching.
+
+== Structs
+
+<code>Case::Struct</code> is a subclass of Ruby's standard <code>Struct</code>
+class that supports structural matching.  When two instances of a normal Ruby
+<code>Struct</code> are matched, their fields are compared using the normal
+equality test.  <code>Case::Struct</code> uses the case-matching
+<code>===</code> operator instead.
+
+Here's an example of some of the things which are possible:
+
+ require 'case'
+
+ Foo = Case::Struct.new :foo
+
+ [Foo["blah"], Foo["hoge"], Foo[3], Foo["testing"]].each do |value|
+   case value
+   when Foo["testing"]
+     puts "matched testing"
+   when Foo["blah"]
+     puts "matched blah"
+   when Foo[String]
+     puts "matched string #{value.foo}"
+   else
+     puts "fell through"
+   end
+ end
+
+This will print:
+
+ matched blah
+ matched string hoge
+ fell through
+ matched testing
+
+== Wildcards
+
+The case gem also supports wildcards.  For example:
+
+ require 'case'
+
+ Foo = Case::Struct :name, :arg
+ 
+ [Foo["blah", 9], Foo["meat", 5], Foo["blah", 23]].each do |value|
+   case value
+   when Foo["blah", Case::Any]
+     puts "blah: #{value.arg}"
+   end
+ end
+
+This will print:
+
+ blah: 9
+ blah: 23
+
+<code>Case::Any</code> can also be used directly, though there's seldom
+reason to do so instead of using an <code>else</code> clause.
+
+ case thing
+ when "foo"
+   # specific case
+ when Case::Any
+   # fall-through
+ end
+
+ case thing
+ when "foo"
+   # specific case
+ else
+   # fall-through
+ end
+
+== Conjunction
+
+Case also supports simultaneously testing several cases in a single when:
+
+ [4.5, 3, 3.0].each do |value|
+   case value
+   when Case::All[Float, 3]
+     puts "float 3"
+   when 3
+     puts "generic 3"
+   when Float
+     puts "generic float"
+   end
+ end
+
+This prints:
+
+ generic float
+ generic 3
+ float 3
+
+== Disjunction
+
+It's also possible to match one of several alternatives, if you pass
+arguments to <code>Case::Any</code>:
+
+ require 'rational'
+ require 'case'
+
+ [3, Rational(3, 1), 6.0, 3.0].each do |value|
+   case value
+   when Case::All[Case::Any[Float, Rational], 3]
+     puts "matched #{value.inspect}"
+   end
+ end
+
+Which prints:
+
+ matched Rational(3, 1)
+ matched 3.0
+
+Once again, <code>Case::Any</code> can be used on its own, though usually
+there's not much point.
+
+ case thing
+ when Case::Any["foo", "bar"]
+   # either of these
+ end
+
+ case thing
+ when "foo", "bar"
+   # either of these
+ end
+
+(Note that <code>Case::Any[]</code> with no arguments matches nothing; it
+is different from <code>Case::Any</code> without braces.)
+
+== Comparisons
+
+<code>Case::Cmp</code> can be used to perform comparisons as part of
+case-matching:
+
+ require 'case'
+
+ [0..5].each do |value|
+   case value
+   when 0, 1
+     puts "0 or 1"
+   when Case::Cmp < 4
+     puts "less than 4"
+   else
+     puts "fell through"
+   end
+ end
+
+This prints:
+
+ 0 or 1
+ 0 or 1
+ less than 4
+ less than 4
+ fell through
+ fell through
+
+The <, >, >= and <= operators are all supported.
+
+== Guards
+
+More general tests can be put in when statements using <code>Case::Guard</code>.
+
+ require 'case'
+
+ ["foobar", "beef", "lorem"].each do |value|
+   case value
+   when Case::Guard.new { |v| v[1, 1] == "o" }
+     puts "second letter in #{value} is o"
+   else
+     puts "just got #{value}"
+   end
+ end
+
+This will print:
+
+ second letter in foobar is o
+ just got beef
+ second letter in lorem is o
+
+(Yes, I realize a regular expression could be used for this purpose.)
+
+In simple cases, when <code>Case::Guard</code> is being used directly, you
+don't even need to bother with the block parameter:
+
+ ["foobar", "beef", "lorem"].each do |value|
+   case value
+   when Case::Guard.new { value[1, 1] == "o" }
+     puts "second letter in #{value} is o"
+   else
+     puts "just got #{value}"
+   end
+ end
+
+(The parameter is really only there for when <code>Case::Guard</code> is
+being used as part of a larger expression.)
+
+== Negation
+
+<code>Case::Not</code> inverts the normal matching.  For example:
+
+ [1, "foobar", :blah].each do |value|
+   case value
+   when Case::Not[String]
+     puts value.inspect
+   end
+ end
+
+This will print:
+
+ 1
+ :blah
+
+== Arrays
+
+<code>Case::Array</code> is a subclass of <code>Array</code> which can
+be used as a pattern to do positional matching in arrays:
+
+ require 'case'
+
+ [["foo", 2], ["bar", 3, 4], ["bar", 9]].each do |value|
+   case value
+   when Case::Array["foo", Case::Any]
+     puts "Foo #{value[1]}"
+   when Case::Array["bar", Case::Any]
+     puts "Bar #{value[1]}"
+   end
+ end
+
+This will print:
+
+ Foo 2
+ Bar 9
+
+Note that <code>Case::Array</code> only matches arrays of the same
+length.
+
+<code>Case::Array</code> should only be used as a pattern; there's no
+need to use it in lieu of <code>Array</code> for your actual data.

data/Rakefile

@@ -4,10 +4,11 @@ require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'rake/clean'
 
-GEM_VERSION = "0.5"
+GEM_VERSION = "0.5.1"
 
 Rake::RDocTask.new do |task|
-  task.rdoc_files.add [ 'lib/**/*.rb' ]
+  task.rdoc_files.add [ 'lib/**/*.rb', 'README.rdoc' ]
+  task.main = 'README.rdoc'
 end
 
 task :clobber => [ :clean ]
@@ -27,7 +28,7 @@ gemspec = Gem::Specification.new do |gemspec|
   gemspec.author = "MenTaLguY <mental@rydia.net>"
   gemspec.summary = "Pattern matching for Ruby"
   gemspec.test_file = 'test/test_all.rb'
-  gemspec.files = FileList[ 'Rakefile', 'test/*.rb', 'lib/**/*.rb' ]
+  gemspec.files = FileList[ 'Rakefile', 'README.rdoc', 'test/*.rb', 'lib/**/*.rb' ]
   gemspec.require_paths = [ 'lib' ]
   gemspec.has_rdoc = true
   gemspec.platform = Gem::Platform::RUBY

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: case
 version: !ruby/object:Gem::Version 
-  version: "0.5"
+  version: 0.5.1
 platform: ruby
 authors: 
 - MenTaLguY <mental@rydia.net>
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 -04:00
+date: 2010-12-09 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -23,12 +23,15 @@ extra_rdoc_files: []
 
 files: 
 - Rakefile
+- README.rdoc
 - test/test_case.rb
 - test/test_all.rb
 - lib/case.rb
 - lib/case/core.rb
 has_rdoc: true
 homepage: 
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -49,9 +52,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: concurrent
-rubygems_version: 1.1.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Pattern matching for Ruby
 test_files: 
 - test/test_all.rb