dbee 1.0.0.pre.alpha

data/lib/dbee/query/key_path.rb

@@ -0,0 +1,54 @@
+# 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
+    # This class represents a relative path from a model to a column.  For example:
+    # Say we have a model called "users" which is represented by a "users" table.
+    # The "users" table also has a one-to-many relationship with a "phone_numbers" table, which
+    # is modeled as a nested model under "users" as "phone_numbers".  Then, to get the column:
+    # "area_code", you would use: "phone_numbers.area_code".
+    # Say the column "name" is located on "users", you could use the key path: "name".
+    # This also works for deeper nested columns in the same fashion.
+    class KeyPath
+      extend Forwardable
+
+      class << self
+        def get(obj)
+          obj.is_a?(self.class) ? obj : new(obj)
+        end
+      end
+
+      SPLIT_CHAR = '.'
+
+      attr_reader :value, :ancestor_names, :column_name
+
+      def_delegators :value, :to_s
+
+      def initialize(value)
+        raise 'Value is required' if value.to_s.empty?
+
+        @value          = value.to_s
+        @ancestor_names = value.to_s.split(SPLIT_CHAR)
+        @column_name    = @ancestor_names.pop
+
+        freeze
+      end
+
+      def hash
+        value.hash
+      end
+
+      def ==(other)
+        other.to_s == to_s
+      end
+      alias eql? ==
+    end
+  end
+end

data/lib/dbee/query/sorter.rb

@@ -0,0 +1,53 @@
+# 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
+    # 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? ==
+    end
+  end
+end

data/lib/dbee/query.rb

@@ -0,0 +1,45 @@
+# 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 'query/field'
+require_relative 'query/filters'
+require_relative 'query/sorter'
+
+module Dbee
+  # This class is an abstration of a simplified SQL expression.  In DB terms:
+  # - fields are the SELECT
+  # - sorters are the ORDER BY
+  # - limit is the TAKE
+  # - filters are the WHERE
+  class Query
+    acts_as_hashable
+
+    attr_reader :fields, :filters, :limit, :sorters
+
+    def initialize(fields: [], filters: [], limit: nil, sorters: [])
+      @fields   = Field.array(fields)
+      @filters  = Filters.array(filters)
+      @limit    = limit.to_s.empty? ? nil : limit.to_i
+      @sorters  = Sorter.array(sorters)
+
+      freeze
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+
+    def eql?(other)
+      other.fields == fields &&
+        other.filters == filters &&
+        other.limit == limit &&
+        other.sorters == sorters
+    end
+  end
+end

data/lib/dbee/version.rb

@@ -0,0 +1,12 @@
+# 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
+  VERSION = '1.0.0-alpha'
+end

data/lib/dbee.rb

@@ -0,0 +1,28 @@
+# 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 'acts_as_hashable'
+require 'forwardable'
+
+require_relative 'dbee/base'
+require_relative 'dbee/model'
+require_relative 'dbee/query'
+require_relative 'dbee/providers'
+
+# Top-level namespace that provides the main public API.
+module Dbee
+  class << self
+    def sql(model, query, provider)
+      model = model.is_a?(Hash) || model.is_a?(Model) ? Model.make(model) : model.to_model
+      query = Query.make(query)
+
+      provider.sql(model, query)
+    end
+  end
+end

data/spec/dbee/base_spec.rb

@@ -0,0 +1,35 @@
+# 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'
+require 'fixtures/models'
+
+describe Dbee::Base do
+  it 'compiles to Model instance correctly' do
+    model_name      = 'Theaters, Members, and Movies'
+    expected_config = yaml_fixture('models.yaml')[model_name]
+
+    expected_model = Dbee::Model.make(expected_config)
+
+    expect(Models::Theaters.to_model).to eq(expected_model)
+  end
+
+  context 'inheritance' do
+    specify 'table is honored if set on subclass' do
+      expect(Models::A.inherited_table_name).to eq('table_set_to_a')
+      expect(Models::B.inherited_table_name).to eq('table_set_to_b')
+    end
+
+    specify 'table is honored if set on parent' do
+      expect(Models::C.inherited_table_name).to eq('table_set_to_a')
+      expect(Models::D.inherited_table_name).to eq('table_set_to_a')
+      expect(Models::E.inherited_table_name).to eq('table_set_to_e')
+    end
+  end
+end

data/spec/dbee/model/constraints/base_spec.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 'spec_helper'
+
+describe Dbee::Model::Constraints::Base do
+  it 'should act as hashable' do
+    expect(described_class).to respond_to(:make)
+    expect(described_class).to respond_to(:array)
+  end
+
+  context '#initialize' do
+    specify 'name is required' do
+      expect { described_class.new(name: '') }.to raise_error(ArgumentError)
+      expect { described_class.new(name: nil) }.to  raise_error(ArgumentError)
+      expect { described_class.new }.to             raise_error(ArgumentError)
+    end
+  end
+
+  context 'equality' do
+    let(:config) { { name: 'type' } }
+
+    subject { described_class.new(config) }
+
+    specify '#hash produces same output as string hash of name' do
+      expect(subject.hash).to eq(config[:name].to_s.hash)
+    end
+
+    specify '#== and #eql? compares attributes' do
+      object2 = described_class.new(config)
+
+      expect(subject).to eq(object2)
+      expect(subject).to eql(object2)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# 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::Model::Constraints::Reference do
+  context '#initialize' do
+    specify 'parent is required' do
+      expect { described_class.new(name: 'a', parent: '') }.to  raise_error(ArgumentError)
+      expect { described_class.new(name: 'a', parent: nil) }.to raise_error(ArgumentError)
+      expect { described_class.new(name: 'a') }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'equality' do
+    let(:config) { { name: 'id', parent: 'patient_id' } }
+
+    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].hash}#{config[:parent]}".hash)
+    end
+
+    specify '#== and #eql? compare attributes' do
+      object2 = described_class.new(config)
+
+      expect(subject).to eq(object2)
+      expect(subject).to eql(object2)
+    end
+  end
+end

data/spec/dbee/model/constraints/static_spec.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 'spec_helper'
+
+describe Dbee::Model::Constraints::Static do
+  context 'equality' do
+    let(:config) { { name: 'type', value: 'general' } }
+
+    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].hash}#{config[:value]}".hash)
+    end
+
+    specify '#== and #eql? compare attributes' do
+      object2 = described_class.new(config)
+
+      expect(subject).to eq(object2)
+      expect(subject).to eql(object2)
+    end
+  end
+end

data/spec/dbee/model/constraints_spec.rb

@@ -0,0 +1,25 @@
+# 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::Model::Constraints do
+  CONFIG = { name: :a }.freeze
+
+  FACTORIES = {
+    Dbee::Model::Constraints::Reference => CONFIG.merge(parent: :b, type: :reference),
+    Dbee::Model::Constraints::Static => CONFIG.merge(value: :b, type: :static)
+  }.freeze
+
+  FACTORIES.each_pair do |constant, config|
+    it "should instantiate #{constant} objects" do
+      expect(described_class.make(config)).to be_a(constant)
+    end
+  end
+end

data/spec/dbee/model_spec.rb

@@ -0,0 +1,113 @@
+# 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'
+require 'fixtures/models'
+
+describe Dbee::Model do
+  describe '#initialize' do
+    specify 'name is set properly' do
+      config = { name: 'theaters' }
+
+      model = described_class.make(config)
+
+      expect(model.name).to eq(config[:name])
+    end
+
+    specify 'table defaults to name' do
+      config = { name: 'theaters' }
+
+      model = described_class.make(config)
+
+      expect(model.table).to eq(config[:name])
+    end
+
+    specify 'table can be explicitly set' do
+      config = { name: 'favorite_comedy_movies', table: 'movies' }
+
+      model = described_class.make(config)
+
+      expect(model.table).to eq(config[:table])
+    end
+
+    specify 'models are set properly' do
+      config = {
+        name: 'theaters',
+        models: [
+          { name: 'members' },
+          { name: 'passes' }
+        ]
+      }
+
+      expected_association_names = config[:models].map { |a| a[:name] }
+
+      model = described_class.make(config)
+
+      association_names = model.models.map(&:name)
+
+      expect(association_names).to eq(expected_association_names)
+    end
+  end
+
+  describe '#ancestors' do
+    let(:yaml_entities) { yaml_fixture('models.yaml') }
+
+    let(:entity_hash) { yaml_entities['Theaters, Members, and Movies'] }
+
+    subject { described_class.make(entity_hash) }
+
+    specify 'returns proper models' do
+      members = subject.models.first
+
+      expected_plan = {
+        'members' => members
+      }
+
+      plan = subject.ancestors(%w[members])
+
+      expect(plan).to eq(expected_plan)
+    end
+
+    specify 'returns proper multi-level models' do
+      members       = subject.models.first
+      demos         = members.models.first
+      phone_numbers = demos.models.first
+
+      expected_plan = {
+        'members' => members,
+        'members.demos' => demos,
+        'members.demos.phone_numbers' => phone_numbers
+      }
+
+      plan = subject.ancestors(%w[members demos phone_numbers])
+
+      expect(plan).to eq(expected_plan)
+    end
+
+    specify 'equality compares attributes' do
+      config = yaml_fixture('models.yaml')['Theaters, Members, and Movies']
+
+      model1 = described_class.make(config)
+      model2 = described_class.make(config)
+
+      expect(model1).to eq(model2)
+      expect(model1).to eql(model2)
+    end
+  end
+
+  context 'README examples' do
+    specify 'code-first and configuration-first models are equal' do
+      config = yaml_fixture('models.yaml')['Readme']
+
+      config_model = described_class.make(config)
+
+      expect(config_model).to eq(ReadmeDataModels::Practices.to_model)
+    end
+  end
+end

data/spec/dbee/providers/null_provider_spec.rb

@@ -0,0 +1,22 @@
+# 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::Providers::NullProvider do
+  specify '#sql returns SELECT NULL' do
+    provider  = described_class.new
+    model     = { name: 'something' }
+    query     = {}
+
+    actual_sql = provider.sql(model, query)
+
+    expect(actual_sql).to eq('SELECT NULL')
+  end
+end

data/spec/dbee/query/field_spec.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 'spec_helper'
+
+describe Dbee::Query::Field do
+  it 'should act as hashable' do
+    expect(described_class).to respond_to(:make)
+    expect(described_class).to respond_to(:array)
+  end
+
+  context '#initialize' do
+    specify 'key_path is required' do
+      expect { described_class.new(key_path: '') }.to   raise_error(ArgumentError)
+      expect { described_class.new(key_path: nil) }.to  raise_error(ArgumentError)
+      expect { described_class.new }.to                 raise_error(ArgumentError)
+    end
+  end
+
+  context 'equality' do
+    let(:config) { { key_path: 'a.b.c', display: 'd' } }
+
+    subject { described_class.new(config) }
+
+    specify '#hash produces same output as concatenated string hash of key_path and display' do
+      expect(subject.hash).to eq("#{config[:key_path]}#{config[:display]}".hash)
+    end
+
+    specify '#== and #eql? compare attributes' do
+      object2 = described_class.new(config)
+
+      expect(subject).to eq(object2)
+      expect(subject).to eql(object2)
+    end
+  end
+end

data/spec/dbee/query/filters/base_spec.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 'spec_helper'
+
+describe Dbee::Query::Filters::Base do
+  it 'should act as hashable' do
+    expect(described_class).to respond_to(:make)
+    expect(described_class).to respond_to(:array)
+  end
+
+  context '#initialize' do
+    specify 'key_path is required' do
+      expect { described_class.new(key_path: '') }.to   raise_error(ArgumentError)
+      expect { described_class.new(key_path: nil) }.to  raise_error(ArgumentError)
+      expect { described_class.new }.to                 raise_error(ArgumentError)
+    end
+  end
+
+  context 'equality' do
+    let(:config) { { key_path: 'a.b.c', value: '123' } }
+
+    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)
+    end
+
+    specify '#== and #eql? compare attributes' do
+      object2 = described_class.new(config)
+
+      expect(subject).to eq(object2)
+      expect(subject).to eql(object2)
+    end
+  end
+end

data/spec/dbee/query/filters_spec.rb

@@ -0,0 +1,33 @@
+# 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::Filters do
+  CONFIG = { key_path: 'a.b.c', value: :d }.freeze
+
+  FACTORIES = {
+    Dbee::Query::Filters::Contains => CONFIG.merge(type: :contains),
+    Dbee::Query::Filters::Equals => CONFIG.merge(type: :equals),
+    Dbee::Query::Filters::GreaterThanOrEqualTo => CONFIG.merge(type: :greater_than_or_equal_to),
+    Dbee::Query::Filters::GreaterThan => CONFIG.merge(type: :greater_than),
+    Dbee::Query::Filters::LessThanOrEqualTo => CONFIG.merge(type: :less_than_or_equal_to),
+    Dbee::Query::Filters::LessThan => CONFIG.merge(type: :less_than),
+    Dbee::Query::Filters::NotContain => CONFIG.merge(type: :not_contain),
+    Dbee::Query::Filters::NotEquals => CONFIG.merge(type: :not_equals),
+    Dbee::Query::Filters::NotStartWith => CONFIG.merge(type: :not_start_with),
+    Dbee::Query::Filters::StartsWith => CONFIG.merge(type: :starts_with)
+  }.freeze
+
+  FACTORIES.each_pair do |constant, config|
+    it "should instantiate #{constant} objects" do
+      expect(described_class.make(config)).to be_a(constant)
+    end
+  end
+end

data/spec/dbee/query/key_path_spec.rb

@@ -0,0 +1,35 @@
+# 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::KeyPath do
+  let(:key_path_string) { 'contacts.demographics.first' }
+
+  subject { described_class.get(key_path_string) }
+
+  specify '#initialize sets correct values' do
+    expect(subject.value).to          eq(key_path_string)
+    expect(subject.column_name).to    eq(key_path_string.split('.').last)
+    expect(subject.ancestor_names).to eq(key_path_string.split('.')[0..-2])
+  end
+
+  specify '#hash is same as value.hash' do
+    expect(subject.hash).to eq(key_path_string.hash)
+  end
+
+  specify '#to_s is same as value' do
+    expect(subject.to_s).to eq(key_path_string)
+  end
+
+  specify 'equality compares to value' do
+    expect(subject).to eq(key_path_string)
+    expect(subject).to eql(key_path_string)
+  end
+end