hash_filterer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 440ade367f017439edb55f6fb4b81f8cab972716
+  data.tar.gz: 1fb93dfcb6472f0314af8a52ef5da645dee9cfc0
+SHA512:
+  metadata.gz: 5b58ce93c4bb097c4e85d12596948e161b2c4f806d04519add10f74fe5c622980bd16748b6b5e7377842b08245e48e661c16c83911a68cf2560233285a2988f1
+  data.tar.gz: 4f5cf9b1774267d8f355a3666d034b80f8b9c406cff1590fc6e1bf2342ca97c52e0c259de83a005824c6802ce97c1219fdff62ec0cf4ece45a7fdd50a579711f

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 gleseur
+
+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,36 @@
+# hash_filterer
+Check hash against a set of rules
+
+## Usage
+Usage is pretty simple, there are only 2 methods:
+ - accept? => Is the hash passing the rules
+ - error_messages => If not passing, messages detailling why
+ - rules are defined as an array of hashes, with string keys (so can be stored directly in a hstore or json field)
+
+```ruby
+require 'hash_filterer'
+
+rules = [{
+  # The key path to the value to be tested (can be an array for nested fields)
+  'key' => %w(foo plouf),
+  # Operator to check with
+  'operator' => '==',
+  # value to check against
+  'value' => 'bar',
+  # Is nil (or missing key) ok or not - default is false
+  'nil_ok' => false,
+  # optional preprocessor for the value to be tested before being checked. must be a public function of the value
+  'preprocessor' => 'downcase',
+  # If an intermediate level is an array, do we need all values to pass, or just one ?
+  'at_least_one' => true
+}]
+
+filterer = HashFilterer.new rules
+filterer.accept? 'foo' => { 'plouf' => 'bar' } # true
+filterer.accept? 'foo' => { 'plouf' => 'bar-bar' } # false
+filterer.error_messages # ["Not bar-bar == bar"]
+filterer.accept? 'foo-foo' => { 'plouf' => 'bar-bar' } # false (as nil_ok is false)
+filterer.accept? 'foo' => {} # false (as nil_ok is false)
+filterer.accept? 'foo' => [{ 'plouf' => 'bar' }, { 'plouf' => 'bar-bar' }] # true (as at_least_one is true)
+filterer.error_messages # [] # As apply to previous check
+```

data/lib/hash_filterer.rb

@@ -0,0 +1,112 @@
+require 'active_support/all'
+
+# Can be used to check if a given hash respects a list of rules
+class HashFilterer
+  # Corresponds to a single rule
+  class Rule
+    class InvalidOperator < ArgumentError; end
+    class InvalidPreprocessor < ArgumentError; end
+
+    attr_reader :error_message
+
+    def self.allowed_operators
+      ['==', '!=', '>', '<', 'IN', '=~']
+    end
+
+    def self.allowed_preprocessors
+      ['downcase']
+    end
+
+    # nil_ok should be true or false to specify the behavior when the value is nil
+    def initialize(key, operator, value, nil_ok, preprocessor, at_least_one) # rubocop:disable Metrics/ParameterLists
+      @keys = Array.wrap key
+      @operator = operator
+      @value = value
+      @nil_ok = nil_ok || false
+      @preprocessor = preprocessor
+      @at_least_one = at_least_one || false
+      check_operator!
+      check_preprocessor!
+    end
+
+    def accept?(hash)
+      values = read_values hash
+      msgs = values.map do |actual|
+        build_message actual unless ok_for actual
+      end.compact
+      return true if @at_least_one && values.length > msgs.length
+      return true if !@at_least_one && msgs.empty?
+      @error_message = msgs.join ' and '
+      false
+    end
+
+    private
+
+    def ok_for(actual)
+      return @nil_ok if actual.nil?
+      return @value.include? actual if @operator == 'IN'
+      return actual =~ Regexp.new(@value) if @operator == '=~'
+      actual.public_send @operator, @value
+    end
+
+    def build_message(actual)
+      actual = 'nil' if actual.nil?
+      "Not #{actual} #{@operator} #{@value}"
+    end
+
+    def read_values(hash)
+      extract_values(hash, @keys.dup).map do |val|
+        preprocess_value val
+      end
+    end
+
+    def preprocess_value(val)
+      return nil if val.nil?
+      return val unless @preprocessor
+      val.public_send @preprocessor
+    end
+
+    def extract_values(hash, current_keys)
+      key = current_keys.shift
+      return [nil] unless hash.key? key
+
+      val = hash[key]
+      return [val] if current_keys.length == 0
+      return val.map { |v| extract_values v, current_keys.dup }.sum if val.is_a? Array
+      extract_values val, current_keys
+    end
+
+    def check_operator!
+      fail InvalidOperator unless self.class.allowed_operators.include? @operator
+    end
+
+    def check_preprocessor!
+      return unless @preprocessor
+      fail InvalidPreprocessor unless self.class.allowed_preprocessors.include? @preprocessor
+    end
+  end
+
+  attr_reader :error_messages
+
+  def initialize(rules)
+    @rules = []
+    (rules || []).each { |r| add_rule r }
+  end
+
+  def accept?(hash)
+    @error_messages = []
+    @rules.all? do |rule|
+      ok = rule.accept? hash
+      @error_messages << rule.error_message unless ok
+      ok
+    end
+  end
+
+  private
+
+  def add_rule(rule)
+    @rules << Rule.new(
+      rule['key'], rule['operator'], rule['value'], rule['nil_ok'], rule['preprocessor'], rule['at_least_one']
+    )
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: hash_filterer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Guillaume Leseur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-10 00:00:00.000000000 Z
+dependencies: []
+description: Applies rules to a hash deciding if it fits or not
+email: guileseur@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/hash_filterer.rb
+homepage: http://rubygems.org/gems/hash_filterer
+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.4.8
+signing_key: 
+specification_version: 4
+summary: Applies rules to a hash
+test_files: []