dbee 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aac48262d54b0524c4c8ecbe241ec9896478f7b02917376b835b64a75f6401bb
-  data.tar.gz: 94285e874df6c27cabd1c212b3456ce77351ee91c34c58bbfc430c1c8183667f
+  metadata.gz: 01e542a4c7d9eb3f9641aa7b54f776f32b88e178129ad0e4af219b3965315090
+  data.tar.gz: a94879eb871f87ed9b9c3f7bccbe3ddfa5a177f558a842572f7632d09feab1fc
 SHA512:
-  metadata.gz: 893af6c116b4687dd80bd4f25c96c991950bdfb799f3de590a33a9780c86ba287f4767c96ea8c6c1f10766c410a9be52fe29194c22ea29d30c9474c59acd4eff
-  data.tar.gz: 5863a68e275638f4b1d34c4326ed3b19b5ef433abed897e8f2bcbf5ec7eb536f5b54c8f666c1e339e49059bbc3ff2a6771b03db8cef6596bd76328b0ebe204e8
+  metadata.gz: af62cb3558f7557e939be6b5b4606c299436f782b40441bad3dac27c18560c9c9e55b1884c3645dcfada969f8d704c0aeb313e9731d0dd1cfcab8d7e634efa9e
+  data.tar.gz: 9f87776b0c84ff7c31c0df4d08d7f0725064adcdec21c8653995d1370426bd7d5a3b13c33946e8c1b72816cf0d9906ea0bc970ba61656876d84b3e0081fb93bc

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 1.1.0 (August 28th, 2019)
+
+Additions:
+
+* Added better equality and sort methods for Ruby objects (added class type checks where needed.)
+
+Changes:
+
+* Removed Sorter in favor of Sorter subclasses.
+* Duplicate filters and sorters will be ignored in a Query.
+
 # 1.0.3 (August 27th, 2019)
 
 Additions:

data/lib/dbee/key_chain.rb

@@ -29,7 +29,7 @@ module Dbee
     end
 
     def ==(other)
-      key_path_set == other.key_path_set
+      other.instance_of?(self.class) && key_path_set == other.key_path_set
     end
     alias eql? ==
 

data/lib/dbee/model/constraints/base.rb

@@ -22,15 +22,17 @@ module Dbee
         end
 
         def <=>(other)
-          "#{name}#{parent}" <=> "#{other.name}#{other.parent}"
+          "#{self.class.name}#{name}#{parent}" <=> "#{other.class.name}#{other.name}#{other.parent}"
         end
 
         def hash
-          "#{name}#{parent}".hash
+          "#{self.class.name}#{name}#{parent}".hash
         end
 
         def ==(other)
-          other.name == name && other.parent == parent
+          other.instance_of?(self.class) &&
+            other.name == name &&
+            other.parent == parent
         end
         alias eql? ==
       end

data/lib/dbee/model.rb

@@ -13,6 +13,7 @@ module Dbee
   # In DB terms, a Model is usually a table, but it does not have to be.  You can also re-model
   # your DB schema using Dbee::Models.
   class Model
+    extend Forwardable
     acts_as_hashable
 
     JOIN_CHAR = '.'
@@ -23,6 +24,12 @@ module Dbee
 
     attr_reader :constraints, :name, :table
 
+    def_delegator :models_by_name, :values, :models
+
+    def_delegator :models, :sort, :sorted_models
+
+    def_delegator :constraints, :sort, :sorted_constraints
+
     def initialize(name:, constraints: [], models: [], table: '')
       raise ArgumentError, 'name is required' if name.to_s.empty?
 
@@ -38,10 +45,6 @@ module Dbee
       array.map { |a| [a.name, a] }.to_h
     end
 
-    def models
-      models_by_name.values
-    end
-
     def ancestors(parts = [], alias_chain = [], found = {})
       return found if Array(parts).empty?
 
@@ -63,10 +66,11 @@ module Dbee
     end
 
     def ==(other)
-      other.name == name &&
+      other.instance_of?(self.class) &&
+        other.name == name &&
         other.table == table &&
-        other.models.sort == models.sort &&
-        other.constraints.sort == constraints.sort
+        other.sorted_constraints == sorted_constraints &&
+        other.sorted_models == sorted_models
     end
     alias eql? ==
 

data/lib/dbee/query/field.rb

@@ -31,7 +31,9 @@ module Dbee
       end
 
       def ==(other)
-        other.key_path == key_path && other.display == display
+        other.instance_of?(self.class) &&
+          other.key_path == key_path &&
+          other.display == display
       end
       alias eql? ==
 

data/lib/dbee/query/filters/base.rb

@@ -26,16 +26,19 @@ module Dbee
         end
 
         def hash
-          "#{key_path}#{value}".hash
+          "#{self.class.name}#{key_path}#{value}".hash
         end
 
         def ==(other)
-          other.key_path == key_path && other.value == value
+          other.instance_of?(self.class) &&
+            other.key_path == key_path &&
+            other.value == value
         end
         alias eql? ==
 
         def <=>(other)
-          "#{key_path}#{value}" <=> "#{other.key_path}#{other.value}"
+          "#{self.class.name}#{key_path}#{value}" <=>
+            "#{other.class.name}#{other.key_path}#{other.value}"
         end
       end
     end

data/lib/dbee/query/sorters/ascending.rb

@@ -0,0 +1,19 @@
+# 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_relative 'base'
+
+module Dbee
+  class Query
+    class Sorters
+      # Equivalent to: ORDER BY field ASC
+      class Ascending < Base; end
+    end
+  end
+end

data/lib/dbee/query/sorters/base.rb

@@ -0,0 +1,43 @@
+# 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 Dbee
+  class Query
+    class Sorters
+      # Abstract representation of the ORDER BY part of a SQL statement.
+      class Base
+        acts_as_hashable
+
+        attr_reader :key_path
+
+        def initialize(key_path:)
+          raise ArgumentError, 'key_path is required' if key_path.to_s.empty?
+
+          @key_path = KeyPath.get(key_path)
+
+          freeze
+        end
+
+        def hash
+          "#{self.class.name}#{key_path}".hash
+        end
+
+        def ==(other)
+          other.instance_of?(self.class) &&
+            other.key_path == key_path
+        end
+        alias eql? ==
+
+        def <=>(other)
+          "#{key_path}#{self.class.name}" <=> "#{other.key_path}#{other.class.name}"
+        end
+      end
+    end
+  end
+end

data/lib/dbee/query/sorters/descending.rb

@@ -0,0 +1,19 @@
+# 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_relative 'base'
+
+module Dbee
+  class Query
+    class Sorters
+      # Equivalent to: ORDER BY field DESC
+      class Descending < Base; end
+    end
+  end
+end

data/lib/dbee/query/sorters.rb

@@ -0,0 +1,29 @@
+# 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_relative 'sorters/ascending'
+require_relative 'sorters/descending'
+
+module Dbee
+  class Query
+    # Top-level class that allows for the making of sorters.  For example, you can call this as:
+    # - Sorters.make(key_path: 'id', direction: :ascending)
+    # - Sorters.make(key_path: 'id')
+    # - Sorters.make(key_path: 'id', direction: :descending)
+    class Sorters
+      acts_as_hashable_factory
+
+      type_key 'direction'
+
+      register '',            Ascending # Default if type is blank.
+      register 'ascending',   Ascending
+      register 'descending',  Descending
+    end
+  end
+end

data/lib/dbee/query.rb

@@ -9,7 +9,7 @@
 
 require_relative 'query/field'
 require_relative 'query/filters'
-require_relative 'query/sorter'
+require_relative 'query/sorters'
 
 module Dbee
   # This class is an abstration of a simplified SQL expression.  In DB terms:
@@ -18,12 +18,19 @@ module Dbee
   # - limit is the TAKE
   # - filters are the WHERE
   class Query
+    extend Forwardable
     acts_as_hashable
 
     class NoFieldsError < StandardError; end
 
     attr_reader :fields, :filters, :limit, :sorters
 
+    def_delegator :fields, :sort, :sorted_fields
+
+    def_delegator :filters, :sort, :sorted_filters
+
+    def_delegator :sorters, :sort, :sorted_sorters
+
     def initialize(fields:, filters: [], limit: nil, sorters: [])
       @fields = Field.array(fields)
 
@@ -32,18 +39,19 @@ module Dbee
       # have implications in downstream SQL generators.
       raise NoFieldsError if @fields.empty?
 
-      @filters  = Filters.array(filters)
+      @filters  = Filters.array(filters).uniq
       @limit    = limit.to_s.empty? ? nil : limit.to_i
-      @sorters  = Sorter.array(sorters)
+      @sorters  = Sorters.array(sorters).uniq
 
       freeze
     end
 
     def ==(other)
-      other.fields.sort == fields.sort &&
-        other.filters.sort == filters.sort &&
-        other.limit == limit &&
-        other.sorters.sort == sorters.sort
+      other.instance_of?(self.class) &&
+        other.sorted_fields == sorted_fields &&
+        other.sorted_filters == sorted_filters &&
+        other.sorted_sorters == sorted_sorters &&
+        other.limit == limit
     end
     alias eql? ==
 

data/lib/dbee/version.rb

@@ -8,5 +8,5 @@
 #
 
 module Dbee
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
 end

data/spec/dbee/key_path_spec.rb

@@ -33,6 +33,11 @@ describe Dbee::KeyPath do
     expect(subject).to eql(key_path_string)
   end
 
+  specify 'equality compares to_s of both objects' do
+    expect(subject).to eq(key_path_string)
+    expect(subject).to eql(:'contacts.demographics.first')
+  end
+
   describe '#ancestor_paths' do
     let(:key_path_string) { 'a.b.c.d.e' }
 

data/spec/dbee/model/constraints/base_spec.rb

@@ -39,8 +39,10 @@ describe Dbee::Model::Constraints::Base do
 
     subject { described_class.new(config) }
 
-    specify '#hash produces same output as string hash of name' do
-      expect(subject.hash).to eq("#{config[:name]}#{config[:parent]}".hash)
+    specify '#hash produces same output as string hash of class name, name, and parent' do
+      expected_hash = "#{described_class.name}#{config[:name]}#{config[:parent]}".hash
+
+      expect(subject.hash).to eq(expected_hash)
     end
 
     specify '#== and #eql? compares attributes' do
@@ -49,5 +51,10 @@ describe Dbee::Model::Constraints::Base do
       expect(subject).to eq(object2)
       expect(subject).to eql(object2)
     end
+
+    it 'returns false unless comparing same object types' do
+      expect(subject).not_to eq(config)
+      expect(subject).not_to eq(nil)
+    end
   end
 end

data/spec/dbee/model/constraints/reference_spec.rb

@@ -23,8 +23,10 @@ describe Dbee::Model::Constraints::Reference do
 
     subject { described_class.new(config) }
 
-    specify '#hash produces same output as concatenated string hash of name and parent' do
-      expect(subject.hash).to eq("#{config[:name]}#{config[:parent]}".hash)
+    specify '#hash produces same output as string hash of class name, name, and parent' do
+      expected_hash = "#{described_class.name}#{config[:name]}#{config[:parent]}".hash
+
+      expect(subject.hash).to eq(expected_hash)
     end
 
     specify '#== and #eql? compare attributes' do
@@ -33,5 +35,10 @@ describe Dbee::Model::Constraints::Reference do
       expect(subject).to eq(object2)
       expect(subject).to eql(object2)
     end
+
+    it 'returns false unless comparing same object types' do
+      expect(subject).not_to eq(config)
+      expect(subject).not_to eq(nil)
+    end
   end
 end

data/spec/dbee/model/constraints/static_spec.rb

@@ -24,7 +24,10 @@ describe Dbee::Model::Constraints::Static do
     end
 
     specify '#hash produces same output as concatenated string hash of name and parent' do
-      expect(subject.hash).to eq("#{config[:name].hash}#{config[:value]}".hash)
+      parent_hash   = "#{described_class.name}#{config[:name]}#{config[:parent]}".hash
+      expected_hash = "#{parent_hash}#{config[:value]}".hash
+
+      expect(subject.hash).to eq(expected_hash)
     end
 
     specify '#== and #eql? compare attributes' do
@@ -33,5 +36,10 @@ describe Dbee::Model::Constraints::Static do
       expect(subject).to eq(object2)
       expect(subject).to eql(object2)
     end
+
+    it 'returns false unless comparing same object types' do
+      expect(subject).not_to eq(config)
+      expect(subject).not_to eq(nil)
+    end
   end
 end

data/spec/dbee/model_spec.rb

@@ -89,16 +89,25 @@ describe Dbee::Model do
 
       expect(plan).to eq(expected_plan)
     end
+  end
 
-    specify 'equality compares attributes' do
-      config = yaml_fixture('models.yaml')['Theaters, Members, and Movies']
+  describe 'equality' do
+    let(:config) { yaml_fixture('models.yaml')['Theaters, Members, and Movies'] }
+
+    subject { described_class.make(config) }
 
+    specify 'equality compares attributes' do
       model1 = described_class.make(config)
       model2 = described_class.make(config)
 
       expect(model1).to eq(model2)
       expect(model1).to eql(model2)
     end
+
+    it 'returns false unless comparing same object types' do
+      expect(subject).not_to eq(config)
+      expect(subject).not_to eq(nil)
+    end
   end
 
   context 'README examples' do

data/spec/dbee/query/field_spec.rb

@@ -38,5 +38,10 @@ describe Dbee::Query::Field do
       expect(subject).to eq(object2)
       expect(subject).to eql(object2)
     end
+
+    it 'returns false unless comparing same object types' do
+      expect(subject).not_to eq('a.b.c')
+      expect(subject).not_to eq(nil)
+    end
   end
 end

data/spec/dbee/query/filters/base_spec.rb

@@ -28,8 +28,9 @@ describe Dbee::Query::Filters::Base do
 
     subject { described_class.new(config) }
 
-    specify '#hash produces same output as concatenated string hash of key_path and value' do
-      expect(subject.hash).to eq("#{config[:key_path]}#{config[:value]}".hash)
+    specify '#hash produces same output as string hash of class name, key_path, and value' do
+      expected_hash = "#{described_class.name}#{config[:key_path]}#{config[:value]}".hash
+      expect(subject.hash).to eq(expected_hash)
     end
 
     specify '#== and #eql? compare attributes' do
@@ -38,5 +39,10 @@ describe Dbee::Query::Filters::Base do
       expect(subject).to eq(object2)
       expect(subject).to eql(object2)
     end
+
+    it 'returns false unless comparing same object types' do
+      expect(subject).not_to eq('a.b.c')
+      expect(subject).not_to eq(nil)
+    end
   end
 end

data/spec/dbee/query/sorters/ascending_spec.rb

@@ -0,0 +1,41 @@
+# 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 Dbee::Query::Sorters::Ascending do
+  context 'equality' do
+    let(:config) do
+      { key_path: 'a.b.c' }
+    end
+
+    subject { described_class.new(config) }
+
+    it 'returns true if instance class and key_paths are equal' do
+      subject2 = described_class.new(config)
+
+      expect(subject).to eq(subject2)
+      expect(subject).to eql(subject2)
+    end
+
+    it 'returns false if instance class is different' do
+      subject2 = Dbee::Query::Sorters::Descending.new(config)
+
+      expect(subject).not_to eq(subject2)
+      expect(subject).not_to eql(subject2)
+    end
+
+    it 'returns false if key_path is different' do
+      subject2 = described_class.new(key_path: 'd.e.f')
+
+      expect(subject).not_to eq(subject2)
+      expect(subject).not_to eql(subject2)
+    end
+  end
+end

data/spec/dbee/query/{sorter_spec.rb → sorters/base_spec.rb}

@@ -9,7 +9,7 @@
 
 require 'spec_helper'
 
-describe Dbee::Query::Sorter do
+describe Dbee::Query::Sorters::Base do
   it 'should act as hashable' do
     expect(described_class).to respond_to(:make)
     expect(described_class).to respond_to(:array)
@@ -24,12 +24,12 @@ describe Dbee::Query::Sorter do
   end
 
   context 'equality' do
-    let(:config) { { key_path: 'a.b.c', direction: :descending } }
+    let(:config) { { key_path: 'a.b.c' } }
 
     subject { described_class.new(config) }
 
-    specify '#hash produces same output as concatenated string hash of key_path and direction' do
-      expect(subject.hash).to eq("#{config[:key_path]}#{config[:direction]}".hash)
+    specify '#hash produces same output as concatenated string hash of class name and key_path' do
+      expect(subject.hash).to eq("#{described_class.name}#{config[:key_path]}".hash)
     end
 
     specify '#== and #eql? compare attributes' do
@@ -38,35 +38,10 @@ describe Dbee::Query::Sorter do
       expect(subject).to eq(object2)
       expect(subject).to eql(object2)
     end
-  end
-
-  describe 'direction helpers' do
-    context 'when direction is ascending' do
-      let(:config) { { key_path: 'a.b.c' } }
-
-      subject { described_class.new(config) }
-
-      it '#ascending? is true' do
-        expect(subject.ascending?).to be true
-      end
-
-      it '#descending? is false' do
-        expect(subject.descending?).to be false
-      end
-    end
-
-    context 'when direction is descending' do
-      let(:config) { { key_path: 'a.b.c', direction: :descending } }
-
-      subject { described_class.new(config) }
-
-      it '#ascending? is false' do
-        expect(subject.ascending?).to be false
-      end
 
-      it '#descending? is true' do
-        expect(subject.descending?).to be true
-      end
+    it 'returns false unless comparing same object types' do
+      expect(subject).not_to eq('a.b.c')
+      expect(subject).not_to eq(nil)
     end
   end
 end

data/spec/dbee/query/sorters/descending_spec.rb

@@ -0,0 +1,41 @@
+# 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 Dbee::Query::Sorters::Descending do
+  context 'equality' do
+    let(:config) do
+      { key_path: 'a.b.c' }
+    end
+
+    subject { described_class.new(config) }
+
+    it 'returns true if instance class and key_paths are equal' do
+      subject2 = described_class.new(config)
+
+      expect(subject).to eq(subject2)
+      expect(subject).to eql(subject2)
+    end
+
+    it 'returns false if instance class is different' do
+      subject2 = Dbee::Query::Sorters::Ascending.new(config)
+
+      expect(subject).not_to eq(subject2)
+      expect(subject).not_to eql(subject2)
+    end
+
+    it 'returns false if key_path is different' do
+      subject2 = described_class.new(key_path: 'd.e.f')
+
+      expect(subject).not_to eq(subject2)
+      expect(subject).not_to eql(subject2)
+    end
+  end
+end

data/spec/dbee/query_spec.rb

@@ -43,6 +43,71 @@ describe Dbee::Query do
     it 'should raise a NoFieldsError if no fields were passed in' do
       expect { described_class.new(fields: []) }.to raise_error(Dbee::Query::NoFieldsError)
     end
+
+    it 'should remove duplicate filters (keep first instance)' do
+      query_hash = {
+        fields: [
+          { key_path: 'a' }
+        ],
+        filters: [
+          { key_path: 'a', value: 'something' },
+          { key_path: 'b', value: 123 },
+          { key_path: 'b', value: '123' },
+          { key_path: 'c', value: nil },
+          { key_path: 'c', value: '' },
+          { key_path: 'd', value: 'r', type: :greater_than_or_equal_to },
+          { key_path: 'd', value: 'r' },
+          { key_path: 'e', value: [1, 2, 3] },
+          { key_path: 'a', value: 'something' },
+          { key_path: 'e', value: [1, 2, 3] }
+        ]
+      }
+
+      expected_filters = Dbee::Query::Filters.array(
+        [
+          { key_path: 'a', value: 'something' },
+          { key_path: 'b', value: 123 },
+          { key_path: 'b', value: '123' },
+          { key_path: 'c', value: nil },
+          { key_path: 'c', value: '' },
+          {
+            key_path: 'd',
+            value: 'r',
+            type: :greater_than_or_equal_to
+          },
+          { key_path: 'd', value: 'r' },
+          { key_path: 'e', value: [1, 2, 3] }
+        ]
+      )
+
+      expect(described_class.make(query_hash).filters).to eq(expected_filters)
+    end
+
+    it 'should remove duplicate sorters (keep first instance)' do
+      query_hash = {
+        fields: [
+          { key_path: 'a' }
+        ],
+        sorters: [
+          { key_path: 'a' },
+          { key_path: 'b' },
+          { key_path: 'c', direction: :descending },
+          { key_path: '1' },
+          { key_path: :a },
+          { key_path: 1 },
+          { key_path: 'c', direction: :descending }
+        ]
+      }
+
+      expected_sorters = Dbee::Query::Sorters.array([
+                                                      { key_path: 'a' },
+                                                      { key_path: 'b' },
+                                                      { key_path: 'c', direction: :descending },
+                                                      { key_path: '1' }
+                                                    ])
+
+      expect(described_class.make(query_hash).sorters).to eq(expected_sorters)
+    end
   end
 
   describe '#key_chain' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbee
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-27 00:00:00.000000000 Z
+date: 2019-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: acts_as_hashable
@@ -178,7 +178,10 @@ files:
 - lib/dbee/query/filters/not_equals.rb
 - lib/dbee/query/filters/not_start_with.rb
 - lib/dbee/query/filters/starts_with.rb
-- lib/dbee/query/sorter.rb
+- lib/dbee/query/sorters.rb
+- lib/dbee/query/sorters/ascending.rb
+- lib/dbee/query/sorters/base.rb
+- lib/dbee/query/sorters/descending.rb
 - lib/dbee/version.rb
 - spec/dbee/base_spec.rb
 - spec/dbee/key_chain_spec.rb
@@ -192,7 +195,9 @@ files:
 - spec/dbee/query/field_spec.rb
 - spec/dbee/query/filters/base_spec.rb
 - spec/dbee/query/filters_spec.rb
-- spec/dbee/query/sorter_spec.rb
+- spec/dbee/query/sorters/ascending_spec.rb
+- spec/dbee/query/sorters/base_spec.rb
+- spec/dbee/query/sorters/descending_spec.rb
 - spec/dbee/query_spec.rb
 - spec/dbee_spec.rb
 - spec/fixtures/models.rb
@@ -234,7 +239,9 @@ test_files:
 - spec/dbee/query/field_spec.rb
 - spec/dbee/query/filters/base_spec.rb
 - spec/dbee/query/filters_spec.rb
-- spec/dbee/query/sorter_spec.rb
+- spec/dbee/query/sorters/ascending_spec.rb
+- spec/dbee/query/sorters/base_spec.rb
+- spec/dbee/query/sorters/descending_spec.rb
 - spec/dbee/query_spec.rb
 - spec/dbee_spec.rb
 - spec/fixtures/models.rb

data/lib/dbee/query/sorter.rb

@@ -1,55 +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 Dbee
-  class Query
-    # Abstract representation of the ORDER BY part of a SQL statement.
-    class Sorter
-      acts_as_hashable
-
-      module Direction
-        ASCENDING = :ascending
-        DESCENDING = :descending
-      end
-      include Direction
-
-      attr_reader :direction, :key_path
-
-      def initialize(key_path:, direction: ASCENDING)
-        raise ArgumentError, 'key_path is required' if key_path.to_s.empty?
-
-        @direction  = Direction.const_get(direction.to_s.upcase.to_sym)
-        @key_path   = KeyPath.get(key_path)
-
-        freeze
-      end
-
-      def descending?
-        direction == DESCENDING
-      end
-
-      def ascending?
-        !descending?
-      end
-
-      def hash
-        "#{key_path}#{direction}".hash
-      end
-
-      def ==(other)
-        other.key_path == key_path && other.direction == direction
-      end
-      alias eql? ==
-
-      def <=>(other)
-        "#{key_path}#{direction}" <=> "#{other.key_path}#{other.direction}"
-      end
-    end
-  end
-end