data_spec 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41b97a4b8d4e7d9ba659c756dd00132cb8fc8865
-  data.tar.gz: 6991ac05e24b5c297ebabfb3d8795669b6681f6a
+  metadata.gz: 38a6a7c19a43116b793ccc2565beba91ec40ad58
+  data.tar.gz: 78178e54b3ad7afc932a487ca8ce453104e95a52
 SHA512:
-  metadata.gz: 4428020420b3c23d340b4893a6bc6882014bf78c860cac3b5540099ec333bf195518c9cfa230cb624ffcc419258ba809129687d190b9cd8b7cc9547f379f38d6
-  data.tar.gz: 7d963c06e3a45144c6b5e05d540ea80a277b90de236cc05170f932b210d4180f0cf7fd6ebe9f09476d5c3077a8c8c9b9819cc4752a6c333e80e199d13e6f9abb
+  metadata.gz: ebd55fded46197f459fd651d339bcef2798f36681a8a0c5d27e96087f13dd92c3cd61d3788fdb90f840cabe2e24337409f40449921b87d503b8718bb0b915fc2
+  data.tar.gz: 23239a0654bdd2c85c817fcb00ff8b810a63c5f4d0eb77bf39fedd0b0d6495357858128c443416c15bff0bed87e67e6b50bdcd5a130f5900d52ed9b71298f449

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+bundler_args: --without development
+rvm:
+  - 2.0.0

data/Gemfile

@@ -4,4 +4,11 @@ ruby '2.0.0'
 # Specify your gem's dependencies in data_spec.gemspec
 gemspec
 
-gem 'debugger'
+group :test do
+  gem 'rake'
+end
+
+group :development do
+  gem 'debugger'
+  gem 'bundler'
+end

data/README.md

@@ -1,6 +1,8 @@
 data_spec
 ========
 
+[![Build Status](https://secure.travis-ci.org/narfanator/data_spec.png)](http://travis-ci.org/narfanator/data_spec) [![Dependency Status](https://gemnasium.com/narfanator/data_spec.png)](https://gemnasium.com/narfanator/data_spec) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/narfanator/data_spec)
+
 Easily compare hashes and arrays in RSpec and Cucumber
 
 Originally inspired by collectiveidea's json_spec gem
@@ -9,29 +11,29 @@ Installation
 ------------
 
     gem 'data_spec'
-    {cucumber}
-    {rspec}
 
-Cucumber
-------------
+# Cucumber
 
-# Setup:
+Setup:
+------------
 
-Include `data_spec/cucumber` and define `data` in your Cucumber environment:
+Include `data_spec` and define `data` in your Cucumber environment:
 ```ruby
 # features/support/env.rb
-require "data_spec/cucumber"
+require "data_spec"
 
 def data
   #...
 end
 ```
 
-# Usage:
+Usage:
+------------
+**The step `Given the data is:` is not supplied by this gem**
 
 Use either YAML or JSON:
 ````ruby
-Given the data is:        # You define this one
+Given the data is:
 """
 chunky: bacon
 """
@@ -75,7 +77,7 @@ Then the data includes:
 - 1
 - 2
 """
-And the data at "even" includes "'in a': hash"
+And the data at "3/even" includes "'in a': hash"
 ```
 
 Check types:
@@ -86,9 +88,9 @@ Given the data is:
 - 1
 - 2013-07-06 20:09:32.824102000 -07:00
 """
-Then the data at "0" is of type String
-Then the data at "1" is of type Fixnum
-Then the data at "2" is of type Time
+Then the data at "0" should be of type String
+Then the data at "1" should be of type Fixnum
+Then the data at "2" should be of type Time
 ```
 
 Use embedded code:
@@ -97,80 +99,158 @@ Given the data is:
 """
 - `1+1`
 - '$1e2$'
-- `"bacon".class`
+- `'bacon'.class`
 """
 Then the data at "0" should be 2
 Then the data at "1" should be 100
-Then the data at "2" should be `String.class`
+Then the data at "2" should be `"chunky".class`
 ```
 (Among other things, this lets you work around Ruby YAML's lack of support for scientific notation)
+
 **Note: This is done via a raw `eval`, so it's dangerous**
 
-#Steps
+Store data for later use:
+```ruby
+Given `@samples` is:
+"""
+where: "http://google.com"
+when: `Time.now`
+"""
+And `@samples` includes:
+"""
+what: {}
+"""
+And `@samples['what']` is:
+"""
+- chunky
+- bacon
+"""
+And the data is:
+"""
+meal: 
+  main_course: `@samples['what'][1]`
+  style: `@samples['what'][0]`
+  ordered: `@samples['when']`
+"""
+Then the data should be:
+"""
+meal:
+  main_course: bacon
+  style: chunky
+  ordered: `@samples['when']`
+"""
+```
+
+Again, this is done by raw eval, so it's dangerous, and it's definitely enough to shoot your foot off with.
+
+If you're using this in anything like a complex sense, look up the "evaluation" and "remember" helpers, below
+
 
+Steps
+----------
+
+Matching:
 * `Then the data should be:`
 * `Then the data should be "..."`
 * `Then the data at "..." should be:`
 * `Then the data at "..." should be "..."`
 
+Inclusion:
 * `Then the data includes:`
 * `Then the data includes "..."`
 * `Then the data at "..." includes:`
 * `Then the data at "..." includes "..."`
 
+Type checking:
 * `Then the data is of type ...`
 * `Then the data at "..." if of type ...`
 
 Pathing is done like so: `data[:chunky]['Bacon'][0]` would be "chunky/bacon/0". Each element (when looking in a hash) is first tried as a symbol, then as a string.
 
-When checking inclusion against an array, you need to supply an array: `[1,2,3]` includes `[2]`, or `[1, [2,3], 4]` includes `[[2,3]]`
+When checking inclusion against an array, you need to supply an array: `[1,2,3]` includes `[2]`, or `[1, [2,3], 4]` includes `[[2,3]]`.
 
 When checking inclusion against a hash, you need to supply a hash: `{one: :two, three: four}` includes `{one: :two}`
 
-RSpec
+You don't see this quite the same in the Cucumber steps because YAML parsing from a string does this inherently: `"one: two"` becomes `{'one' => 'two'}` and
+`"[one, two]"` or `"- one\n- two"` becomes `['one', 'two']`
+
+# RSpec
+
+Setup
 --------
+```ruby
+#in spec/spec_helper.rb
+require 'data_spec'
+```
 
+Matchers
+--------
+Three matchers:
 * `match_data(...).at(...)`
 * `includes_data(...).at(...)`
 * `match_block(lambda{...}).at(...)`
 
-Exact matching is (as it turns out!) handled by `==`, while partial matching is handled by http://stackoverflow.com/questions/3826969/ruby-hash-include-another-hash-deep-check
-Note that pathing is applied to the object being checked: in `hash1.should match_data(hash2).at("path/0")`, `hash1[:path][0]` would be compared to `hash2`.
+Exact matching is handled by `==`, while partial matching is handled by 
+[`deep_include?`](http://stackoverflow.com/questions/3826969/ruby-hash-include-another-hash-deep-check)
+
+Note that pathing is applied to the object being checked:
+
+    hash1.should match_data(hash2).at("path/0")
+
+results in:
+
+    hash1[:path][0].should match_data(hash2)
+
+# Library
 
 Helpers
 --------
-* DataSpec::Helpers.at_path(data, path)
-* DataSpec.parse
+* `DataSpec::Helpers.at_path(data, path)`
+* `DataSpec.parse`
 
-`at_path` is what provides the "pathing" functionality, while `parse` provides interpreting embedded code.
+`at_path` is what provides the "pathing" functionality, while `parse` provides the interpreting of embedded code.
 
 As seen in the examples, you can use $ at the beginning and end, or backticks instead of quotes. 
-The backticks will actually be converted to dollar signs, but they're prettier and easier to read.
+The backticks will actually be converted to dollar signs (YAML parsers choke on backticks), 
+but they're prettier and easier to read.
 
-Refinements
--------
-`DataSpec::Refinements` adds `tree_walk_with_self` to both `Hash` and `Array`.
-It allows you to apply a block to every key/value pair in the hash or array, traversing recursively.
-Supply a block accepting `(key, value), hash`, where `hash` is the current node; `hash[key] == value`; this allows you to alter the values.
+* `DataSpec::Helpers.evaluate(string)`
 
-Issues
--------
-* The YAML/JSON equivelance check is failing. 
-* The error messages suck. Plan is to provide them as a diff'd YAML, although I'm not sure what to do for blocks
-* No table syntax as in json_spec
-* No explicit testing of `tree_walks_with_self`
-* No support for XML
+This simply does an `eval` on the string; however, _because it also used when parsing YAML/JSON_, you can add variables
+in which it is run, and use those variables in your YAML and JSON. 
 
-Contributing
------------
-Go for it! Accepted code will have Cucumber and RSpec testing and be minimalist; if you spot a bug, try to provide a failing test in the report.
+* `DataSpec::Helpers.remember(string, data)
 
-"Minimalist" doesn't mean fewest lines of code (although that's usually the case); it generally means "fewest new functions and objects"
+This is another way to add data to the evaulation scope; pass in the complete variable name (such as `@sample_data`) and the data to be stored.
+
+Refinements
+-------
+Defined in `DataSpec::Refinements`; to use, `using DataSpec::Refinements`
 
+* `Array.tree_walk_with_self{|(key, value), array| ... }`
+* `Array.deep_include? sub_array`
+* `Hash.tree_walk_with_self{|(key, value), hash| ... }`
+* `Hash.deep_include? sub_hash`
 
+`tree_walk_with_self` allows you to apply a block to every key/value pair in the hash or array, traversing recursively.
+The third yielded value is the current node: `hash[key] == value`  - this allows you to alter the values of the hash during traversal.
 
+`Array.deep_include? sub_array` simply does `(sub_array - self).empty?`, which is true when all elements of the sub-array
+are present in `self`
 
+`Hash.deep_include? sub_hash` is used to detect if every key/value pair in the `sub_hash` is present in `self`
 
+#Contributing
 
+Remaining Issues
+-------
+* The error messages suck. Plan is to provide them as a diff'd YAML, although I'm not sure what to do for blocks
+* No table syntax as in `json_spec`
+* No explicit testing of `tree_walks_with_self`
+* No support for XML
 
+Pull Requests
+-----------
+Go for it! Accepted code will have Cucumber and RSpec testing and be minimalist; if you spot a bug, try to provide a failing test in the report.
 
+"Minimalist" doesn't mean fewest lines of code (although that's usually the case); it means "fewest new functions and objects"

data/Rakefile

@@ -1 +1,11 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "cucumber/rake/task"
+
+RSpec::Core::RakeTask.new(:spec)
+Cucumber::Rake::Task.new(:cucumber) do |t|
+    t.cucumber_opts = "--tags ~@fail"
+end
+
+task :test => [:spec, :cucumber]
+task :default => :test

data/data_spec.gemspec

@@ -14,11 +14,9 @@ Gem::Specification.new do |spec|
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.test_files    = spec.files.grep(%r{^(spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_dependency "cucumber"
   spec.add_dependency "rspec"

data/features/core.feature

@@ -3,33 +3,33 @@ Feature: Core Steps
   Scenario: JSON / YAML Equality
     Given the data is:
     """
-    - chunky: bacon
-      ordered_by:
-      - person: joe
-        wants:
-          pieces: `1+1`
-      - person: josephina
-        wants:
-          pieces: `1e2`
+    chunky: bacon
+    ordered_by:
+    - person: joe
+      wants:
+        pieces: `1+1`
+    - person: josephina
+      wants:
+        pieces: `1e2`
     """
     Then the data should be:
     """
     {
-      "chunky": "bacon", 
       "ordered_by": [
         {
-          "person": "joe",
           "wants": {
             "pieces": "`1+1`"
-          }
+          },
+          "person": "joe"
         }, 
         {
-          "person": "josephina",
           "wants": {
             "pieces": "`1e2`"
-          } 
+          }, 
+          "person": "josephina"
         }
-      ]
+      ],
+      "chunky": "bacon"
     }
     """
 
@@ -110,9 +110,9 @@ Feature: Core Steps
     hash: {}
     array: []
     """
-    Then the data at "date" is of type Time
-    And the data at "fixnum" is of type Fixnum
-    And the data at "float" is of type Float
-    And the data at "string" is of type String
-    And the data at "hash" is of type Hash
-    And the data at "array" is of type Array
+    Then the data at "date" should be of type Time
+    And the data at "fixnum" should be of type Fixnum
+    And the data at "float" should be of type Float
+    And the data at "string" should be of type String
+    And the data at "hash" should be of type Hash
+    And the data at "array" should be of type Array

data/features/memory.feature

@@ -0,0 +1,126 @@
+Feature: Storage of local information
+
+  Scenario: Variable Assignment
+    Given `@var` is "chunky"
+    And the data is:
+    """
+    `@var`
+    """
+    Then the data should be:
+    """
+    chunky
+    """
+
+  Scenario: Array Assignment
+    Given `@var` is:
+    """
+    - chunky
+    - bacon
+    """
+    And the data is:
+    """
+    - `@var[0]`
+    - `@var[1]`
+    """
+    Then the data at "0" should be "`@var[0]`"
+    And the data should be:
+    """
+    `@var`
+    """
+
+  Scenario: Array Appending
+    Given `@var` is:
+    """
+    - chunky
+    - bacon
+    """
+    And `@var` includes:
+    """
+    - two
+    - three
+    """
+    And the data is:
+    """
+    `@var`
+    """
+    Then the data should include "`@var[2,3]`"
+
+  Scenario: Hash Assignment
+    Given `@var` is:
+    """
+    chunky: bacon
+    bacon: chunky
+    """
+    And the data is:
+    """
+    `@var`
+    """
+    Then the data at "chunky" should be "bacon"
+    And the data should be:
+    """
+    bacon: chunky
+    chunky: bacon
+    """
+
+  Scenario: Hash Appending
+    Given `@var` is:
+    """
+    chunky: bacon
+    bacon: chunky
+    """
+    And `@var` includes:
+    """
+    bacon: bacon
+    one: two
+    """
+    And the data is:
+    """
+    `@var`
+    """
+    Then the data at "bacon" should be "bacon"
+    And the data at "one" should be "two"
+
+  Scenario: Nesting:
+    Given `@var` is:
+    """
+    nested:
+      hash:
+        chunky: bacon
+    """
+    And `@var['nested']` includes:
+    """
+    array:
+    - 1
+    - 2
+    """
+    And the data is:
+    """
+    - `@var['nested']['hash']['chunky']`
+    - `@var['nested']['array']`
+    """
+    Then the data should be:
+    """
+    - bacon
+    - - 1
+      - 2
+    """
+
+  Scenario: Multiple Variables
+    Given `@one` is:
+    """
+    one: two
+    """
+    And `@two` is:
+    """
+    two: three
+    """
+    And the data is:
+    """
+    - `@one`
+    - `@two`
+    """
+    Then the data is:
+    """
+    - one: two
+    - two: three
+    """

data/features/readme.feature

@@ -0,0 +1,95 @@
+Feature: Readme Examples
+
+  Scenario: Matching
+    Given the data is:
+    """
+    chunky: bacon
+    """
+    Then the data should be:
+    """
+    {
+      "chunky": "bacon"
+    }
+    """
+  Scenario: Path Selection
+    Given the data is:
+    """
+    interleaved:
+    - hashes:
+        and:
+        - arrays
+    """
+    Then the data at "interleaved/0/hashes" should be:
+    """
+    and:
+    - arrays
+    """
+
+  Scenario: Inclusion
+    Given the data is:
+    """
+    - 1
+    - 2
+    - 3
+    - even:
+        'in a': hash
+        'with only': some keys
+    """
+    Then the data should include:
+    """
+    - 1
+    - 2
+    """
+    And the data at "3/even" should include "'in a': hash"
+
+  Scenario: Type Checking
+    Given the data is:
+    """
+    - bacon
+    - 1
+    - 2013-07-06 20:09:32.824102000 -07:00
+    """
+    Then the data at "0" should be of type String
+    Then the data at "1" should be of type Fixnum
+    Then the data at "2" should be of type Time
+
+  Scenario: Embedded Code
+    Given the data is:
+    """
+    - `1+1`
+    - '$1e2$'
+    - `"bacon".class`
+    """
+    Then the data at "0" should be "2"
+    Then the data at "1" should be "100"
+    Then the data at "2" should be "`"chunky".class`"
+
+  Scenario: Memory
+    Given `@samples` is:
+    """
+    where: "http://google.com"
+    when: `Time.now`
+    """
+    And `@samples` includes:
+    """
+    what: {}
+    """
+    And `@samples['what']` is:
+    """
+    - chunky
+    - bacon
+    """
+    And the data is:
+    """
+    meal: 
+      main_course: `@samples['what'][1]`
+      style: `@samples['what'][0]`
+      ordered: `@samples['when']`
+    """
+    Then the data should be:
+    """
+    meal:
+      main_course: bacon
+      style: chunky
+      ordered: `@samples['when']`
+    """

data/features/support/env.rb

@@ -1,5 +1,5 @@
 require "data_spec/cucumber"
-require 'debugger'
+#require 'debugger'
 
 def data
   @data

data/lib/data_spec/cucumber.rb

@@ -1,6 +1,20 @@
+require File.expand_path("../../data_spec", __FILE__)
 require 'data_spec'
+require 'time'
 
-World(DataSpec::Helpers, DataSpec::Matchers, DataSpec::Inclusion, DataSpec::Block)
+World(DataSpec::Helpers, DataSpec::Matchers)
+
+Given(/^`(.*?)` is:?(?: "(.*?)")?$/) do |var, inline, *block|
+  DataSpec::Helpers.evaluate("#{var} = DataSpec.parse(%##{(inline || block.first)}#)")
+end
+
+Given(/^`(.*?)` includes:?(?: "(.*?)")?$/) do |var, inline, *block|
+  if DataSpec.parse("`#{var}`").is_a? Hash
+    DataSpec::Helpers.evaluate("#{var}.merge! DataSpec.parse(%##{(inline || block.first)}#)")
+  elsif DataSpec.parse("`#{var}`").is_a? Array
+    DataSpec::Helpers.evaluate("#{var} += DataSpec.parse(%##{(inline || block.first)}#)")
+  end
+end
 
 # Then the data at "path" should be "data"
 # Then the data should be: (...)
@@ -12,6 +26,12 @@ Then(/^the data(?: at "(.*?)")? should include:?(?: "(.*?)")?$/) do |path, inlin
   data.should include_data(DataSpec.parse(inline || block.first)).at(path)
 end
 
-Then(/^the data at "(.*?)" is of type ([A-Z][a-z]+)$/) do |path, type|
-  data.should match_block(lambda{|item| item.is_a? Object.const_get(type)}).at(path)
+Then(/^the data at "(.*?)" should be of type ([A-Z][a-z]+)$/) do |path, type|
+  if type == "Time"
+    #JSON doesn't actually interpret a time string into a Time,
+    # YAML will, but Time doesn't parse a Time object
+    data.should match_block(lambda{|item| Time.parse(item.to_s).is_a? Time}).at(path)
+  else
+    data.should match_block(lambda{|item| item.is_a? Object.const_get(type)}).at(path)
+  end
 end

data/lib/data_spec/helpers.rb

@@ -1,11 +1,10 @@
+require 'yaml'
 module DataSpec
   module Refinements
     refine Array do
       def tree_walk_with_self &block  
         self.each_with_index do |element, index|
-          if element.is_a? Hash  
-            element.tree_walk_with_self &block
-          elsif element.is_a? Array       
+          if element.is_a?(Hash) || element.is_a?(Array)
             element.tree_walk_with_self &block
           else
             yield [index, element], self    
@@ -20,17 +19,16 @@ module DataSpec
         
     refine Hash do               
       def tree_walk_with_self &block  
-        self.each do |key,value| 
-          if value.is_a? Hash    
-            value.tree_walk_with_self &block
-          elsif value.is_a? Array
+        self.each do |key, value| 
+          if value.is_a?(Hash) || value.is_a?(Array)
             value.tree_walk_with_self &block
           else
-            yield [key,value], self         
+            yield [key, value], self         
           end
         end
       end                        
 
+      #TODO: Can I replace this with a block passed to Tree Walker?
       def deep_include?(sub_hash)
         sub_hash.keys.all? do |key|
           self.has_key?(key) && if sub_hash[key].is_a?(Hash)
@@ -47,17 +45,28 @@ end
 using DataSpec::Refinements              
 module DataSpec
   module Helpers             
+    def self.evaluate string
+      eval(string)
+    end
+    def self.remember varname, data
+      instance_variable_set(varname, data)
+    end
     def self.parse yaml
       # `code` is more readable, but not parsable, for our purposes we're converting it to $
       unrendered = YAML.load(yaml.gsub("`", "$"))
     
-      return unrendered unless unrendered.is_a?(Array) || unrendered.is_a?(Hash)
-
-      unrendered.tree_walk_with_self do |(k, v), h|
-        if v =~ /^\$(.+)\$$/     
-          h[k] = eval($1)        
+      if unrendered.is_a?(Array) || unrendered.is_a?(Hash)
+        rendered = unrendered.tree_walk_with_self do |(k, v), h|
+          if v =~ /^\$(.+)\$$/     
+            h[k] = self.evaluate($1)        
+          end
         end
+      elsif unrendered.is_a?(String) && unrendered =~ /^\$(.+)\$$/
+        rendered = self.evaluate($1)
+      else
+        rendered = unrendered
       end
+      rendered
     end
     def self.at_path data, path
       return data if path.nil? || path.empty?

data/lib/data_spec/matchers.rb

@@ -15,12 +15,10 @@ module DataSpec
         @path = path
       end
 
-      diffable
+      failure_message_for_should do |actual|
+        "Got:\n#{actual.to_yaml}\nExpected:\n#{expected.to_yaml}"
+      end
     end
-  end
-
-  module Inclusion
-    extend RSpec::Matchers::DSL
 
     matcher :include_data do |expected|
       match do |actual|
@@ -31,12 +29,10 @@ module DataSpec
         @path = path
       end
 
-      diffable
+      failure_message_for_should do |actual|
+        "Got:\n#{actual.to_yaml}\nExpected:\n#{expected.to_yaml}"
+      end
     end
-  end
-
-  module Block 
-    extend RSpec::Matchers::DSL
 
     matcher :match_block do |block|
       match do |actual|
@@ -48,7 +44,4 @@ module DataSpec
       end
     end
   end
-
-  module Interpolation
-  end
 end

data/lib/data_spec/version.rb

@@ -1,3 +1,3 @@
 module DataSpec
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/data_spec.rb

@@ -5,7 +5,10 @@ require 'data_spec/matchers'
 if RSpec && RSpec.respond_to?(:configure)
   RSpec.configure do |config|
     config.include DataSpec::Matchers
-    config.include DataSpec::Inclusion
-    config.include DataSpec::Block
+    config.include DataSpec::Helpers
   end
 end
+
+if defined?(World)
+  require 'data_spec/cucumber'
+end

data/spec/data_spec/block_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
 
-describe DataSpec::Block do
+describe DataSpec::Matchers do
   it "can check versus a block" do
     "chunky".should match_block(lambda{|got| got.is_a? String})
+
     "chunky".should_not match_block(lambda{|got| got.is_a? Integer})
   end
 

data/spec/data_spec/helpers_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe DataSpec do
+  it "can remember things for use in evaluation" do
+    time = Time.now
+   DataSpec::Helpers.remember("@var", time)
+   DataSpec::Helpers.evaluate("@var.day").should be(time.day)
+  end
+end

data/spec/data_spec/inclusion_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe DataSpec::Inclusion do
+describe DataSpec::Matchers do
 
   it "can check array inclusion" do
     [1,2,3].should include_data([2])
@@ -46,9 +46,9 @@ describe DataSpec::Inclusion do
   end
 
   it "can check at a path" do
-    [1, {array: [2, {chunky: :bacon, bacon: :chunky} ] } ].should include_data({chunky: :bacon}).at("1/array/1")
-    [1, {array: [2, {chunky: :bacon, bacon: :chunky} ] } ].should include_data({chunky: :bacon}).at("1/array/1")
+    [1, {breakfast: [2, {chunky: :bacon, bacon: :chunky} ] } ].should include_data({chunky: :bacon}).at("1/breakfast/1")
+    [1, {breakfast: [2, {chunky: :bacon, bacon: :chunky} ] } ].should include_data({chunky: :bacon}).at("1/breakfast/1")
 
-    [1, {array: [2, {chunky: :bacon, bacon: :chunky} ] } ].should_not include_data({chunky: :nocab}).at("1/array/1")
+    [1, {breakfast: [2, {chunky: :bacon, bacon: :chunky} ] } ].should_not include_data({chunky: :nocab}).at("1/breakfast/1")
   end
 end

data/spec/data_spec/matchers_spec.rb

@@ -6,30 +6,37 @@ describe DataSpec::Matchers do
     {}.should match_data({})
     {}.should_not match_data([])
   end
+
   it "should match empty arrays" do
     [].should match_data([])
     [].should_not match_data({})
   end
+
   it "should match strings" do
     "Bacon".should match_data("Bacon")
     "Bacon".should_not match_data("Chunky")
   end
+
   it "should match integers" do
     1.should match_data(1)
     2.should_not match_data(1)
   end
+
   it "should match floats" do
     1.1.should match_data(1.1)
     2.1.should_not match_data(1.1)
   end
+
   it "should match true" do
     true.should match_data(true)
     true.should_not match_data(false)
   end
+
   it "should match false" do
     false.should match_data(false)
     false.should_not match_data(true)
   end
+
   it "should match nil" do
     nil.should match_data(nil)
     nil.should_not match_data("something")

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 require 'bundler/setup'
-require 'debugger'
+#require 'debugger'
 
 require 'data_spec' # and any other gems you need
 

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: data_spec
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - narfanator
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-07 00:00:00.000000000 Z
+date: 2013-07-09 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -75,12 +61,15 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - data_spec.gemspec
 - features/core.feature
+- features/memory.feature
+- features/readme.feature
 - features/step_definitions/steps.rb
 - features/support/env.rb
 - lib/data_spec.rb
@@ -89,6 +78,7 @@ files:
 - lib/data_spec/matchers.rb
 - lib/data_spec/version.rb
 - spec/data_spec/block_spec.rb
+- spec/data_spec/helpers_spec.rb
 - spec/data_spec/inclusion_spec.rb
 - spec/data_spec/interpolation_spec.rb
 - spec/data_spec/matchers_spec.rb
@@ -120,9 +110,12 @@ summary: RSpec matchers and Cucumber steps for describing hash and array structu
   including deep nesting
 test_files:
 - features/core.feature
+- features/memory.feature
+- features/readme.feature
 - features/step_definitions/steps.rb
 - features/support/env.rb
 - spec/data_spec/block_spec.rb
+- spec/data_spec/helpers_spec.rb
 - spec/data_spec/inclusion_spec.rb
 - spec/data_spec/interpolation_spec.rb
 - spec/data_spec/matchers_spec.rb