dbee 1.0.0.pre.alpha

data/lib/dbee/base.rb

@@ -0,0 +1,109 @@
+# 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
+  # Instead of using the configuration-first approach, you could use this super class for
+  # Model declaration.
+  class Base
+    class << self
+      def table(name)
+        @table_name = name.to_s
+
+        self
+      end
+
+      def association(name, opts = {})
+        associations_by_name[name.to_s] = opts.merge(name: name)
+
+        self
+      end
+
+      def to_model(name = nil, constraints = [])
+        name  = derive_name(name)
+        key   = [name, constraints]
+
+        to_models[key] ||= Model.make(model_config(name, constraints))
+      end
+
+      def table_name
+        @table_name.to_s
+      end
+
+      def associations_by_name
+        @associations_by_name ||= {}
+      end
+
+      def inherited_table_name
+        subclasses.each do |subclass|
+          return subclass.table_name unless subclass.table_name.empty?
+        end
+
+        ''
+      end
+
+      def inherited_associations_by_name
+        reversed_subclasses.each_with_object({}) do |subclass, memo|
+          memo.merge!(subclass.associations_by_name)
+        end
+      end
+
+      private
+
+      def subclasses
+        ancestors.select { |a| a < Dbee::Base }
+      end
+
+      def reversed_subclasses
+        subclasses.reverse
+      end
+
+      def model_config(name, constraints)
+        {
+          constraints: constraints,
+          models: associations,
+          name: name,
+          table: derive_table
+        }
+      end
+
+      def derive_name(name)
+        name.to_s.empty? ? inflected_name : name.to_s
+      end
+
+      def derive_table
+        inherited_table = inherited_table_name
+
+        inherited_table.empty? ? inflected_name : inherited_table
+      end
+
+      def associations
+        inherited_associations_by_name.values.each_with_object([]) do |config, memo|
+          model_klass             = config[:model]
+          associated_constraints  = config[:constraints]
+          name                    = config[:name]
+
+          memo << model_klass.to_model(name, associated_constraints)
+        end
+      end
+
+      def to_models
+        @to_models ||= {}
+      end
+
+      def inflected_name
+        name.split('::')
+            .last
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# 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 Model
+    class Constraints
+      # Base class for all constraints.
+      class Base
+        acts_as_hashable
+
+        attr_reader :name
+
+        def initialize(name:)
+          raise ArgumentError, 'name is required' if name.to_s.empty?
+
+          @name = name.to_s
+        end
+
+        def hash
+          name.hash
+        end
+
+        def ==(other)
+          other.name == name
+        end
+        alias eql? ==
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# 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 Model
+    class Constraints
+      # A Reference constraint is a constraint between two data models.  In DB terms:
+      # the name represents the column name on the child and the parent represents the
+      # column name on the parent table.
+      class Reference < Base
+        attr_reader :parent
+
+        def initialize(name:, parent:)
+          super(name: name)
+
+          raise ArgumentError, 'parent is required' if parent.to_s.empty?
+
+          @parent = parent.to_s
+
+          freeze
+        end
+
+        def hash
+          "#{super}#{parent}".hash
+        end
+
+        def ==(other)
+          super && other.parent == parent
+        end
+        alias eql? ==
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# 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 Model
+    class Constraints
+      # A static constraint is a equality constraint on a child column to a static value.
+      # It is usually used in conjunction with a ReferenceConstraint, further giving it more
+      # scoping.
+      class Static < Base
+        attr_reader :value
+
+        def initialize(name:, value: nil)
+          super(name: name)
+
+          @value = value
+
+          freeze
+        end
+
+        def hash
+          "#{super}#{value}".hash
+        end
+
+        def ==(other)
+          super && other.value == value
+        end
+        alias eql? ==
+      end
+    end
+  end
+end

data/lib/dbee/model/constraints.rb

@@ -0,0 +1,26 @@
+# 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 'constraints/reference'
+require_relative 'constraints/static'
+
+module Dbee
+  class Model
+    # Top-level class that allows for the making of constraints.  For example,
+    # you can call this as:
+    # - Constraints.make(type: :reference, name: :id, parent: some_id)
+    # - Constraints.make(type: :static, name: :genre, value: :comedy)
+    class Constraints
+      acts_as_hashable_factory
+
+      register 'reference', Reference
+      register 'static',    Static
+    end
+  end
+end

data/lib/dbee/model.rb

@@ -0,0 +1,79 @@
+# 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 'model/constraints'
+
+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
+    acts_as_hashable
+
+    JOIN_CHAR = '.'
+
+    class ModelNotFound < StandardError; end
+
+    attr_reader :constraints, :name
+
+    def initialize(name:, constraints: [], models: [], table: '')
+      raise ArgumentError, 'name is required' if name.to_s.empty?
+
+      @name             = name.to_s
+      @constraints      = Constraints.array(constraints)
+      @models_by_name   = name_hash(Model.array(models))
+      @table            = table.to_s
+
+      freeze
+    end
+
+    def name_hash(array)
+      array.map { |a| [a.name, a] }.to_h
+    end
+
+    def table
+      @table.to_s.empty? ? name : @table
+    end
+
+    def models
+      models_by_name.values
+    end
+
+    def ancestors(parts = [], alias_chain = [], found = {})
+      return found if Array(parts).empty?
+
+      alias_chain = [] if Array(alias_chain).empty?
+
+      model_name = parts.first
+
+      model = models_by_name[model_name.to_s]
+
+      raise ModelNotFound, "Cannot traverse: #{model_name}" unless model
+
+      new_alias_chain = alias_chain + [model_name]
+
+      new_alias = new_alias_chain.join(JOIN_CHAR)
+
+      found[new_alias] = model
+
+      model.ancestors(parts[1..-1], new_alias_chain, found)
+    end
+
+    def ==(other)
+      other.name == name &&
+        other.table == table &&
+        other.models == models &&
+        other.constraints == constraints
+    end
+    alias eql? ==
+
+    private
+
+    attr_reader :models_by_name
+  end
+end

data/lib/dbee/providers/null_provider.rb

@@ -0,0 +1,21 @@
+# 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
+  module Providers
+    # Default stand-in provider that ships with Dbee.  The main use-case would be to plug in a
+    # provider or provide your own implementation.  There really is no real-world use
+    # of this provider.
+    class NullProvider
+      def sql(_model, _query)
+        'SELECT NULL'
+      end
+    end
+  end
+end

data/lib/dbee/providers.rb

@@ -0,0 +1,10 @@
+# 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 'providers/null_provider'

data/lib/dbee/query/field.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_relative 'key_path'
+
+module Dbee
+  class Query
+    # This class is an abstraction of the SELECT part of a SQL statement.
+    # The key_path is the relative path to the column while the display is the AS part of the
+    # SQL SELECT statement.
+    class Field
+      acts_as_hashable
+
+      attr_reader :key_path, :display
+
+      def initialize(key_path:, display: nil)
+        raise ArgumentError, 'key_path is required' if key_path.to_s.empty?
+
+        @key_path = KeyPath.get(key_path)
+        @display = (display.to_s.empty? ? key_path : display).to_s
+
+        freeze
+      end
+
+      def hash
+        "#{key_path}#{display}".hash
+      end
+
+      def ==(other)
+        other.key_path == key_path && other.display == display
+      end
+      alias eql? ==
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# 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 Filters
+      # Defines the shared implementation for all filters.
+      class Base
+        acts_as_hashable
+
+        attr_reader :key_path, :value
+
+        def initialize(key_path:, value: nil)
+          raise ArgumentError, 'key_path is required' if key_path.to_s.empty?
+
+          @key_path = KeyPath.get(key_path)
+          @value    = value
+
+          freeze
+        end
+
+        def hash
+          "#{key_path}#{value}".hash
+        end
+
+        def ==(other)
+          other.key_path == key_path && other.value == value
+        end
+        alias eql? ==
+      end
+    end
+  end
+end

data/lib/dbee/query/filters/contains.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 Filters
+      # Equivalent to a SQL x LIKE '%value%' statement.
+      class Contains < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/equals.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 Filters
+      # Equivalent to a SQL WHERE x = 'y' statement.
+      class Equals < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/greater_than.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 Filters
+      # Equivalent to a SQL x > 123 statement.
+      class GreaterThan < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/greater_than_or_equal_to.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 Filters
+      # Equivalent to a SQL x >= 123 statement.
+      class GreaterThanOrEqualTo < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/less_than.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 Filters
+      # Equivalent to a SQL x < 123 statement.
+      class LessThan < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/less_than_or_equal_to.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 Filters
+      # Equivalent to a SQL x <= 123 statement.
+      class LessThanOrEqualTo < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/not_contain.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 Filters
+      # Equivalent to a SQL x NOT LIKE '%value%' statement.
+      class NotContain < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/not_equals.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 Filters
+      # Equivalent to a SQL WHERE x != 'y' statement.
+      class NotEquals < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/not_start_with.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 Filters
+      # Equivalent to a SQL x NOT LIKE 'value%' statement.
+      class NotStartWith < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters/starts_with.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 Filters
+      # Equivalent to a SQL x LIKE 'value%' statement.
+      class StartsWith < Base; end
+    end
+  end
+end

data/lib/dbee/query/filters.rb

@@ -0,0 +1,40 @@
+# 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 'filters/contains'
+require_relative 'filters/equals'
+require_relative 'filters/greater_than_or_equal_to'
+require_relative 'filters/greater_than'
+require_relative 'filters/less_than_or_equal_to'
+require_relative 'filters/less_than'
+require_relative 'filters/not_contain'
+require_relative 'filters/not_equals'
+require_relative 'filters/not_start_with'
+require_relative 'filters/starts_with'
+
+module Dbee
+  class Query
+    # Top-level class that allows for the making of filters.  For example, you can call this as:
+    # - Filters.make(type: :contains, value: 'something')
+    class Filters
+      acts_as_hashable_factory
+
+      register 'contains',                  Contains
+      register 'equals',                    Equals
+      register 'greater_than_or_equal_to',  GreaterThanOrEqualTo
+      register 'greater_than',              GreaterThan
+      register 'less_than_or_equal_to',     LessThanOrEqualTo
+      register 'less_than',                 LessThan
+      register 'not_contain',               NotContain
+      register 'not_equals',                NotEquals
+      register 'not_start_with',            NotStartWith
+      register 'starts_with',               StartsWith
+    end
+  end
+end