rulix 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4c4b442c751d4de70d8ae4dc25d2433da4820fa3
+  data.tar.gz: d4d3c2d5928c563975905a70534e89117cb758b4
+SHA512:
+  metadata.gz: 503fe431b92c2906eb9cf1dc4c0cdd4718458609c9bb7937fb9cfa7ea9919da5c07c0dae54fe1e8d5def127373fc1aba2deed4357039c41fcc6dc826a7f25064
+  data.tar.gz: 0c0d83b8f3831d08f7d7ae78f6368f7f0d044a20b428d36805bc7fa9f1b3a67e97deed61c8b709cacbd375625629f3bce911f45c5ec4d66c2f25b69f22d16e89

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Mitch Monsen
+
+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,254 @@
+# Rulix
+
+Rulix is a gem for defining and using rules to manipulate, validate, and transform datasets.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rulix'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rulix
+
+## Usage
+
+Rulix is an engine for defining rulesets that you can apply to your datasets. It has two primary functions; Mutation and Validation.
+
+## Rules
+
+Rules in Rulix are, at their core, procs. Anything that can be coerced into a proc can be used as a rule.
+
+```ruby
+# Procs and lambdas work fine
+-> (value) { value.gsub /\d+/, '' }
+
+# Symbols respond to :to_proc, so they work too
+:strip
+
+# Any object that can be coerced into a proc will work!
+class DashStripper
+  def strip_dashes string
+    string.gsub /-/, ''
+  end
+
+  def to_proc
+    method(:strip_dashes)
+  end
+end
+
+DashStripper.new
+```
+
+#### Using Rules
+
+Rules can be supplied directly in a ruleset as long as they can be coerced into procs with `to_proc`.
+
+```ruby
+ruleset = {
+  first_name: -> (name) { name.reverse },
+  last_name: :strip
+}
+```
+
+For a more permanent rule definition, you can register a procable object or block under a symbol through the embedded registry for Rulix to use.
+
+```ruby
+my_super_neat_transformation = -> (string) { string.upcase.chars.shuffle.join }
+
+Rulix::Mutator.register :make_super_neat, my_super_neat_transformation
+```
+
+Then, you can supply the symbol in a Rulix ruleset.
+
+```ruby
+dataset = {
+  foo: 'oh man this is going to be so cool'
+}
+
+rules = {
+  foo: :make_super_neat
+}
+
+Rulix::Mutator.run dataset, rules
+#=> {:foo=>" T OI   INHOHMSNSTS B OIAOEOGGOLC "}
+```
+
+#### Configuring Rules
+
+Some rules may need additional definition or configuration based on context. If you are writing a rule that needs additional options passed in, make the options a hash that is either taken as initialization arguments, or as the first argument of your proc.
+
+
+```ruby
+# Configurable proc
+-> (options, value) { value[0..options[:trim_to] - 1] }
+
+# Configured procable object
+class CharacterRemover
+  attr_accessor :character
+
+  def initialize options = nil
+    options ||= {}
+
+    self.character = options[:character]
+  end
+
+  def remove_from string
+    string.gsub character, ''
+  end
+
+  def to_proc
+    method(:remove_from)
+  end
+end
+```
+
+## Rulesets
+
+Rulix rulesets are just Ruby hashes.
+
+```ruby
+ruleset = { first_name: :strip }
+```
+
+In order to properly map to a dataset, they need to follow the structure of the dataset that they're validating.
+
+```ruby
+ruleset = { first_name: :strip }
+
+# This will work
+proper_dataset = { first_name: 'Bob ' }
+
+# This one won't :(
+bad_dataset = { person: { first_name: 'Bob ' } }
+```
+
+Rulix does support nested hashes in a dataset, as long as the ruleset matches the format.
+
+```ruby
+dataset = {
+  person: {
+    first_name: 'Bob '
+  }
+}
+
+ruleset = {
+  person: {
+    first_name: :strip
+  }
+}
+```
+
+Multiple rules can be applied to the same data point in a dataset.
+
+```ruby
+dataset = { name: 'Bob   Johnson  ' }
+
+ruleset = { name: [:squeeze_spaces, :strip] }
+
+Rulix::Mutator.run dataset, ruleset
+#=> { name: 'Bob Johnson' }
+```
+
+## Mutation
+
+You can mutate a dataset with `Rulix::Mutator`. This is most useful for sanitizing user inputs (like params hashes in Rails), but it can be used for any operation that needs to perform consistent mutations on a set of data.
+
+```ruby
+dataset = {
+  first_name: 'Bob ',
+  last_name: 'Johnson '
+}
+
+ruleset = {
+  first_name: :strip,
+  last_name: :strip
+}
+
+Rulix::Mutator.run dataset, ruleset
+#=> { first_name: 'Bob', last_name: 'Johnson' }
+```
+
+## Validation
+
+Use `Rulix::Validator` to validate a dataset. You can test if a dataset is valid with `Rulix::Validator.valid?(dataset, ruleset)`. If your dataset fails validation, you can extract errors with `Rulix::Validator.errors(dataset, ruleset)`
+
+```ruby
+dataset = {
+  phone: {
+    number: '800-555-5555'
+  }
+}
+
+ruleset = {
+  phone: {
+    number: [{format: /\d{10}/, message: 'does not match format'}]
+  }
+}
+
+Rulix::Validator.valid? dataset, ruleset
+#=> false
+Rulix::Validator.errors dataset, ruleset
+#=> { phone: { number: ['does not match format'] } }
+```
+
+## Custom Validators and Mutators
+
+You can write your own mutators and validators and make them available to Rulix for building rulesets as long as they implement their respective interfaces.
+
+#### Custom Mutators
+
+A mutator changes data, so its only interface requirement is that it returns a modified version of the supplied argument.
+
+```ruby
+string = 'A String of Sorts'
+data = { foo: string }
+bad_rule = -> (str) { [str] }
+
+rules = { foo: [bad_rule, :strip] }
+
+Rulix::Mutator.run data, rules
+#=> NoMethodError: undefined method `strip' for ["A String of Sorts"]:Array
+```
+
+#### Custom Validators
+
+Validators should return `true` if the rule is satisfied, and `[false, error_message]` if the validation fails. Rulix will run all supplied validations against the left-hand argument and compile the errors into a single array in place.
+
+`Rulix::Validator` will always return an array under the given validated key, even if there is only one error.
+
+```ruby
+Rulix::Validator.register :doesnt_end_in_oo do |val|
+  val.end_with?('oo') ? [false, 'ends in oo'] : true
+end
+
+Rulix::Validator.register :digits_only do |val|
+  /^[0-9]+$/ === val ? true : [false, 'contains non-digits']
+end
+
+data = {
+  my_field: 'foo'
+}
+
+rules = {
+  my_field: [:digits_only, :doesnt_end_in_oo]
+}
+
+Rulix::Validator.run data, rules
+#=> { my_field: ['contains non-digits', 'ends in oo'] }
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/blarshk/rulix/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/test_*.rb'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rulix"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rulix/core_ext/hash.rb

@@ -0,0 +1,96 @@
+# Stole this from Rails; rather copy the source than introduce
+# ActiveSupport as a dependency
+class Hash
+  # Returns a new hash with +self+ and +other_hash+ merged recursively.
+  #
+  #   h1 = { a: true, b: { c: [1, 2, 3] } }
+  #   h2 = { a: false, b: { x: [3, 4, 5] } }
+  #
+  #   h1.deep_merge(h2) # => { a: false, b: { c: [1, 2, 3], x: [3, 4, 5] } }
+  #
+  # Like with Hash#merge in the standard library, a block can be provided
+  # to merge values:
+  #
+  #   h1 = { a: 100, b: 200, c: { c1: 100 } }
+  #   h2 = { b: 250, c: { c1: 200 } }
+  #   h1.deep_merge(h2) { |key, this_val, other_val| this_val + other_val }
+  #   # => { a: 100, b: 450, c: { c1: 300 } }
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+
+  # Same as +deep_merge+, but modifies +self+.
+  def deep_merge!(other_hash, &block)
+    other_hash.each_pair do |current_key, other_value|
+      this_value = self[current_key]
+
+      self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+        this_value.deep_merge(other_value, &block)
+      else
+        if block_given? && key?(current_key)
+          block.call(current_key, this_value, other_value)
+        else
+          other_value
+        end
+      end
+    end
+
+    self
+  end
+
+  # Returns a hash, removing all values that cause the block to evaluate to true
+  # Iterates recursively over nested hashes
+  def deep_reject &block
+    dup.deep_reject! &block
+  end
+
+  # Same as +deep_reject+, but modifies +self+.
+  def deep_reject! &block
+    each_pair do |current_key, value|
+      this_value = self[current_key]
+
+      if this_value.is_a?(Hash)
+        self[current_key] = this_value.deep_reject &block
+      else
+        if block_given? && key?(current_key)
+          self.delete current_key if block.call current_key, this_value
+        end
+      end
+    end
+  end
+
+  # Returns a hash, removing all elements that
+  # respond to and return true from :empty?
+  # Iterates recursively over nested hashes
+  # Will continue to call itself until the second run
+  # does not differ from the first (kind of gross)
+  # TODO: Try to make this less gross
+  def deep_compact
+    result = dup.deep_compact!
+    result2 = result.dup.deep_compact!
+
+    if result != result2
+      result = result2
+
+      result.deep_compact
+    end
+
+    result
+  end
+
+  def deep_compact!
+    each_pair do |current_key, value|
+      this_value = self[current_key]
+
+      if this_value.respond_to?(:empty?)
+        if this_value.empty?
+          self.delete current_key
+        elsif this_value.is_a?(Hash)
+          self[current_key] = this_value.deep_compact
+        end
+      else
+        self.delete current_key if this_value.nil?
+      end
+    end
+  end
+end

data/lib/rulix/mutator.rb

@@ -0,0 +1,17 @@
+require_relative './registry'
+
+module Rulix
+  class Mutator
+    include Rulix::Registry
+
+    def self.run dataset, ruleset
+      dataset.deep_merge ruleset do |key, val1, val2|
+        val2 = [val2] unless val2.is_a? Array
+
+        ops = get_operations val2
+
+        ops.reduce(val1) { |val, op| op.call(val) }
+      end
+    end
+  end
+end

data/lib/rulix/registry.rb

@@ -0,0 +1,65 @@
+module Rulix
+  module Registry
+    def self.included other
+      other.class_eval do
+        @registry ||= {}
+
+        def self.register symbol, procable = nil, &block
+          return register_block symbol, &block if block_given?
+
+          if !procable.respond_to?(:to_proc)
+            unless (procable.respond_to?(:new) && procable.new.respond_to?(:to_proc))
+              raise ArgumentError, "You attempted to register :#{symbol}, but the argument you passed can't be coerced into a proc!"
+            end
+          end
+
+          @registry[symbol] = procable
+        end
+
+        private
+
+        def self.register_block symbol, &block
+          @registry[symbol] = block.to_proc
+        end
+
+        def self.get_operations operations
+          operations.map do |op|
+            get_operation op
+          end
+        end
+
+        def self.get_operation operation
+          case operation
+          when Symbol
+            return @registry[operation].to_proc if @registry[operation] && @registry[operation].respond_to?(:to_proc)
+            
+            operation.to_proc
+          when Hash
+            # If you're passing a hash as a rule argument, we assume that it's been registered
+            # The registered rule must be instantiatable, and we assume the args passed
+            # should be passed to the object as config options
+            key = operation.keys.first
+            arguments = operation[key]
+
+            registered_procable = @registry[key]
+
+            raise ArgumentError, "You've supplied a hash argument for a rule, but there's no rule registered for #{key}!" unless registered_procable
+
+            case registered_procable
+            when Proc
+              registered_procable.curry[arguments ]
+            else
+              registered_procable.new(arguments).to_proc
+            end
+          when Proc
+            operation
+          else
+            raise ArgumentError, "Can't coerce #{operation} into useable proc!" unless operation.respond_to? :to_proc
+
+            operation.to_proc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rulix/validator.rb

@@ -0,0 +1,72 @@
+require_relative './registry'
+
+module Rulix
+  class Validator
+    include Rulix::Registry
+
+    def self.run dataset, ruleset
+      dataset = data_for_ruleset dataset, ruleset
+
+      dataset.deep_merge ruleset do |key, val1, val2|
+        val2 = [val2] unless val2.is_a? Array
+
+        ops = get_operations val2
+
+        success, errors = ops.reduce([true, []]) do |result, op|
+          success, errors = result
+
+          new_success, *new_errors = op.call(val1)
+
+          [success && new_success, errors.concat(new_errors)]
+        end
+
+        errors
+      end
+    end
+
+    def self.valid? dataset, ruleset
+      run = run dataset, ruleset
+
+      run.deep_compact.empty?
+    end
+
+    def self.errors dataset, ruleset
+      run = run dataset, ruleset
+
+      run.deep_compact
+    end
+
+    private
+
+    def self.data_for_ruleset dataset, ruleset
+      seed = {}
+
+      reduce_into_hash seed, dataset, ruleset
+    end
+
+    def self.reduce_into_hash hash, dataset, ruleset
+      ruleset.reduce(hash) do |data_hash, values|
+        key, val = values
+
+        if val.is_a? Hash
+          seed = {}
+          nested_value = value_from_dataset dataset, key
+
+          data_hash[key] = reduce_into_hash seed, nested_value, val
+        else
+          data_hash[key] = value_from_dataset dataset, key
+        end
+
+        data_hash
+      end
+    end
+
+    def self.value_from_dataset dataset, key
+      if dataset.respond_to? :[]
+        dataset[key]
+      else
+        dataset.public_send(key)
+      end
+    end
+  end
+end

data/lib/rulix/validators/alpha_validator.rb

@@ -0,0 +1,19 @@
+module Rulix
+  module Validators
+    class AlphaValidator
+      def self.to_proc
+        new.method(:call)
+      end
+
+      def call string
+        /^[a-zA-Z\s?]*$/ === string || [false, error_message(string)]
+      end
+
+      def error_message string
+        "contains non-alpha characters"
+      end
+    end
+  end
+end
+
+Rulix::Validator.register :alpha_only, Rulix::Validators::AlphaValidator

data/lib/rulix/validators/format_validator.rb

@@ -0,0 +1,24 @@
+module Rulix
+  module Validators
+    class FormatValidator
+      attr_accessor :format, :message
+
+      def initialize options = nil
+        options ||= {}
+
+        self.format = options[:format]
+        self.message = options.fetch :message, 'does not match format'
+      end
+
+      def call string
+        format === string || [false, message]
+      end
+
+      def to_proc
+        method(:call)
+      end
+    end
+  end
+end
+
+Rulix::Validator.register :format, Rulix::Validators::FormatValidator

data/lib/rulix/validators/length_validator.rb

@@ -0,0 +1,34 @@
+module Rulix
+  module Validators
+    class LengthValidator
+      attr_accessor :min, :max
+
+      def initialize options = nil
+        options ||= {}
+        min = options[:min] || options[:exactly] || 0
+        max = options[:max] || options[:exactly] || min + 1
+
+        self.min = min
+        self.max = max
+      end
+
+      def call string
+        (min..max).cover?(string.length) || [false, error_message(string)]
+      end
+
+      def error_message string
+        if string.length < min
+          "is too short"
+        elsif string.length > max
+          "is too long"
+        end
+      end
+
+      def to_proc
+        method(:call)
+      end
+    end
+  end
+end
+
+Rulix::Validator.register :length, Rulix::Validators::LengthValidator

data/lib/rulix/version.rb

@@ -0,0 +1,3 @@
+module Rulix
+  VERSION = "0.1.0"
+end

data/lib/rulix.rb

@@ -0,0 +1,8 @@
+require_relative './rulix/version'
+require_relative './rulix/mutator'
+require_relative './rulix/validator'
+require_relative './rulix/core_ext/hash'
+
+Dir[File.dirname(__FILE__) + '/rulix/validators/*.rb'].each { |f| require f }
+
+module Rulix; end

data/rulix.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rulix/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rulix"
+  spec.version       = Rulix::VERSION
+  spec.authors       = ["Mitch Monsen"]
+  spec.email         = ["mmonsen7@gmail.com"]
+
+  spec.summary       = "Simple data manipulation and validation through rulesets"
+  spec.description   = "Rulix lets you fold complex rulesets onto complex data structures; useful for validation, data sanitization, and mutation."
+  spec.homepage      = "https://github.com/blarshk/rulix"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: rulix
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mitch Monsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: Rulix lets you fold complex rulesets onto complex data structures; useful
+  for validation, data sanitization, and mutation.
+email:
+- mmonsen7@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rulix.rb
+- lib/rulix/core_ext/hash.rb
+- lib/rulix/mutator.rb
+- lib/rulix/registry.rb
+- lib/rulix/validator.rb
+- lib/rulix/validators/alpha_validator.rb
+- lib/rulix/validators/format_validator.rb
+- lib/rulix/validators/length_validator.rb
+- lib/rulix/version.rb
+- rulix.gemspec
+homepage: https://github.com/blarshk/rulix
+licenses: []
+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.6
+signing_key: 
+specification_version: 4
+summary: Simple data manipulation and validation through rulesets
+test_files: []
+has_rdoc: