redcard 1.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+.rbx
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+script: RUBYLIB=lib bundle exec rspec
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - rbx-nightly-18mode
+  - rbx-nightly-19mode
+  - jruby-18mode
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify gem dependencies in redcard.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Brian Ford. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# RedCard
+
+RedCard provides a standard way to ensure that the running Ruby implementation
+matches the desired language version, implementation, and implementation
+version.
+
+
+## Why Do We Need It?
+
+Once upon a time, Ruby was a very simple universe. There was a single Ruby
+implementation and a single stable version. Now there are multiple current
+language versions, multiple implementations, and numerous versions of those
+multiple implementations.
+
+In an ideal world, every Ruby implementation would provide the same features
+and all such features would have consistent behavior. In the real world, this
+is not the case. Hence, the need arises to have some facility for restricting
+the conditions under which an application or library runs. RedCard provides
+various mechanisms for specifying what language version, implementation, and
+implementation version are required.
+
+
+NOTE: In this documentation, Ruby version specifies the version of the Ruby
+programming language itself. Historically, the word "Ruby" could have applied
+to the language or the original implementation of the language. We refer to
+the original implementation as MRI or Matz's Ruby Implementation. RedCard
+distinguishes between Ruby language versions, Ruby implementations, and
+implementation versions.
+
+
+## Be Liberal
+
+RedCard provides an API for specifying multiple implementations and versions.
+
+    RedCard.check *requirements
+
+The parameter, requirements, is an Array of Symbols or Strings with an
+optional final Hash of implementations as keys and implementation versions as
+values.
+
+The following examples illustrate this:
+
+    # Requires any version JRuby or Rubinius
+    RedCard.check :rubinius, :jruby
+
+    # Requires Ruby language 1.9 and MRI or Rubinius
+    RedCard.check :mri, :rubinius, "1.9"
+
+    # Requires Ruby language 1.9.3 or 2.0
+    RedCard.check "1.9.3", "2.0"
+
+    # Requires Ruby language 1.9 and Rubinius version 2.0
+    RedCard.check "1.9", :rubinius => "2.0"
+
+
+## Be Conservative
+
+RedCard provides some convenience files that define restrictive requirements.
+Using these, you can easily restrict the application to a single language
+version, implementation, and implementation version.
+
+The following examples illustrate this:
+
+    # Requires at minimum Ruby version 1.9 but accepts anything greater
+    require 'redcard/1.9'
+
+    # Requires Rubinius 2.0
+    require 'redcard/rubinius/2.0'
+
+    # Requires Ruby 1.9 and Rubinius
+    require 'redcard/1.9'
+    require 'redcard/rubinius'
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler/gem_tasks'
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/redcard/1.8.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify "1.8"

data/lib/redcard/1.9.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify "1.9"

data/lib/redcard/2.0.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify "2.0"

data/lib/redcard/engine.rb

@@ -0,0 +1,17 @@
+class RedCard
+  class Engine
+    def initialize(engine, candidate)
+      @engine = engine.to_s
+      @candidate = candidate.to_s
+    end
+
+    def valid?
+      case @engine
+      when "rbx"
+        @candidate == "rbx" or @candidate == "rubinius"
+      else
+        @candidate == @engine
+      end
+    end
+  end
+end

data/lib/redcard/ironruby.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify :ironruby

data/lib/redcard/jruby/1.7.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify :jruby => "1.7"

data/lib/redcard/jruby.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify :jruby

data/lib/redcard/maglev.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify :maglev

data/lib/redcard/rubinius/2.0.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify :rubinius => "2.0"

data/lib/redcard/rubinius.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify :rubinius

data/lib/redcard/topaz.rb

@@ -0,0 +1,3 @@
+require 'redcard'
+
+RedCard.verify :topaz

data/lib/redcard/version.rb

@@ -0,0 +1,41 @@
+class RedCard
+  VERSION = "1.0.0"
+
+  class Version
+    def initialize(version, candidate)
+      @version_spec = version.to_str
+      @version = convert @version_spec
+
+      case candidate
+      when Range
+        @minimum_spec = candidate.begin.to_str
+        @maximum_spec = candidate.end.to_str
+        @exclusive = candidate.exclude_end?
+
+        @minimum = convert @minimum_spec
+        @maximum = convert @maximum_spec
+      else
+        @minimum = convert candidate.to_str
+        @maximum = nil
+        @exclusive = nil
+      end
+    end
+
+    def valid?
+      return false unless @version >= @minimum
+      return true if @maximum.nil?
+
+      if @exclusive
+        return @version < @maximum
+      else
+        return @version <= @maximum
+      end
+    end
+
+    def convert(string)
+      major, minor, tiny, patch = string.split "."
+      parts = [major, minor, tiny, patch].map { |x| x.to_i }
+      ("1%03d%03d%03d%05d" % parts).to_i
+    end
+  end
+end

data/lib/redcard.rb

@@ -0,0 +1,100 @@
+require 'redcard/version'
+require 'redcard/engine'
+
+class RedCard
+  class InvalidRubyVersionError < Exception; end
+  class InvalidRubyEngineError < Exception; end
+  class UnknownRubyEngineError < Exception; end
+  class InvalidRubyError < Exception; end
+
+  def self.check(*requirements)
+    new(*requirements).check
+  end
+
+  def self.verify(*requirements)
+    card = new(*requirements)
+    unless card.check
+      raise card.error, card.message
+    end
+  end
+
+  def self.engine
+    (defined?(RUBY_ENGINE) && RUBY_ENGINE) || "ruby"
+  end
+
+  def self.engine_version
+    case engine
+    # when "ironruby"
+      # TODO
+    when "jruby"
+      Object.const_get :JRUBY_VERSION
+    # when "maglev"
+      # TODO
+    when "rbx"
+      if defined?(::Rubinius)
+        Object.const_get(:Rubinius).const_get(:VERSION)
+      end
+    when "ruby"
+      RUBY_VERSION
+    when "topaz"
+      if defined?(::Topaz)
+        Object.const_get(:Topaz).const_get(:VERSION)
+      end
+    else
+      raise UnknownRubyEngineError, "#{engine} is not recognized"
+    end
+  end
+
+
+  attr_reader :error, :message
+
+  def initialize(*requirements)
+    @engine_versions = requirements.last.kind_of?(Hash) ? requirements.pop.to_a : []
+    @engines = requirements.select { |x| x.kind_of? Symbol }
+    @versions = requirements.select { |x| x.kind_of? String or x.kind_of? Range }
+  end
+
+  def check
+    unless @engines.empty? or
+           @engines.any? { |x| Engine.new(RedCard.engine, x).valid? }
+      invalid_engine
+      return false
+    end
+
+    unless @versions.empty? or
+           @versions.any? { |x| Version.new(RUBY_VERSION, x).valid? }
+      invalid_ruby_version
+      return false
+    end
+
+    return true if @engine_versions.empty?
+
+    @engine_versions.map! do |e, v|
+      [Engine.new(RedCard.engine, e), Version.new(RedCard.engine_version, v)]
+    end
+
+    return true if @engine_versions.any? do |engine, version|
+      engine.valid? and version.valid?
+    end
+
+    invalid_engine_version
+    return false
+  end
+
+  private
+
+  def invalid_ruby_version
+    @error = InvalidRubyVersionError
+    @message = "#{RUBY_VERSION} is not supported"
+  end
+
+  def invalid_engine
+    @error = InvalidRubyEngineError
+    @message = "#{RedCard.engine} is not supported"
+  end
+
+  def invalid_engine_version
+    @error = InvalidRubyError
+    @message = "#{RedCard.engine} version #{RedCard.engine_version} is not supported"
+  end
+end

data/redcard.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+require 'redcard/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "redcard"
+  gem.version       = "#{RedCard::VERSION}"
+  gem.authors       = ["Brian Shirai"]
+  gem.email         = ["brixen@gmail.com"]
+  gem.homepage      = "https://github.com/brixen/redcard"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) unless File.extname(f) == ".bat" }.compact
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.summary       = <<-EOS
+RedCard provides a standard way to ensure that the running Ruby implementation
+matches the desired language version, implementation, and implementation
+version.
+                      EOS
+  gem.has_rdoc                  = true
+  gem.extra_rdoc_files          = %w[ README.md LICENSE ]
+  gem.rubygems_version  = %q{1.3.5}
+  gem.rubyforge_project         = 'http://rubyforge.org/projects/mspec'
+
+  gem.rdoc_options  << '--title' << 'MSpec Gem' <<
+                    '--main' << 'README' <<
+                    '--line-numbers'
+
+  gem.add_development_dependency "rake",   "~> 0.9"
+  gem.add_development_dependency "rspec",  "~> 2.8"
+end
+

data/spec/1.9_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe "Ruby version requirement" do
+  before do
+    redcard_save_state
+    redcard_unload "redcard/1.9"
+  end
+
+  after do
+    redcard_restore_state
+  end
+
+  it "succeeds if RUBY_VERSION is 1.9.0" do
+    redcard_version "1.9.0"
+    expect { require 'redcard/1.9' }.not_to raise_error
+  end
+
+  it "succeeds if RUBY_VERSION is 1.9.9" do
+    redcard_version "1.9.9"
+    expect { require 'redcard/1.9' }.not_to raise_error
+  end
+
+  it "succeeds if RUBY_VERSION is 1.10.0" do
+    redcard_version "1.10.0"
+    expect { require 'redcard/1.9' }.not_to raise_error
+  end
+
+  it "succeeds if RUBY_VERSION is 2.0.0" do
+    redcard_version "2.0.0"
+    expect { require 'redcard/1.9' }.not_to raise_error
+  end
+
+  it "raises an InvalidRubyVersionError if RUBY_VERSION is less than 1.9" do
+    redcard_version "1.8.9"
+    expect { require 'redcard/1.9' }.to raise_error(RedCard::InvalidRubyVersionError)
+  end
+end

data/spec/check_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe "RedCard.check" do
+  before do
+    redcard_save_state
+  end
+
+  after do
+    redcard_restore_state
+  end
+
+  context "when RUBY_VERSION is '2.10.1'" do
+    before do
+      redcard_version "2.10.1"
+    end
+
+    it "returns true for '2.0'" do
+      expect(RedCard.check("2.0")).to be_true
+    end
+
+    it "returns true for '2.0.0'" do
+      expect(RedCard.check("2.0.0")).to be_true
+    end
+
+    it "returns true for '2.9.10'" do
+      expect(RedCard.check("2.9.10")).to be_true
+    end
+
+    it "returns true for '2.10.1'" do
+      expect(RedCard.check("2.10.1")).to be_true
+    end
+
+    it "returns true for '1.9.100'" do
+      expect(RedCard.check("1.9.100")).to be_true
+    end
+
+    it "returns true for '1.8.10'" do
+      expect(RedCard.check("1.8.10")).to be_true
+    end
+
+    it "returns false for '2.10.2'" do
+      expect(RedCard.check("2.10.2")).to be_false
+    end
+
+    it "returns true for '1.8.10'..'2.10.1'" do
+      expect(RedCard.check("1.8.10".."2.10.1")).to be_true
+    end
+
+    it "returns true for '1.8.10'..'2.10.2'" do
+      expect(RedCard.check("1.8.10".."2.10.2")).to be_true
+    end
+
+    it "returns true for '1.8.10'..'2.11'" do
+      expect(RedCard.check("1.8.10".."2.11")).to be_true
+    end
+
+    it "returns false for '2.10.2'..'2.11.2'" do
+      expect(RedCard.check("2.10.2"..."2.11.2")).to be_false
+    end
+
+    it "returns false for '1.8.10'...'2.10.1'" do
+      expect(RedCard.check("1.8.10"..."2.10.1")).to be_false
+    end
+
+    context "when RUBY_ENGINE is 'rbx'" do
+      before do
+        redcard_engine "rbx"
+      end
+
+      it "returns true for '1.9', :rbx" do
+        expect(RedCard.check("1.9", :rbx)).to be_true
+      end
+
+      it "returns false for '1.9', :topaz" do
+        expect(RedCard.check("1.9", :topaz)).to be_false
+      end
+
+      context "when Rubinius::VERSION is '2.0.0'" do
+        before do
+          redcard_engine_version "2.0.0"
+        end
+
+        it "returns true for '1.9', :rbx => '2.0'" do
+          expect(RedCard.check("1.9", :rbx => "2.0")).to be_true
+        end
+
+        it "returns true for '1.9', :rbx => '1.2.4'" do
+          expect(RedCard.check("1.9", :rbx => "1.2.4")).to be_true
+        end
+
+        it "returns false for '1.9', :rbx => '2.1'" do
+          expect(RedCard.check("1.9", :rbx => "2.1")).to be_false
+        end
+      end
+    end
+  end
+
+  context "when RUBY_ENGINE is 'rbx'" do
+    before do
+      redcard_engine "rbx"
+    end
+
+    it "returns true for :rbx" do
+      expect(RedCard.check(:rbx)).to be_true
+    end
+
+    it "returns false for :topaz" do
+      expect(RedCard.check(:topaz)).to be_false
+    end
+  end
+end

data/spec/rubinius/2.0_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Rubinius version requirement" do
+  before do
+    redcard_save_state
+    redcard_unload "redcard/rubinius/2.0"
+  end
+
+  after do
+    redcard_restore_state
+  end
+
+  it "succeeds if RUBY_ENGINE is 'rbx' and Rubinius::VERSION is greater than or equal to 2.0" do
+    redcard_engine "rbx"
+    redcard_engine_version "2.0.0"
+    expect { require 'redcard/rubinius/2.0' }.not_to raise_error
+  end
+
+  it "raises an InvalidRubyEngineError if RUBY_ENGINE is 'topaz'" do
+    redcard_engine "topaz"
+    redcard_engine_version "2.0.0"
+    expect { require 'redcard/rubinius/2.0' }.to raise_error(RedCard::InvalidRubyError)
+  end
+
+  it "raises an InvalidEngineVersionError if Rubinius::VERSION is less than 2.0" do
+    redcard_engine "rbx"
+    redcard_engine_version "1.2.4"
+    expect { require 'redcard/rubinius/2.0' }.to raise_error(RedCard::InvalidRubyError)
+  end
+end

data/spec/rubinius_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "Ruby engine requirement" do
+  before do
+    redcard_save_state
+    redcard_unload "redcard/rubinius"
+  end
+
+  after do
+    redcard_restore_state
+  end
+
+  it "succeeds if RUBY_ENGINE is 'rbx'" do
+    redcard_engine "rbx"
+    expect { require 'redcard/rubinius' }.not_to raise_error
+  end
+
+  it "raises an InvalidRubyEngineError if RUBY_ENGINE is 'topaz'" do
+    redcard_engine "topaz"
+    expect { require 'redcard/rubinius' }.to raise_error(RedCard::InvalidRubyEngineError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,94 @@
+require 'redcard'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+end
+
+class RedCard
+  module Specs
+    @verbose = nil
+    @ruby_version = nil
+    @engine = nil
+    @engine_version = nil
+
+    def self.save_state
+      @verbose = $VERBOSE
+      $VERBOSE = nil
+      @ruby_version = RUBY_VERSION
+      @ruby_engine = RedCard.engine
+    end
+
+    def self.save_engine_version
+      @engine_version = RedCard.engine_version
+    end
+
+    def self.restore_state
+      $VERBOSE = nil
+      Object.const_set :RUBY_VERSION, @ruby_version
+
+      engine_version = @engine_version ? @engine_version : nil
+      Object.const_set :RUBY_ENGINE, @ruby_engine
+
+      $VERBOSE = @verbose
+    end
+
+    def self.version=(version)
+      Object.const_set :RUBY_VERSION, version
+    end
+
+    def self.engine=(engine)
+      Object.const_set :RUBY_ENGINE, engine
+    end
+
+    def self.engine_version=(version)
+      case RedCard.engine
+      # when "ironruby"
+        # TODO
+      when "jruby"
+        Object.const_set :JRUBY_VERSION, version
+      # when "maglev"
+        # TODO
+      when "rbx"
+        unless defined?(::Rubinius)
+          Object.const_set :Rubinius, Module.new
+        end
+        Object.const_get(:Rubinius).const_set(:VERSION, version)
+      when "ruby"
+        RUBY_VERSION
+      when "topaz"
+        unless defined?(::Topaz)
+          Object.const_set :Topaz, Module.new
+        end
+        Object.const_get(:Topaz).const_set(:VERSION, version)
+      end
+    end
+  end
+end
+
+def redcard_save_state
+  RedCard::Specs.save_state
+end
+
+def redcard_restore_state
+  RedCard::Specs.restore_state
+end
+
+def redcard_unload(path)
+  $".delete "#{path}.rb"
+  $".delete File.expand_path("../../lib/#{path}.rb", __FILE__)
+end
+
+def redcard_version(version)
+  RedCard::Specs.version = version
+end
+
+def redcard_engine(engine)
+  RedCard::Specs.engine = engine
+end
+
+def redcard_engine_version(version)
+  RedCard::Specs.save_engine_version
+  RedCard::Specs.engine_version = version
+end

data/spec/verify_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe "RedCard.verify" do
+  before do
+    redcard_save_state
+  end
+
+  after do
+    redcard_restore_state
+  end
+
+  context "when RUBY_VERSION is '2.10.1'" do
+    before do
+      redcard_version "2.10.1"
+    end
+
+    it "returns nil for '2.0'" do
+      expect(RedCard.verify("2.0")).to be_nil
+    end
+
+    it "returns nil for '2.0.0'" do
+      expect(RedCard.verify("2.0.0")).to be_nil
+    end
+
+    it "returns nil for '2.9.10'" do
+      expect(RedCard.verify("2.9.10")).to be_nil
+    end
+
+    it "returns nil for '2.10.1'" do
+      expect(RedCard.verify("2.10.1")).to be_nil
+    end
+
+    it "returns nil for '1.9.100'" do
+      expect(RedCard.verify("1.9.100")).to be_nil
+    end
+
+    it "returns nil for '1.8.10'" do
+      expect(RedCard.verify("1.8.10")).to be_nil
+    end
+
+    it "raises an InvalidRubyVersionError for '2.10.2'" do
+      expect { RedCard.verify("2.10.2") }.to raise_error(RedCard::InvalidRubyVersionError)
+    end
+
+    it "returns nil for '1.8.10'..'2.10.1'" do
+      expect(RedCard.verify("1.8.10".."2.10.1")).to be_nil
+    end
+
+    it "returns nil for '1.8.10'..'2.10.2'" do
+      expect(RedCard.verify("1.8.10".."2.10.2")).to be_nil
+    end
+
+    it "returns nil for '1.8.10'..'2.11'" do
+      expect(RedCard.verify("1.8.10".."2.11")).to be_nil
+    end
+
+    it "raises an InvalidRubyVersionError for '2.10.2'..'2.11.2'" do
+      expect { RedCard.verify("2.10.2"..."2.11.2") }.to raise_error(RedCard::InvalidRubyVersionError)
+    end
+
+    it "raises an InvalidRubyVersionError for '1.8.10'...'2.10.1'" do
+      expect { RedCard.verify("1.8.10"..."2.10.1") }.to raise_error(RedCard::InvalidRubyVersionError)
+    end
+
+    context "when RUBY_ENGINE is 'rbx'" do
+      before do
+        redcard_engine "rbx"
+      end
+
+      it "returns nil for '1.9', :rbx" do
+        expect(RedCard.verify("1.9", :rbx)).to be_nil
+      end
+
+      it "raises an InvalidRubyEngineError for '1.9', :topaz" do
+        expect { RedCard.verify("1.9", :topaz) }.to raise_error(RedCard::InvalidRubyEngineError)
+      end
+
+      context "when Rubinius::VERSION is '2.0.0'" do
+        before do
+          redcard_engine_version "2.0.0"
+        end
+
+        it "returns nil for '1.9', :rbx => '2.0'" do
+          expect(RedCard.verify("1.9", :rbx => "2.0")).to be_nil
+        end
+
+        it "returns nil for '1.9', :rbx => '1.2.4'" do
+          expect(RedCard.verify("1.9", :rbx => "1.2.4")).to be_nil
+        end
+
+        it "raises an InvalidRubyError for '1.9', :rbx => '2.1'" do
+          expect { RedCard.verify("1.9", :rbx => "2.1") }.to raise_error(RedCard::InvalidRubyError)
+        end
+      end
+    end
+  end
+
+  context "when RUBY_ENGINE is 'rbx'" do
+    before do
+      redcard_engine "rbx"
+    end
+
+    it "returns nil for :rbx" do
+      expect(RedCard.verify(:rbx)).to be_nil
+    end
+
+    it "raises an InvalidRubyEngineError for :topaz" do
+      expect { RedCard.verify(:topaz) }.to raise_error(RedCard::InvalidRubyEngineError)
+    end
+  end
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: redcard
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Brian Shirai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+description: 
+email:
+- brixen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/redcard.rb
+- lib/redcard/1.8.rb
+- lib/redcard/1.9.rb
+- lib/redcard/2.0.rb
+- lib/redcard/engine.rb
+- lib/redcard/ironruby.rb
+- lib/redcard/jruby.rb
+- lib/redcard/jruby/1.7.rb
+- lib/redcard/maglev.rb
+- lib/redcard/rubinius.rb
+- lib/redcard/rubinius/2.0.rb
+- lib/redcard/topaz.rb
+- lib/redcard/version.rb
+- redcard.gemspec
+- spec/1.9_spec.rb
+- spec/check_spec.rb
+- spec/rubinius/2.0_spec.rb
+- spec/rubinius_spec.rb
+- spec/spec_helper.rb
+- spec/verify_spec.rb
+homepage: https://github.com/brixen/redcard
+licenses: []
+post_install_message: 
+rdoc_options:
+- --title
+- MSpec Gem
+- --main
+- README
+- --line-numbers
+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: http://rubyforge.org/projects/mspec
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: RedCard provides a standard way to ensure that the running Ruby implementation
+  matches the desired language version, implementation, and implementation version.
+test_files:
+- spec/1.9_spec.rb
+- spec/check_spec.rb
+- spec/rubinius/2.0_spec.rb
+- spec/rubinius_spec.rb
+- spec/spec_helper.rb
+- spec/verify_spec.rb
+has_rdoc: true