json_spec 0.8.1 → 1.0.0

data/json_spec.gemspec

@@ -1,26 +1,22 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "json_spec/version"
+# encoding: utf-8
 
-Gem::Specification.new do |s|
-  s.name        = "json_spec"
-  s.version     = JsonSpec::VERSION
-  s.authors     = ["Steve Richert"]
-  s.email       = ["steve.richert@gmail.com"]
-  s.homepage    = "https://github.com/collectiveidea/json_spec"
-  s.summary     = "Easily handle JSON in RSpec and Cucumber"
-  s.description = "Easily handle JSON in RSpec and Cucumber"
+Gem::Specification.new do |gem|
+  gem.name    = "json_spec"
+  gem.version = "1.0.0"
 
-  s.rubyforge_project = "json_spec"
+  gem.authors     = ["Steve Richert"]
+  gem.email       = ["steve.richert@gmail.com"]
+  gem.summary     = "Easily handle JSON in RSpec and Cucumber"
+  gem.description = "Easily handle JSON in RSpec and Cucumber"
+  gem.homepage    = "https://github.com/collectiveidea/json_spec"
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f) }
-  s.require_paths = ["lib"]
+  gem.add_dependency "multi_json", "~> 1.0"
+  gem.add_dependency "rspec",      "~> 2.0"
 
-  s.add_dependency "multi_json", "~> 1.0"
-  s.add_dependency "rspec", "~> 2.0"
+  gem.add_development_dependency "cucumber", "~> 1.1", ">= 1.1.1"
+  gem.add_development_dependency "rake",     "~> 0.9"
 
-  s.add_development_dependency "rake", "~> 0.9"
-  s.add_development_dependency "cucumber", "~> 1.1", ">= 1.1.1"
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
 end

data/lib/json_spec/configuration.rb

@@ -13,15 +13,23 @@ module JsonSpec
     end
 
     def excluded_keys=(keys)
-      @excluded_keys = keys.map{|k| k.to_s }.uniq
+      @excluded_keys = keys.map(&:to_s).uniq
     end
 
     def exclude_keys(*keys)
       self.excluded_keys = keys
     end
 
+    def directory
+      @directory
+    end
+
+    def directory=(directory)
+      @directory = directory
+    end
+
     def reset
-      instance_variables.each{|iv| remove_instance_variable(iv) }
+      instance_variables.each{|ivar| remove_instance_variable(ivar) }
     end
   end
 end

data/lib/json_spec/cucumber.rb

@@ -18,6 +18,14 @@ Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? be:$/ do |pa
   end
 end
 
+Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? be file "(.+)"$/ do |path, negative, file_path|
+  if negative
+    last_json.should_not be_json_eql.to_file(file_path).at_path(path)
+  else
+    last_json.should be_json_eql.to_file(file_path).at_path(path)
+  end
+end
+
 Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? be (".*"|\-?\d+(?:\.\d+)?(?:[eE][\+\-]?\d+)?|\[.*\]|%?\{.*\}|true|false|null)$/ do |path, negative, value|
   if negative
     last_json.should_not be_json_eql(JsonSpec.remember(value)).at_path(path)
@@ -34,6 +42,14 @@ Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? include:$/ d
   end
 end
 
+Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? include file "(.+)"$/ do |path, negative, file_path|
+  if negative
+    last_json.should_not include_json.from_file(file_path).at_path(path)
+  else
+    last_json.should include_json.from_file(file_path).at_path(path)
+  end
+end
+
 Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? include (".*"|\-?\d+(?:\.\d+)?(?:[eE][\+\-]?\d+)?|\[.*\]|%?\{.*\}|true|false|null)$/ do |path, negative, value|
   if negative
     last_json.should_not include_json(JsonSpec.remember(value)).at_path(path)
@@ -63,11 +79,10 @@ Then /^the (?:JSON|json)(?: response)? should( not)? have "(.*)"$/ do |negative,
 end
 
 Then /^the (?:JSON|json)(?: response)?(?: at "(.*)")? should( not)? be an? (.*)$/ do |path, negative, type|
-  klass = Module.const_get(type.gsub(/^./){|x| x.upcase })
   if negative
-    last_json.should_not have_json_type(klass).at_path(path)
+    last_json.should_not have_json_type(type).at_path(path)
   else
-    last_json.should have_json_type(klass).at_path(path)
+    last_json.should have_json_type(type).at_path(path)
   end
 end
 

data/lib/json_spec/errors.rb

@@ -1,5 +1,8 @@
 module JsonSpec
-  class MissingPathError < StandardError
+  class Error < StandardError
+  end
+
+  class MissingPath < Error
     attr_reader :path
 
     def initialize(path)
@@ -10,4 +13,22 @@ module JsonSpec
       %(Missing JSON path "#{path}")
     end
   end
+
+  class MissingDirectory < Error
+    def to_s
+      "No JsonSpec.directory set"
+    end
+  end
+
+  class MissingFile < Error
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def to_s
+      "No JSON file at #{path}"
+    end
+  end
 end

data/lib/json_spec/helpers.rb

@@ -1,4 +1,4 @@
-require 'multi_json'
+require "multi_json"
 
 module JsonSpec
   module Helpers
@@ -23,6 +23,13 @@ module JsonSpec
       end
     end
 
+    def load_json(relative_path)
+      missing_json_directory! if JsonSpec.directory.nil?
+      path = File.join(JsonSpec.directory, relative_path)
+      missing_json_file!(path) unless File.exist?(path)
+      File.read(path)
+    end
+
     private
       def value_at_json_path(ruby, path)
         return ruby unless path
@@ -40,7 +47,15 @@ module JsonSpec
       end
 
       def missing_json_path!(path)
-        raise JsonSpec::MissingPathError.new(path)
+        raise JsonSpec::MissingPath.new(path)
+      end
+
+      def missing_json_directory!
+        raise JsonSpec::MissingDirectory
+      end
+
+      def missing_json_file!(path)
+        raise JsonSpec::MissingFile.new(path)
       end
   end
 end

data/lib/json_spec/matchers/be_json_eql.rb

@@ -0,0 +1,63 @@
+module JsonSpec
+  module Matchers
+    class BeJsonEql
+      include JsonSpec::Helpers
+      include JsonSpec::Exclusion
+      include JsonSpec::Messages
+
+      attr_reader :expected, :actual
+
+      def diffable?
+        true
+      end
+
+      def initialize(expected_json = nil)
+        @expected_json = expected_json
+      end
+
+      def matches?(actual_json)
+        raise "Expected equivalent JSON not provided" if @expected_json.nil?
+
+        @actual, @expected = scrub(actual_json, @path), scrub(@expected_json)
+        @actual == @expected
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def to_file(path)
+        @expected_json = load_json(path)
+        self
+      end
+
+      def excluding(*keys)
+        excluded_keys.merge(keys.map(&:to_s))
+        self
+      end
+
+      def including(*keys)
+        excluded_keys.subtract(keys.map(&:to_s))
+        self
+      end
+
+      def failure_message_for_should
+        message_with_path("Expected equivalent JSON")
+      end
+
+      def failure_message_for_should_not
+        message_with_path("Expected inequivalent JSON")
+      end
+
+      def description
+        message_with_path("equal JSON")
+      end
+
+      private
+        def scrub(json, path = nil)
+          generate_normalized_json(exclude_keys(parse_json(json, path))).chomp + "\n"
+        end
+    end
+  end
+end

data/lib/json_spec/matchers/have_json_path.rb

@@ -0,0 +1,30 @@
+module JsonSpec
+  module Matchers
+    class HaveJsonPath
+      include JsonSpec::Helpers
+
+      def initialize(path)
+        @path = path
+      end
+
+      def matches?(json)
+        parse_json(json, @path)
+        true
+      rescue JsonSpec::MissingPath
+        false
+      end
+
+      def failure_message_for_should
+        %(Expected JSON path "#{@path}")
+      end
+
+      def failure_message_for_should_not
+        %(Expected no JSON path "#{@path}")
+      end
+
+      def description
+        %(have JSON path "#{@path}")
+      end
+    end
+  end
+end

data/lib/json_spec/matchers/have_json_size.rb

@@ -0,0 +1,35 @@
+module JsonSpec
+  module Matchers
+    class HaveJsonSize
+      include JsonSpec::Helpers
+      include JsonSpec::Messages
+
+      def initialize(size)
+        @expected = size
+      end
+
+      def matches?(json)
+        ruby = parse_json(json, @path)
+        @actual = Enumerable === ruby ? ruby.size : 1
+        @actual == @expected
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def failure_message_for_should
+        message_with_path("Expected JSON value size to be #{@expected}, got #{@actual}")
+      end
+
+      def failure_message_for_should_not
+        message_with_path("Expected JSON value size to not be #{@expected}, got #{@actual}")
+      end
+
+      def description
+        message_with_path(%(have JSON size "#{@expected}"))
+      end
+    end
+  end
+end

data/lib/json_spec/matchers/have_json_type.rb

@@ -0,0 +1,49 @@
+module JsonSpec
+  module Matchers
+    class HaveJsonType
+      include JsonSpec::Helpers
+      include JsonSpec::Messages
+
+      def initialize(type)
+        @classes = type_to_classes(type)
+      end
+
+      def matches?(json)
+        @ruby = parse_json(json, @path)
+        @classes.any?{|c| c === @ruby }
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def failure_message_for_should
+        message_with_path("Expected JSON value type to be #{@classes.join(", ")}, got #{@ruby.class}")
+      end
+
+      def failure_message_for_should_not
+        message_with_path("Expected JSON value type to not be #{@classes.join(", ")}, got #{@ruby.class}")
+      end
+
+      def description
+        message_with_path(%(have JSON type "#{@classes.join(", ")}"))
+      end
+
+      private
+        def type_to_classes(type)
+          case type
+          when Class then [type]
+          when Array then type.map{|t| type_to_classes(t) }.flatten
+          else
+            case type.to_s.downcase
+            when "boolean"     then [TrueClass, FalseClass]
+            when "object"      then [Hash]
+            when "nil", "null" then [NilClass]
+            else [Module.const_get(type.to_s.capitalize)]
+            end
+          end
+        end
+    end
+  end
+end

data/lib/json_spec/matchers/include_json.rb

@@ -0,0 +1,57 @@
+module JsonSpec
+  module Matchers
+    class IncludeJson
+      include JsonSpec::Helpers
+      include JsonSpec::Exclusion
+      include JsonSpec::Messages
+
+      def initialize(expected_json = nil)
+        @expected_json = expected_json
+      end
+
+      def matches?(actual_json)
+        raise "Expected included JSON not provided" if @expected_json.nil?
+
+        actual = parse_json(actual_json, @path)
+        expected = exclude_keys(parse_json(@expected_json))
+        case actual
+        when Hash then actual.values.map{|v| exclude_keys(v) }.include?(expected)
+        when Array then actual.map{|e| exclude_keys(e) }.include?(expected)
+        else false
+        end
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def from_file(path)
+        @expected_json = load_json(path)
+        self
+      end
+
+      def excluding(*keys)
+        excluded_keys.merge(keys.map(&:to_s))
+        self
+      end
+
+      def including(*keys)
+        excluded_keys.subtract(keys.map(&:to_s))
+        self
+      end
+
+      def failure_message_for_should
+        message_with_path("Expected included JSON")
+      end
+
+      def failure_message_for_should_not
+        message_with_path("Expected excluded JSON")
+      end
+
+      def description
+        message_with_path("include JSON")
+      end
+    end
+  end
+end

data/lib/json_spec/matchers.rb

@@ -1,225 +1,16 @@
-require "json"
-require "rspec"
+require "json_spec/matchers/be_json_eql"
+require "json_spec/matchers/include_json"
+require "json_spec/matchers/have_json_path"
+require "json_spec/matchers/have_json_type"
+require "json_spec/matchers/have_json_size"
 
 module JsonSpec
   module Matchers
-    class BeJsonEql
-      include JsonSpec::Helpers
-      include JsonSpec::Exclusion
-
-      attr_reader :expected, :actual
-
-      def diffable?
-        true
-      end
-
-      def initialize(expected_json)
-        @expected_json = expected_json
-      end
-
-      def matches?(actual_json)
-        @actual, @expected = scrub(actual_json, @path), scrub(@expected_json)
-        @actual == @expected
-      end
-
-      def at_path(path)
-        @path = path
-        self
-      end
-
-      def excluding(*keys)
-        excluded_keys.merge(keys.map{|k| k.to_s })
-        self
-      end
-
-      def including(*keys)
-        excluded_keys.subtract(keys.map{|k| k.to_s })
-        self
-      end
-
-      def failure_message_for_should
-        message = "Expected equivalent JSON"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      def failure_message_for_should_not
-        message = "Expected inequivalent JSON"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      def description
-        message = "equal JSON"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      private
-        def scrub(json, path = nil)
-          generate_normalized_json(exclude_keys(parse_json(json, path))).chomp + "\n"
-        end
-    end
-
-    class IncludeJson
-      include JsonSpec::Helpers
-      include JsonSpec::Exclusion
-
-      def initialize(expected_json)
-        @expected_json = expected_json
-      end
-
-      def matches?(actual_json)
-        actual = parse_json(actual_json, @path)
-        expected = exclude_keys(parse_json(@expected_json))
-        case actual
-        when Hash then actual.values.map{|v| exclude_keys(v) }.include?(expected)
-        when Array then actual.map{|e| exclude_keys(e) }.include?(expected)
-        else false
-        end
-      end
-
-      def at_path(path)
-        @path = path
-        self
-      end
-
-      def excluding(*keys)
-        excluded_keys.merge(keys.map{|k| k.to_s })
-        self
-      end
-
-      def including(*keys)
-        excluded_keys.subtract(keys.map{|k| k.to_s })
-        self
-      end
-
-      def failure_message_for_should
-        message = "Expected included JSON"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      def failure_message_for_should_not
-        message = "Expected excluded JSON"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      def description
-        message = "include JSON"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-    end
-
-    class HaveJsonPath
-      include JsonSpec::Helpers
-
-      def initialize(path)
-        @path = path
-      end
-
-      def matches?(json)
-        begin
-          parse_json(json, @path)
-          true
-        rescue JsonSpec::MissingPathError
-          false
-        end
-      end
-
-      def failure_message_for_should
-        %(Expected JSON path "#{@path}")
-      end
-
-      def failure_message_for_should_not
-        %(Expected no JSON path "#{@path}")
-      end
-
-      def description
-        %(have JSON path "#{@path}")
-      end
-    end
-
-    class HaveJsonType
-      include JsonSpec::Helpers
-
-      def initialize(klass)
-        @klass = klass
-      end
-
-      def matches?(json)
-        @ruby = parse_json(json, @path)
-        @ruby.is_a?(@klass)
-      end
-
-      def at_path(path)
-        @path = path
-        self
-      end
-
-      def failure_message_for_should
-        message = "Expected JSON value type to be #{@klass}, got #{@ruby.class}"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      def failure_message_for_should_not
-        message = "Expected JSON value type to not be #{@klass}, got #{@ruby.class}"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      def description
-        message = %(have JSON type "#{@klass.to_s}")
-        message << %( at path "#{@path}") if @path
-        message
-      end
-    end
-
-    class HaveJsonSize
-      include JsonSpec::Helpers
-
-      def initialize(size)
-        @expected = size
-      end
-
-      def matches?(json)
-        ruby = parse_json(json, @path)
-        @actual = ruby.is_a?(Enumerable) ? ruby.size : 1
-        @actual == @expected
-      end
-
-      def at_path(path)
-        @path = path
-        self
-      end
-
-      def failure_message_for_should
-        message = "Expected JSON value size to be #{@expected}, got #{@actual}"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      def failure_message_for_should_not
-        message = "Expected JSON value size to not be #{@expected}, got #{@actual}"
-        message << %( at path "#{@path}") if @path
-        message
-      end
-
-      def description
-        message = %(have JSON size "#{@expected}")
-        message << %( at path "#{@path}") if @path
-        message
-      end
-    end
-
-    def be_json_eql(json)
+    def be_json_eql(json = nil)
       JsonSpec::Matchers::BeJsonEql.new(json)
     end
 
-    def include_json(json)
+    def include_json(json = nil)
       JsonSpec::Matchers::IncludeJson.new(json)
     end
 
@@ -227,8 +18,8 @@ module JsonSpec
       JsonSpec::Matchers::HaveJsonPath.new(path)
     end
 
-    def have_json_type(klass)
-      JsonSpec::Matchers::HaveJsonType.new(klass)
+    def have_json_type(type)
+      JsonSpec::Matchers::HaveJsonType.new(type)
     end
 
     def have_json_size(size)

data/lib/json_spec/memory.rb

@@ -5,12 +5,11 @@ module JsonSpec
     end
 
     def memorize(key, value)
-      memory[key] = value
+      memory[key.to_sym] = value
     end
 
     def remember(json)
-      return json if memory.empty?
-      json.gsub(/%\{(#{memory.keys.map{|k| Regexp.quote(k) }.join("|")})\}/){ memory[$1] }
+      memory.empty? ? json : json % memory
     end
 
     def forget

data/lib/json_spec/messages.rb

@@ -0,0 +1,8 @@
+module JsonSpec
+  module Messages
+    def message_with_path(message)
+      message << %( at path "#{@path}") if @path
+      message
+    end
+  end
+end

data/lib/json_spec.rb

@@ -1,8 +1,10 @@
-require "json_spec/version"
+require "json"
+require "rspec"
 require "json_spec/errors"
 require "json_spec/configuration"
 require "json_spec/exclusion"
 require "json_spec/helpers"
+require "json_spec/messages"
 require "json_spec/matchers"
 require "json_spec/memory"