RubyGems - anaphoric_case - Versions diffs - 0.0.1 - Mend

anaphoric_case 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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