RubyGems - anaphoric_case - Versions diffs - 0.0.1 - Mend

anaphoric_case 0.0.1

Files changed (10) hide show

data/.gitignore +7 -0
data/Gemfile +13 -0
data/README.md +56 -0
data/Rakefile +53 -0
data/anaphoric_case.gemspec +27 -0
data/lib/anaphoric_case/version.rb +3 -0
data/lib/anaphoric_case.rb +137 -0
data/spec/anaphoric_case_spec.rb +454 -0
data/spec/spec_helper.rb +85 -0
metadata +103 -0

data/.gitignore ADDED Viewed

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+report/*
+.yardoc
+.DS_Store

data/Gemfile ADDED Viewed

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Specify your gem's dependencies in anaphoric_case.gemspec
+#
+gem 'rake','0.9.1'
+gem 'pry','0.9.4pre1'
+gem 'rspec'
+gem 'simplecov'
+gem 'rspec-prof'
+gem 'i18n'
+gem 'ruby-debug19'
+#gemspec

data/README.md ADDED Viewed

@@ -0,0 +1,56 @@
+#Anaphoric Case
+Provides an anaphoric if, and anaphoric case-like construct as kernel methods.
+###Examples:
+English:  If the dog is on fire, put it out!
+Ruby: If the dog is on fire, put the dog out!
+This is all well and good provided dog is a simple reference, but if the dog
+is something more complicated, you wind up either having to do an assign
+in the if condition, or assign to a temporary variable before you extinguish
+Fido.
+This is similar to the use case for the andand gem.  It's especially handy
+when the dog being on fire is not a simple binary condition.  If Rin-tin-tin
+can summon help depending upon his dire situation, like if dog.fire also says
+which *part* of the dog is on fire, or where he is drowning at.
+    # Listen for sounds of distress
+    if dog.fire
+      owner.tell(dog.fire)
+    elsif dog.drowning
+      owner.tell(dog.drowning)
+    elsif dog.hungry
+      owner.tell(dog.hungry)
+    end
+An anaphoric if doesn't need to call `dog.fire` again in the executed block.
+    aif(dog.fire) { |it| owner.tell(it) }
+If you have multiple conditions, you probably want to use the switch/on construct
+    owner.tell(switch do
+      on dog.fire
+      on dog.drowing
+      on dog.hungry
+    end)
+Here, the dog will tell his owner the first condition he encounters.  `switch` can
+also behave like a regular case statement (albiet with fallthrough) if you like.
+    switch dog.name do
+      on /Rover/ { |it| "Come on over #{it}"}
+      on /Fido/  { |it| "Give #{it} a bone"}
+      on /Rin-Tin-Tin/ { |it| "#{it} is frequently mistaken for Lassie"}
+    end
+If the switch parameter takes a block, it will be passed into the block as an optional
+block parameter.  In addition, the `on` method will yield the parameter object of the
+`switch` method, rather than it's own parameter.
+If `switch` is called with an explicit receiver, it acts somewhat like `tap` in that the
+block is executed in the context of the receiver.

data/Rakefile ADDED Viewed

@@ -0,0 +1,53 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = "-d"
+end
+RSpec::Core::RakeTask.new(:spec_with_report) do |spec|
+  spec.fail_on_error = false
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = "--format html --out report/tests/report.html"
+end
+desc "Run all specs, profile the code, and generate a coverage report"
+task :report do
+  Dir.mkdir "report" unless File.exists? "report"
+  Dir.mkdir "report/profile" unless File.exists? "report/profile"
+  Dir.mkdir "report/tests" unless File.exists? "report/tests"
+  File.open "report/index.html","w" do |f|
+    f.write <<-HTML
+      <html>
+        <body>
+          <h1> Status Report </h1>
+          <p>
+            <a href="coverage/index.html"> Coverage </a>
+          </p>
+          <p>
+            <a href="profile/profile.graph.html"> Graph Speed Profile </a><br/>
+            <a href="profile/profile.stack.html"> Speed Profile </a>
+          </p>
+          <p>
+            <a href="test/report.html"> Test Report </a>
+          </p>
+        </body>
+      </html>
+    HTML
+  end
+  ENV["REPORT"] = "1"
+  Rake::Task[:spec_with_report].invoke
+  ENV["REPORT"] = ""
+end
+desc "Delete the report directory"
+task :clear_report do
+  `rm -rf report`
+end
+task :default => :spec

data/anaphoric_case.gemspec ADDED Viewed

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "anaphoric_case/version"
+Gem::Specification.new do |s|
+  s.name        = "anaphoric_case"
+  s.version     = AnaphoricCase::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Stephen Prater"]
+  s.email       = ["me@stephenprater.com"]
+  s.homepage    = "http://github.com/stephenprater/anaphoric_case"
+  s.summary     = %q{Provides a simple anaphoric case statement (called "switch/on")}
+  s.description = %q{You have twenty or so methods, and you want to call the first one that returns something other than nil,
+  If the dog is on fire, put it out.}
+  s.rubyforge_project = "anaphoric_case"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('simplecov')
+  s.add_development_dependency('rspec-prof')
+  s.add_development_dependency('i18n')
+end

data/lib/anaphoric_case/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module AnaphoricCase
+  VERSION = "0.0.1"
+end

data/lib/anaphoric_case.rb ADDED Viewed

@@ -0,0 +1,137 @@
+require 'pry'
+module AnaphoricCase
+  @__nest = 0
+  class << self
+    # @private
+    attr_accessor :__nest
+    def switch_stack
+      Thread.current[:__switch_stack] ||= []
+    end
+  end
+end
+module Kernel
+  # aif - anaphoric if.
+  #
+  # English is nice, in that if you want to make a conditional, you can say
+  # "if the dog is on fire, then put it out!" to say the equivalent thing in Ruby
+  # you say "if the dog is on fire, then put the dog out." - which is fine, if something
+  # of a hassle sometimes.  The "it" in the first example is an anaphor -
+  #
+  # @param [Object] result - any object, although it generally take the form of an expression.
+  # @return [Object, FalseClass] returns the results of the block if the paramater was
+  #   truthy (ie, it wasn't `nil` or `false`) or FalseClass if it wasn't
+  # @yield [Object] yields the parameter into a block if it's truthy, the block can optionally return
+  #   a different value, which will become the return value of #aif
+  def aif result = true, &block
+    if result
+      unless block.nil? then result = block.call(*[result].slice(0,block.arity)) end
+      return result
+    end
+    false
+  end
+  # switch - anaphoric case construct
+  #
+  # this is basically a form of sugar over a whole list of || operators or +or+ statements
+  # @example
+  #   thing = switch do
+  #     on object.quick_method_that_might_return_nil
+  #     on object.medium_method_that_might_return_nil
+  #     on object.slow_method_that_might_return_nil
+  #     on { raise 'everything returned nil!' }
+  #   end
+  #   # thing will be equal to results of the first method that
+  #   # didn't return nil
+  #
+  # This prevents you from either writing a difficult to read list of || operators, or
+  # having to construct lazily evaluated list of methods and parameters in order to do
+  # the cheapest thing.
+  # @param [Object] object -
+  #   parameter of all +on+ calls will be compared to this object using +===+
+  # @yield A block during which the +on+ method will be available - the block is required.
+  #   The block is always executed in the context of the receiver of the +switch+ method
+  #   so most of the time this is +self+ but if you call +switch+ with an explicit receiver
+  #   it acts somewhat like the {Object#tap} method
+  # @raise [ArgumentError] I tried to tell you the callable or block was required
+  # @return [Object, FalseClase] the results of the first call to +on+ that returned
+  #   anything truthy, or of its block
+  def switch object = nil, &block
+    block = block.dup # enable cross thread sharing of blocks
+    AnaphoricCase.__nest += 1
+    raise ArgumentError, "switch requires a block" unless block_given?
+    class << self
+      def on result = true, &block
+        # the current switch block in this thread
+        it = AnaphoricCase.switch_stack.last.instance_eval { @it }
+        begin
+          if it and (result === it or result == true)
+            result = Kernel.aif it, &block
+            throw :result, result if result
+          elsif result and not it
+            result = Kernel.aif result, &block
+            throw :result, result if result
+          end
+        rescue ArgumentError => e
+          if e.message =~ /throw :result/
+            raise NameError, "on without associated switch"
+          else
+            raise e
+          end
+        end
+        false
+      end
+    end
+    block.instance_eval do
+      @it = object
+    end
+    AnaphoricCase.switch_stack << block
+    res = catch :result do
+      if block.arity > 0
+        self.instance_exec(object, &block)
+      else
+        self.instance_eval(&block)
+      end
+    end
+    res ? res : false
+  ensure
+    AnaphoricCase.__nest -= 1
+    Thread.current[:__switch_stack].pop if object
+    if AnaphoricCase.__nest == 0
+      class << self
+        #you can get here without the on method being defined,
+        #so rescue this silently if so.
+        remove_method :on rescue nil
+      end
+    end
+  end
+  # on
+  #
+  # the +on+ method is available only in the {#switch} block - it basically
+  # functions exactly like the aif method.
+  #
+  # The first +on+ method whose argument is truthy will execute it's block and
+  # cause switch to return the value of the block.
+  # @see #aif
+  # @see #switch
+  # @param [Object] result - any object, normally an expression
+  #   it defaults to true, so you can use an +on+ without an argument as a default clause
+  # @raise [NameError] if called from outside of a switch block or across
+  #   the stack rewinding barrier
+  # @yield [Object] yields the parameter into the block, which can optionally
+  #   return a different value. <br/> if the block of an +on+ returns +nil+ or +false+,
+  #   evaluation will continue at the next call to +on+. If the block is ommitted
+  #   the parameter passed to +on+ will be returned (by {#switch})
+  def on result=true; super; end
+  remove_method :on
+end

data/spec/anaphoric_case_spec.rb ADDED Viewed

@@ -0,0 +1,454 @@
+require 'spec_helper'
+require 'anaphoric_case'
+require 'timeout'
+describe "it is an anaphoric case" do
+  before :all do
+    class Harness
+      def initialize
+        @array = [1,2,3,4,5]
+        @hash = { :bacon => "cheese", :pie => "sky", :snoopy => "pizza" }
+        @string = "That is quite a mustache you've got there, sheriff."
+        @snitch = 0
+      end
+      def count
+        @array
+      end
+      def flavors thing
+        @hash[thing]
+      end
+      def compliment
+        @string
+      end
+      def snitch
+        @snitch
+      end
+      def narc
+        @snitch += 1
+        if @string == "I committed regicide"
+          true
+        else
+          false
+        end
+      end
+      def cover_evidence
+        @string = "I committed regicide"
+        false
+      end
+    end
+  end
+  before :each do
+    @test = Harness.new
+  end
+  profile :all do
+    it "provides a simple aif method" do
+      res = nil
+      aif(5 + 4) { |it| res = it }
+      res.should == 9
+      res = nil
+      res = aif(5 + 4) { 'okay!' }
+      res.should == 'okay!'
+      res = aif(5 < 4) { 'monkey' }
+      res.should == false
+    end
+    it "should return the first object which is truthy" do
+      res = switch do
+        on 1
+        on false
+        on nil
+      end
+      res.should == 1
+      res = switch do
+        on false
+        on 2
+        on nil
+      end
+      res.should == 2
+      res = switch do
+        on false
+        on nil
+        on :bob
+      end
+      res.should == :bob
+      res = switch do
+        on false
+        on [1,2,3,4,5]
+      end
+      res.should == [1,2,3,4,5]
+    end
+    it "is lazy" do
+      res = switch do
+        on @test.narc
+        on @test.cover_evidence
+        on @test.narc
+        on @test.compliment
+      end
+      res.should == true
+      @test.snitch.should == 2
+    end
+    it "can execute anaphoric blocks using on" do
+      res = switch do
+        on(false) { |it| it.blah_blah } #this would raise an error if it was ever called
+        on(1) { |it| it + 1 }
+      end
+      res.should == 2
+    end
+    it "can have an else clause by way of on with no parameters" do
+      res = switch do
+        on false
+        on nil
+        on { 5 }
+      end
+      res.should == 5
+      res = switch do
+        on 1
+        on { 1 }
+      end
+      res.should == 1
+    end
+    it "on blocks which return falsey cause evaulation to continue" do
+      res = switch do
+        on { nil }
+        on { :turtle }
+      end
+      res.should == :turtle
+    end
+    it "can execute within an object" do
+      test_test = proc do
+        switch do
+          on(count.length > 5)   { count }
+          on(count.length < 5)   { count }
+          on(count.length == 5)  { :five }
+        end
+      end
+      @test.instance_eval(&test_test).should == :five
+      @test.count.slice!(0,3)
+      @test.instance_eval(&test_test).should == [4,5]
+      @test.count.concat [1,1,1,1]
+      @test.instance_eval(&test_test).should == [4,5,1,1,1,1]
+    end
+    it "can look in an object if it's not within it" do
+      res = switch do
+        on(@test.flavors :lime)
+        on(@test.flavors :snoopy)
+        on(@test.flavors :mushrooms)
+      end
+      res.should == "pizza"
+    end
+    it "can't call on from outside of switch block" do
+      lambda { on }.should raise_error NameError
+      # ensure the on method is defined the next time
+      # we call it
+      flag = false
+      t1 = Thread.new do
+        switch do
+          on false
+          flag = true
+          sleep 0.1
+          on true
+        end
+        flag = false
+      end
+      Timeout.timeout(1) { loop until flag == true }
+      # should transform the uncaught :throw error into a NameError
+      (self.respond_to? :on).should be true #it's defined in the thread
+      lambda { on }.should raise_error NameError, "on without associated switch"
+      loop until flag == false
+      (self.respond_to? :on).should be false
+      lambda { on }.should raise_error NameError
+    end
+    it "can raise past the (internal) throw" do
+      lambda do
+        switch do
+          on { |a,b,c| raise ArgumentError }
+        end
+      end.should raise_error ArgumentError
+    end
+    it "can nest safely" do
+      res = switch do
+        on(@test.compliment =~ /mustache/) do |it|
+          switch do
+            on(@test.compliment =~ /baron/) { "The Barons Mustache"}
+            on(@test.compliment =~ /sheriff/) { "The Sheriff's Mustache" }
+          end
+        end
+        on(@test.count == 5)
+      end
+      res.should == "The Sheriff's Mustache"
+      res = switch do
+        on do |it|
+          switch do
+            on { nil }
+          end
+        end
+        on { 5 }
+      end
+      res.should == 5
+    end
+    it "can be called with explicit receiver" do
+      # this makes it act a little bit like "tap"
+      res = @test.switch do
+        on (flavors :lime) { |it| it.blah } #would raise
+        on (flavors :snoopy)
+        on { raise 'terribly awry'}
+      end
+      res.should == "pizza"
+    end
+    it "can act like a regular case statement if called with a parameter" do
+      test = lambda do |test_obj|
+        res = switch test_obj do
+          on(/baron/)   { |it| "'#{it.chomp('.')},' said the queen."}
+          on(/sheriff/) { |it| "'#{it.chomp('.')},' I said."}
+          on
+        end
+      end
+      test.call("That's a nice mustache sheriff.").should == "'That's a nice mustache sheriff,' I said."
+      test.call("That's a nice mustache baron.").should == "'That's a nice mustache baron,' said the queen."
+      test.call("I hate mustache's").should == "I hate mustache's"
+    end
+    it "can act like a regular case statement nested" do
+      remember = @test.compliment.dup
+      res = switch @test.compliment do
+        on /sheriff/ do |it|
+          # its is @test.compliment
+          switch it do
+            #it is STILL @test.compliment
+            on(/mustache/) { |thing| false }
+            #return false to fall through
+          end
+        end
+        # here it should STILL be @test.compliment
+        # which means this should NOT match
+        on(/baron/) { |it| it.blah }
+        # but this should.
+        on(/sheriff/) { |it| it + "okay" }
+      end
+      res.should == remember + "okay"
+    end
+    it "can be called both with and without a parameter" do
+      res = switch do
+        # there is no default __it__
+        on @test.compliment =~ /sheriff/ do |it|
+          # it here is "43" the place where sheriff occures
+          switch it do |ot|
+            on(ot > 43)  { raise 'ohnoes' }
+            on(ot < 43)  { raise 'ohnoes again'}
+            # this will signal completion
+            on(ot == 43) { 'okay!' }
+          end
+        end
+        # so this will not run
+        on(@test.compliment =~ /baron/) { |it| it.blah }
+      end
+      res.should == 'okay!'
+      res = switch @test.compliment do
+        # this will match
+        on /mustache/ do |it|
+          switch do
+            # this should not match, but it's truthy
+            on /poor/
+          end
+        end
+      end
+      #so the result of the entire block is the last truthy thing
+      res.should == /poor/
+      res = switch @test.compliment do
+        on /mustache/ do |it|
+          # this will CLOSE around it.
+          switch do
+            on(it =~ /sheriff/) { 'yes it is' }
+            on true
+          end
+        end
+        on(/baron/) { true }
+      end
+      res.should == 'yes it is'
+      # can switch eval contexts each time
+      res = switch "this" do
+        on /this/ do
+          switch "that" do
+            on /that/ do
+              switch "thing" do
+                on /thing/ do
+                  "foogle bear"
+                end
+              end
+            end
+          end
+        end
+      end
+      res.should == "foogle bear"
+    end
+    it "nests in threads" do
+      res1, res2 = nil,nil
+      t1 = Thread.new do
+        res1 = switch "this" do
+          on /this/ do
+            switch "that" do
+              on(/that/) { "that" }
+            end
+          end
+        end
+      end
+      t2 = Thread.new do
+        res2 = switch "weasel" do
+          on /weasel/ do
+            switch "monkey" do
+              on(/monkey/) { "monkey" }
+            end
+          end
+        end
+      end
+      Timeout.timeout 1 do
+        loop do
+          t = [t1.status, t2.status]
+          t.delete(false)
+          break if t.empty?
+        end
+      end
+      res1.should == "that"
+      res2.should == "monkey"
+    end
+    it "reusing blocks with params works across threads" do
+      thing = proc do
+        on(/Pestilence/) { |it| sleep 0.1; "#{it} made you cough." } #yep, mess it up
+        on(/Death/) { |it| "#{it} killed you." }
+        on(/Famine/) { |it| "#{it} made you hungry."}
+        on(/War/) { |it| "#{it} was loud." }
+      end
+      res1 = switch "War in Iraq", &thing
+      res1.should == "War in Iraq was loud."
+      res2, res3,res4 = nil, nil, nil
+      t1 = Thread.new do
+        res2 = switch "Famine in Ireland", &thing
+      end
+      t2 = Thread.new do
+        res3 = switch "Death at a Funeral", &thing
+      end
+      t3 = Thread.new do
+        res4 = switch "Pestilence at the presschool", &thing
+      end
+      Timeout.timeout 1 do
+        loop do
+          t = [t1.status, t2.status, t3.status]
+          t.delete(false)
+          break if t.empty?
+        end
+      end
+      res2.should == "Famine in Ireland made you hungry."
+      res3.should == "Death at a Funeral killed you."
+      res4.should == "Pestilence at the presschool made you cough."
+    end
+    it "threads?" do
+      res1, res2, res3 = nil, nil, nil
+      t1 = Thread.new do
+        res1 = switch do
+          on(@test.flavors :lime)
+          on(@test.flavors :snoopy)
+          on(@test.flavors :bacon)
+        end
+      end
+      t2 = Thread.new do
+        res2 = switch do
+          on(@test.count.length == 6)
+          on(@test.count.length == 5) { @test.count }
+        end
+      end
+      # this is designed to make sure it running after the first two
+      # finish.  if switch isn't thread safe, the last
+      # call to on will raise NoMethodError
+      t3 = Thread.new do
+        res3 = switch do
+          on false
+          on nil
+          sleep 0.1
+          on true
+        end
+      end
+      Timeout.timeout 1 do
+        loop do
+          t = [t1.status, t2.status, t3.status]
+          t.delete(false)
+          break if t.empty?
+        end
+      end
+      res1.should == "pizza"
+      res2.should == [1,2,3,4,5]
+      res3.should == true
+    end
+  end
+end

data/spec/spec_helper.rb ADDED Viewed

@@ -0,0 +1,85 @@
+if ENV["REPORT"] == "1" then
+  require 'simplecov'
+  require 'ruby-prof'
+  require 'rspec-prof'
+  require 'ruby-debug'
+  SimpleCov.start do
+    add_filter "/spec.rb/"
+    coverage_dir "report/coverage"
+  end
+  class RSpecProf::Profiler
+    def initialize options
+      @options = default_options.merge(options)
+      ENV["RUBY_PROF_MEASURE_MODE"] = options[:measure_mode]
+      RubyProf.figure_measure_mode
+      STDOUT.puts "initi"
+    end
+    alias :old_default :default_options
+    def default_options
+      old = old_default
+      old.merge({
+        :directory => './report/profile',
+        :printer => RubyProf::GraphHtmlPrinter,
+        :stop_block => proc do |result|
+          #remove every Rspec method possible.
+          result.threads.each do |thread_id, methods|
+            begin
+              match = /RSpec.*?/
+              i = 0
+              while i < methods.size
+                mi = methods[i]
+                method_name = mi.full_name
+                if method_name =~ /RSpec.*?/
+                  (i += 1; next) if mi.root?
+                  methods.delete_at(i)
+                  mi.eliminate!
+                else
+                  i += 1
+                end
+              end
+            end
+          end
+          result
+        end
+      })
+    end
+    def stop
+      file = options[:file] + ".html"
+      result = RubyProf.stop
+      printer_class = options[:printer]
+      with_io(file) do |out|
+        if @options[:stop_block].respond_to? :call
+          result = @options[:stop_block].call(result)
+        end
+        printer = printer_class.new(result)
+        printer.print(out, :print_file => options[:print_file], :min_percent => options[:min_percent])
+      end
+    end
+  end
+  RSpec.configure do |config|
+    config.around :each do |example|
+      STDOUT.puts example.metadata[:description]
+      example.run
+    end
+  end
+else
+  module EmptyProfile
+    def profile *args
+      yield
+    end
+  end
+  RSpec.configure do |config|
+    config.extend EmptyProfile
+  end
+end
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

metadata ADDED Viewed

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: anaphoric_case
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease:
+platform: ruby
+authors:
+- Stephen Prater
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-09-15 00:00:00.000000000 -05:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &4006280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *4006280
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &4006070 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *4006070
+- !ruby/object:Gem::Dependency
+  name: rspec-prof
+  requirement: &4005860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *4005860
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &4005650 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *4005650
+description: ! "You have twenty or so methods, and you want to call the first one
+  that returns something other than nil,\n  If the dog is on fire, put it out."
+email:
+- me@stephenprater.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- anaphoric_case.gemspec
+- lib/anaphoric_case.rb
+- lib/anaphoric_case/version.rb
+- spec/anaphoric_case_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/stephenprater/anaphoric_case
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: anaphoric_case
+rubygems_version: 1.5.2
+signing_key:
+specification_version: 3
+summary: Provides a simple anaphoric case statement (called "switch/on")
+test_files:
+- spec/anaphoric_case_spec.rb
+- spec/spec_helper.rb