match_reduce 1.0.0.pre.alpha → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c3c23c5467e8d1b83480b9440ace8237b05e588a5ea8e0b34212c5130ec2e29
-  data.tar.gz: f7a93d0e34f59b842d1a52e9990f6be7d9901e8a22b55c7af024c52475229c8f
+  metadata.gz: c0ca62d59ead19578324d9c7e81ad9f671d6d92b467b5ffe8b110e1b60d0e127
+  data.tar.gz: 63d0e69d3e187763f8fc8c4f2413c2bc00f6a5e61eddfd30e744473f6f04f2a4
 SHA512:
-  metadata.gz: a0bb6158c5e8a48f279eaaa1c8c8fcaa36c6b48f5b7232a64f6ecba2949e46ea53fc6194c6095ae6fc6c39b8e45fc44b7689de1ca00e1589dbc88a580c0a330f
-  data.tar.gz: dfe1f78b5036761f777f978d0ee2075a06364b356722f14ca74c8a03b873cc2df227aa286cf69258146e2a0688ba6c875a84ed5b64b30286c06694300f287613
+  metadata.gz: 9eb86c78525d6de4bd4abc06c47c8d27fab79e88488cdde1c3e36c8fa4b06182aee657433cb003a2d7f9986d1422d69e1d61c8777a1be453c2d51efc2ba3d7b9
+  data.tar.gz: 0ba05d835f6bd6403a9a1c4d9d360a4904ea6eca5a92e732cfd207cf8a35c93ab64e4869189c18fd638c586b6f2c8f4d5c7bf357b818669ca8db490c5f9a2c18

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.0.0 (September 18th, 2019)
+
+* Initial implementation released.
+
 # 1.0.0-alpha (September 17th, 2019)
 
 * Initial implementation alpha release for testing.

data/README.md

@@ -4,11 +4,11 @@
 
 MatchReduce is a high-speed, in-memory data aggregation and reduction algorithm.  The lifecycle is:
 
-1. define aggregates
+1. define aggregators
 2. pump records into algorithm
 3. grab results
 
-The dataset will only be processed once no matter how many aggregates you define.  An aggregate is expressed as:
+The dataset will only be processed once no matter how many aggregators you define.  An aggregator is expressed as:
 
 * patterns: an array of hashes, which are used to pattern match records
 * reducer: a function, which is used when a record matches
@@ -37,7 +37,7 @@ A very basic example of calling this library would be:
 ````ruby
 require 'match_reduce'
 
-aggregates = [
+aggregators = [
  {
    name: :total_game_points
    reducer: ->(memo, record, resolver) { memo.to_i + resolver.get(record, :game_points).to_i },
@@ -52,7 +52,7 @@ records = [
   { game: 2, game_points: 240, team: 'Bulls', team_points: 110 }
 ]
 
-results = MatchReduce.process(aggregates, records)
+results = MatchReduce.process(aggregators, records)
 ````
 
 `results` would be equal to:
@@ -72,10 +72,10 @@ results = MatchReduce.process(aggregates, records)
 
 Notes:
 
-* Not specifying patterns means: "match on everything"
+* Not specifying patterns, as in the example above, means: "match on everything"
 * group_keys will limit the records matched on, per aggregator, to the first record only.  This is why only the first and third records matched.
-* keys are type-indifferent and will extracted using (the Objectable library)[https://github.com/bluemarblepayroll/objectable].  This means you can leverage dot-notation, non-hash record types, and indifference.  You can also customize the resolver used and pass it as a third argument to MatchReduce#process(aggregates, records, resolver).
-* Names of aggregates are type-sensitive, so: `:total_game_points` and `'total_game_points'` are two different aggregates and will produce two different results.
+* keys are type-indifferent and will extracted using (the Objectable library)[https://github.com/bluemarblepayroll/objectable].  This means you can leverage dot-notation, non-hash record types, and indifference.  You can also customize the resolver used and pass it as a third argument to MatchReduce#process(aggregators, records, resolver).
+* Names of aggregators are type-sensitive, so: `:total_game_points` and `'total_game_points'` are two different aggregators and will produce two different results.
 
 ### Adding Patterns
 
@@ -84,7 +84,7 @@ Let's say we want to discretely know how many points the Bulls, Celtics, and Roc
 ````ruby
 require 'match_reduce'
 
-aggregates = [
+aggregators = [
  {
    name: :bulls_points
    patterns: { team: 'Bulls' },
@@ -112,7 +112,7 @@ records = [
   { game: 2, game_points: 240, team: 'Bulls', team_points: 110 }
 ]
 
-results = MatchReduce.process(aggregates, records)
+results = MatchReduce.process(aggregators, records)
 ````
 
 `results` would now be equal to:
@@ -144,12 +144,12 @@ results = MatchReduce.process(aggregates, records)
 ]
 ````
 
-We could also choose to aggregate multiple teams together by providing multiple patterns:
+We could also choose to aggregator multiple teams together by providing multiple patterns:
 
 ````ruby
 require 'match_reduce'
 
-aggregates = [
+aggregators = [
  {
    name: :bulls_and_celtics_points
    patterns: [
@@ -168,7 +168,7 @@ records = [
   { game: 2, game_points: 240, team: 'Bulls', team_points: 110 }
 ]
 
-results = MatchReduce.process(aggregates, records)
+results = MatchReduce.process(aggregators, records)
 ````
 
 `results` would now be equal to:
@@ -176,7 +176,7 @@ results = MatchReduce.process(aggregates, records)
 ````ruby
 [
   MatchReduce::Processor::Result.new(
-    name: :bulls_points,
+    name: :bulls_and_celtics_points,
     records: [
       { game: 1, game_points: 199, team: 'Bulls', team_points: 100 },
       { game: 1, game_points: 199, team: 'Celtics', team_points: 99 },

data/lib/match_reduce.rb

@@ -11,23 +11,19 @@ require 'acts_as_hashable'
 require 'hash_math'
 require 'objectable'
 
-require_relative 'match_reduce/any'
-require_relative 'match_reduce/aggregate'
+require_relative 'match_reduce/aggregator'
 require_relative 'match_reduce/index'
 require_relative 'match_reduce/processor'
 
 # Top-level namespace
 module MatchReduce
-  # Define the only instance as a helper constant for the entire library to share.
-  # Technically it is not a singleton, but it does not have to be because it will still
-  # provide equality where we need it: #hash, #eql?, and #==.  We are using this as a
-  # special flag indicating: "match on any value".  So even if we were to instantiate
-  # multiple Any objects, the point is moot.
-  ANY = Any.new
+  # Something unique which will represent "match on all values".  This is used as the base
+  # value for all pattern keys.
+  ANY = :__ANY__
 
   class << self
-    def process(aggregates, records, resolver = Objectable.resolver)
-      Processor.new(aggregates, resolver)
+    def process(aggregators, records, resolver: Objectable.resolver, any: ANY)
+      Processor.new(aggregators, resolver: resolver, any: any)
                .add_each(records)
                .results
     end

data/lib/match_reduce/{aggregate.rb → aggregator.rb}

@@ -8,8 +8,8 @@
 #
 
 module MatchReduce
-  # An aggregate is a group of patterns with a reducer that you wish to report on.
-  class Aggregate
+  # An aggregator is a group of patterns with a reducer that you wish to report on.
+  class Aggregator
     acts_as_hashable
 
     attr_reader :group_keys,
@@ -22,7 +22,7 @@ module MatchReduce
 
       @name       = name
       @group_keys = Array(group_keys)
-      @patterns   = stringed_keys(not_empty(array(patterns)))
+      @patterns   = stringed_keys(ensure_not_empty(array(patterns)))
       @reducer    = reducer
 
       freeze
@@ -54,7 +54,7 @@ module MatchReduce
       val.is_a?(Hash) ? [val] : Array(val)
     end
 
-    def not_empty(val)
+    def ensure_not_empty(val)
       val.empty? ? [{}] : val
     end
   end

data/lib/match_reduce/index.rb

@@ -8,30 +8,30 @@
 #
 
 module MatchReduce
-  # The Index holds all the aggregates, the reverse lookup data structure, and the ability
-  # to retrieve aggregates based on a pattern
+  # The Index holds all the aggregators, the reverse lookup data structure, and the ability
+  # to retrieve aggregators based on a pattern
   class Index
     extend Forwardable
 
-    attr_reader :aggregates,
-                :any_value,
+    attr_reader :aggregators,
+                :any,
                 :lookup
 
     def_delegators :record, :keys
 
-    def initialize(aggregates = [], any_value = ANY)
-      @any_value  = any_value
-      @aggregates = Aggregate.array(aggregates).uniq(&:name)
-      @lookup     = {}
+    def initialize(aggregators = [], any: ANY)
+      @any = any
+      @aggregators = Aggregator.array(aggregators).uniq(&:name)
+      @lookup = {}
 
-      all_keys = @aggregates.flat_map(&:keys)
-      @record  = HashMath::Record.new(all_keys, any_value)
+      all_keys = @aggregators.flat_map(&:keys)
+      @record  = HashMath::Record.new(all_keys, any)
 
-      @aggregates.map do |aggregate|
-        aggregate.patterns.each do |pattern|
+      @aggregators.map do |aggregator|
+        aggregator.patterns.each do |pattern|
           normalized_pattern = record.make!(pattern)
 
-          get(normalized_pattern) << aggregate
+          get(normalized_pattern) << aggregator
         end
       end
 

data/lib/match_reduce/processor.rb

@@ -11,18 +11,18 @@ require_relative 'processor/results_builder'
 
 module MatchReduce
   # This is the main lifecycle of the algorithm.  You initialize a new instance of this
-  # class using aggregates, then you pump in records into it.  Once done, call #results
+  # class using aggregators, then you pump in records into it.  Once done, call #results
   # to get the results.
   class Processor
     extend Forwardable
 
     def_delegators :results_builder, :results, :resolver
 
-    def_delegators :index, :aggregates
+    def_delegators :index, :aggregators, :any
 
-    def initialize(aggregates, resolver)
-      @index            = Index.new(aggregates)
-      @results_builder  = ResultsBuilder.new(index.aggregates, resolver)
+    def initialize(aggregators, resolver: Objectable.resolver, any: ANY)
+      @index            = Index.new(aggregators, any: any)
+      @results_builder  = ResultsBuilder.new(index.aggregators, resolver)
 
       freeze
     end
@@ -32,16 +32,16 @@ module MatchReduce
     end
 
     def add(record)
-      hit_aggregates = Set.new
+      hit_aggregators = Set.new
 
       record_patterns(record).each do |hash_pattern|
-        # Each index find hit means the aggregate matched on the record
-        index.find(hash_pattern).each do |aggregate|
-          next if hit_aggregates.include?(aggregate)
+        # Each index find hit means the aggregator matched on the record
+        index.find(hash_pattern).each do |aggregator|
+          next if hit_aggregators.include?(aggregator)
 
-          add_to_results_builder(aggregate, record)
+          add_to_results_builder(aggregator, record)
 
-          hit_aggregates << aggregate
+          hit_aggregators << aggregator
         end
       end
 
@@ -53,8 +53,8 @@ module MatchReduce
     attr_reader :index,
                 :results_builder
 
-    def make_group_id(aggregate, record)
-      aggregate.group_keys.map { |group_key| resolver.get(record, group_key) }
+    def make_group_id(aggregator, record)
+      aggregator.group_keys.map { |group_key| resolver.get(record, group_key) }
     end
 
     def record_matrix(record)
@@ -69,10 +69,10 @@ module MatchReduce
       [{}] + record_matrix(record).to_a
     end
 
-    def add_to_results_builder(aggregate, record)
-      group_id = make_group_id(aggregate, record)
+    def add_to_results_builder(aggregator, record)
+      group_id = make_group_id(aggregator, record)
 
-      results_builder.add(aggregate, record, group_id)
+      results_builder.add(aggregator, record, group_id)
     end
   end
 end

data/lib/match_reduce/processor/result.rb

@@ -9,7 +9,7 @@
 
 module MatchReduce
   class Processor
-    # This is the main resulting value object returned, one per aggregate.
+    # This is the main resulting value object returned, one per aggregator.
     class Result
       attr_reader :name, :records, :value
 

data/lib/match_reduce/processor/result_builder.rb

@@ -11,14 +11,14 @@ require_relative 'result'
 
 module MatchReduce
   class Processor
-    # This class understands how to take an aggregate and derive a result for it.
+    # This class understands how to take an aggregator and derive a result for it.
     class ResultBuilder
-      def initialize(aggregate, resolver)
-        raise ArgumentError, 'aggregate is required'  unless aggregate
-        raise ArgumentError, 'resolver is required'   unless resolver
+      def initialize(aggregator, resolver)
+        raise ArgumentError, 'aggregator is required' unless aggregator
+        raise ArgumentError, 'resolver is required' unless resolver
 
-        @aggregate  = aggregate
-        @resolver   = resolver
+        @aggregator = aggregator
+        @resolver = resolver
 
         @records    = []
         @value      = nil
@@ -26,7 +26,7 @@ module MatchReduce
       end
 
       def add(record, group_id)
-        if aggregate.grouped?
+        if aggregator.grouped?
           return self if group_ids.include?(group_id)
 
           group_ids << group_id
@@ -34,18 +34,18 @@ module MatchReduce
 
         records << record
 
-        @value = aggregate.reduce(value, record, resolver)
+        @value = aggregator.reduce(value, record, resolver)
 
         self
       end
 
       def result
-        Result.new(aggregate.name, records, value)
+        Result.new(aggregator.name, records, value)
       end
 
       private
 
-      attr_reader :aggregate,
+      attr_reader :aggregator,
                   :group_ids,
                   :records,
                   :resolver,

data/lib/match_reduce/processor/results_builder.rb

@@ -11,21 +11,21 @@ require_relative 'result_builder'
 
 module MatchReduce
   class Processor
-    # This class knows how to group together aggregates in order to produce results.
+    # This class knows how to group together aggregators in order to produce results.
     class ResultsBuilder
       attr_reader :resolver
 
-      def initialize(aggregates, resolver)
-        raise ArgumentError, 'aggregates are required' unless aggregates
+      def initialize(aggregators, resolver)
+        raise ArgumentError, 'aggregators are required' unless aggregators
 
-        @result_by_name = aggregates.map { |a| [a.name, ResultBuilder.new(a, resolver)] }.to_h
+        @result_by_name = aggregators.map { |a| [a.name, ResultBuilder.new(a, resolver)] }.to_h
         @resolver       = resolver
 
         freeze
       end
 
-      def add(aggregate, record, group_id)
-        tap { result_by_name[aggregate.name].add(record, group_id) }
+      def add(aggregator, record, group_id)
+        tap { result_by_name[aggregator.name].add(record, group_id) }
       end
 
       def results

data/lib/match_reduce/version.rb

@@ -8,5 +8,5 @@
 #
 
 module MatchReduce
-  VERSION = '1.0.0-alpha'
+  VERSION = '1.0.0'
 end

data/match_reduce.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.3.8'
 
   s.add_dependency('acts_as_hashable', '~>1', '>=1.1.0')
-  s.add_dependency('hash_math', '>=1.0.0-alpha')
+  s.add_dependency('hash_math', '~>1')
   s.add_dependency('objectable', '~>1')
 
   s.add_development_dependency('guard-rspec', '~>4.7')

data/spec/fixtures/snapshots/processor/abstract.yaml

@@ -3,7 +3,7 @@ records:
   - { a: a2, b: b2, c: c2, d: d2, e: e2, val: 2 }
   - { a: a3, b: b3, c: c3, d: d3, e: e3, val: 3 }
 
-aggregates:
+aggregators:
   - name: all (no patterns)
     sum_reducer_key: val
     patterns:

data/spec/fixtures/snapshots/processor/teams_and_players.yaml

@@ -29,7 +29,7 @@ records:
     player: rip_hamilton
     player_points: 100
 
-aggregates:
+aggregators:
   - name: total_points_by_team_player
     patterns:
     sum_reducer_key: player_points

data/spec/match_reduce/{aggregate_spec.rb → aggregator_spec.rb}

@@ -9,7 +9,7 @@
 
 require 'spec_helper'
 
-describe MatchReduce::Aggregate do
+describe MatchReduce::Aggregator do
   describe '#initialize' do
     it 'sets patterns to at least one hash' do
       subject = described_class.new(name: :sig1)

data/spec/match_reduce/index_spec.rb

@@ -11,23 +11,23 @@ require 'spec_helper'
 
 describe MatchReduce::Index do
   def lookup_by_name(lookup)
-    lookup.each_with_object({}) do |(pattern, aggregates), memo|
-      memo[pattern] = aggregates.map(&:name)
+    lookup.each_with_object({}) do |(pattern, aggregators), memo|
+      memo[pattern] = aggregators.map(&:name)
     end
   end
 
   let(:base_value) { MatchReduce::ANY }
 
   describe '#initialization' do
-    context 'constructing aggregates' do
-      specify 'when all aggregates when empty' do
+    context 'constructing aggregators' do
+      specify 'when all aggregators when empty' do
         subject = described_class.new
 
-        expect(subject.aggregates).to eq([])
+        expect(subject.aggregators).to eq([])
       end
 
-      specify 'only each first unique aggregate name is kept' do
-        aggregates = [
+      specify 'only each first unique aggregator name is kept' do
+        aggregators = [
           { name: :sig3 },
           { name: :sig1 },
           { name: 'sig2' },
@@ -39,14 +39,14 @@ describe MatchReduce::Index do
           { name: :sig5 }
         ]
 
-        subject = described_class.new(aggregates)
+        subject = described_class.new(aggregators)
 
-        expect(subject.aggregates.length).to eq(7)
+        expect(subject.aggregators.length).to eq(7)
       end
     end
 
     context 'constructing lookup' do
-      it 'creates lookup with aggregates' do
+      it 'creates lookup with aggregators' do
         subject = described_class.new
 
         expected = {}
@@ -54,13 +54,13 @@ describe MatchReduce::Index do
         expect(subject.lookup).to eq(expected)
       end
 
-      it 'creates lookup with aggregates that have no patterns' do
-        aggregates = [
+      it 'creates lookup with aggregators that have no patterns' do
+        aggregators = [
           { name: :sig3 },
           { name: :sig1 }
         ]
 
-        subject = described_class.new(aggregates)
+        subject = described_class.new(aggregators)
 
         expected = {
           {} => %i[sig3 sig1]
@@ -69,8 +69,8 @@ describe MatchReduce::Index do
         expect(lookup_by_name(subject.lookup)).to eq(expected)
       end
 
-      it 'creates lookup with aggregates that have patterns and no patterns' do
-        aggregates = [
+      it 'creates lookup with aggregators that have patterns and no patterns' do
+        aggregators = [
           { name: :sig3 },
           { name: :sig1 },
           {
@@ -79,7 +79,7 @@ describe MatchReduce::Index do
           }
         ]
 
-        subject = described_class.new(aggregates)
+        subject = described_class.new(aggregators)
 
         expected = {
           { 'a' => base_value, 'b' => base_value, 'c' => base_value } => %i[sig3 sig1],

data/spec/match_reduce/processor_spec.rb

@@ -17,8 +17,8 @@ describe MatchReduce::Processor do
   end
 
   def snapshot(snapshot)
-    records     = snapshot.fetch('records', [])
-    aggregates  = snapshot.fetch('aggregates', []).map do |a|
+    records = snapshot.fetch('records', [])
+    aggregators = snapshot.fetch('aggregators', []).map do |a|
       {
         name: a['name'],
         patterns: a['patterns'],
@@ -33,25 +33,23 @@ describe MatchReduce::Processor do
 
     OpenStruct.new(
       records: records,
-      aggregates: aggregates,
+      aggregators: aggregators,
       results: results
     )
   end
 
-  let(:resolver) { Objectable.resolver }
-
   describe 'snapshots' do
     yaml_fixture_files('snapshots', 'processor').each_pair do |filename, snapshot_config|
       specify File.basename(filename) do
         example = snapshot(snapshot_config)
 
-        subject = described_class.new(example.aggregates, resolver)
+        subject = described_class.new(example.aggregators)
 
         results = subject.add_each(example.records).results
 
-        err_msg = "invalid: #{example.results.length} results != #{example.aggregates.length} aggs"
+        err_msg = "invalid: #{example.results.length} results != #{example.aggregators.length} aggs"
 
-        expect(example.results.length).to eq(example.aggregates.length), err_msg
+        expect(example.results.length).to eq(example.aggregators.length), err_msg
 
         results.each_with_index do |result, i|
           expect(result).to eq(example.results[i])

data/spec/match_reduce_spec.rb

@@ -10,7 +10,7 @@
 require 'spec_helper'
 
 class ProcessorMock
-  def initialize(_aggregates, _resolver); end
+  def initialize(_aggregators, resolver: nil, any: nil); end
 
   def add_each(_records)
     self
@@ -23,17 +23,20 @@ end
 
 describe MatchReduce do
   specify '#process should create new Processor, call add_each, then call results' do
-    resolver    = nil
-    aggregates  = []
-    records     = []
-    results     = []
+    resolver    = 1
+    any         = 2
+    aggregators = 3
+    records = 4
 
-    processor = ProcessorMock.new(aggregates, resolver)
+    processor = ProcessorMock.new(aggregators, resolver: resolver, any: any)
+
+    expect(MatchReduce::Processor).to receive(:new).with(aggregators, resolver: resolver, any: any)
+                                                   .and_return(processor)
 
-    expect(MatchReduce::Processor).to receive(:new).with(aggregates, resolver).and_return(processor)
     expect(processor).to receive(:add_each).with(records).and_return(processor)
-    expect(processor).to receive(:results).and_return(results)
 
-    described_class.process(aggregates, records, resolver)
+    expect(processor).to receive(:results)
+
+    described_class.process(aggregators, records, resolver: resolver, any: any)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: match_reduce
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.alpha
+  version: 1.0.0
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-17 00:00:00.000000000 Z
+date: 2019-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: acts_as_hashable
@@ -34,16 +34,16 @@ dependencies:
   name: hash_math
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre.alpha
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre.alpha
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: objectable
   requirement: !ruby/object:Gem::Requirement
@@ -179,8 +179,7 @@ files:
 - Rakefile
 - bin/console
 - lib/match_reduce.rb
-- lib/match_reduce/aggregate.rb
-- lib/match_reduce/any.rb
+- lib/match_reduce/aggregator.rb
 - lib/match_reduce/index.rb
 - lib/match_reduce/processor.rb
 - lib/match_reduce/processor/result.rb
@@ -190,8 +189,7 @@ files:
 - match_reduce.gemspec
 - spec/fixtures/snapshots/processor/abstract.yaml
 - spec/fixtures/snapshots/processor/teams_and_players.yaml
-- spec/match_reduce/aggregate_spec.rb
-- spec/match_reduce/any_spec.rb
+- spec/match_reduce/aggregator_spec.rb
 - spec/match_reduce/index_spec.rb
 - spec/match_reduce/processor/result_spec.rb
 - spec/match_reduce/processor_spec.rb
@@ -212,9 +210,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 
@@ -223,8 +221,7 @@ summary: Dataset aggregation and reducer algorithm
 test_files:
 - spec/fixtures/snapshots/processor/abstract.yaml
 - spec/fixtures/snapshots/processor/teams_and_players.yaml
-- spec/match_reduce/aggregate_spec.rb
-- spec/match_reduce/any_spec.rb
+- spec/match_reduce/aggregator_spec.rb
 - spec/match_reduce/index_spec.rb
 - spec/match_reduce/processor/result_spec.rb
 - spec/match_reduce/processor_spec.rb

data/lib/match_reduce/any.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Copyright (c) 2019-present, Blue Marble Payroll, LLC
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-#
-
-module MatchReduce
-  # This class represents a wildcard.  Direct use of this class should be avoided, instead,
-  # use the MatchReduce top-level-declared helper ANY constant.
-  class Any
-    SPECIAL_VALUE = [name, :any].freeze
-
-    private_constant :SPECIAL_VALUE
-
-    # Just be something totally unique.  Matching values cannot actually be an array, therefore
-    # there should never be a chance of a collision if the hash of this object is based on
-    # an array structure.
-    def hash
-      SPECIAL_VALUE.hash
-    end
-
-    def ==(other)
-      other.instance_of?(self.class) && hash == other.hash
-    end
-    alias eql? ==
-  end
-end

data/spec/match_reduce/any_spec.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Copyright (c) 2019-present, Blue Marble Payroll, LLC
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-#
-
-require 'spec_helper'
-
-describe MatchReduce::Any do
-  describe '#hash' do
-    it 'should be based on an array of the class name and the symbol :any' do
-      expect(described_class.new.hash).to eq(['MatchReduce::Any', :any].hash)
-    end
-  end
-
-  describe 'equality' do
-    specify '#== should always be equal if the classes and hash are the same' do
-      expect(described_class.new).to eq(described_class.new)
-
-      expect(described_class.new).not_to eq(:any)
-    end
-
-    specify '#eql? should always be equal if the classes and hash are the same' do
-      expect(described_class.new).to eql(described_class.new)
-
-      expect(described_class.new).not_to eq(:any)
-    end
-  end
-end