rspec_normalized_hash 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+.rvmrc
+*.DS_Store
+doc
+.yardoc
+.tmp

data/.yardopts

@@ -0,0 +1,4 @@
+lib/**/*.rb
+spec/**/*.rb
+-
+NormalizedHash.md

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2, :cli => "--color --format nested" do
+  watch(%r{^spec/[^\.]+_spec\.rb})
+  watch(%r{^lib/\w(.+:w)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/LICENSE

@@ -0,0 +1,17 @@
+#
+# Author:: Dmytro Kovalov (<dmytro.kovalov@gmail.com>)
+# Copyright:: Copyright (c) 2012, Dmytro Kovalov
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#

data/NormalizedHash.md

@@ -0,0 +1,134 @@
+# @title Normalized Hash Data Structure Standard
+
+Normalized Hash Data Structure Standard
+---------------------------------------
+
+Specification below describes hash data structure, main goal of which is to make data produced by Uliska parser easy to use by software that does not know about internal data structure, i.e. data driven and schema-less. Data structures should be built in such a way as to make data self-documenting, easy adaptable and "software-friendly".
+
+### Hashes
+
+* Uliska output data structure is multi-level Hash
+
+* Hash key is one of the following classes: String, Symbol
+
+* Hash keys should be descriptive and programmatically convertible to human readable form:
+
+GOOD: 
+
+````
+:filesystem_size.humanize
+````
+
+BAD:
+
+````
+:fs_s.humanize
+````
+
+* Hash values belong to one of the classes: Numeric, String, Hash, Array
+
+* On the lowest level of the Hash only String, Numeric and simple Array are allowed as Hash values. Simple array here is an array containing only scalar values -- String or Numeric.
+
+
+### Arrays
+
+* Array can consist of Numeric, String, Hash values
+
+* All elements of each Array should be of the same class
+
+* Use of Arrays of Hashes acceptable, although discouraged:
+
+OK:
+
+````ruby
+   { :local_users => 
+      [ { :name => "nobody",
+         :password => "*",
+         :uid => -2,
+         :gid => -2,
+         :gecos => "Unprivileged User",
+         :homedir => "/var/empty",
+         :shell => "/usr/bin/false"
+       },
+       { :name => "root",
+         :password => "*",
+         :uid => 0,
+         :gid => 0,
+         :gecos => "System Administrator",
+         :homedir => "/var/root",
+         :shell => "/bin/sh"
+       }
+     ]
+   }
+````
+    
+BETTER:
+
+````ruby
+   { :local_users => 
+      {
+      :nobody => 
+        { :name  =>  "nobody",
+          :password => "*",
+          :uid => -2,
+          :gid => -2,
+          :gecos => "Unprivileged User",
+          :homedir => "/var/empty",
+          :shell => "/usr/bin/false"
+        },
+      :root => 
+        { :name => "root",
+          :password => "*",
+          :uid => 0,
+          :gid => 0,
+          :gecos => "System Administrator",
+          :homedir => "/var/root",
+          :shell => "/bin/sh"
+        }
+      }
+   }
+````
+
+* When Arrays of Hashes are used additional conditions must be satisfied:
+
+  - each Hash in an Array should have key `name` or
+
+  - if name of the Hash enclosing Array-of-Hashes is English noun in plural form, each Hash should have key which is singular form of the same noun:
+
+  **Example 1** -- Array of Hashes with `"name"` key:
+
+````ruby
+ {   :local_users=>
+     [{:name=>"root",
+       :password=>"x",
+       :uid=>0,
+       :gid=>0,
+       :gecos=>"root",
+       :homedir=>"/root",
+       :shell=>"/bin/bash"},
+      {:name=>"daemon",
+       :password=>"x",
+       :uid=>1,
+       :gid=>1,
+       :gecos=>"daemon",
+       :homedir=>"/usr/sbin",
+       :shell=>"/bin/sh"}
+     ]
+ }
+````
+
+  **Example 2** -- Enclosing collection `"groups"` is an Array of Hashes. Each Hash has key `"group"`:
+
+````ruby
+    {:groups=>
+     [ {:group=>"root",   :password=>"x", :gid=>0, :members=>[]},
+       {:group=>"daemon", :password=>"x", :gid=>1, :members=>[]},
+       {:group=>"bin",    :password=>"x", :gid=>2, :members=>[]},
+       {:group=>"sys",    :password=>"x", :gid=>3, :members=>[]}
+      ]
+}
+````
+
+Local Variables:
+fill-column: 9999
+End:

data/README.md

@@ -0,0 +1,44 @@
+
+Normalized Hash tests for RSpec
+===============================
+
+These are RSpec tests for Normalized Hash data structure standard. Standard itself and rationale why we (I) need it, is described in NormalizedHash.md file.
+
+
+RSpec deep hash tests were insired by https://github.com/vitalish/rspec-deep-matchers specs.
+
+Usage
+-----
+
+
+````ruby
+
+   require 'rspec_normalized_hash'
+
+   describe "Good data structure" do
+
+       before(:each) { subject @data }
+
+       it { should have_keys_in_class [String, Symbol] }
+       it { should have_values_in_class [Fixnum, String, Numeric, Hash, Array] }
+       it { should have_array_values_in_class [String,Numeric,Hash] }
+       it { should have_array_values_of_the_same_class }
+
+       it { NOT IMPLEMENTED: enclosed arrays in Hash }
+   end
+                                   
+````
+
+License 
+=======
+
+Apache 2
+
+Author
+======
+
+Dmytro Kovalov
+
+dmytro.kovalov@gmail.com
+
+Aug,Sept 2012

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :doc do 
+  sh "yardoc" 
+end

data/lib/normalized_hash/array_values.rb

@@ -0,0 +1,124 @@
+module NormalizedHash
+  module Matchers
+
+    # Test that array has only elements of expeted class(es). 
+    #
+    # Array is a value in deep (multilevel) hash.  Check done
+    # hierarchically for all arrays' values.
+    #
+    # @param [Array, Class] expected class(es) allowed
+    #
+    # = Usage
+    #     it { @hash.should  have_array_values_in_class [String,Numeric,Hash] }
+    #     it { @hash.should  have_array_values_in_class Numeric }
+    #
+    def have_array_values_in_class(expected)
+      ArrayValues.new(expected)
+    end
+
+    # Test that array elements are all in the same class.
+    #
+    # Array is a value in deep (multilevel) hash. Check done
+    # hierarchically for all arrays' values.
+    #
+    # @param none
+    #
+    # = Usage
+    #     it { @hash.should  have_array_values_of_the_same_class }
+    #
+    def have_array_values_of_the_same_class
+      SameArrayValues.new Object # dummy class, not used but needs to
+                                 # be here because of constructor
+    end
+
+    # RSpec::Matchers class for testing hierarchically arrays, that
+    # are elements of deep hash. 
+    # 
+    # SameArrayValues class tests that all values of the Array are on
+    # the same class.
+    class SameArrayValues < HashMatchers
+      def description 
+        "have all values of the same class"
+      end
+
+      # Test that all values of the tested Array are of the same class
+      #
+      # @param [Array] target tested array
+      #
+      # @return true if pass, false if fail
+      def matches? target
+        result = true
+        case target
+        when Array
+          @actual = target.map(&:class).uniq
+          result = !(@actual.count > 1)
+        when Hash
+
+          target.each_value do |val|
+            if val.is_a? Array
+              result &&= SameArrayValues.new(Object).matches? val
+              @actual = val.map(&:class).uniq unless result
+            end
+          end
+
+        end
+        result
+      end
+
+      def failure_message_for_should
+        "expected #{@actual.inspect} to be one class"
+      end
+
+      def failure_message_for_should_not
+        "expected #{@actual.inspect} be at least 2 different classes"
+      end
+
+    end
+
+
+    # RSpec::Matchers class for testing hierarchically arrays, that
+    # are elements of deep hash. 
+    # 
+    # ArrayValues class ensures that all values of the tested
+    # Array belong to expected classes.
+    class ArrayValues < HashMatchers
+
+      def description 
+        "have every value one of class: #{@expectation.join ','}"
+      end
+
+      # Test that all values of the tested Array belong to expecetd
+      # class(es).
+      #
+      # @param [Array] target array to test
+      #
+      # @return true if pass, false if fail
+      def matches?(target)
+        result = true
+        @target, @actual = target, target.map(&:class).uniq
+
+        case @target
+        when Array
+          result &&= (@actual - @expectation).empty?
+        when Hash
+          @target.each_value do |val|
+            result &&= ArrayValues.new(@expectation).matches?(val) if [Hash, Array].include? val.class
+            @target = val unless result
+          end
+        end
+
+        result
+      end
+
+
+      def failure_message_for_should
+        "expected #{@target.inspect} to have values of classes #{@expectation.inspect}"
+      end
+
+      def failure_message_for_should_not
+        "expected #{@target.inspect} differ from  #{@expectation.inspect}"
+      end
+    end
+
+  end
+end

data/lib/normalized_hash/hash_enclosed_in_array.rb

@@ -0,0 +1,142 @@
+
+require 'active_support/all'
+
+module NormalizedHash
+  module Matchers
+
+    # Test that array has only elements of expeted class(es). 
+    #
+    # @param TODO
+    #
+    # = Usage
+    #     it { @TODO.should TODO }
+    #
+    def have_all_keys_be_word_name_or_singular_of (expected)
+      KeyNamesOfEnclosedHash.new(expected)
+    end
+
+    def all_arrays_have_hash_with_key_word_name_or_singular_of_hash_key
+      HashEnclosingArray.new
+    end
+
+    # Simple class to be inherited by other matcher classes that take
+    # String expectation.
+    class KeyNameMatchers
+      def initialize(expectation)
+        expectation = expectation.to_s.downcase
+        @expectation = expectation.singularize
+        raise ArgumentError, "#{expectation} must have singular form. Got #{@expectation}" if @expectation == expectation
+      end
+    end
+
+    # RSpec::Matchers class for testing hashes enclosed in an array.
+    # 
+    # Array of Hashes: each Hash should have key :name or :<collection.singularize>
+    #
+    # Hash here (subject) is an instance of Hash, which is an element
+    # of an Array, and Array itself is a value of a Hash:
+    #
+    #     { :foos => 
+    #           [                               <--- subject
+    #                 { :foo (or :name) => ...,
+    #                   :bar => ...,
+    #                 },
+    #                 { :foo (or :name) => ...,
+    #                   :bar => ...,
+    #                 },
+    #                ]
+    #     }
+    class KeyNamesOfEnclosedHash < KeyNameMatchers
+      def description 
+        "have key :name or '#{@expectation.singularize}' in every enclosed Hash "
+      end
+
+      # Test that all values of the tested Array are of the same class
+      #
+      # @param [Array] target tested array
+      #
+      # @return true if pass, false if fail
+      def matches? target
+        @target = target 
+        result = true
+
+        target.each do |hash|
+          next unless hash.is_a? Hash
+          keys = hash.keys.map(&:to_s).map(&:downcase)
+          result &&= false unless (keys.include? @expectation || keys.include?("name"))
+        end
+
+        result
+      end
+
+      def failure_message_for_should
+        "expected each of #{@target.map(&:keys)} include '#{@expectation.singularize}'"
+      end
+      
+      def failure_message_for_should_not
+        "expected #{@target.map(&:keys)} not include '#{@expectation.singularize}'"
+      end
+    end # class KeyNamesOfEnclosedHash < HashMatchers
+
+    # Hash (subject) ancloses Array wit ha bunch of Hases inside. Each
+    # aHas is then tested by KeyNamesOfEnclosedHash
+    #
+    #
+    #     { :foos =>                          <--- subject 
+    #              [
+    #                 { :foo (or :name) => ...,   
+    #                   :bar => ...,
+    #                 },
+    #                 { :foo (or :name) => ...,
+    #                   :bar => ...,
+    #                 },
+    #                ]
+    #     }
+    class HashEnclosingArray
+      def description
+        @description
+      end
+
+      def failure_message_for_should
+        [@target.inspect, description, @failure].join ' '
+      end
+
+      def failure_message_for_should_not
+        [@target.inspect, 'not', description, @failure].join ' '
+      end
+
+
+      # Run matcher only if target is Hash with Array embedded at the
+      # first depth level. Not recursive, recursion should be
+      # implemented on level higher.
+      def matches? target
+
+        result = true
+        @target = target
+
+        if (target.is_a?(Hash) && target.values.map(&:class).include?(Array))
+          
+          @description = "enclose Arrays of Hashes with key #{@target.keys}"
+          @failure = ":\n"
+          
+          target.each do |key,array|
+            if array.is_a? Array
+              @checked = array
+              res = KeyNamesOfEnclosedHash.new(key).matches?(array)
+              result &&= res
+              @failure << { key => array}.inspect unless res
+            end
+          end
+        else
+          @description = "*** spec did not run *** " 
+          result = false
+        end
+        
+        result
+      end
+      
+    end # ArrayEnclosingHashes < KeyNameMatchers
+
+  end  
+end
+

data/lib/normalized_hash/hash_keys.rb

@@ -0,0 +1,68 @@
+module NormalizedHash
+  module Matchers
+
+    # Test that hash has only keys of expected class(es). 
+    #
+    # Check done hierarchically for all Hashes.
+    #
+    # @param [Array, Class] expected class(es) allowed
+    #
+    # == Usage
+    #     it { @hash.should  have_keys_in_class [String,Numeric,Hash,Array] }
+    #     it { @hash.should  have_keys_in_class Numeric }
+    #
+    def have_keys_in_class(expected)
+      HashKeys.new(expected)
+    end
+
+    # RSpec::Matchers class for testing hierarchically hashes, that
+    # are elements of deep hash. 
+    # 
+    # HashKeys class tests that all keys of the Hash belong to list of
+    # Classes.
+    # 
+    # == Usage 
+    #    it { @hash.should have_keys_in_class [String, Symbol] }
+    #    it { @hash.should have_keys_in_class String }
+    class HashKeys < HashMatchers
+
+      def description 
+        "have (recursively) every key one of class: #{[@expectation].flatten.join ','}"
+      end
+
+      # Test that all keys of the tested Hash belong to provided list
+      # of classes
+      #
+      # @param [Hash] target hash under test
+      #
+      # @return true if pass, false if fail
+      def matches?(target)
+        result = true
+        
+        if target.is_a? Hash
+
+          @target, @actual = target, target.keys.map(&:class).uniq
+
+          result &&= (@actual - @expectation).empty?
+
+          @target.each_value do |val|
+            result &&= HashKeys.new(@expectation).matches?(val) if val.is_a? Hash
+            @target = val unless result
+          end
+        end
+
+        result
+      end
+
+
+      def failure_message_for_should
+        "expected #{@target.keys.inspect} #{@actual} to be one of #{@expectation.inspect}"
+      end
+
+      def failure_message_for_should_not
+        "expected #{@target.keys.inspect} differ from  #{@expectation.inspect}"
+      end
+    end
+
+  end
+end

data/lib/normalized_hash/hash_values.rb

@@ -0,0 +1,69 @@
+module NormalizedHash
+  module Matchers
+    
+    # Test that hash has only values of expected class(es). 
+    #
+    # Check done hierarchically for all Hashes.
+    #
+    # @param [Array, Class] expected class(es) allowed
+    #
+    # == Usage
+    #
+    #     it { @hash.should  have_values_in_class [String,Numeric,Hash,Array] }
+    #     it { @hash.should  have_values_in_class Numeric }
+    #
+    def have_values_in_class(expected)
+      HashValues.new(expected)
+    end
+
+    # RSpec::Matchers class for testing hierarchically hashes, that
+    # are elements of deep hash. 
+    # 
+    # HashValues class tests that all values of the Hash belong to
+    # list of Classes.
+    # 
+    # == Usage 
+    #    it { @hash.should have_values_in_class [String, Symbol] }
+    #    it { @hash.should have_values_in_class String }
+    #
+    class HashValues < HashMatchers
+
+      def description 
+        "have (recursively) every value one of class: #{[@expectation].flatten.join ','}"
+      end
+
+      # Test that all values of the tested Hash belong to provided
+      # list of classes
+      #
+      # @param [Hash] target hash under test
+      #
+      # @return true if pass, false if fail
+      def matches?(target)
+        result = true
+
+        if target.is_a? Hash
+          @target, @actual = target, target.values.map(&:class).uniq
+
+          result &&= (@actual - @expectation).empty?
+          
+          @target.each_value do |val|
+            result &&= HashValues.new(@expectation).matches?(val) if val.is_a?(Hash)
+            @target = val unless result
+          end
+        end
+
+        result
+      end
+
+
+      def failure_message_for_should
+        "expected #{@target.values.inspect} to have values of classes #{@expectation.inspect}"
+      end
+
+      def failure_message_for_should_not
+        "expected #{@target.values.inspect} differ from  #{@expectation.inspect}"
+      end
+    end
+
+  end
+end

data/lib/normalized_hash/matchers.rb

@@ -0,0 +1,26 @@
+module NormalizedHash
+  module Matchers
+    
+    # All numeric classes we want to consider
+    NUMBERS = [Fixnum, Bignum, Numeric, Float]
+
+    class HashMatchers
+
+      def initialize(expectation)
+        # Convert to array for simpler checks
+        @expectation = [expectation].flatten
+        
+        # All expectionations should be Class, no other classes
+        unless @expectation.map(&:class).uniq == [Class]
+          raise ArgumentError,
+          "#{@expectation.inspect}: Expectation should be Class or Array[of Classes], got #{@expectation.class}"
+        end
+
+        # Expand expectation with all numeric classes if at least one
+        # numeric present.
+        (@expectation += NUMBERS).uniq! unless (@expectation & NUMBERS).empty?
+
+      end
+    end
+  end
+end

data/lib/rspec_normalized_hash.rb

@@ -0,0 +1,10 @@
+$: << File.dirname(__FILE__)
+require 'rspec'
+require "normalized_hash/matchers"
+require "normalized_hash/hash_keys"
+require "normalized_hash/hash_values"
+require "normalized_hash/array_values"
+require "normalized_hash/hash_enclosed_in_array"
+module RSpec::Matchers
+  include NormalizedHash::Matchers
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+module NormalizedHash
+    module Matchers
+        VERSION="0.0.1"
+   end 
+end 

data/rspec_normalized_hash.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "version"
+
+Gem::Specification.new do |s|
+  s.name        = "rspec_normalized_hash"
+  s.version     = NormalizedHash::Matchers::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["dmytro"]
+  s.email       = ["dmytro.kovalov@gmail.com"]
+  s.homepage    = "http://github.com/dmytro/rspec_normalized_hash"
+  s.summary     = %q{Recursive Hash structure matcher for rspec.}
+  s.description = " Specification of Normalized Hash data structure main goal is to make data produced by parsers easy to use by software that does not know about internal data structure, i.e. data driven and schema-less. Data structures should be built in such a way as to make data self-documenting, easy adaptable and 'software-friendly'.
+Gem contains RSpec tests for testing Hash data structure for compliance with the requirements.
+See README.md and NormalizedHash.md files in gem's root directory."
+
+  s.rubyforge_project = "normalized-hash"
+
+  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_dependency 'rspec', '>= 2.0.0'
+  s.add_dependency 'active_support'
+  s.add_dependency 'i18n'
+
+
+  s.add_development_dependency('rb-fsevent')
+  s.add_development_dependency('guard-rspec')
+  s.add_development_dependency('growl')
+end

data/spec/array_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'Normalized Hash - Array' do
+
+  before(:each) { @hash = GOOD_HASH }
+
+  context "simple" do
+    context "Numeric array" do 
+      subject { @hash[:n_array].dup } # Call dup here since I'm modifying data
+      it { should have_array_values_in_class Numeric }
+      it { should have_array_values_of_the_same_class }
+      it "with different values should not have same class" do 
+        subject << 'a'
+        should_not have_array_values_of_the_same_class
+      end
+    end
+    
+    context "String array" do 
+      subject { @hash[:s_array] }
+      it { should have_array_values_in_class String }
+    end
+
+    context "mixed array" do 
+      subject { @hash[:mix_array] }
+      it { should     have_array_values_in_class [String,Numeric,Hash] }
+      it { should_not have_array_values_in_class IO }
+    end
+
+    context "array of Hash'es" do
+      subject { @hash[:array_hash] }
+      it { should     have_array_values_in_class [String,Numeric,Hash] }
+      it { should_not have_array_values_in_class IO }
+    end
+  end
+
+  context "multi level" do 
+    subject { @hash }
+    it { should     have_array_values_in_class [String,Numeric,Hash] }
+    it { should_not have_array_values_in_class IO }
+    it { should_not have_array_values_of_the_same_class }
+    it "when removed mixed array should all be in the same class" do 
+      subject.delete :mix_array
+      should have_array_values_of_the_same_class
+    end
+  end
+end

data/spec/hash_enclosing_array_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'Normalized Hash - enclosing array' do
+
+  before(:each) { @hash = GOOD_HASH }
+  
+  context "Hash enclosed in Array " do 
+    context "Hash-> Array-> [Hash]" do 
+      context :simple do 
+        subject {  @hash[:names] }
+        it { should have_all_keys_be_word_name_or_singular_of :names }
+        it { @hash[:people].should have_all_keys_be_word_name_or_singular_of :people}
+
+        it { should_not have_all_keys_be_word_name_or_singular_of :last_names }
+        it { @hash[:people].should have_all_keys_be_word_name_or_singular_of :people}
+      end
+
+      context :simple_changed do 
+        subject {  @hash[:names] << { :not_really_name => 'some string', :name => 'name' } }
+        it { should have_all_keys_be_word_name_or_singular_of :names }
+        it { should_not have_all_keys_be_word_name_or_singular_of :last_names }
+      end
+    end # context "keys of Hash enclosed in an Array" do 
+
+    context "Hash-> [Array]-> Hash " do
+      context "one level" do
+        subject { {:people => @hash[:people]} }
+        it { should all_arrays_have_hash_with_key_word_name_or_singular_of_hash_key }
+      end
+
+      context '2 levels' do 
+        subject { 
+          { 
+            :deep => 
+            { :two_levels => 
+              [
+               { :name => :one},
+               { :name => :two},
+              ]
+            }
+          }
+        }
+        it { should_not all_arrays_have_hash_with_key_word_name_or_singular_of_hash_key }
+      end
+    end # context "Hash-> [Array]-> Hash" do 
+  end #  context "enclosed in Array Hash" do 
+end

data/spec/hash_keys_and_values_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe 'Normalized Hash - keys and values' do
+
+  before(:each) { @hash = GOOD_HASH }
+  # ------------------------------------------------------------
+  context 'Hash keys and values' do
+    context "simple hash" do
+      
+      context "single Symbol key" do
+        subject { @hash[:symbol] }
+
+        it { should      have_keys_in_class Symbol }
+        it { should_not  have_keys_in_class String }
+
+        it { should      have_values_in_class [String, Numeric, Array, Hash] }
+        it { should_not  have_values_in_class IO }
+
+        it { should  have_array_values_in_class [Numeric, String, Hash] }
+
+      end
+      
+      context "single String key" do
+        subject { @hash[:string] }
+
+        it { should      have_keys_in_class String }
+        it { should_not  have_keys_in_class Symbol }
+
+        it { should      have_values_in_class [String, Numeric, Array, Hash] }
+        it { should_not  have_values_in_class IO }
+      end
+      
+      context "Symbol and String keys" do
+        subject { @hash[:sym_str] }
+        
+        it { should     have_keys_in_class [Symbol, String] }
+        it { should     have_keys_in_class [Symbol, String, File] }
+        it { should_not have_keys_in_class [Symbol, File] }
+        it { should_not have_keys_in_class Symbol }
+        it { should_not have_keys_in_class String }
+      end
+
+      context "nested Hash" do
+        
+        context "2 levels" do
+          subject { @hash[:l2] }
+          it { should                                  have_keys_in_class [Symbol, String] }
+          it { subject.merge({[1,2] => 1 }).should_not have_keys_in_class [Symbol, String] }
+
+          it { should      have_values_in_class [String, Numeric, Array, Hash] }
+          it { should_not  have_values_in_class IO }
+
+        end
+        
+        context "3 levels" do
+          subject {  @hash }
+          it { should have_keys_in_class [Symbol, String] }
+
+
+          it {
+            bad = { :a => { :b => { :bbb => [1,2,3], 'ccc' => "string", 42 => 42 }}}
+            bad.should_not  have_keys_in_class [Symbol, String]
+          }
+
+          it { should      have_values_in_class [String, Numeric, Array, Hash] }
+          
+          it {
+            subject.merge(
+                          { :file => File.new('.tmp','w') }
+                          ).should_not have_values_in_class [String, Numeric, Array, Hash]
+          }
+        end # 3 levels
+      end # nested Hash
+    end # Hash  
+
+
+  end # context 'Hash keys and values' do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+require 'rspec_normalized_hash'
+require 'test_data'

data/spec/test_data.rb

@@ -0,0 +1,63 @@
+
+#
+# TEST DATA: Good normalized hash for use in tests
+# ================================================
+GOOD_HASH =  { 
+  :symbol => { :str => 'str',  :num => 42,  :arr => [1,2,3]  }, # single symbol key
+  :string => { 'str' => 'str', 'num' => 42, 'arr' => [1,2,3] }, # single string key
+  :sym_str => { 
+    :a => 1, :aa => 'a',
+    'b' => 2, 'bb' => 'bb'
+  },
+  :l2 => {  # level 2 hash
+    :aa => 1,  
+    :bb => { :bbb => [1,2,3], 'ccc' => "string", :ddd => 42 }, # symbol and string keys
+    'cc' => 3 
+  },
+  :b => { 
+    :ba => 1, 
+    :bb => 2, 
+    'bc' => { :caa => 1, :cbb => 'asdfas', 'dd' => 'file'}, 
+    'abc' => 'a' 
+  },
+  :n_array => [1,2,3,4],
+  :s_array => ["a","b","c"],
+  :mix_array => [1, "a", {} ],
+  :array_hash => 
+  [
+   { :name =>'a' },
+   { :name =>'b' },
+   { :name =>'c' },
+  ],
+  
+  :names => 
+  [
+   { :name =>'a' },
+   { :name =>'b' },
+   { :name =>'c' },
+  ],
+  
+  :people => 
+  [
+   { :person =>'a' },
+   { :person =>'b' },
+   { :person =>'c' },
+  ]
+}
+
+# ============================================================
+@enclosed_hash = { 
+  :simple => [
+              { },
+              { },
+              { },
+             ],
+  :nested => { 
+    :level2 => [
+                { },
+                { },
+                { },
+               ]
+  }
+}
+# ============================================================

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: rspec_normalized_hash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- dmytro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: growl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! ' Specification of Normalized Hash data structure main goal is to make
+  data produced by parsers easy to use by software that does not know about internal
+  data structure, i.e. data driven and schema-less. Data structures should be built
+  in such a way as to make data self-documenting, easy adaptable and ''software-friendly''.
+
+  Gem contains RSpec tests for testing Hash data structure for compliance with the
+  requirements.
+
+  See README.md and NormalizedHash.md files in gem''s root directory.'
+email:
+- dmytro.kovalov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- Guardfile
+- LICENSE
+- NormalizedHash.md
+- README.md
+- Rakefile
+- lib/normalized_hash/array_values.rb
+- lib/normalized_hash/hash_enclosed_in_array.rb
+- lib/normalized_hash/hash_keys.rb
+- lib/normalized_hash/hash_values.rb
+- lib/normalized_hash/matchers.rb
+- lib/rspec_normalized_hash.rb
+- lib/version.rb
+- rspec_normalized_hash.gemspec
+- spec/array_spec.rb
+- spec/hash_enclosing_array_spec.rb
+- spec/hash_keys_and_values_spec.rb
+- spec/spec_helper.rb
+- spec/test_data.rb
+homepage: http://github.com/dmytro/rspec_normalized_hash
+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: normalized-hash
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Recursive Hash structure matcher for rspec.
+test_files:
+- spec/array_spec.rb
+- spec/hash_enclosing_array_spec.rb
+- spec/hash_keys_and_values_spec.rb
+- spec/spec_helper.rb
+- spec/test_data.rb
+has_rdoc: