jason_spec 0.0.1

data/.document

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

data/.rspec

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

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "rufus-json", "1.0.6"
+gem "rspec", "~> 2.8.0"
+
+group :development do
+  gem "yard", "~> 0.7"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 1.8.7"
+  gem "simplecov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,72 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    addressable (2.3.5)
+    builder (3.2.2)
+    diff-lcs (1.1.3)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
+    git (1.2.6)
+    github_api (0.10.1)
+      addressable
+      faraday (~> 0.8.1)
+      hashie (>= 1.2)
+      multi_json (~> 1.4)
+      nokogiri (~> 1.5.2)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.19)
+    httpauth (0.2.0)
+    jeweler (1.8.7)
+      builder
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      github_api (= 0.10.1)
+      highline (>= 1.6.15)
+      nokogiri (= 1.5.10)
+      rake
+      rdoc
+    json (1.8.0)
+    jwt (0.1.8)
+      multi_json (>= 1.5)
+    multi_json (1.8.0)
+    multi_xml (0.5.5)
+    multipart-post (1.2.0)
+    nokogiri (1.5.10)
+    oauth2 (0.9.2)
+      faraday (~> 0.8)
+      httpauth (~> 0.2)
+      jwt (~> 0.1.4)
+      multi_json (~> 1.0)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.0)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    rufus-json (1.0.6)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    yard (0.8.7.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  jeweler (~> 1.8.7)
+  rdoc (~> 3.12)
+  rspec (~> 2.8.0)
+  rufus-json (= 1.0.6)
+  simplecov
+  yard (~> 0.7)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 OrganisedMinds GmbH
+
+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,120 @@
+# jason_spec
+
+Write specs for JSON without writing JSON or data-structures
+
+<a href="http://www.flickr.com/photos/frogdna/5534481247/" title="Friday the 13th - Jason Mask Replica by frogDNA, on Flickr"><img src="http://farm6.staticflickr.com/5094/5534481247_361aa64980.jpg" width="375" height="500" alt="Friday the 13th - Jason Mask Replica"></a>
+
+## Install
+
+`gem install jason_spec`
+
+or, in your Gemfile, possibly in the test group
+
+`gem "jason_spec"`
+
+
+## Usage
+
+### Test by specification
+
+Jason spec is designed to test json by specifying the desired result. This
+means you should not type or create any JSON; or even data structures.
+
+The following snippet:
+
+```ruby
+%q({"first_name":"Jason","last_name":"Voorhees"}).should have_jason([:first_name,:last_name])
+```
+
+would result in a match. The supplied JSON has a `:first_name` and a
+`:last_name` key - that's all we wanted to know.
+
+Off course, you can also specify your root object:
+
+```ruby
+%q({"movie":{"title":"Friday the 13th","release_year":"1980"}}).should have_jason(
+  movie: [ :title, :release_year ]
+)
+```
+
+### Test by object
+
+Now it is also nice to test the actual values; you can do this by supplying an
+object in the specifications key, like so:
+
+```ruby
+# assuming ActiveRecord or so
+
+my_movie = Movie.find(x)
+
+%q({"movie":{"title":"Friday the 13th","release_year":"1980"}}).should have_jason(
+  { movie: { my_movie => [ :title, :release_year ] } }
+)
+```
+
+This will check the values of the JSON against the value of `my_movie.title`
+and `my_movie.release_year`
+
+### Test by enhanced specification
+
+Now; that is all pretty nice and dandy, but what about complex(er) JSON
+structures? How can I test those, without supplying huge structures as a
+specification?
+
+**Jason::Spec** to the resque:
+
+```ruby
+%q({"movies":[{"title":"Friday the 13th"},{"title":"Nightmare on Elm Street"}]}).should have_jason(
+  movies: Jason.spec( type: Array, size: 2, each: [ :title ] )
+)
+```
+
+Basicly we are saying; the JSON should have a `movies` key, it should hold
+an `Array` with a size of `2` and each element should have a `title` key.
+
+Off course you should combine all of it to make full use of the potential:
+
+```ruby
+json = %q({"user":{
+    "user_name":"jason",
+    "favorite_movies":[
+      {"title":"Friday the 13th","id":1},
+      {"title":"Nightmare on Elm Street","id":2}
+    ]
+  },
+  "links":[
+    { "href":"/users/2", "rel": "self" },
+    { "href":"/users/2/movies", "rel": "favorite movies"}
+  ]
+})
+
+json.should have_jason(
+  user: {
+    user_name: "jason",
+    favorite_movies: Jason.spec(type: Array, each: [ :title, :id ])
+  },
+  links: Jason.spec(type: Array, each: [ :href, :rel ])
+)
+```
+
+## State
+
+Alpha - not even released to RubyGems.org.
+
+The final example might just work, see `spec/readme_spec.rb`
+
+## Contributing to jason_spec
+
+* 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) 2013 OrganisedMinds GmbH. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+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 = "jason_spec"
+  gem.homepage = "http://github.com/coffeeaddict/jason_spec"
+  gem.license = "MIT"
+  gem.summary = %Q{Spec your JSON}
+  gem.description = %Q{Write specifications for the expected json, without writing json}
+  gem.email = "hartog@organisedminds.com"
+  gem.authors = ["Hartog C. de Mik"]
+  # dependencies defined in Gemfile
+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 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/jason/have_jason_matcher.rb

@@ -0,0 +1,158 @@
+require 'pp'
+require 'jason/spec'
+
+module Jason
+
+  # Provides the have_jason functionality
+  class HaveJasonMatcher
+
+    # @param [Array,Hash] specs   List of specifications
+    #
+    # @example Specs by array
+    #   # will check if the actual JSON has a foo and a bar key
+    #   HaveJasonMatcher.new([ :foo, :bar ])
+    #
+    # @example Specs by hash
+    #   # will check if the actual has an item object with a foo and a bar key
+    #   HaveJasonMatcher.new( item: [ :foo, :bar ])
+    #
+    #   # will check if the actual has an item object with a foo key with a
+    #   # bar value
+    #   HaveJasonMatcher.new( item: { foo: "bar" } )
+    #
+    # @example Specs by hash with objects
+    #   # will check if the actual has a attribute key with the value of
+    #   # ruby_object.attribute()
+    #   HaveJasonMatcher.new( ruby_object => [ :attribute ] )
+    #
+    # @example Specs by Jason.spec
+    #   # will check the actual against the provided Jason::Spec
+    #   HaveJasonMatcher.new( item: Jason.spec(type: Hash, fields: [ :foo, :bar ] ))
+    #
+    def initialize(specs)
+      @specs = specs
+    end
+
+    # Check if the given JSON matches the specifications
+    #
+    # @param [JSON, Hash] actual   the value to check
+    #
+    # @return [Boolean]
+    #
+    def matches?(actual)
+      @actual = actual.is_a?(String) ? Rufus::Json.decode(actual) : actual
+
+      @misses = match_recursively(@specs, @actual)
+
+      @misses.empty?
+    end
+
+    # recursivly walk over the specs and the actual to find any misses
+    #
+    # @param [Array,Hash] specs    List of specifications
+    # @param [Array,Hash] actual   Provided data-structure (once JSON)
+    #
+    # @return [Hash] Hash with all the misses
+    #
+    def match_recursively(specs, actual, root="")
+      actual ||= {}
+
+      misses = {}
+
+      if specs.is_a?(Array)
+        specs.map(&:to_s).each do |key|
+          res_key = root != "" ? "#{root}.#{key}" : "#{key}"
+          if !actual.has_key? key
+            misses[res_key] = :missing
+          end
+        end
+
+        return misses
+      end
+
+      if specs.is_a?(Jason::Spec)
+        root = "root" if root == ""
+
+        if !actual
+          misses[root] = { expected: { key: root }, got: :not_present }
+        elsif !specs.fits?(actual)
+          misses[root] = { expected: specs.opts, got: specs.misses }
+        end
+
+        return misses
+      end
+
+      specs.each do |key, value|
+        res_key = root != "" ? "#{root}.#{key}" : "#{key}"
+        key = key.to_s if key.is_a?(Symbol)
+
+        if key.is_a?(String)
+          if value.is_a?(Jason::Spec)
+            if !actual[key]
+              misses[res_key] = { expected: { key: key }, got: :not_present }
+              next
+            end
+
+            if !value.fits?(actual[key])
+              misses[res_key] = { expected: value.opts, got: value.misses }
+            end
+
+          elsif value.is_a?(Array) or value.is_a?(Hash)
+            begin
+              misses.merge!(match_recursively(value, actual[key], res_key))
+            rescue => ex
+              $stderr.puts ex.backtrace.join("\n\t")
+              misses[res_key] = { error: ex.message }
+            end
+
+          elsif actual[key] != value
+            misses[res_key] = { expected: value, got: actual[key] }
+          end
+
+        else # the key is an object, the value is an array of methods
+          value.each do |attr|
+            res_key = root != "" ? "#{root}.#{attr}" : "#{attr}"
+
+            if attr.is_a?(Hash)
+              misses.merge!(match_recursively(attr, actual[attr], res_key))
+              next
+            end
+
+            attr = attr.to_s
+
+            expected = key.send(attr) rescue nil
+            found    = actual[attr]
+
+            if found
+              if expected.is_a?(Time)
+                # revert to seconds - microseconds do not compare
+                found = Time.at(Time.parse(found).to_i)
+                expected = Time.at(expected.to_i)
+
+              elsif expected.is_a?(Date)
+                found = Date.parse(found)
+
+              end
+            end
+
+            if found != expected
+              misses[res_key] = { expected: expected, got: found }
+            end
+          end
+        end
+      end
+
+      return misses
+    end
+
+    # @return [String] Message to provide if it should have matched but didn't
+    def failure_message
+      "Jason misses: #{@misses.pretty_inspect}\n\tin #{@actual}"
+    end
+
+    # @return [String] Message to provide if it shouldn't have matched but did
+    def negative_failure_message
+      "Jason has: #{@actual}"
+    end
+  end
+end

data/lib/jason/matchers.rb

@@ -0,0 +1,14 @@
+require 'jason/have_jason_matcher'
+
+module Jason
+  module Matchers
+    def have_jason(spec)
+      Jason::HaveJasonMatcher.new(spec)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Jason::Matchers
+end
+

data/lib/jason/spec.rb

@@ -0,0 +1,264 @@
+module Jason
+
+  # @returns [Jason::Spec] Specifications for JSON checking
+  def self.spec(spec)
+    Spec.new(spec)
+  end
+
+  # Class for holding and checking specifications for a JSON structure
+  #
+  # @attr_reader [Hash] specs Stored specifications
+  # @attr_reader [Array] misses List of collected failures
+  #
+  class Spec
+    attr_reader :specs, :misses
+
+    # @param [Hash] specs   Specifications for testing
+    # @option specs [Class]   :type    Type of the actual
+    # @option specs [Integer] :size    Size of the actual
+    # @option specs [Array]   :each    Each element in actual should have
+    #                                  these fields
+    # @option specs [Array]   :fields  Fields that should be present in actual
+    #
+    def initialize(specs)
+      @specs = specs
+      @misses = []
+    end
+
+    # Check if the specs fit the actual
+    #
+    # @returns [Boolean]
+    #
+    def fits?(actual)
+      @misses = [] # reset misses
+      @specs.each do |key, value|
+        method = :"match_#{key}"
+        if !respond_to?(method)
+          @misses << "Unknown spec: #{key}"
+          break
+        end
+
+        begin
+          self.send(method, value, actual)
+        rescue => ex
+          @misses << "Error in #{key} check: #{ex.class}: #{ex.message}"
+        end
+
+        break if @misses.any?
+      end
+
+      @misses.empty?
+    end
+
+    # Does the value match the requested type, populates @misses in failure
+    #
+    # @param [Symbol, String, Class] type  What type should the value be.
+    #        Supported strings are: hash, array, string or boolean
+    #
+    # @param [Object] value
+    #
+    # @example Hash
+    #   match_type(:hash,   { foo: "bar" }) # match
+    #   match_type("array", [0,1,2])        # match
+    #   match_type(String,  "meh")          # match
+    #   match_tyoe(:booelean, false)        # match
+    #
+    # @return [void]
+    def match_type(type, value)
+      matched = case type
+      when :array, :Array, "array", "Array"
+        value.is_a?(Array)
+      when :hash, :Hash, "hash", "Hash"
+        value.is_a?(Hash)
+      when :string, "string", "String"
+        value.is_a?(String)
+      when :boolean, :Boolean, "boolean", "Boolean"
+        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      else
+        value.is_a?(type)
+      end
+
+      @misses << "Type mismatch; Expected #{type}, got #{value.class}: #{value}" if !matched
+    end
+
+    # Does the value match the requested size. Populates @misses in failure
+    #
+    # @param [Integer] size  The needed size
+    # @param [Object] value
+    # @return [void]
+    #
+    def match_size(size, value)
+      if !value.respond_to?(:size)
+        @misses << "Size mismatch; #{value} has no size"
+        return
+      end
+
+      hit = if size.is_a?(Fixnum)
+        value.size == size
+      elsif size.is_a?(Range)
+        size.cover?(value.size)
+      elsif size.is_a?(Array)
+        size.include?(value.size)
+      end
+
+      @misses << "Size mismatch; Expected #{size}, got #{value.size}" if !hit
+    end
+
+    # Does the array contain each of the requested specs
+    #
+    # @param [Hash,Array,Jason::Spec] mapping  What the array should contain
+    # @param [Array] value  Array to check
+    # @param [Symbol] type  How to check:
+    #   * :each - all items must match)
+    #   * :any - at least one item must match)
+    #   * :none - no item may match
+    # @param [String] root  Root for recursive checks
+    #
+    # @return [void]
+    #
+    # @example Shallow check for key
+    # match_each([ :id ], [ { 'id' => 1 }])
+    #
+    # @example Shallow check for key with any
+    # match_each([ :id ], [ { 'id' => 1 }, { 'bar' => 'beer' } ], :any )
+    #
+    # @example Shallow check for key with none
+    # not match_each([ :id ], [ { 'id' => 1 }, { 'bar' => 'beer' } ], :any )
+    #
+    # @example Deep check
+    # match_each(
+    #   { item: [ :id, :name ] }
+    #   [ { "item" => { "id" => "one", "name" => "two" } } ]
+    # )
+    #
+    def match_each(mapping, value, type=:each, root="")
+      misses = []
+      if mapping.is_a?(Array)
+        misses = match_each_shallow(mapping, value)
+      else
+        value.each_with_index do |val, index|
+          if !val.is_a?(Hash)
+            misses << "Each check failed. #{val} is no hash at #{root}[#{index}]"
+            break
+          end
+
+          mapping.each do |key, fields|
+            key = key.to_s
+            miss_key = root == "" ? key : "#{root}.#{key}"
+
+            if !val[key]
+              misses << "Each check failed. Key #{miss_key} is missing at #{root}[#{index}]"
+            end
+
+            if !val[key].is_a?(Hash)
+              misses << "Each check failed. #{miss_key} is no hash at #{root}[#{index}]"
+            end
+
+            if fields.is_a?(Hash)
+              match_each(fields,val[key],type,miss_key)
+              next
+            end
+
+            fields.each do |attr|
+              if !val[key].has_key?(attr.to_s)
+                misses << "Each check failed. #{miss_key}[#{attr}] is missing at #{root}[#{index}]"
+              end
+            end
+          end
+        end
+      end
+
+      case type
+      when :each
+        @misses += misses.compact
+      when :any
+        if misses.compact.size == value.size
+          @misses << "Shallow any check failed: #{misses}"
+        end
+      when :none
+        if misses.compact.size != value.size
+          @misses << "Shallow none check failed: #{misses}"
+        end
+      end
+    end
+
+    # Wrapper around #match_each
+    #
+    def match_any(fields, value)
+      match_each(fields, value, :any)
+    end
+
+    # Wrapper around #match_each
+    #
+    def match_none(fields, value)
+      match_each(fields, value, :none)
+    end
+
+    # Match each only for fields
+    #
+    # @param [Array<Symbol>] fields  list of required fields
+    # @param [Array] list of objects that carry fields
+    # @return [void]
+    #
+    def match_each_shallow(fields, value)
+      misses = []
+      value.each_with_index do |val, index|
+        fields.each do |attr|
+          if !val.has_key?(attr.to_s)
+            misses[index] = "Shallow each check failed. Key #{attr} is missing at [#{index}]"
+            break
+          end
+        end
+      end
+
+      return misses
+    end
+
+    # Match fields on a hash
+    # @param [Hash,Array<Symbol>] fields  list of required fields
+    # @param [Hash] value  Hash to check fields in
+    # @return [void]
+    #
+    # @example Using array (each)
+    # # every field must be present
+    # spec = Jason.spec(fields: [ :id, :name ])
+    # spec.fits({ 'id' => 1, 'name' => "jason" })
+    # not spec.fits({ 'id' => 1 })
+    #
+    # @example Using each
+    # # same as passing the array
+    # spec = Jason.spec(fields: { each: [ :id, :name ] })
+    # spec.fits({ 'id' => 1, 'name' => "jason" })
+    # not spec.fits({ 'id' => 1 })
+    #
+    # @example Using any
+    # spec = Jason.spec(fields: { any: [ :id, :name ] })
+    # spec.fits({ 'id' => 1 })
+    #
+    # @example Using none
+    # spec = Jason.spec(fields: { none: [ :id, :name ] })
+    # not spec.fits({ 'id' => 1 })
+    #
+    def match_fields(fields, value, type=:each)
+      if fields.is_a?(Hash)
+        fields.each do |type, v_fields|
+          match_fields(v_fields, value, type)
+        end
+        return
+      end
+
+      fields.map!(&:to_s)
+      res = fields & value.keys
+
+      case type
+      when :each
+        @misses << "Field(s) #{res - fields} are missing" if res.sort != fields.sort
+      when :any
+        @misses << "None of the fields #{fields} where found" if res.empty?
+      when :none
+        @misses << "Fields #{res} found, none of them where expected" if res.any?
+      end
+    end
+
+  end
+end

data/lib/jason_spec.rb

@@ -0,0 +1,4 @@
+require 'rspec'
+require 'rufus-json/automatic'
+
+require 'jason/matchers'

data/spec/have_jason_matcher_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+require 'jason_spec'
+
+describe Jason::HaveJasonMatcher do
+  it "should match non-rooted objects" do
+    %({"first_name":"Jason","last_name":"Voorhees"}).should have_jason(
+      [:first_name, :last_name]
+    )
+  end
+
+  it "should negate match non-rooted objects" do
+    %({"first_name":"Jason","last_name":"Voorhees"}).should_not have_jason(
+      [:url, :email]
+    )
+  end
+
+  it "should match rooted objects" do
+    %({"user":{"first_name":"Jason","last_name":"Voorhees"}}).should have_jason(
+      { user: [:first_name, :last_name] }
+    )
+  end
+
+  it "should negate match rooted objects" do
+    %({"user":{"first_name":"Jason","last_name":"Voorhees"}}).should_not have_jason(
+      { user: [:email, :url] }
+    )
+  end
+
+  describe "With given object" do
+    class User
+      attr_reader :first_name, :last_name
+      def initialize(fn, ln)
+        @first_name = fn; @last_name = ln
+      end
+    end
+
+    let(:user) { User.new("Jason", "Voorhees") }
+
+    it "should exactly match rooted object" do
+      %({"user":{"first_name":"Jason","last_name":"Voorhees"}}).should have_jason(
+        { user: { user => [:first_name, :last_name] } }
+      )
+    end
+
+    it "should negate exactly match rooted object" do
+      %({"user":{"first_name":"Freddy","last_name":"Kruger"}}).should_not have_jason(
+        { user: { user => [:first_name, :last_name] } }
+      )
+    end
+
+    it "should exactly match non-rooted object" do
+      %({"first_name":"Jason","last_name":"Voorhees"}).should have_jason(
+        { user => [:first_name, :last_name] }
+      )
+    end
+
+    it "should negate exactly matched non-rooted object" do
+      %({"user":{"first_name":"Freddy","last_name":"Kruger"}}).should_not have_jason(
+        { user => [:first_name, :last_name] }
+      )
+    end
+  end
+
+  describe "With Jason::Spec" do
+    it "takes a Jason::Spec" do
+      %([{"name":"Alexis"},{"name":"Ali"},{"name":"Freddy Kruger"}]).should have_jason(
+        Jason.spec(type: :array, each: [ :name ])
+      )
+    end
+  end
+end

data/spec/jason_spec_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe Jason::Spec do
+  it "provides a spec class method" do
+    Jason.should be_respond_to :spec
+    Jason.spec({}).should be_kind_of(Jason::Spec)
+  end
+
+  it "refuses unknown specs" do
+    spec = Jason.spec(unknown: 1)
+    spec.should_not be_fits(:anything)
+  end
+
+  describe "Type" do
+    it "takes a type spec" do
+      spec = Jason::Spec.new(type: Array)
+      spec.fits?(:x)
+      spec.misses.should_not include("Unknown spec: type")
+    end
+
+    it "Matches by string/symbol" do
+      [ "array", "Array", :array, :Array ].each do |type|
+        spec = Jason::Spec.new(type: type)
+        spec.should be_fits([])
+      end
+
+      [ "hash", "Hash", :hash, :Hash ].each do |type|
+        spec = Jason::Spec.new(type: type)
+        spec.should be_fits({})
+      end
+
+      [ "boolean", "Boolean", :boolean, :Boolean ].each_with_index do |type,i|
+        spec = Jason::Spec.new(type: type)
+        spec.should be_fits(true)
+        spec.should be_fits(false)
+      end
+    end
+
+    it "Matches by class" do
+      spec = Jason::Spec.new(type: Jason::Spec)
+      spec.should be_fits(spec)
+    end
+  end
+
+  describe "Size" do
+    it "takes a size spec" do
+      spec = Jason::Spec.new(size: 1)
+      spec.fits?(:x)
+      spec.misses.should_not include("Unknown spec: size")
+    end
+
+    it "takes a fixnum for size" do
+      spec = Jason.spec(size: 1)
+      spec.should_not be_fits( [ ] )
+      spec.should     be_fits( [ 1 ] )
+    end
+
+    it "takes a range for size" do
+      spec = Jason.spec(size: 1..3)
+      spec.should     be_fits( [ 1 ] )
+      spec.should     be_fits( [ 1, 2 ])
+      spec.should_not be_fits( [ ] )
+      spec.should_not be_fits( [ 1, 2, 3, 4 ] )
+    end
+
+    it "takes an array (as a range) for size" do
+      spec = Jason.spec(size: [ 1, 3, 5 ])
+      spec.should     be_fits( [ 1 ] )
+      spec.should_not be_fits( [ 1, 2 ] )
+      spec.should     be_fits( [ 1, 2, 3 ] )
+    end
+
+    it "matches hashes by key size" do
+      spec = Jason::Spec.new(size: 1)
+      spec.should_not be_fits({ a: 1, b: 2 })
+      spec.should     be_fits({ c: 3 })
+    end
+  end
+
+  describe "Each" do
+    it "takes an each spec" do
+      spec = Jason.spec(each: [ :id ])
+      spec.fits?(:x)
+      spec.misses.should_not include("Unknown spec: each")
+    end
+
+    it "checks that each item in the array matches" do
+      spec = Jason.spec(each: [ :id ])
+      spec.should     be_fits([ { 'id' => 1 }, { 'id' => 2 } ])
+      spec.should_not be_fits([ { 'id' => 1 }, { 'uid' => 2 } ])
+    end
+  end
+
+  describe "Complex each structures" do
+    it "should match hash structures" do
+      spec = Jason.spec(each: { item: [ :id, :name ], link: [ :href ] })
+      res = spec.fits?([ { "item" => {  "id" => 1, "name" => "Jason" }, "link" => { "href" => "file:///" } } ] )
+
+      $stderr.puts spec.misses
+      res.should be_true
+
+      spec.should_not be_fits( [ { "item" => {  "nid" => 1, "fame" => "Jason" }, "link" => { "href" => "file:///" } } ] )
+    end
+
+    it "should match deep hash structures"
+    it "should match Jason::Spec"
+  end
+
+  describe "Any" do
+    it "takes an any spec" do
+      spec = Jason.spec(any: [ :id ])
+      spec.fits?(:x)
+      spec.misses.should_not include("Unknown spec: any")
+    end
+
+    it "checks if there is at least one item in the array that match" do
+      spec = Jason.spec(any: [ :id ])
+      spec.should     be_fits([ { 'id' => 1 }, { 'id' => 2 } ])
+      spec.should     be_fits([ { 'id' => 1 }, { 'uid' => 2 } ])
+      spec.should_not be_fits([ { 'uid' => 1 }, { 'uid' => 2 } ])
+    end
+  end
+
+  describe "None" do
+    it "takes a none spec" do
+      spec = Jason.spec(none: [ :id ])
+      spec.fits?(:x)
+      spec.misses.should_not include("Unknown spec: none")
+    end
+
+    it "checks if there are no items in the array that match" do
+      spec = Jason.spec(none: [ :id ])
+      spec.should_not be_fits([ { 'id' => 1 }, { 'id' => 2 } ])
+      spec.should_not be_fits([ { 'id' => 1 }, { 'uid' => 2 } ])
+      spec.should     be_fits([ { 'uid' => 1 }, { 'uid' => 2 } ])
+    end
+  end
+
+  describe "Fields" do
+    it "takes a fields spec" do
+      spec = Jason.spec(fields: [ :id ])
+      spec.fits?(:x)
+      spec.misses.should_not include("Unknown spec: fields")
+    end
+
+    it "checks if all the provided fields are in the hash" do
+      spec = Jason.spec(fields: [ :a, :b, :c ])
+      spec.should_not be_fits({ 'd' => 1 })
+      spec.should_not be_fits({ 'b' => 1 })
+      spec.should     be_fits({ 'a' => 1, 'b' => 2, 'c' => 3 })
+    end
+
+    it "checks each" do
+      spec = Jason.spec(fields: { each: [ :a, :b, :c ] })
+      spec.should_not be_fits({ 'd' => 1 })
+      spec.should_not be_fits({ 'b' => 1 })
+      spec.should     be_fits({ 'a' => 1, 'b' => 2, 'c' => 3 })
+    end
+
+    it "checks any" do
+      spec = Jason.spec(fields: { any: [ :a, :b, :c ] })
+      spec.should     be_fits({ 'b' => 1 })
+      spec.should     be_fits({ 'a' => 1, 'c' => 3 })
+      spec.should_not be_fits({ 'd' => 1 })
+    end
+
+    it "checks none" do
+      spec = Jason.spec(fields: { none: [ :a, :b, :c ] })
+      spec.should_not be_fits({ 'b' => 1 })
+      spec.should_not be_fits({ 'a' => 1, 'b' => 2, 'c' => 3 })
+      spec.should be_fits({ 'd' => 1 })
+    end
+  end
+end

data/spec/matchers_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Jason::Matchers do
+  let(:fake_rspec) do
+    fake = Class.new
+    fake.send(:include, Jason::Matchers)
+    fake.new
+  end
+
+  it "provides have_jason in rspec space" do
+    fake_rspec.should be_respond_to(:have_jason)
+  end
+
+  it "should return instantiate a Jason::Spec" do
+    spec = { type: Array }
+    Jason::HaveJasonMatcher.should_receive(:new).with(spec)
+    fake_rspec.have_jason(spec)
+  end
+
+  it "should return a Jason::Spec" do
+    fake_rspec.have_jason({}).should be_is_a(Jason::HaveJasonMatcher)
+  end
+end

data/spec/readme_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe "Examples from readme" do
+  it "should do the most basic example" do
+    %q({"first_name":"Jason","last_name":"Voorhees"}).should have_jason([:first_name,:last_name])
+  end
+
+  it "should do the root example" do
+    %q({"movie":{"title":"Friday the 13th","release_year":"1980"}}).should have_jason(
+      movie: [ :title, :release_year ]
+    )
+  end
+
+  it "should do the object example" do
+    class Movie
+      attr_reader :title, :release_year
+      def self.find(x)
+        new
+      end
+      def initialize
+        @title = "Friday the 13th"
+        @release_year = "1980"
+      end
+    end
+
+    my_movie = Movie.find(1)
+
+    %q({"movie":{"title":"Friday the 13th","release_year":"1980"}}).should have_jason(
+      { movie: { my_movie => [ :title, :release_year ] } }
+    )
+  end
+
+  it "should do the basic Jason.spec example" do
+    %q({"movies":[{"title":"Friday the 13th"},{"title":"Nightmare on Elm Street"}]}).should have_jason(
+      movies: Jason.spec( type: Array, size: 2, each: [ :title ] )
+    )
+  end
+
+  it "should do the final example" do
+    json = %q({"user":{
+        "user_name":"jason",
+        "favorite_movies":[
+          {"title":"Friday the 13th","id":1},
+          {"title":"Nightmare on Elm Street","id":2}
+        ]
+      },
+      "links":[
+        { "href":"/users/2", "rel": "self" },
+        { "href":"/users/2/movies", "rel": "favorite movies"}
+      ]
+    })
+
+    json.should have_jason(
+      user: {
+        user_name: "jason",
+        favorite_movies: Jason.spec(type: Array, each: [ :title, :id ])
+      },
+      links: Jason.spec(type: Array, each: [ :href, :rel ])
+    )
+  end
+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 'jason_spec'
+
+# 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,144 @@
+--- !ruby/object:Gem::Specification
+name: jason_spec
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Hartog C. de Mik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rufus-json
+  requirement: &9558320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *9558320
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &9574040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *9574040
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &9572560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: *9572560
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &9571440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *9571440
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &9570460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *9570460
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &9569260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *9569260
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &9568280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *9568280
+description: Write specifications for the expected json, without writing json
+email: hartog@organisedminds.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- lib/jason/have_jason_matcher.rb
+- lib/jason/matchers.rb
+- lib/jason/spec.rb
+- lib/jason_spec.rb
+- spec/have_jason_matcher_spec.rb
+- spec/jason_spec_spec.rb
+- spec/matchers_spec.rb
+- spec/readme_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/coffeeaddict/jason_spec
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1377093198486398749
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Spec your JSON
+test_files: []