mithril-specs 0.2.0

data/CHANGELOG.md

@@ -0,0 +1,31 @@
+## Development Versions
+
+#### Version 0.2.0
+  * Implemented ProxyController
+
+#### Version 0.1.2
+  * Added HelpActions mixin
+
+#### Version 0.1.1
+  * Added logger property to Mithril module
+
+#### Version 0.1.0
+  * Implemented AbstractController
+
+#### Version 0.0.4
+  * Renamed ActionMixin to MixinWithActions for clarity
+  * Improved specs for Mixin, MixinWithActions
+
+#### Version 0.0.3
+  * Implemented Mithril::Parsers::SimpleParser
+
+#### Version 0.0.2
+  * Implemented Mithril::Controllers::Mixins::ActionsBase
+  * Implemented Mithril::Request
+  * Added and monkey-patched RSpec Matchers
+
+#### Version 0.0.1
+  * Implemented Mithril::Mixin
+
+#### Version 0.0.0
+  * Smoke test

data/spec/mithril/controllers/_text_controller_helper.rb

@@ -0,0 +1,81 @@
+# spec/controllers/text_controller_helper.rb
+
+require 'mithril/controllers/abstract_controller_helper'
+
+shared_examples_for "Mithril::Controllers::_TextController" do
+  it_behaves_like Mithril::Controllers::AbstractController
+  
+  let :input do "text input"; end
+  
+  describe :parser do
+    specify { expect(instance.parser).to be_a Mithril::Parsers::SimpleParser }
+  end # describe
+
+  describe :parse_command do
+    specify { expect(instance.parse_command input).to be_a Array }
+
+    specify "returns nil" do
+      command, args = instance.parse_command input
+      expect(command).to be nil
+    end # specify
+  end # describe
+  
+  describe :command_missing do
+    specify "returns the text with a helpful message" do
+      output = instance.command_missing input
+      expect(output).to match /don't know how/
+      expect(output).to match /#{input}/
+    end # specify
+  end # describe
+  
+  describe :invoke_command do
+    specify "returns the text with a helpful message" do
+      output = instance.invoke_command input
+      expect(output).to match /don't know how/
+      expect(output).to match /#{input}/
+    end # specify
+  end # describe
+  
+  context "with actions defined" do
+    let :command   do FactoryGirl.generate :action_key; end
+    let :arguments do %w(arguments for command); end
+    
+    before :each do
+      described_class.define_action command do |session, args| args.join(' '); end
+    end # before each
+    
+    specify { expect(instance.can_invoke? command.to_s).to be true }
+    
+    describe :invoke_command do
+      let :text do "#{command} #{arguments.join(' ')}"; end
+      
+      specify "invokes matching action" do
+        instance.should_receive(:invoke_action).with(command, arguments).and_call_original
+        instance.should_receive(:"action_#{command}").with(request.session, arguments).and_call_original
+        instance.invoke_command text
+      end # specify
+      
+      specify { expect(instance.invoke_command text).to eq arguments.join(' ') }
+      
+      context "with a non-matching command" do
+        let :non_matching do FactoryGirl.generate :action_key; end
+        
+        specify { expect(instance.invoke_command non_matching.to_s).to match /don't know how/i }
+      end # context
+    end # describe
+  end # context
+  
+  describe "empty actions" do
+    def self.input
+      chars, words = [*"a".."z", *"0".."9"], [""] * 5
+      5.times do |i|
+        word = ""
+        (6 + rand(10)).times do word << chars[rand(36)]; end
+        words[i] = word
+      end # times
+      words.join " "
+    end # helper input
+    
+    it_behaves_like "Mithril::Controllers::AbstractController#empty_actions", input
+  end # describe
+end # describe

data/spec/mithril/controllers/abstract_controller_helper.rb

@@ -0,0 +1,118 @@
+# spec/mithril/controllers/abstract_controller_helper.rb
+
+require 'mithril/controllers/mixins/actions_base_helper'
+
+require 'mithril/controllers/abstract_controller'
+
+shared_examples_for Mithril::Controllers::AbstractController do
+  it_behaves_like Mithril::Controllers::Mixins::ActionsBase
+  
+  describe :constructor do
+    specify { expect(described_class).to construct.with(1).arguments }
+    specify { expect { described_class.new request }.not_to raise_error }
+  end # describe
+  
+  describe :parser do
+    specify { expect(instance).to respond_to(:parser).with(0).arguments }
+  end # describe
+  
+  describe :parse_command do
+    let :input do Object.new; end
+    
+    specify { expect(instance).to respond_to(:parse_command).with(1).arguments }
+    specify "delegates to the parser" do
+      instance.parser.should_receive(:parse_command).with(input)
+      instance.parse_command(input)
+    end # specify
+  end # describe
+  
+  describe :command_missing do
+    let :input do Object.new; end
+    
+    specify { expect(instance).to respond_to(:command_missing).with(1).arguments }
+  end # describe
+  
+  describe :commands do
+    specify { expect(instance).to respond_to(:commands).with(0).arguments }
+    specify { expect(instance.commands).to be_a Array }
+  end # describe
+  
+  describe :has_command? do
+    specify { expect(instance).to respond_to(:has_command?).with(1).arguments }
+    specify { expect(instance).not_to have_command FactoryGirl.generate :action_key }
+  end # describe
+  
+  describe :can_invoke? do
+    specify { expect(instance).to respond_to(:can_invoke?).with(1).arguments }
+    specify { expect(instance.can_invoke? FactoryGirl.generate(:action_key).to_s).
+      to eq false }
+  end # describe
+  
+  describe :invoke_command do
+    specify { expect(instance).to respond_to(:invoke_command).with(1).arguments }
+  end # describe
+  
+  context "with actions defined" do
+    let :command do FactoryGirl.generate :action_key; end
+    
+    before :each do described_class.define_action command do |session, args|; end; end
+    
+    specify { expect(instance.commands).to include command.to_s.gsub('_',' ') }
+    
+    specify { expect(instance).to have_action command }
+    
+    describe "inheriting defined actions" do
+      let :descendant_class do Class.new described_class; end
+      let :instance do descendant_class.new request; end
+      
+      specify { expect(instance).to have_action command }
+    end # describe
+  end # context
+  
+  describe "empty actions" do
+    describe :allow_empty_action? do
+      specify { expect(instance).to respond_to(:allow_empty_action?).with(0).arguments }
+    end # describe
+  end # describe
+end # shared examples
+
+shared_examples_for "Mithril::Controllers::AbstractController#empty_actions" do |input|
+  let :arguments do instance.parse_command(input)[1]; end
+  
+  before :each do
+    if instance.has_action? :""
+      instance.stub :_action do |session, arguments| arguments; end
+    else
+      described_class.send :define_action, :"" do |session, arguments| arguments; end
+    end # if-else
+  end # before each
+  
+  context "disallowing empty actions" do
+    before :each do instance.stub :allow_empty_action? do false; end; end
+    
+    specify { expect(instance.allow_empty_action?).to be false }
+    
+    specify "rejects arbitrary input" do
+      expect(instance.can_invoke? input).to be false
+    end # describe
+  end # context
+  
+  context "allowing empty actions" do
+    before :each do instance.stub :allow_empty_action? do true; end; end
+    
+    specify { expect(instance.allow_empty_action?).to be true }
+    
+    specify "accepts arbitrary input" do
+      expect(instance.can_invoke? input).to be true
+    end # specify
+    
+    specify "calls invoke action on empty action" do
+      instance.should_receive(:invoke_action).with(:"", arguments).and_call_original
+      instance.invoke_command input
+    end # specify
+    
+    specify "returns the input" do
+      expect(instance.invoke_command input).to eq arguments
+    end # specify
+  end # context
+end # shared examples

data/spec/mithril/controllers/mixins/actions_base_helper.rb

@@ -0,0 +1,121 @@
+# spec/mithril/controllers/mixins/actions_base_helper.rb
+
+require 'mithril/controllers/mixins/actions_base'
+require 'mithril/request'
+
+shared_examples_for Mithril::Controllers::Mixins::ActionsBase do
+  let :command do FactoryGirl.generate :action_key; end
+  
+  specify { expect(instance).not_to respond_to :"action_#{command}" }
+  
+  describe "self.define_action" do
+    specify { expect(described_class).to respond_to(:define_action).
+      with(1..2).arguments.and.a_block }
+  end # describe
+  
+  describe "self.actions" do
+    specify { expect(described_class).to respond_to(:actions).with(0..1).arguments }
+    
+    specify { expect(described_class.actions).to be_a Hash }
+  end # describe
+  
+  describe :request do
+    specify { expect(instance).to respond_to(:request).with(0).arguments }
+    specify { expect(instance.request).to be_a [Mithril::Request, nil] }
+  end # describe
+  
+  describe :actions do
+    specify { expect(instance).to respond_to(:actions).with(0..1).arguments }
+    specify { expect(instance.actions).to be_a Hash }
+  end # describe
+  
+  describe :has_action? do
+    let :command do FactoryGirl.generate :action_key; end
+    
+    specify { expect(instance).to respond_to(:has_action?).with(1..2).arguments }
+    specify { expect(instance.has_action? command).to be false }
+    specify { expect(instance.has_action? command, true).to be false }
+  end # describe
+  
+  describe :invoke_action do
+    specify { expect(instance).to respond_to(:invoke_action).with(2..3).arguments }
+  end # describe
+  
+  context "with an action defined" do
+    let :command do FactoryGirl.generate :action_key; end
+    
+    before :each do
+      described_class.define_action command do |session, arguments| arguments.join(" "); end
+    end # before each
+    
+    specify { expect(described_class.actions).to have_key command }
+    specify { expect(described_class.actions true).to have_key command }
+    
+    specify { expect(instance.actions).to have_key command }
+    specify { expect(instance.actions true).to have_key command }
+    
+    specify { expect(instance).to have_action command }
+    specify { expect(instance).to have_action command, true }
+    
+    describe :invoke_action do
+      let :request do defined?(super) ? super() : FactoryGirl.build(:request); end
+      let :arguments do %w(some args); end
+      let :output do arguments.join(" "); end
+      
+      before :each do instance.stub :request do request; end; end
+      
+      specify "calls the defined method" do
+        instance.should_receive(:"action_#{command}").with(request.session, arguments)
+        instance.invoke_action command, arguments
+      end # specify
+      
+      specify "calls the defined method as private" do
+        instance.should_receive(:"action_#{command}").with(request.session, arguments)
+        instance.invoke_action command, arguments, true
+      end # specify
+      
+      specify { instance.invoke_action(command, arguments).should eq output }
+      specify { instance.invoke_action(command, arguments, true).should eq output }
+    end # describe
+  end # context
+  
+  describe "with a private action defined" do
+    let :command do FactoryGirl.generate :action_key; end
+    
+    before :each do
+      described_class.define_action command, :private => true do |session, arguments|
+        arguments.join(" ")
+      end # define action
+    end # before each
+    
+    specify { expect(described_class.actions).not_to have_key command }
+    specify { expect(described_class.actions true).to have_key command }
+    
+    specify { expect(instance.actions).not_to have_key command }
+    specify { expect(instance.actions true).to have_key command }
+    
+    specify { expect(instance).not_to have_action command }
+    specify { expect(instance).to have_action command, true }
+    
+    describe :invoke_action do
+      let :request do defined?(super) ? super() : FactoryGirl.build(:request); end
+      let :arguments do %w(some args); end
+      let :output do arguments.join(" "); end
+      
+      before :each do instance.stub :request do request; end; end
+      
+      specify "calls the defined method" do
+        instance.should_not_receive(:"action_#{command}")
+        instance.invoke_action command, arguments
+      end # specify
+      
+      specify "calls the defined method as private" do
+        instance.should_receive(:"action_#{command}").with(request.session, arguments)
+        instance.invoke_action command, arguments, true
+      end # specify
+      
+      specify { instance.invoke_action(command, arguments).should be nil }
+      specify { instance.invoke_action(command, arguments, true).should eq output }
+    end # describe
+  end # describe
+end # shared_examples

data/spec/mithril/controllers/mixins/help_actions_helper.rb

@@ -0,0 +1,111 @@
+# spec/mithril/controllers/mixins/help_actions_helper.rb
+
+require 'mithril/controllers/mixins/actions_base_helper'
+
+require 'mithril/controllers/mixins/help_actions'
+
+shared_examples_for Mithril::Controllers::Mixins::HelpActions do
+  it_behaves_like Mithril::Controllers::Mixins::ActionsBase
+  
+  describe :help_message do
+    specify { expect(instance).to respond_to(:help_message).with(0).arguments }
+    specify { expect(instance.help_message).to be_a String }
+  end # describe
+  
+  describe "help action" do
+    specify { expect(instance).to have_action :help }
+    
+    context "with a help string defined" do
+      let :arguments do %w(); end
+      
+      before :each do
+        instance.stub :help_message do
+          "You put your left foot in, you take your left foot out."
+        end # stub
+      end # before each
+      
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /put your left foot in/i }
+      
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /following commands are available/i }
+    end # context
+    
+    describe "with no arguments" do
+      let :arguments do %w(); end
+      
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /following commands are available/i }
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /help/i }
+    end # context
+    
+    describe "with help" do
+      let :arguments do %w(help); end
+      
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /the help command/i }
+    end # describe
+  end # describe
+  
+  context "with additional actions defined" do
+    let :action_keys do
+      [].tap do |ary|
+        1.times do ary << FactoryGirl.generate(:action_key); end
+      end # tap
+    end # let
+    
+    before :each do
+      action_keys.each do |key|
+        described_class.send :define_action, key do |session, arguments|; end
+      end # each
+    end # before each
+    
+    describe "help action" do
+      specify "lists available commands" do
+        (action_keys << :help).each do |key|
+          command = key.to_s.gsub('_',' ')
+          expect(instance.invoke_action :help, %w()).to match /#{command}/
+        end # each
+      end # specify
+      
+      specify "invokes the command with help" do
+        session = instance.request ? (instance.request.session || {}) : {}
+        action_keys.each do |key|
+          command = key.to_s.gsub('_',' ')
+          instance.should_receive(:"action_#{key}").with(session, %w(help))
+          instance.invoke_action :help, command.split(' ')
+        end # each
+      end # specify
+    end # describe
+  end # context
+  
+  context "with additional commands defined" do
+    let :commands do
+      [].tap do |ary|
+        1.times do ary << FactoryGirl.generate(:action_key).to_s.gsub('_', ' '); end
+      end # tap
+    end # let
+    
+    before :each do
+      instance.stub :commands do commands; end
+      instance.stub :has_command? do |command| commands.include? command; end
+    end # before each
+    
+    describe "help action" do
+      specify "lists available commands" do
+        (commands << "help").each do |command|
+          expect(instance.invoke_action :help, %w()).to match /#{command}/
+        end # each
+      end # specify
+      
+      specify "invokes the command with help" do
+        session = instance.request ? (instance.request.session || {}) : {}
+        commands.each do |command|
+          instance.should_receive(:invoke_command).with("#{command} help")
+          instance.invoke_action :help, [command]
+        end # each
+      end # specify
+    end # describe
+  end # context
+end # shared examples

data/spec/mithril/controllers/proxy_controller_helper.rb

@@ -0,0 +1,111 @@
+# spec/mithril/controllers/proxy_controller_helper.rb
+
+require 'mithril/controllers/abstract_controller_helper'
+
+require 'mithril/controllers/abstract_controller'
+require 'mithril/controllers/proxy_controller'
+
+shared_examples_for Mithril::Controllers::ProxyController do
+  it_behaves_like Mithril::Controllers::AbstractController
+  
+  let :proxy do described_class; end
+  let :child do Class.new Mithril::Controllers::AbstractController; end
+  let :proxy_instance do proxy.new request; end
+  let :child_instance do child.new request; end
+  let :proxy_action do FactoryGirl.generate :action_key; end
+  let :child_action do FactoryGirl.generate :action_key; end
+  let :proxy_command do proxy_action.to_s.gsub('_', ' '); end
+  let :child_command do child_action.to_s.gsub('_', ' '); end
+  
+  before :each do
+    proxy.define_action proxy_action do |session, arguments|; "proxy command"; end
+    child.define_action child_action do |session, arguments|; "child command"; end
+  end # before each
+  
+  let :session   do {}; end
+  let :arguments do []; end
+  
+  specify { expect(proxy_instance).to have_action proxy_action }
+  specify { expect(child_instance).to have_action child_action }
+  specify { expect(proxy_instance).not_to have_action child_action }
+  
+  describe :allow_own_actions_while_proxied? do
+    specify { expect(proxy_instance).to respond_to(:allow_own_actions_while_proxied?).
+      with(0).arguments }
+  end # describe
+  
+  describe :proxy do
+    specify { expect(proxy_instance).to respond_to(:proxy).with(0).arguments }
+    specify { expect(proxy_instance.proxy).to be_a [Mithril::Controllers::AbstractController, nil] }
+  end # describe proxy
+  
+  describe :commands do
+    specify { expect(proxy_instance.commands).to include proxy_command }
+    specify { expect(proxy_instance.commands).not_to include child_command }
+  end # describe
+  
+  describe :has_command? do
+    specify { expect(proxy_instance).to have_command proxy_command }
+    specify { expect(proxy_instance).not_to have_command child_command }
+  end # describe
+  
+  describe :can_invoke? do
+    specify { expect(proxy_instance.can_invoke? proxy_command).to be true }
+    specify { expect(proxy_instance.can_invoke? child_command).to be false }
+  end # describe
+  
+  describe :can_invoke_on_self? do
+    specify { expect(proxy_instance).to respond_to(:can_invoke_on_self?).
+      with(1).arguments }
+    specify { expect(proxy_instance.can_invoke_on_self? proxy_command).to be true }
+    specify { expect(proxy_instance.can_invoke_on_self? child_command).to be false }
+  end # describe
+  
+  describe :invoke_command do
+    specify { expect(proxy_instance.invoke_command proxy_command).to eq "proxy command" }
+  end # describe
+  
+  context "with a proxy subject defined" do
+    before :each do proxy_instance.stub :proxy do child_instance; end; end
+    
+    specify { expect(proxy_instance.proxy).to be child_instance }
+    
+    specify { expect(proxy_instance.commands).to include child_command }
+    
+    specify { expect(proxy_instance).to have_command child_command }
+    
+    specify { expect(proxy_instance.can_invoke? child_command).to be true }
+    
+    specify { expect(proxy_instance.can_invoke_on_self? child_command).to be false }
+    
+    specify { expect(proxy_instance.invoke_command child_command).to eq "child command" }
+    
+    context "allowing own actions" do
+      before :each do proxy_instance.stub :allow_own_actions_while_proxied? do true; end; end
+      
+      specify { expect(proxy_instance.allow_own_actions_while_proxied?).to be true }
+      
+      specify { expect(proxy_instance.commands).to include proxy_command }
+
+      specify { expect(proxy_instance).to have_command proxy_command }
+
+      specify { expect(proxy_instance.can_invoke? proxy_command).to be true }
+
+      specify { expect(proxy_instance.invoke_command proxy_command).to eq "proxy command" }
+    end # context
+
+    context "allowing own actions" do
+      before :each do proxy_instance.stub :allow_own_actions_while_proxied? do false; end; end
+
+      specify { expect(proxy_instance.allow_own_actions_while_proxied?).to be false }
+
+      specify { expect(proxy_instance.commands).not_to include proxy_command }
+
+      specify { expect(proxy_instance).not_to have_command proxy_command }
+
+      specify { expect(proxy_instance.can_invoke? proxy_command).to be false }
+
+      specify { expect(proxy_instance.invoke_command proxy_command).to match /don't know how/i }
+    end # context
+  end # context
+end # shared examples

data/spec/mithril/mixin_helper.rb

@@ -0,0 +1,54 @@
+# spec/mithril/mixin_helper.rb
+
+require 'mithril/mixin'
+
+shared_examples_for Mithril::Mixin do
+  let :ancestor_instance_method do FactoryGirl.generate(:action_key); end
+  let :ancestor_class_method do FactoryGirl.generate(:action_key); end
+  let :ancestor_module do
+    mod = Module.new
+    mod.send :extend, Mithril::Mixin
+    mod.send :define_method, ancestor_instance_method do; end
+    mod.const_set :ClassMethods, Module.new
+    mod::ClassMethods.send :define_method, ancestor_class_method do; end
+    mod
+  end # let
+  
+  let :parent_instance_method do FactoryGirl.generate(:action_key); end
+  let :parent_class_method do FactoryGirl.generate(:action_key); end
+  let :parent_module do
+    mod = Module.new
+    mod.send :extend, Mithril::Mixin
+    mod.send :mixin, ancestor_module
+    mod.send :define_method, parent_instance_method do; end
+    mod.const_set :ClassMethods, Module.new
+    mod::ClassMethods.send :define_method, parent_class_method do; end
+    mod
+  end # let
+  
+  context "with a direct mixin" do
+    before :each do described_class.send :mixin, ancestor_module; end
+    
+    describe "instance methods are mixed in" do
+      specify { expect(instance).to respond_to ancestor_instance_method }
+    end # describe
+    
+    describe "class method are mixed in" do
+      specify { expect(described_class).to respond_to ancestor_class_method }
+    end # describe
+  end # context
+  
+  context "with a cascading mixin" do
+    before :each do described_class.send :mixin, parent_module; end
+    
+    describe "instance methods are mixed in" do
+      specify { expect(instance).to respond_to ancestor_instance_method }
+      specify { expect(instance).to respond_to parent_instance_method }
+    end # describe
+    
+    describe "class method are mixed in" do
+      specify { expect(described_class).to respond_to ancestor_class_method }
+      specify { expect(described_class).to respond_to parent_class_method }
+    end # describe
+  end # context
+end # shared examples

data/spec/mithril/spec_helper.rb

@@ -0,0 +1,11 @@
+# spec/spec_helper.rb
+
+require 'rspec'
+require 'factory_girl'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end # config
+
+#=# Require Factories, Custom Matchers, &c #=#
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: mithril-specs
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Rob "Merlin" Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mithril
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: Spec helpers for the Mithril interactive text engine
+email: merlin@sleepingkingstudios.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- spec/mithril/controllers/_text_controller_helper.rb
+- spec/mithril/controllers/abstract_controller_helper.rb
+- spec/mithril/controllers/mixins/actions_base_helper.rb
+- spec/mithril/controllers/mixins/help_actions_helper.rb
+- spec/mithril/controllers/proxy_controller_helper.rb
+- spec/mithril/mixin_helper.rb
+- spec/mithril/spec_helper.rb
+- CHANGELOG.md
+- README.md
+homepage: http://sleepingkingstudios.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- spec
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Mithril spec helpers
+test_files: []