clearly-query 0.3.1.pre

data/spec/lib/clearly/query/definition_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Clearly::Query::Definition do
+  include_context 'shared_setup'
+
+  it 'is not valid with nil model' do
+    expect {
+      Clearly::Query::Definition.new({hash: Customer.clearly_query_def})
+    }.to raise_error(Clearly::Query::QueryArgumentError, 'could not build definition from options')
+  end
+
+  it 'is not valid with nil hash' do
+    expect {
+      Clearly::Query::Definition.new({model: Customer})
+    }.to raise_error(Clearly::Query::QueryArgumentError, "value must not be empty, got ''")
+  end
+
+  it 'can be instantiated' do
+    Clearly::Query::Definition.new({model:Customer, hash: Customer.clearly_query_def})
+  end
+
+
+end

data/spec/lib/clearly/query/graph_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Clearly::Query::Graph do
+  include_context 'shared_setup'
+
+  context 'creates the expected branch when' do
+    it 'maps customer associations' do
+      association_graph = {join: customer_def.model, on: nil, associations: customer_def.associations}
+      graph = Clearly::Query::Graph.new(association_graph, :associations)
+      result = graph.branches
+
+      expect(result.size).to eq(1)
+      expect(result[0].size).to eq(6)
+
+      expect(result[0][0][:join]).to eq(Customer)
+      expect(result[0][1][:join]).to eq(Order)
+      expect(result[0][2][:join]).to eq(Arel::Table.new(:orders_products))
+      expect(result[0][3][:join]).to eq(Product)
+      expect(result[0][4][:join]).to eq(Arel::Table.new(:parts_products))
+      expect(result[0][5][:join]).to eq(Part)
+    end
+
+    it 'maps order associations' do
+      association_graph = {join: order_def.model, on: nil, associations: order_def.associations}
+      graph = Clearly::Query::Graph.new(association_graph, :associations)
+      result = graph.branches
+
+      expect(result.size).to eq(2)
+
+      expect(result[0].size).to eq(2)
+      expect(result[1].size).to eq(5)
+
+      expect(result[0][0][:join]).to eq(Order)
+      expect(result[0][1][:join]).to eq(Customer)
+
+      expect(result[1][0][:join]).to eq(Order)
+      expect(result[1][1][:join]).to eq(Arel::Table.new(:orders_products))
+      expect(result[1][2][:join]).to eq(Product)
+      expect(result[1][3][:join]).to eq(Arel::Table.new(:parts_products))
+      expect(result[1][4][:join]).to eq(Part)
+    end
+
+    it 'maps part associations' do
+      association_graph = {join: part_def.model, on: nil, associations: part_def.associations}
+      graph = Clearly::Query::Graph.new(association_graph, :associations)
+      result = graph.branches
+
+      expect(result.size).to eq(1)
+      expect(result[0].size).to eq(6)
+
+      expect(result[0][5][:join]).to eq(Customer)
+      expect(result[0][4][:join]).to eq(Order)
+      expect(result[0][3][:join]).to eq(Arel::Table.new(:orders_products))
+      expect(result[0][2][:join]).to eq(Product)
+      expect(result[0][1][:join]).to eq(Arel::Table.new(:parts_products))
+      expect(result[0][0][:join]).to eq(Part)
+    end
+
+    it 'maps product associations' do
+      association_graph = {join: product_def.model, on: nil, associations: product_def.associations}
+      graph = Clearly::Query::Graph.new(association_graph, :associations)
+      result = graph.branches
+
+      expect(result.size).to eq(2)
+
+      expect(result[0].size).to eq(4)
+      expect(result[1].size).to eq(3)
+
+      expect(result[0][0][:join]).to eq(Product)
+      expect(result[0][1][:join]).to eq(Arel::Table.new(:orders_products))
+      expect(result[0][2][:join]).to eq(Order)
+      expect(result[0][3][:join]).to eq(Customer)
+
+      expect(result[1][0][:join]).to eq(Product)
+      expect(result[1][1][:join]).to eq(Arel::Table.new(:parts_products))
+      expect(result[1][2][:join]).to eq(Part)
+    end
+
+  end
+
+end

data/spec/lib/clearly/query/helper_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Clearly::Query::Helper do
+  include_context 'shared_setup'
+
+  it 'raises error with one argument for infix operator' do
+    expect {
+      Clearly::Query::Helper.string_concat_infix('+', 'test')
+    }.to raise_error(ArgumentError,"string concatenation requires operator and two or more arguments, given '1'")
+  end
+
+  it 'raises error with no arguments for infix operator' do
+    expect {
+      Clearly::Query::Helper.string_concat_infix('+')
+    }.to raise_error(ArgumentError,"string concatenation requires operator and two or more arguments, given '0'")
+  end
+end

data/spec/lib/clearly/query/version_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Clearly::Query do
+  it 'has a version number' do
+    expect(Clearly::Query::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,89 @@
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
+
+require 'simplecov'
+
+# start code coverage
+SimpleCov.start
+
+require 'active_record'
+require 'sqlite3'
+require 'logger'
+require 'zonebie'
+require 'database_cleaner'
+
+include ActiveRecord::Tasks
+
+require 'clearly/query'
+
+# include supporting files
+Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each { |file| require file }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:expect]
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  # Zonebie can set this to a random timezone at the beginning of test runs.
+  # Specifically for Active Support, it sets Time.zone.
+  Zonebie.set_random_timezone
+
+  app_root = File.expand_path('../..', __FILE__)
+  rspec_root = File.join(app_root, 'spec')
+  support_root = File.join(rspec_root, 'support')
+  db_root = File.join(support_root, 'db')
+  migrations_path = File.join(db_root, 'migrate')
+  test_db_path = File.join(app_root, 'tmp', 'db', 'test.sqlite3')
+
+  # if test database exists, delete it
+  File.delete(test_db_path) if File.exist?(test_db_path)
+
+  # configure database
+  DatabaseTasks.env = 'test'
+  DatabaseTasks.database_configuration = {
+      'test' => {
+          adapter: :sqlite3,
+          database: test_db_path,
+          pool: 5,
+          timeout: 5000
+      }
+  }
+  DatabaseTasks.db_dir = File.join rspec_root, 'db'
+  #DatabaseTasks.fixtures_path = File.join root, 'test/fixtures'
+  DatabaseTasks.migrations_paths = [migrations_path]
+  #DatabaseTasks.seed_loader = Seeder.new File.join root, 'db/seeds.rb'
+  DatabaseTasks.root = rspec_root
+
+  # Set the logger for active record
+  ActiveRecord::Base.logger = Logger.new(File.join('tmp', 'debug.activerecord.log'))
+
+  # configure ActiveRecord database
+  ActiveRecord::Base.configurations = DatabaseTasks.database_configuration
+
+  # Connect to db for environment
+  ActiveRecord::Base.establish_connection DatabaseTasks.env.to_sym
+
+  # run migrations
+  ActiveRecord::Migrator.migrate(migrations_path)
+
+  #load 'active_record/railties/databases.rake'
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+end

data/spec/support/db/migrate/001_db_create.rb

@@ -0,0 +1,62 @@
+class DbCreate < ActiveRecord::Migration
+  def change
+    create_table :customers do |t|
+      t.string        :name,            null: false
+      t.datetime      :last_contact_at, null: false
+      t.timestamps null: false
+    end
+
+    create_table :orders do |t|
+      t.datetime      :shipped_at,  null: true
+      t.integer       :customer_id, null: false
+      t.timestamps null: false
+    end
+
+    add_foreign_key :orders, :customers
+
+    create_table :products do |t|
+      t.string        :name,            null: false
+      t.string        :code,            null: false
+      t.string        :brand,           null: false
+      t.datetime      :introduced_at,   null: false
+      t.datetime      :discontinued_at, null: true
+      t.timestamps null: false
+    end
+
+    create_table :orders_products, id: false do |t|
+      t.integer :order_id, null: false
+      t.integer :product_id, null: false
+      t.timestamps null: false
+    end
+
+    add_foreign_key :orders_products, :customers
+    add_foreign_key :orders_products, :orders
+
+    create_table :parts do |t|
+      t.string        :name,            null: false
+      t.string        :code,            null: false
+      t.string        :manufacturer,    null: false
+      t.timestamps null: false
+    end
+
+    create_table :parts_products, id: false do |t|
+      t.integer :product_id, null: false
+      t.integer :part_id,    null: false
+      t.timestamps null: false
+    end
+
+    add_foreign_key :parts_products, :products
+    add_foreign_key :parts_products, :parts
+
+    add_index :customers, :name, unique: true
+
+    add_index :products, :name, unique: true
+    add_index :products, :code, unique: true
+
+    add_index :parts, :name, unique: true
+    add_index :parts, :code, unique: true
+
+    add_index :parts_products, [:product_id, :part_id], unique: true
+
+  end
+end

data/spec/support/models/customer.rb

@@ -0,0 +1,63 @@
+require 'active_record'
+
+class Customer < ActiveRecord::Base
+
+  has_many :orders, inverse_of: :customer
+
+  def self.clearly_query_def
+    {
+        fields: {
+            valid: [:name, :last_contact_at],
+            text: [:name],
+            mappings: [
+                {
+                    name: :title,
+                    value: Clearly::Query::Helper.string_concat(
+                        Customer.arel_table[:name],
+                        Arel::Nodes.build_quoted(' title'))
+                }
+            ]
+        },
+        associations: [
+            {
+                join: Order,
+                on: Order.arel_table[:customer_id].eq(Customer.arel_table[:id]),
+                available: true,
+                associations: [
+                    {
+                        join: Arel::Table.new(:orders_products),
+                        on: Order.arel_table[:id].eq(Arel::Table.new(:orders_products)[:order_id]),
+                        available: false,
+                        associations: [
+                            {
+                                join: Product,
+                                on: Product.arel_table[:id].eq(Arel::Table.new(:orders_products)[:product_id]),
+                                available: true,
+                                associations: [
+                                    {
+                                        join: Arel::Table.new(:parts_products),
+                                        on: Product.arel_table[:id].eq(Arel::Table.new(:parts_products)[:product_id]),
+                                        available: false,
+                                        associations: [
+                                            {
+                                                join: Part,
+                                                on: Part.arel_table[:id].eq(Arel::Table.new(:parts_products)[:part_id]),
+                                                available: true,
+                                                associations: []
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            }
+        ],
+        defaults: {
+            order_by: :created_at,
+            direction: :desc
+        }
+    }
+  end
+end

data/spec/support/models/order.rb

@@ -0,0 +1,66 @@
+require 'active_record'
+
+class Order < ActiveRecord::Base
+
+  belongs_to :customer, inverse_of: :orders
+  has_and_belongs_to_many :products
+
+  def self.clearly_query_def
+    {
+        fields: {
+            valid: [:title, :shipped_at],
+            text: [:title],
+            mappings: [
+                {
+                    name: :title,
+                    value: Clearly::Query::Helper.string_concat(
+                        Customer.arel_table
+                            .where(Customer.arel_table[:id].eq(Order.arel_table[:customer_id]))
+                            .project(Customer.arel_table[:name]),
+                        Arel::Nodes.build_quoted(' ('),
+                        Arel::Nodes::SqlLiteral.new('CASE WHEN "orders"."shipped_at" IS NULL THEN \'not shipped\' ELSE "orders"."shipped_at" END'),
+                        Arel::Nodes.build_quoted(')'))
+                }
+            ]
+        },
+        associations: [
+            {
+                join: Customer,
+                on: Customer.arel_table[:id].eq(Order.arel_table[:customer_id]),
+                available: true
+            },
+            {
+                join: Arel::Table.new(:orders_products),
+                on: Order.arel_table[:id].eq(Arel::Table.new(:orders_products)[:order_id]),
+                available: false,
+                associations: [
+                    {
+                        join: Product,
+                        on: Product.arel_table[:id].eq(Arel::Table.new(:orders_products)[:product_id]),
+                        available: true,
+                        associations: [
+                            {
+                                join: Arel::Table.new(:parts_products),
+                                on: Product.arel_table[:id].eq(Arel::Table.new(:parts_products)[:product_id]),
+                                available: false,
+                                associations: [
+                                    {
+                                        join: Part,
+                                        on: Part.arel_table[:id].eq(Arel::Table.new(:parts_products)[:part_id]),
+                                        available: true,
+                                        associations: []
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            }
+        ],
+        defaults: {
+            order_by: :created_at,
+            direction: :desc
+        }
+    }
+  end
+end

data/spec/support/models/part.rb

@@ -0,0 +1,63 @@
+require 'active_record'
+
+class Part < ActiveRecord::Base
+
+  has_and_belongs_to_many :products
+
+  def self.clearly_query_def
+    {
+        fields: {
+            valid: [:title, :name, :code, :manufacturer],
+            text: [:title, :name, :code, :manufacturer],
+            mappings: [
+                {
+                    name: :title,
+                    value: Clearly::Query::Helper.string_concat(
+                        Part.arel_table[:code],
+                        Arel::Nodes.build_quoted(' '),
+                        Part.arel_table[:manufacturer])
+                }
+            ]
+        },
+        associations: [
+            {
+                join: Arel::Table.new(:parts_products),
+                on: Product.arel_table[:id].eq(Arel::Table.new(:parts_products)[:product_id]),
+                available: false,
+                associations: [
+                    {
+                        join: Product,
+                        on: Product.arel_table[:id].eq(Arel::Table.new(:orders_products)[:product_id]),
+                        available: true,
+                        associations: [
+                            {
+                                join: Arel::Table.new(:orders_products),
+                                on: Order.arel_table[:id].eq(Arel::Table.new(:orders_products)[:order_id]),
+                                available: false,
+                                associations: [
+                                    {
+                                        join: Order,
+                                        on: Order.arel_table[:customer_id].eq(Customer.arel_table[:id]),
+                                        available: true,
+                                        associations: [
+                                            {
+                                                join: Customer,
+                                                on: Customer.arel_table[:id].eq(Order.arel_table[:customer_id]),
+                                                available: true
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            }
+        ],
+        defaults: {
+            order_by: :name,
+            direction: :asc
+        }
+    }
+  end
+end