arel_hash 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7aaa91bdfe961029995869190679c3423e5b7532
+  data.tar.gz: cc879c66d4d164e4dd5e265bbfafdb91f582c9ab
+SHA512:
+  metadata.gz: 708f2575e65dc2648ac7c053aa494a1c26d5a65bc0b45ad722164be13498f32b64a2aedaced20ac25e1f96e536d4490be5c5263cf7994a0ebd3d36b9b2bf6a29
+  data.tar.gz: ebb46a957a56352a97a22a7b4f0d594e4427ba12bf365f2ec3f691792c6bbbc460ab83cb2de8168118efd51c200396291ac7e91f1faf6ad33db0d3416ed76fd2

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.6

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Bert Bruynooghe
+
+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,15 @@
+# ArelHash
+
+ArelHash is a library that offers some utilities for serializing/deserializing Arel expressions into/from hashes.
+At the heart of the where part of such an ArelHash expression, we have core expressions in the form of: 
+
+ ``` { <predication>: { <left_operand> => <right_operand> } } ```
+  
+with ```operand``` being a 'column name' if it is a symbol, or a constant otherwise.
+ 
+These expressions can be combined using *OR* and/or *AND*:
+ 
+    { or: [ <subexpression>, <subexpression>, ... ] }
+    { and: [ <subexpression>, <subexpression>, ... ] }
+ 
+ 

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/arel_hash.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'arel_hash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "arel_hash"
+  spec.version       = ArelHash::VERSION
+  spec.authors       = ['Bert Bruynooghe']
+  spec.email         = ['bert.bruynooghe@up-nxt.com']
+  spec.summary       = %q{A serialization specification of ARel.}
+  spec.description   = %q{A serialization specification of ARel, with some utilities.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.5"
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_dependency 'arel', '>= 6.0.0'
+end

data/lib/arel/any_node.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Any < Unary
+    end
+  end
+end

data/lib/arel/contains_node.rb

@@ -0,0 +1,6 @@
+module Arel
+  module Nodes
+    class Contains < Unary
+    end
+  end
+end

data/lib/arel_hash.rb

@@ -0,0 +1,31 @@
+require 'arel_hash/version'
+require 'arel'
+require 'arel_hash/arel/nodes/casted'
+require 'arel/any_node'
+require 'arel/contains_node'
+require 'arel_hash/node_factory'
+require 'arel_hash/sanitizer'
+require 'arel_hash/optimizer'
+require 'arel_hash/arel_hash_factory'
+
+module ArelHash
+  Nodes = Arel::Nodes
+  Equality = Nodes::Equality
+
+  ZERO_RESULTS_NODE = Equality.new(Nodes::build_quoted('f'), Nodes::build_quoted('t'))
+  ZERO_RESULTS_HASH = { or: [] }
+  NO_FILTER_HASH = { and: [] }
+
+  def self.create_node(table, hash)
+    NodeFactory.new(table).create_node(hash)
+  end
+
+  def self.singleton_tuple!(hash)
+    raise "#{hash}: only hashes with maximum one key are supported" unless hash.length == 1
+    return hash.keys.first, hash.values.first
+  end
+
+  def self.create_from_active_record(hash, properties)
+    ArelHashFactory.new(properties).create_from_active_record(hash)
+  end
+end

data/lib/arel_hash/arel/nodes/casted.rb

@@ -0,0 +1,12 @@
+# temporary fix for arel issue: see https://github.com/rails/arel/pull/414
+module Arel
+  module Nodes
+    class Casted
+      unless self.instance_methods(false).include? :hash
+        def hash
+          [self.class, self.val, self.attribute].hash
+        end
+      end
+    end
+  end
+end

data/lib/arel_hash/arel_hash_factory.rb

@@ -0,0 +1,54 @@
+module ArelHash
+  class ArelHashFactory
+    def initialize(properties)
+      @properties = properties
+    end
+
+    def create_from_active_record(hash)
+      { :and => hash.map { |k, v| name_value_to_arel_hash(k.to_sym, v) } }
+    end
+
+    private
+
+    # converts a tuple from a where hash (as in ActiveRecord where) to a valid arel_hash expression
+    def name_value_to_arel_hash(attr_name, value)
+      case value
+      when Array
+        arel_hash_for_array_value(attr_name, value)
+      when Range
+        arel_hash_for_range_value(attr_name, value)
+      else
+        arel_hash_for_singleton_value(attr_name, value)
+      end
+    end
+
+    def arel_hash_for_array_value(attr_name, values)
+      { or: self.class.make_canonical(values).map do |option|
+        { and: option.map do |requirement|
+          arel_hash_for_singleton_value(attr_name, requirement)
+        end }
+      end }
+    end
+
+    def arel_hash_for_range_value(attr_name, range)
+      { and: [create_arel_hash_tuple(:gteq, attr_name, range.first),
+              create_arel_hash_tuple(range.exclude_end? ? :lt : :lt_eq, attr_name, range.end)] }
+    end
+
+    def arel_hash_for_singleton_value(attr_name, value)
+      create_arel_hash_tuple(:eq, attr_name, value)
+    end
+
+    def create_arel_hash_tuple(predication, attr_name, value)
+      if @properties.fetch(attr_name.to_s, {})['multivalue']
+        { "#{predication}_any".to_sym => { value => attr_name } }
+      else
+        { predication => { attr_name => value } }
+      end
+    end
+
+    def self.make_canonical(values)
+      values.map { |v| v.is_a?(Array) ? v : [v] }
+    end
+  end
+end

data/lib/arel_hash/node_factory.rb

@@ -0,0 +1,75 @@
+module ArelHash
+  class NodeFactory
+    # @param [Arel::Table] table the arel table to work on
+    def initialize(table)
+      @table = table
+    end
+
+    # @param [Hash<Symbol, Hash<Symbol, Object>>] hash a hash, which is a serialization of an Arel::Node
+    def create_node(hash)
+      operator, value = ArelHash.singleton_tuple!(hash)
+      do_create_node(operator, value)
+    end
+
+    private
+
+    def do_create_node(operator, value)
+      if %i(or and).include?(operator)
+        create_collection_node(operator, value)
+      else
+        create_predication_node(operator, value)
+      end
+    end
+
+    def create_collection_node(operator, value)
+      if operator == :or
+        create_or_node(value)
+      elsif operator == :and
+        create_and_node(value)
+      end
+    end
+
+    def create_predication_node(predicate, attribute_value_hash)
+      first, last = ArelHash.singleton_tuple!(attribute_value_hash).map { |v| wrap_operand(v) }
+      first.send(*expand_meta_predicates(predicate, last))
+    end
+
+    def expand_meta_predicates(predicate, value)
+      # TODO: support ALL
+      if (predicate=predicate.to_s).end_with?('_any') && value.is_a?(Arel::Attributes::Attribute)
+        predicate = predicate[0...-4]
+        value = Nodes::Any.new(value)
+      end
+      return predicate.to_sym, value
+    end
+
+    def wrap_operand(operand)
+      case operand
+      when Symbol then
+        @table[operand]
+      when Array then
+        operand.map { |o| wrap_operand(o) }
+      else
+        Nodes::build_quoted(operand).extend Arel::Predications
+      end
+    end
+
+    def create_and_node(values)
+      join_nodes(create_node_collection(values), :and)
+    end
+
+    def create_or_node(values)
+      join_nodes(create_node_collection(values), :or) || ZERO_RESULTS_NODE
+    end
+
+    def join_nodes(node_collection, operator)
+      node_collection.reduce(nil) do |m, node|
+        (m && node) ? m.send(operator, node) : node
+      end
+    end
+
+    def create_node_collection(values)
+      values.map { |v| create_node(v) }.uniq
+    end
+  end
+end

data/lib/arel_hash/optimizer.rb

@@ -0,0 +1,72 @@
+module ArelHash
+  class Optimizer
+    def initialize(predicates = [])
+      @predicates = predicates
+    end
+
+    def optimize(arel_hash)
+      operator, value = ArelHash.singleton_tuple!(arel_hash)
+      (%i(and or).include?(operator)) ? optimize_collection_node(operator, value) : arel_hash
+    end
+
+    private
+
+    def optimize_collection_node(operator, children)
+      children = children.map { |h| optimize(h) }.uniq
+      arel_hash = shallow_optimize_collection_node(operator, children)
+      children = ArelHash.singleton_tuple!(arel_hash).last
+      (children.length == 1) ? children.first : arel_hash
+    end
+
+    def shallow_optimize_collection_node(operator, children)
+      if operator == :or
+        Hash[operator, optimize_or_nodes(children)]
+      elsif operator == :and
+        Hash[operator, optimize_and_nodes(children)]
+      end
+    end
+
+    def optimize_or_nodes(nodes)
+      nodes.delete_if { |n| n == ArelHash::ZERO_RESULTS_HASH && nodes.length > 1 }
+      nodes = optimize_eqs_and_ins(nodes) if @predicates.include?('in') && @predicates.include?('eq')
+      nodes.include?(ArelHash::NO_FILTER_HASH) ? [ArelHash::NO_FILTER_HASH] : nodes
+    end
+
+    def optimize_and_nodes(nodes)
+      nodes.delete_if { |n| n == ArelHash::NO_FILTER_HASH && nodes.length > 1 }
+      nodes = optimize_duplicate_eqs(nodes)
+      nodes.include?(ArelHash::ZERO_RESULTS_HASH) ? [ArelHash::ZERO_RESULTS_HASH] : nodes
+    end
+
+    def optimize_duplicate_eqs(nodes)
+      eqs, other = partition_by_keys(nodes, 'eq')
+      values_per_attribute(eqs).map do |attr_name, values|
+        (values.length > 1) ? ArelHash::ZERO_RESULTS_HASH : { eq: Hash[attr_name, values.first] }
+      end.concat(other)
+    end
+
+    # @return [Array<Hash>] an array of predicate arelHashes
+    def optimize_eqs_and_ins(nodes)
+      ins_or_eqs, other = partition_by_keys(nodes, *%w(eq in))
+      values_per_attribute(ins_or_eqs).map do |attr_name, value|
+        (value.length > 1) ? { in: Hash[attr_name, value] } : { eq: Hash[attr_name, value.first] }
+      end.concat(other)
+    end
+
+    # @param [Array<Hash<Symbol, Hash<Symbol, Object>>>] nodes
+    # @return [Hash<Symbol, Array<String>>] attribute_name/value pair, with value being an Array
+    def values_per_attribute(nodes)
+      nodes.each_with_object({}) do |arel_hash, m|
+        name_value_pair = ArelHash.singleton_tuple!(arel_hash).last
+        attr_name, value = ArelHash.singleton_tuple!(name_value_pair)
+        m[attr_name] = (m[attr_name]||[]).concat(Array(value)).uniq
+      end
+    end
+
+    def partition_by_keys(hash_collection, *keys)
+      hash_collection.partition do |h|
+        keys.include?(ArelHash.singleton_tuple!(h).first.to_s)
+      end
+    end
+  end
+end

data/lib/arel_hash/sanitizer.rb

@@ -0,0 +1,27 @@
+module ArelHash
+  class Sanitizer
+    def initialize(predicates = [], attribute_names = [])
+      @predicates = (predicates || [])
+      @attribute_names = (attribute_names || [])
+    end
+
+    def sanitize(arel_hash)
+      operator, operand = ArelHash.singleton_tuple!(arel_hash)
+      if operator == :and || operator == :or
+        Hash[operator, operand.map { |o| sanitize(o) }]
+      else
+        sanitize_predication_hash(operator, operand)
+      end
+    end
+
+    private
+
+    def sanitize_predication_hash(operator, attr_name_value)
+      valid = @predicates.empty? || @predicates.include?(operator.to_s)
+      valid &&= attr_name_value.flatten.all? do |v|
+        (!v.is_a?(Symbol)) || @attribute_names.empty? || @attribute_names.include?(v.to_s)
+      end
+      valid ? Hash[operator, attr_name_value] : ArelHash::ZERO_RESULTS_HASH
+    end
+  end
+end

data/lib/arel_hash/version.rb

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

data/spec/arel_hash/optimizer_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module ArelHash
+  describe Optimizer do
+    let(:optimizer) { Optimizer.new(%w(eq in)) }
+    it 'removes AND nodes with single operands' do
+      expect(optimizer.optimize(and: [{ eq: { x: 1 } }])).to eq(eq: { x: 1 })
+    end
+    it 'removes OR nodes with single operands' do
+      expect(optimizer.optimize(or: [{ eq: { x: 1 } }])).to eq(eq: { x: 1 })
+    end
+    it 'maintains AND nodes without operands' do
+      expect(optimizer.optimize(and: [])).to eq(and: [])
+    end
+    it 'maintains OR nodes without operands' do
+      expect(optimizer.optimize(or: [])).to eq(or: [])
+    end
+    it 'removes duplicate nodes' do
+      expect(optimizer.optimize(and: [{ eq: { x: 1 } }, { eq: { x: 1 } }])).to eq(eq: { x: 1 })
+    end
+    describe 'ZERO_RESULTS_HASH' do
+      it 'eats other AND operands' do
+        expect(optimizer.optimize(and: [ZERO_RESULTS_HASH, { eq: { x: 1 } }])).to eq ZERO_RESULTS_HASH
+      end
+      it 'gets eaten by other OR operands' do
+        expect(optimizer.optimize(or: [ZERO_RESULTS_HASH, { eq: { x: 1 } }])).to eq(eq: { x: 1 })
+      end
+    end
+    describe 'NO_FILTER_HASH' do
+      it 'eats other OR operands' do
+        expect(optimizer.optimize(or: [NO_FILTER_HASH, { eq: { x: 1 } }])).to eq NO_FILTER_HASH
+      end
+      it 'gets eaten by other AND operands' do
+        expect(optimizer.optimize(and: [NO_FILTER_HASH, { eq: { x: 1 } }])).to eq(eq: { x: 1 })
+      end
+    end
+    it 'combines EQ and IN for OR' do
+      expected = { in: { amount: [5, 6, 7, 8] } }
+      expect(optimizer.optimize(or: [{ eq: { amount: 5 } }, { eq: { amount: 6 } }, { in: { amount: [7, 8] } }])).to eq expected
+    end
+    it 'returns zero results for AND of EQ with same attribute and different values' do
+      expect(optimizer.optimize(and: [{ eq: { amount: 5 } }, { eq: { amount: 6 } }])).to eq ZERO_RESULTS_HASH
+    end
+
+  end
+end

data/spec/arel_hash/sanitizer_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+module ArelHash
+  describe Sanitizer do
+    it 'does not sanitize if predicates and attribute_names are set to nil' do
+      expect(Sanitizer.new.sanitize(eq: { x: 1 })).to eq(eq: { x: 1 })
+    end
+    it 'sanitizes base on given predicates' do
+      expect(Sanitizer.new([ 'not_eq'], [1]).sanitize(eq: { x: 1 })).to eq(ZERO_RESULTS_HASH)
+    end
+    it 'sanitizes based on given attribute_names' do
+      expect(Sanitizer.new(['eq'], [ 'y' ]).sanitize(eq: { x: 1 })).to eq(ZERO_RESULTS_HASH)
+    end
+    it 'sanitizes deeply' do
+      expect(Sanitizer.new(['eq'], ['y']).sanitize(or: [or: [eq: { x: 1 }]])).to eq(or: [or: [ZERO_RESULTS_HASH]])
+    end
+    it 'sanitizes based on operand type' do
+      expect(Sanitizer.new([], %w(x)).sanitize(eq: {1 => :x})).to eq(eq: {1 => :x})
+    end
+  end
+end

data/spec/arel_hash_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module ArelHash
+  describe '.create_node' do
+    let(:table) { Arel::Table.new(:test) }
+    let(:result) { double }
+    describe 'predication node' do
+      it 'is supported' do
+        expected = Equality.new(table[:amount], Nodes::build_quoted(5))
+        expect(ArelHash.create_node(table, eq: { amount: 5 })).to eq expected
+      end
+      it 'does support inverted operand orders' do
+        expected = Equality.new(Nodes::build_quoted(5), table[:amount])
+        expect(ArelHash.create_node(table, eq: { 5 => :amount })).to eq expected
+      end
+      it 'does not support multi column hashes' do
+        multi_column_hash = { age: 4, amount: 50 }
+        expect do
+          ArelHash.create_node(table, eq: multi_column_hash)
+        end.to raise_exception "#{multi_column_hash}: only hashes with maximum one key are supported"
+      end
+    end
+
+    describe 'AND' do
+      it 'returns nil if no operands' do
+        expect(ArelHash.create_node(table, and: [])).to eq nil
+      end
+      it 'ignores the AND if only one operand' do
+        expected = Equality.new(table[:age], Nodes::build_quoted(4))
+        expect(ArelHash.create_node(table, and: [eq: { age: 4 }])).to eq expected
+      end
+      it 'properly builds a node for 2 operands' do
+        expected = Nodes::LessThanOrEqual.new(table[:age], Nodes::build_quoted(6))
+                     .and(Nodes::GreaterThanOrEqual.new(table[:age], Nodes::build_quoted(4)))
+        expect(ArelHash.create_node(table, and: [{ lteq: { age: 6 } }, { gteq: { age: 4 } }])).to eq expected
+      end
+      it 'does not support multi predicate hashes' do
+        multi_predicate_hash = { lteq: { age: 6 }, gteq: { age: 4 } }
+        expect do
+          ArelHash.create_node(table, and: [multi_predicate_hash])
+        end.to raise_exception "#{multi_predicate_hash}: only hashes with maximum one key are supported"
+      end
+      it 'handles empty operands' do
+        expect(ArelHash.create_node(table, and: [])).to eq(nil)
+      end
+    end
+
+    describe 'OR' do
+      it 'returns zero result if no operands' do
+        expect(ArelHash.create_node(table, or: [])).to eq ArelHash::ZERO_RESULTS_NODE
+      end
+      it 'ignores the OR if only one operand' do
+        expected = Equality.new(table[:amount], Nodes::build_quoted(5))
+        expect(ArelHash.create_node(table, or: [eq: { amount: 5 }])).to eq expected
+      end
+      it 'properly builds a node for 2 operands' do
+        expected = Equality.new(table[:amount], Nodes::build_quoted(5))
+                     .or(Equality.new(table[:age], Nodes::build_quoted(4)))
+        expect(ArelHash.create_node(table, or: [{ eq: { amount: 5 } }, { eq: { age: 4 } }])).to eq expected
+      end
+      it 'properly builds a node for 3 operands' do
+        expected = Equality.new(table[:amount], Nodes::build_quoted(5))
+                     .or(Equality.new(table[:age], Nodes::build_quoted(4)))
+                     .or(Equality.new(table[:shoe_size], Nodes::build_quoted(3)))
+        expect(ArelHash.create_node(table, or: [{ eq: { amount: 5 } }, { eq: { age: 4 } }, { eq: { shoe_size: 3 } }])).to eq expected
+      end
+      it 'does not support multi predicate hashes' do
+        multi_predicate_hash = { lteq: { age: 4 }, gteq: { age: 6 } }
+        expect do
+          ArelHash.create_node(table, or: [multi_predicate_hash])
+        end.to raise_exception "#{multi_predicate_hash}: only hashes with maximum one key are supported"
+      end
+      it 'squashes ORs with identical operands' do
+        expected = Equality.new(table[:amount], Nodes::build_quoted(5))
+        expect(ArelHash.create_node(table, or: [{ eq: { amount: 5 } }, { eq: { amount: 5 } }])).to eq expected
+      end
+    end
+
+    describe 'any' do
+      it 'builds regular any nodes' do
+        expected = table[:amount].eq_any([Nodes::build_quoted(1), Nodes::build_quoted(2)])
+        expect(ArelHash.create_node(table, eq_any: { amount: [1, 2] })).to eq expected
+      end
+      it 'creates ANY nodes if second operand is a symbol' do
+        # TODO: not sure if we have to break down [[],[]] into ORs and ANDs of eq_any
+        expected = Equality.new(Nodes::build_quoted(1), Nodes::Any.new(table[:amount]))
+        expect(ArelHash.create_node(table, eq_any: { 1 => :amount })).to eq expected
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'arel_hash'

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: arel_hash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bert Bruynooghe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-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.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: arel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+description: A serialization specification of ARel, with some utilities.
+email:
+- bert.bruynooghe@up-nxt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- arel_hash.gemspec
+- lib/arel/any_node.rb
+- lib/arel/contains_node.rb
+- lib/arel_hash.rb
+- lib/arel_hash/arel/nodes/casted.rb
+- lib/arel_hash/arel_hash_factory.rb
+- lib/arel_hash/node_factory.rb
+- lib/arel_hash/optimizer.rb
+- lib/arel_hash/sanitizer.rb
+- lib/arel_hash/version.rb
+- spec/arel_hash/optimizer_spec.rb
+- spec/arel_hash/sanitizer_spec.rb
+- spec/arel_hash_spec.rb
+- spec/spec_helper.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.2.3
+signing_key: 
+specification_version: 4
+summary: A serialization specification of ARel.
+test_files:
+- spec/arel_hash/optimizer_spec.rb
+- spec/arel_hash/sanitizer_spec.rb
+- spec/arel_hash_spec.rb
+- spec/spec_helper.rb