masterplan 0.3.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gem "activesupport", '~>2.3.5'
+
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (2.3.10)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport (~> 2.3.5)
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  rspec (~> 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Martin Tepper
+
+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.rdoc

@@ -0,0 +1,181 @@
+= Masterplan
+
+Masterplan is a library for comparing Ruby data structures against predefined templates.
+
+At Travel IQ, this is used to define a canonical definition of the structure and format of the requests and responses of our APIs.
+In short, you get something that is similar to a XML Scheme - a template against which your data can be compared, to
+ensure its correctness programmatically. Only without the XML part.
+
+Examples make this easier to explain. Say you have a webservice or class that produces
+a Ruby data structure like this:
+
+    {
+      :airports => [
+        {
+          :name => "Tegel Airport",
+          :code => "TXL",
+          :latitude => 2.35454,
+          :longitude => 54.67867
+        },
+        {
+          :name => "Schönefeld Airport",
+          :code => "SXF",
+          :latitude => 5.35454,
+          :longitude => 34.67867
+        }
+      ]
+    }
+
+and so on and so forth. In your tests of this service, you want to make sure that this
+structure follows certain rules:
+
+* It's a Hash with one key, :airports
+* The value is an Array, and it can be empty, but not null
+* Each entry is a hash
+* Each hash has the keys :name, :code, :latitude, :longitude
+* No value of these keys is ever null
+* Name and code are strings
+* The strings aren't empty
+* The code is three characters long and consists of uppercase letters
+* Latitude and Longitude are floats
+
+In a more XML-centric world, you would define an XML (or Relax-NG etc.) Scheme that defines all
+these rules and then use that to validate your output. But we also want to deliver JSON...so we'll define
+the rules as a Masterplan::Document, and validate the data while it's still Ruby, and say that as long
+as the source data is correct, the representation in JSON or XML will also be correct:
+
+    include Masterplan::DefineRules
+
+    doc = Masterplan::Document.new(
+      :airports => [
+        {
+          :name => "Tegel Airport",
+          :code => rule("TXL", :matches => /[A-Z]{3}/),
+          :latitude => 2.35454,
+          :longitude => 54.67867
+        },
+        {
+          :name => "Schönefeld Airport",
+          :code => "SXF",
+          :latitude => 5.35454,
+          :longitude => 34.67867
+        }
+      ]
+    )
+
+It doesn't look much different from the example, but there are a lot of rules built-in.
+You can now use the doc object to check your data against the template:
+
+    Masterplan.compare(:scheme => doc, :to => [{:example => :data}])
+
+And it will throw a Masterplan::FailedError exception, and print out debugging data:
+
+    >> Masterplan.compare(:scheme => doc, :to => {:example => :data})
+    Masterplan::FailedError: keys don't match in 'root':
+    expected:	airports
+    received:	example
+
+    Expected:
+    {"airports"=>
+      [{:latitude=>2.35454,
+        :longitude=>54.67867,
+        :code=>
+         #<Masterplan::Rule:0x6d0bd70
+          @example_value="TXL",
+          @options=
+           {"compare_each"=>false,
+            "allow_nil"=>false,
+            "included_in"=>false,
+            "matches"=>/[A-Z]{3}/}>,
+        :name=>"Tegel Airport"},
+       {:latitude=>5.35454,
+        :longitude=>34.67867,
+        :code=>"SXF",
+        :name=>"Schönefeld Airport"}]}
+
+
+    but was:
+    {"example"=>:data}
+
+Another example:
+
+    >> Masterplan.compare(:scheme => doc, :to => {:airports => [{:name => "Bla", :latitude => 1.1, :longitude => 2.3, :code => "XXx"}]})
+    Masterplan::FailedError: value at 'root'=>'airports'=>'0'=>'code' "XXx" (String) does not match /[A-Z]{3}/ !
+
+    Expected:
+    {"name"=>"Tegel Airport",
+     "latitude"=>2.35454,
+     "code"=>
+      #<Masterplan::Rule:0x6d0bd70
+       @example_value="TXL",
+       @options=
+        {"compare_each"=>false,
+         "allow_nil"=>false,
+         "included_in"=>false,
+         "matches"=>/[A-Z]{3}/}>,
+     "longitude"=>54.67867}
+
+
+    but was:
+    {"name"=>"Bla", "latitude"=>1.1, "code"=>"XXx", "longitude"=>2.3}
+
+The implicit rules are:
+
+* Each object in the data needs to be of the same class as in the template
+* hash keys must match up
+* The first element of an Array in the template is used as the template for all elements in the data. That's why we didn't
+  have to restate the custom rule about the code in the above example, as only the "Tegel Airport" hash is used for all checks.
+
+You can add extra rules with the rule method - see Masterplan::DefineRules#rule for details.
+
+There is also an added assertion for unit tests or specs:
+
+    assert_masterplan(doc, [{:example => :data})
+
+== Use schemes as examples in documentation
+
+A problem with webservices is that you need to keep the documentation up to date - something
+that is easily forgotten. If you have a masterplan document, you can use it not only as the template,
+but also as an example in, say, online documentation:
+
+    <pre>
+      <%= JSON.dump(doc.to_hash) %>
+    </pre>
+
+The to_hash method removes the Masterplan::Rule objects for clean output.
+
+== Caveat
+
+Note that for the moment, schemes, i.e. the outermost object, can only be hashes.
+
+== Installation
+
+Currently, you can only install from Github. Add this to your Gemfile:
+
+    gem 'masterplan', :git => 'git://github.com/traveliq/masterplan.git'
+
+If you don't use bundler, you're on your own, sorry.
+
+== Authors
+
+Martin Tepper (monogreen.de), Holger Pillmann (holger.pillmann@gmail.com), Dr. Florian Odronitz (odo@mac.com)
+
+== Contact
+
+For questions, contact the authors or developer@traveliq.net
+
+== Contributing to masterplan
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 www.travel-iq.com. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "masterplan"
+  gem.homepage = "http://github.com/traveliq/masterplan"
+  gem.license = "MIT"
+  gem.summary = %Q{Masterplan is a library for comparing Ruby data structures against predefined templates.}
+  gem.description = %Q{Please see the README}
+  gem.email = "developer@traveliq.net"
+  gem.authors = ["Martin Tepper"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "masterplan #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/lib/masterplan.rb

@@ -0,0 +1,94 @@
+require 'active_support'
+require 'active_support/version'
+if ActiveSupport::VERSION::STRING >= "3.0.0"
+  require 'active_support/core_ext'
+end
+require 'test/unit/assertions'
+require 'masterplan'
+require 'masterplan/rule'
+require 'masterplan/document'
+require 'masterplan/define_rules'
+require 'unit_test_extensions'
+module Masterplan
+
+  class FailedError < Test::Unit::AssertionFailedError
+    attr_accessor :printed
+  end
+
+  class << self
+
+    def compare(options = {:scheme => {}, :to => {}})
+      scheme = options[:scheme]
+      testee = options[:to]
+      raise ArgumentError, ":to needs to be a hash !" unless testee.is_a?(Hash)
+      raise ArgumentError, ":scheme needs to be a Masterplan::Document !" unless scheme.is_a?(Document)
+      compare_hash(scheme, testee)
+      true
+    end
+
+    private
+
+    def compare_value(template, value, path)
+      if template.is_a?(Rule)
+        template.masterplan_compare(value, path)
+      else
+        Rule.check_class_equality!(template, value, path)
+      end
+    end
+
+    def compare_hash(template, testee, trail = ["root"])
+      template.stringify_keys!
+      testee.stringify_keys!
+      raise FailedError, "keys don't match in #{format_path(trail)}:\nexpected:\t#{template.keys.sort.join(',')}\nreceived:\t#{testee.keys.sort.join(',')}" if template.keys.sort != testee.keys.sort
+      template.each do |t_key, t_value|
+        current_path = trail + [t_key]
+        value = testee[t_key]
+        compare_value(t_value, value, format_path(current_path))
+        if value && t_value.is_a?(Array)
+          # all array elements need to be of the same type as the first value in the template
+          elements_template = t_value.first
+          value.each_with_index do |elements_value, index|
+            array_path = current_path + [index]
+            compare_value(elements_template, elements_value, format_path(array_path))
+            if elements_value.is_a?(Hash)
+              compare_hash(elements_template, elements_value, array_path)
+            end
+          end
+        end
+        if value.is_a?(Array) && t_value.is_a?(Rule) && t_value.options['compare_each']
+          value.each_with_index do |elements_value, index| 
+            elements_template = t_value.example_value[index]
+            array_path = current_path + [index]
+            compare_value(elements_template, elements_value, format_path(array_path))
+            if elements_value.is_a?(Hash)
+              compare_hash(elements_template, elements_value, array_path)
+            end
+          end
+        end
+        if value.is_a?(Hash)
+          if t_value.is_a?(Masterplan::Rule)
+            compare_value(t_value, value, current_path)
+            compare_hash(t_value.example_value, value, current_path)
+          else
+            compare_hash(t_value, value, current_path)
+          end
+        end
+      end
+
+    rescue Masterplan::FailedError => e
+      raise e if e.printed
+
+      error = Masterplan::FailedError.new
+      error.printed = true
+
+      expected = PP.pp(template, '')
+      outcome = PP.pp(testee, '')
+
+      raise error, "#{e.message}\n\nExpected:\n#{expected}\n\nbut was:\n#{outcome}", caller
+    end
+
+    def format_path(trail)
+      "'" + trail.join("'=>'") + "'"
+    end
+  end
+end

data/lib/masterplan/define_rules.rb

@@ -0,0 +1,26 @@
+module Masterplan
+
+  # Include this module into whatever code generates Masterplan::Documents - you get
+  # methods that make it easier to generate Masterplan::Rule objects.
+  module DefineRules
+
+    # This turns the supplied +example_value+ (any object) into an object that carries rules about itself with it.
+    # The rules will be applied when a template is compared with assert_masterplan. Rules are:
+    # (default): This always applies - the value must be of the same class as the +example_value+
+    # 'allow_nil': This allows the value to be nil (breaking the first rule)
+    # 'included_in': Pass an array of values - the value must be one of these
+    # 'matches': Pass a regexp - the value must match it, and be a String
+    def rule(example_value, options = {})
+      Rule.new(example_value, options)
+    end
+
+    #for iterating over each example in an array intead of using only the first to compare the data array with
+    def iterating_rule(example_value, options = {})
+      if example_value
+        Rule.new(example_value, :compare_each => true) 
+      end
+    end
+
+  end
+
+end

data/lib/masterplan/document.rb

@@ -0,0 +1,37 @@
+module Masterplan
+  class Document < Hash
+
+    def initialize(hash = {})
+      raise ArgumentError, "Can only work with a Hash, not a #{hash.class.name} !" unless hash.is_a?(Hash)
+      hash.each do |k, v|
+        self[k] = v
+      end
+    end
+
+    # Turns a Masterplan::Document into a plain Hash - this removes all special
+    # objects like Masterplan::Rule and replaces them with their example values, so
+    # the result can be used as documentation.
+    def to_hash
+      result = {}
+      each do |k, v|
+        result[k] = self.class.derulerize(v)
+      end
+      result
+    end
+
+    private
+
+    def self.derulerize(object)
+      case object
+      when Hash
+        new(object).to_hash
+      when Array
+        object.map { |e| derulerize(e) }
+      when Masterplan::Rule
+        derulerize(object.example_value)
+      else
+        object
+      end
+    end
+  end
+end

data/lib/masterplan/rule.rb

@@ -0,0 +1,99 @@
+module Masterplan
+  class Rule
+
+    OPTIONS = ["allow_nil", "compare_each", "included_in", "matches"]
+
+    attr_accessor :options, :example_value
+
+    def initialize(example, options = {})
+      options.stringify_keys!
+      options['allow_nil'] ||= false
+      options['compare_each'] ||= false
+      options["included_in"] ||= false
+      options["matches"] ||= false
+      raise ArgumentError, "options can be #{OPTIONS.join(',')}, not #{options.keys.inspect}" unless options.keys.sort == OPTIONS.sort
+      self.example_value = example
+      self.options = options
+      self.masterplan_compare(example, "initialization of rule")
+    end
+
+    def masterplan_compare(value, path)
+#      puts "#{path} #{@masterplan_rule_options.inspect}"
+#      puts self.inspect
+#      puts value.inspect
+#      puts @masterplan_rule_options["included_in"].inspect
+#      puts !@masterplan_rule_options["included_in"].include?(value) if @masterplan_rule_options["included_in"]
+      return true if masterplan_check_allowed_nil!(value, path)
+      return true if masterplan_check_included_in!(value, path)
+      return true if masterplan_check_matches!(value, path)
+      return true if masterplan_check_class_equality!(value, path)
+    end
+
+    def self.check_class_equality!(template, value, path)
+
+      value_klass = case value
+        when Document
+          Hash
+        when Rule
+          value.example_value.class
+        else
+          value.class
+      end
+      template_klass = case template
+        when Document
+          Hash
+        when Rule
+          template.example_value.class
+        else
+          template.class
+      end
+      if template_klass != value_klass
+        raise FailedError, "value at #{path} (#{value_klass}) is not a #{template_klass} !"
+      else
+        true
+      end
+    end
+
+    private
+
+    def masterplan_check_class_equality!(value, path)
+      self.class.check_class_equality!(self, value, path)
+    end
+
+    def masterplan_check_allowed_nil!(value, path)
+      if options['allow_nil']
+        if value.nil?
+          true
+        else
+          false
+        end
+      else
+        false
+      end
+    end
+
+    def masterplan_check_included_in!(value, path)
+      if options["included_in"]
+        unless options["included_in"].include?(value)
+          raise Masterplan::FailedError, "value at #{path} #{value.inspect} (#{value.class}) is not one of #{options["included_in"].inspect} !"
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+
+    def masterplan_check_matches!(value, path)
+      if options["matches"]
+        if value !~ options["matches"]
+          raise Masterplan::FailedError, "value at #{path} #{value.inspect} (#{value.class}) does not match #{options["matches"].inspect} !"
+        else
+          true
+        end
+      else
+        false
+      end
+    end
+  end
+end

data/lib/unit_test_extensions.rb

@@ -0,0 +1,9 @@
+module Test
+  module Unit
+    module Assertions
+      def assert_masterplan(scheme, compare_to)
+        Masterplan.compare(:scheme => scheme, :to => compare_to)
+      end
+    end
+  end
+end

data/masterplan.gemspec

@@ -0,0 +1,72 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{masterplan}
+  s.version = "0.3.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Martin Tepper"]
+  s.date = %q{2011-02-02}
+  s.description = %q{Please see the README}
+  s.email = %q{developer@traveliq.net}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/masterplan.rb",
+    "lib/masterplan/define_rules.rb",
+    "lib/masterplan/document.rb",
+    "lib/masterplan/rule.rb",
+    "lib/unit_test_extensions.rb",
+    "masterplan.gemspec",
+    "spec/masterplan_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/traveliq/masterplan}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Masterplan is a library for comparing Ruby data structures against predefined templates.}
+  s.test_files = [
+    "spec/masterplan_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, ["~> 2.3.5"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, ["~> 2.3.5"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, ["~> 2.3.5"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/spec/masterplan_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+include Masterplan::DefineRules
+
+describe "Masterplan" do
+  before(:each) do
+    @scheme = Masterplan::Document.new({
+      "ship" => {
+        "parts" => [
+          {
+            "name" => "Mast",
+            "length" => rule(12.3, :allow_nil => true),
+            "material" => rule("wood", :included_in => ['wood', 'steel', 'human'])
+          },
+          {
+            "name" => "Rudder",
+            "length" => nil,
+            "material" => "steel"
+          }
+        ]
+      }
+    })
+  end
+  
+  describe "Testing with #compare" do
+
+    it "returns true for a valid document, treating symbols and strings alike" do
+      Masterplan.compare(
+        :scheme => @scheme,
+        :to => {
+          :ship => {
+            :parts => [
+              :name => "Thingy",
+              :length => 1.0,
+              :material => "human"
+            ]
+          }
+        }
+      ).should be_true
+    end
+    it "complains if a key is missing" do
+      lambda do
+        Masterplan.compare(
+          :scheme => @scheme,
+          :to => {
+            :tank => {}
+          }
+        )
+      end.should raise_error(Masterplan::FailedError, /expected:	ship*\n*received:	tank/)
+    end
+    it "complains if not given a Masterplan::Document"
+    it "complains if there are extra keys"
+    it "complains if a value is of the wrong class"
+    it "complains if a value is nil"
+    it "does not complain if a value is nil and the rule allows nil"
+    it "complains if a value does not match the regexp rule"
+    it "complains if a value is not included in the rule list"
+    it "checks all values of value arrays, but only against the first array value of the scheme"
+    it "checks all array values one-to-one if the compare_each rule is used"
+  end
+
+  it "convertsinto plain example hashes"
+  it "doesn't create a Document out of anything other than a Hash"
+  it "checks that the examples of rules obey the rules"
+  it "has a unit test extension method"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'masterplan'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: masterplan
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Martin Tepper
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-02 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  requirement: *id001
+  prerelease: false
+  type: :runtime
+  name: activesupport
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  requirement: *id002
+  prerelease: false
+  type: :development
+  name: rspec
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id003
+  prerelease: false
+  type: :development
+  name: bundler
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id004
+  prerelease: false
+  type: :development
+  name: jeweler
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id005
+  prerelease: false
+  type: :development
+  name: rcov
+description: Please see the README
+email: developer@traveliq.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/masterplan.rb
+- lib/masterplan/define_rules.rb
+- lib/masterplan/document.rb
+- lib/masterplan/rule.rb
+- lib/unit_test_extensions.rb
+- masterplan.gemspec
+- spec/masterplan_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/traveliq/masterplan
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Masterplan is a library for comparing Ruby data structures against predefined templates.
+test_files: 
+- spec/masterplan_spec.rb
+- spec/spec_helper.rb