hash_police 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c88a2f2754bcb69fb42484064e449b19ccfe298f
+  data.tar.gz: 7090be452d009ad83b02332efb1728a5e5c4c0e7
+SHA512:
+  metadata.gz: 800ff7adfd4390e9e73ac23e8cdf3c98d6f149d381109eeec6002ecc2008ddfca33780be071ad0f5a58f34ab96f9f308b6816da09745745065c85b7da1073fcd
+  data.tar.gz: 539f2ea73356ccf466e947de2e04b68b99f2f4d06196ebc7065ed1d157ac125fd562e063ff4fbe2c12d0cbee97d477cfad85001c44779db4bfa51fc1c5b4c138

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp

data/.rspec

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Yang-Hsing Lin
+
+MIT License
+
+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,68 @@
+# HashPolice
+A gem to check whether given to hashes are of the same format
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'hash_police'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hash_police
+
+## Usage
+
+``ruby
+
+rule = {
+  :name => "a string",
+  :age => 28,
+  :favorites => [ "a string" ],
+  :locations => [
+    { :name => "string", :duration => 3 }
+  ]
+}
+
+valid = {
+  :name => "Jack",
+  :age => 28,
+  :favorites => [ "sport", "music" ],
+  :locations => [
+    { :name => "Taiwan", :duration => 25 },
+    { :name => "US", :duration => 5 }
+  ]
+}
+
+invalid = {
+  :name => [],
+  :age => "not a number",
+  :locations => [
+    { :name => "Taiwan", :duration => 25 },
+    { :name => 23 }
+  ]
+}
+
+police = HashPolice::Police.new(rule)
+
+result = police.check(valid)
+result.passed? # => true
+result.error_messages # => ""
+
+result = police.check(invalid)
+result.passed? # => false
+result.error_messages # => "`name`: expect String, got Array; `favorites`: missing; `locations.1.name`: expect String, got Array; `locations.1.duration`: missing"
+
+``
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/hash_police.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hash_police/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hash_police"
+  spec.version       = HashPolice::VERSION
+  spec.authors       = ["Yang-Hsing Lin"]
+  spec.email         = ["yanghsing.lin@gmail.com"]
+  spec.description   = %q{a gem to check whether given to hashes are of the same format}
+  spec.summary       = %q{a gem to check whether given to hashes are of the same format}
+  spec.homepage      = ""
+  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.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/hash_police/check_result.rb

@@ -0,0 +1,35 @@
+class HashPolice::CheckResult
+  attr_reader :context_key
+
+  def initialize context_key
+    @context_key = context_key
+    @errors = []
+    @children = []
+  end
+
+  def differ_type options
+    @errors << "`#{context_key}`: expect #{options[:expect]}, got #{options[:got]}"
+  end
+
+  def error_messages
+    all_errors.join("; ")
+  end
+
+  def all_errors
+    @children.reduce(@errors) do |memo, child|
+      memo + child.all_errors
+    end
+  end
+
+  def concat child_result
+    @children << child_result
+  end
+
+  def missing
+    @errors << "`#{context_key}`: missing"
+  end
+
+  def passed?
+    all_errors.empty?
+  end
+end

data/lib/hash_police/police.rb

@@ -0,0 +1,65 @@
+require "hash_police/check_result"
+
+module HashPolice
+  class Police
+    attr_reader :rule, :context_key
+    def initialize rule, context_key = ""
+      @rule = rule
+      @passed = false
+      @context_key = context_key
+    end
+
+    def check target
+      result = CheckResult.new(context_key)
+      unless type_matched?(rule, target)
+        if context_key != "" && target.nil?
+          result.missing
+        else
+          result.differ_type(:expect => rule.class, :got => target.class)
+        end
+        return result
+      end
+
+      unless scalar?(rule)
+        context_prefix = context_key == "" ? "" : "#{context_key}."
+        if rule.kind_of?(Array)
+          target.each_with_index do |t, index|
+            police = self.class.new(rule.first, "#{context_prefix}#{index}")
+            result.concat(police.check(t))
+          end
+        end
+
+        if rule.kind_of?(Hash)
+          rule = stringify_keys(self.rule)
+          target = stringify_keys(target)
+
+          rule.each do |rule_key, rule_val|
+            police = self.class.new(rule_val, "#{context_prefix}#{rule_key}")
+            result.concat(police.check(target[rule_key]))
+          end
+        end
+      end
+
+      result
+    end
+
+    private
+    def type_matched? rule, target
+      return true if bool?(rule) && bool?(target)
+      rule.class == target.class
+    end
+
+    def bool? val
+      !! val == val
+    end
+
+    def scalar? val
+      ! val.kind_of?(Array) && ! val.kind_of?(Hash)
+    end
+
+    def stringify_keys hash
+      JSON.parse(hash.to_json, :quirks_mode => true)
+    end
+
+  end
+end

data/lib/hash_police/version.rb

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

data/lib/hash_police.rb

@@ -0,0 +1,6 @@
+require "hash_police/version"
+require "hash_police/police"
+
+module HashPolice
+  # Your code goes here...
+end

data/spec/hash_police/check_result_spec.rb

@@ -0,0 +1,71 @@
+require "hash_police/check_result"
+
+describe HashPolice::CheckResult do
+  let(:context_key) { "the-key" }
+  let(:result) { HashPolice::CheckResult.new context_key }
+
+  describe "::new(context_key)" do
+    it "takes a context_key to init" do
+      result = HashPolice::CheckResult.new "the-key"
+    end
+  end
+
+  describe "#error_messages" do
+    context "when without children" do
+      it "returns plain reason" do
+        result.differ_type(:expect => String, :got => Fixnum)
+        result.error_messages.should == "`the-key`: expect String, got Fixnum"
+      end
+    end
+
+    context "when with children" do
+      it "returns message with children's ones" do
+        children = [1,2,3].map do |i|
+          child = HashPolice::CheckResult.new("key-#{i}") 
+          result.concat(child)
+          child
+        end
+
+        children[1].differ_type(:expect => String, :got => Fixnum)
+        children[2].missing
+
+        result.error_messages.should == "`key-2`: expect String, got Fixnum; `key-3`: missing"
+      end
+    end
+
+  end
+
+  describe "#missing" do
+    it "adds missing message to errors" do
+      result.missing
+
+      result.error_messages.should == "`#{context_key}`: missing"
+    end
+  end
+
+  describe "#differ_type(:expect => Class1, :got => Class2)" do
+    it "adds message to error_messages" do
+      result.differ_type(:expect => String, :got => Array)
+      result.error_messages.should == "`#{context_key}`: expect String, got Array"
+    end
+  end
+
+  describe "passed?" do
+    it "returns true if all_errors empty" do
+      result.passed?.should == true
+    end
+
+    it "returns false if all_errors not empty" do
+      result.missing
+
+      result.passed?.should == false
+    end
+  end
+
+  describe "#concat(result)" do
+    it "concat the child with its message" do
+      child = double
+      result.concat(child)
+    end
+  end
+end

data/spec/hash_police/police_spec.rb

@@ -0,0 +1,101 @@
+require "hash_police/police"
+require "json"
+
+describe HashPolice::Police do
+  describe "::new(rule)" do
+    it "takes a rule hash to init" do
+      police = HashPolice::Police.new({ :hello => "world" })
+    end
+  end
+
+  describe "#check" do
+    let(:police) { HashPolice::Police.new(rule) }
+    let(:rule) { "a string" }
+    let(:target) { rule.clone }
+    let(:result) { double(:result, :concat => nil ) }
+
+    before(:each) do
+      HashPolice::CheckResult.stub(:new).and_return(result)
+    end
+
+    context "when rule is scalar value" do
+      it "passes if a string" do
+        HashPolice::CheckResult.stub(:new => double)
+        police.check "another string"
+      end
+
+      it "failed if type not match" do
+        result.should_receive(:differ_type).with(:expect => String, :got => Fixnum)
+        police.check 12345
+      end
+    end
+
+    context "when rule is an array of scalar" do
+      let(:rule) { [ 1 ] }
+      let(:nested_result1) { double(:nested_result1) }
+      let(:nested_result2) { double(:nested_result2) }
+
+      before(:each) do
+        HashPolice::CheckResult.stub(:new).and_return(result, 
+                                                      nested_result1,
+                                                      nested_result2)
+      end
+
+      it "passes if target is an of the same type" do
+        police.check [ 1, 3, 4 ]
+      end
+
+      it "failed if target is not an array" do
+        result.should_receive(:differ_type).with(:expect => Array, :got => Fixnum)
+        police.check 12345
+      end
+
+      it "faild if not all elements are of the same type" do
+        result.should_receive(:concat).with(nested_result1)
+        result.should_receive(:concat).with(nested_result2)
+        nested_result2.should_receive(:differ_type).with(:expect => Fixnum, :got => String)
+
+        police.check [ 123, "string" ]
+      end
+    end
+
+    context "when rule is a hash of scalar" do
+      let(:rule) do
+        {
+          :name => "Jack",
+          :married => true,
+          :nested => {
+            :key => "val"
+          }
+        }
+      end
+      let(:nested_result1) { double(:nested_result1) }
+      let(:nested_result2) { double(:nested_result2) }
+      let(:nested_result3) { double(:nested_result3, :concat => nil) }
+
+      before(:each) do
+        HashPolice::CheckResult.stub(:new).and_return(result, 
+                                                      nested_result1,
+                                                      nested_result2,
+                                                      nested_result3)
+      end
+
+      it "passes if all keys are matched" do
+        police.check(target)
+      end
+
+      it "passes if target with stringed key" do
+        target["name"] = target.delete :name
+
+        police.check(target)
+      end
+
+      it "failed if missing key" do
+        target.delete :name
+        nested_result1.should_receive(:missing).with()
+
+        police.check(target)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: hash_police
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yang-Hsing Lin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-13 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
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: a gem to check whether given to hashes are of the same format
+email:
+- yanghsing.lin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- hash_police.gemspec
+- lib/hash_police.rb
+- lib/hash_police/check_result.rb
+- lib/hash_police/police.rb
+- lib/hash_police/version.rb
+- spec/hash_police/check_result_spec.rb
+- spec/hash_police/police_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: a gem to check whether given to hashes are of the same format
+test_files:
+- spec/hash_police/check_result_spec.rb
+- spec/hash_police/police_spec.rb