like-structure 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+.idea
+.rvmrc
+tmp/*
+
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in be_like.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/features/like_method.feature

@@ -0,0 +1,106 @@
+Feature: Be Like Matcher
+  In order to check whether data structure matches given criteria
+  I want to test it against some reference structure
+  Which may contain keywords like anything, any_array and so on.
+
+  Scenario: Very Boring Example, Testing Against Exact Simple Object
+    Given a file named "simple_spec.rb" with:
+      """
+        require "spec_helper"
+
+        describe "nil" do
+          subject{ nil }
+          it{ should be_like nil }
+          it{ should_not be_like [] }
+        end
+
+        describe "A string which is a simple element" do
+          subject{ "Once upon a midnight dreary, while I pondered weak and weary," }
+          it{ should be_like "Once upon a midnight dreary, while I pondered weak and weary," }
+          it{ should_not be_like nil }
+        end
+      """
+    When I run `rspec simple_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Using any* matchers
+    Given a file named "anystar_spec.rb" with:
+      """
+        require "spec_helper"
+
+        describe "A string" do
+          subject{ "Quoth the raven, 'Nevermore.'" }
+          it{ should     be_like Wildcard.any_string }
+          it{ should_not be_like "any_string" }
+          it{ should_not be_like Wildcard.any_array }
+          it{ should     be_like Wildcard.anything }
+          it{ should     be_like Wildcard.not_nil }
+        end
+
+        describe "nil" do
+          subject{ nil }
+          it{ should_not be_like Wildcard.any_array }
+          it{ should     be_like Wildcard.anything }
+          it{ should_not be_like Wildcard.not_nil }
+        end
+      """
+    When I run `rspec anystar_spec.rb`
+    Then the examples should all pass
+
+  Scenario: A Complicated Structure Of Arrays
+    Given a file named "arrays_spec.rb" with:
+      """
+        require "spec_helper"
+
+        describe "An array containing strings and arrays" do
+          subject{ [["black", "cat"], nil, [["edgar", "alan"], "poe"]] }
+          it{ should     be_like Wildcard.any_array }
+          it{ should     be_like Wildcard.anything }
+          it{ should_not be_like Wildcard.any_hash }
+          it{ should     be_like [Wildcard.anything, Wildcard.anything, Wildcard.anything] }
+          it{ should_not be_like [Wildcard.anything, Wildcard.anything, Wildcard.anything, Wildcard.anything] }
+          it{ should     be_like [Wildcard.not_nil, nil, Wildcard.not_nil] }
+          it{ should     be_like [Wildcard.any_array, nil, Wildcard.any_array] }
+          it{ should_not be_like [["cat", "black"], nil, Wildcard.any_array] }
+          it{ should     be_like [Wildcard.anything, nil, [Wildcard.any_array, Wildcard.any_string]] }
+          it{ should     be_like [["black", "cat"], nil, [Wildcard.any_array, "poe"]] }
+          it{ should     be_like [["black", "cat"], nil, [["edgar", "alan"], "poe"]] }
+          it{ should_not be_like [["black", "cat"], nil, ["edgar", "alan", "poe"]] }
+        end
+      """
+    When I run `rspec arrays_spec.rb`
+    Then the examples should all pass
+
+  Scenario: A Complicated Structure Of Hashes
+    Given a file named "hashes_spec.rb" with:
+      """
+        require "spec_helper"
+
+        describe "A hash of hashes" do
+          subject{ {"edgar" => {"alan" => "poe"}, {"black" => "cat"} => {"is" => {"one of" => "works"}}, "this should point to" => nil} }
+          it{ should     be_like Wildcard.anything }
+          it{ should     be_like Wildcard.any_hash }
+          it{ should     be_like({"edgar" => Wildcard.anything, {"black" => "cat"} => Wildcard.anything, "this should point to" => Wildcard.anything})}
+          it{ should     be_like({"edgar" => Wildcard.not_nil, {"black" => "cat"} => Wildcard.not_nil, "this should point to" => nil})}
+          it{ should     be_like({"edgar" => Wildcard.any_hash, {"black" => "cat"} => {"is" => Wildcard.any_hash}, "this should point to" => nil})}
+          it{ should     be_like({"edgar" => Wildcard.any_hash, {"black" => "cat"} => {"is" => Wildcard.any_hash}, "this should point to" => nil})}
+          it{ should     be_like({"edgar" => {"alan" => "poe"}, {"black" => "cat"} => {"is" => {"one of" => "works"}}, "this should point to" => nil})}
+        end
+      """
+    When I run `rspec hashes_spec.rb`
+    Then the examples should all pass
+
+  Scenario: Wildcards In Hash Keys Does Not Work (Yet)
+    Given a file named "wildcards_in_hashes_spec.rb" with:
+      """
+        require "spec_helper"
+
+        describe "A hash with wildcard in key" do
+          subject{ {"edgar" => "raven"} }
+          it{ should_not be_like({Wildcard.anything => "raven"}) }
+          it{ should     be_like({"edgar" => Wildcard.anything}) }
+          it{ should_not be_like({Wildcard.anything => Wildcard.anything}) }
+        end
+      """
+    When I run `rspec wildcards_in_hashes_spec.rb`
+    Then the examples should all pass

data/features/step_definitions/copied_from_rspec.rb

@@ -0,0 +1,5 @@
+#again, copied from https://github.com/rspec/rspec-expectations/blob/master/spec/spec_helper.rb
+Then /^the example(?:s)? should(?: all)? pass$/ do
+  Then %q{the output should contain "0 failures"}
+  Then %q{the exit status should be 0}
+end

data/features/support/env.rb

@@ -0,0 +1,6 @@
+# copied from https://github.com/rspec/rspec-expectations/blob/master/features/support/env.rb
+require 'aruba/cucumber'
+
+Before do
+  @aruba_timeout_seconds = 3
+end

data/lib/like_structure.rb

@@ -0,0 +1,2 @@
+require 'like_structure/extensions'
+require 'like_structure/wildcard'

data/lib/like_structure/extensions.rb

@@ -0,0 +1,32 @@
+require 'set'
+class Object
+  def like?(pattern)
+    pattern.reverse_like?(self)
+  end
+  def reverse_like?(actual)
+    actual == self
+  end
+end
+
+class Array
+  def reverse_like?(actual)
+    return false unless actual.kind_of?(Array) && actual.size == self.size
+    [actual, self].transpose.each do |actual_item, expected_item|
+      return false unless actual_item.like?(expected_item)
+    end
+    true
+  end
+end
+
+class Hash
+  def reverse_like?(actual)
+#    expected_keys_wildcards, expected_keys_exact = self.keys.partition{ |k| k.kind_of?(Wildcard) } #TODO wildcards in keys
+    expected_keys_exact = self.keys
+    actual_keys = Set[*actual.keys]
+    return false unless expected_keys_exact.size == actual_keys.size
+    expected_keys_exact.each do |key|
+      return false unless actual_keys.delete?(key) && actual[key].like?(self[key])
+    end
+    true
+  end
+end

data/lib/like_structure/version.rb

@@ -0,0 +1,3 @@
+module LikeStructure
+  VERSION = "0.0.1"
+end

data/lib/like_structure/wildcard.rb

@@ -0,0 +1,50 @@
+module Wildcard
+  class Wildcard ; end
+
+  class TypeWildcard < Wildcard
+    def initialize(type)
+      @type = type
+    end
+
+    def reverse_like?(actual)
+      actual.kind_of?(@type)
+    end
+  end
+
+  class AnythingWildcard < Wildcard
+    def initialize(allow_nil)
+      @allow_nil = allow_nil
+    end
+    def reverse_like?(actual)
+      @allow_nil || !actual.nil?
+    end
+  end
+
+  def self.anything
+    AnythingWildcard.new(true)
+  end
+
+  def self.not_nil
+    AnythingWildcard.new(false)
+  end
+
+  def self.respond_to? name, include_private = false
+    analyze_method_name(name) ? true : super
+  end
+
+  def self.method_missing name, *args, &block
+    args.empty? && block.nil? && analyze_method_name(name) or super
+  end
+
+  def self.analyze_method_name(name)
+    case name.to_s
+    when /\Aany_(\w+)\Z/
+      type_name = $1.capitalize
+      return false unless Object.const_defined?(type_name)
+      TypeWildcard.new(Object.const_get(type_name))
+    else
+      false
+    end
+  end
+
+end

data/like_structure.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "like_structure/version"
+
+Gem::Specification.new do |s|
+  s.name        = "like-structure"
+  s.version     = LikeStructure::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sebastian Skalacki"]
+  s.email       = ["skalee@gmail.com"]
+  s.homepage    = "https://github.com/skalee/be_like"
+  s.summary     = %q{Like RegExp but for arrays, hashes.}
+  s.description = %q{Allows for matching data structures against given criteria. Very useful for testing JSON responses but may be used anywhere.}
+
+#  s.rubyforge_project = "be_like"
+
+  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"]
+
+  s.add_development_dependency 'aruba', "~> 0.3.5"
+  s.add_development_dependency 'rspec-core', "~>2.0"
+  s.add_development_dependency 'cucumber', "~>0.10.2"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+#copied from https://github.com/rspec/rspec-expectations/blob/master/spec/spec_helper.rb
+def add_to_load_path(path, prepend=false)
+  path = File.expand_path("../../#{path}/lib", __FILE__)
+  if prepend
+    $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  else
+    $LOAD_PATH << path unless $LOAD_PATH.include?(path)
+  end
+end
+
+require 'test/unit'
+
+add_to_load_path("rspec-expectations", :prepend)
+add_to_load_path("rspec-core")
+add_to_load_path("rspec-mocks")
+
+require 'rspec/expectations'
+require 'rspec/core'
+require 'rspec/mocks'
+
+Dir['./spec/support/**/*'].each {|f| require f}
+
+RSpec::configure do |config|
+  config.color_enabled = true
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
+end
+
+require 'like_structure'

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: like-structure
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sebastian Skalacki
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-04-18 00:00:00.000000000 +02:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: &2153366740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.5
+  type: :development
+  prerelease: false
+  version_requirements: *2153366740
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: &2153366240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153366240
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &2164540680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  type: :development
+  prerelease: false
+  version_requirements: *2164540680
+description: Allows for matching data structures against given criteria. Very useful
+  for testing JSON responses but may be used anywhere.
+email:
+- skalee@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- features/like_method.feature
+- features/step_definitions/copied_from_rspec.rb
+- features/support/env.rb
+- lib/like_structure.rb
+- lib/like_structure/extensions.rb
+- lib/like_structure/version.rb
+- lib/like_structure/wildcard.rb
+- like_structure.gemspec
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/skalee/be_like
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Like RegExp but for arrays, hashes.
+test_files:
+- features/like_method.feature
+- features/step_definitions/copied_from_rspec.rb
+- features/support/env.rb
+- spec/spec_helper.rb