spectacles 6.0.0 → 7.0.0

data/specs/adapters/postgresql_adapter_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-
-describe "Spectacles::SchemaStatements::PostgreSQLAdapter" do
-  config = {
-    :adapter => "postgresql",
-    :host => "localhost",
-    :username => "postgres",
-    :database => "postgres",
-    :min_messages => "error"
-  }
-  configure_database(config)
-  recreate_database("spectacles_test")
-  load_schema
-
-  it_behaves_like "an adapter", "PostgreSQLAdapter"
-  it_behaves_like "a view model"
-
-  test_base = Class.new do
-    extend Spectacles::SchemaStatements::PostgreSQLAdapter
-    def self.schema_search_path; ""; end
-    def self.select_value(_, _); "\"products\""; end;
-    def self.quote_table_name(name); name; end
-    def self.quote_column_name(name); name; end
-  end
-
-  describe "#view_build_query" do
-    it "should escape double-quotes returned by Postgres" do
-      _(test_base.view_build_query(:new_product_users)).must_match(/\\"/)
-    end
-  end
-
-  describe "#materialized_views" do
-    it "should support materialized views" do
-      _(test_base.supports_materialized_views?).must_equal true
-    end
-  end
-
-  describe "#create_materialized_view_statement" do
-    it "should work with no options" do
-      query = test_base.create_materialized_view_statement(:view_name, "select_query_here")
-      _(query).must_match(/create materialized view view_name as select_query_here with data/i)
-    end
-
-    it "should allow column names to be specified" do
-      query = test_base.create_materialized_view_statement(:view_name, "select_query_here",
-        columns: %i(first second third))
-      _(query).must_match(/create materialized view view_name \(first,second,third\) as select_query_here with data/i)
-    end
-
-    it "should allow storage parameters to be specified" do
-      query = test_base.create_materialized_view_statement(:view_name, "select_query_here",
-        storage: { bats_in_belfry: true, max_wingspan: 15 })
-      _(query).must_match(/create materialized view view_name with \(bats_in_belfry=true, max_wingspan=15\) as select_query_here with data/i)
-    end
-
-    it "should allow tablespace to be specified" do
-      query = test_base.create_materialized_view_statement(:view_name, "select_query_here",
-        tablespace: :the_final_frontier)
-      _(query).must_match(/create materialized view view_name tablespace the_final_frontier as select_query_here with data/i)
-    end
-
-    it "should allow empty view to be created" do
-      query = test_base.create_materialized_view_statement(:view_name, "select_query_here",
-        data: false)
-      _(query).must_match(/create materialized view view_name as select_query_here with no data/i)
-    end
-  end
-end

data/specs/adapters/sqlite3_adapter_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe "Spectacles::SchemaStatements::SQLite3Adapter" do
-  File.delete(File.expand_path(File.dirname(__FILE__) + "/../test.db")) rescue nil
-
-  ActiveRecord::Base.establish_connection(
-    :adapter => "sqlite3",
-    :database => "specs/test.db"
-  )
-  load_schema
-
-  it_behaves_like "an adapter", "SQLite3Adapter"
-  it_behaves_like "a view model"
-end

data/specs/spec_helper.rb

@@ -1,53 +0,0 @@
-require 'simplecov'
-SimpleCov.start do
-  add_filter "/specs"
-end
-
-require 'rubygems'
-require 'bundler'
-Bundler.require(:default, :development, :test)
-
-require 'minitest/spec'
-require 'minitest/autorun'
-require 'minitest/pride'
-require 'support/minitest_shared'
-require 'support/minitest_matchers'
-require 'support/schema_statement_examples'
-require 'support/view_examples'
-
-class User < ActiveRecord::Base
-  has_many :products
-end
-
-class Product < ActiveRecord::Base
-  belongs_to :user
-end
-
-ActiveRecord::Schema.verbose = false
-
-def configure_database(config)
-  @database_config = config
-end
-
-def load_schema
-  ActiveRecord::Schema.define(:version => 1) do
-    create_table :users do |t|
-      t.string :first_name
-      t.string :last_name
-    end
-
-    create_table :products do |t|
-      t.string :name
-      t.integer :value
-      t.boolean :available, :default => true
-      t.belongs_to :user
-    end
-  end
-end
-
-def recreate_database(database)
-  ActiveRecord::Base.establish_connection(@database_config)
-  ActiveRecord::Base.connection.drop_database(database) rescue nil
-  ActiveRecord::Base.connection.create_database(database)
-  ActiveRecord::Base.establish_connection(@database_config.merge(:database => database))
-end

data/specs/spectacles/abstract_adapter_override_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe "loading an adapter" do
-  it "calls the original AR::CA::AbstractAdapter.inherited method" do
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
-      def self.inherited(subclass)
-        @_spectacles_inherited_called = true
-      end
-    end
-    load File.join(__dir__, '../../lib/spectacles/abstract_adapter_override.rb')
-    Class.new(ActiveRecord::ConnectionAdapters::AbstractAdapter)
-    _(ActiveRecord::ConnectionAdapters::AbstractAdapter.instance_variable_get("@_spectacles_inherited_called")).must_equal true
-  end
-end

data/specs/spectacles/schema_statements/abstract_adapter_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-describe Spectacles::SchemaStatements::AbstractAdapter do
-  class TestBase
-    extend Spectacles::SchemaStatements::AbstractAdapter
-
-    def self.materialized_views
-      @materialized_views ||= nil
-      @materialized_views || super
-    end
-
-    def self.with_materialized_views(list)
-      @materialized_views = list
-      yield
-    ensure
-      @materialized_views = nil
-    end
-  end
-
-  describe "#create_view" do
-    it "throws error when block not given and no build_query" do
-      _(lambda { TestBase.create_view(:view_name) }).must_raise(RuntimeError)
-    end
-  end
-
-  describe "#views" do
-    it "throws error when accessed on AbstractAdapter" do
-      _(lambda { TestBase.views }).must_raise(RuntimeError)
-    end
-  end
-
-  describe "#supports_materialized_views?" do
-    it "returns false when accessed on AbstractAdapter" do
-      _(TestBase.supports_materialized_views?).must_equal false
-    end
-  end
-
-  describe "#materialized_views" do
-    it "throws error when accessed on AbstractAdapter" do
-      _(lambda { TestBase.materialized_views }).must_raise(NotImplementedError)
-    end
-  end
-
-  describe "#materialized_view_exists?" do
-    it "is true when materialized_views includes the view" do
-      TestBase.with_materialized_views(%w(alpha beta gamma)) do
-        _(TestBase.materialized_view_exists?(:beta)).must_equal true
-      end
-    end
-
-    it "is false when materialized_views does not include the view" do
-      TestBase.with_materialized_views(%w(alpha beta gamma)) do
-        _(TestBase.materialized_view_exists?(:delta)).must_equal false
-      end
-    end
-  end
-
-  describe "#materialized_view_build_query" do
-    it "throws error when accessed on AbstractAdapter" do
-      _(lambda { TestBase.materialized_view_build_query(:books) }).must_raise(NotImplementedError)
-    end
-  end
-
-  describe "#create_materialized_view" do
-    it "throws error when accessed on AbstractAdapter" do
-      _(lambda { TestBase.create_materialized_view(:books) }).must_raise(NotImplementedError)
-    end
-  end
-
-  describe "#drop_materialized_view" do
-    it "throws error when accessed on AbstractAdapter" do
-      _(lambda { TestBase.drop_materialized_view(:books) }).must_raise(NotImplementedError)
-    end
-  end
-
-  describe "#refresh_materialized_view" do
-    it "throws error when accessed on AbstractAdapter" do
-      _(lambda { TestBase.refresh_materialized_view(:books) }).must_raise(NotImplementedError)
-    end
-  end
-
-end

data/specs/spectacles/view_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Spectacles::View do
-  it "is an abstract class" do
-    _(Spectacles::View.abstract_class?).must_be true
-  end
-end

data/specs/support/minitest_matchers.rb

@@ -1,5 +0,0 @@
-require 'minitest/spec'
-
-module MiniTest::Expectations
-  infect_an_assertion :assert_equal, :must_be
-end

data/specs/support/minitest_shared.rb

@@ -1,20 +0,0 @@
-require 'minitest/spec'
-
-MiniTest::Spec.class_eval do
-  def self.shared_examples
-    @shared_examples ||= {}
-  end
-end
-
-module MiniTest::Spec::SharedExamples
-  def shared_examples_for(desc, &block)
-    MiniTest::Spec.shared_examples[desc] = block
-  end
-
-  def it_behaves_like(desc, *args)
-    examples = MiniTest::Spec.shared_examples[desc]
-    instance_exec(*args, &examples)
-  end
-end
-
-Object.class_eval { include(MiniTest::Spec::SharedExamples) }

data/specs/support/schema_statement_examples.rb

@@ -1,241 +0,0 @@
-shared_examples_for "an adapter" do |adapter|
-  shared_base = Class.new do
-    extend Spectacles::SchemaStatements.const_get(adapter)
-    def self.quote_table_name(name); name; end
-    def self.quote_column_name(name); name; end
-    def self.execute(query); query; end
-  end
-
-  describe "ActiveRecord::SchemaDumper#dump" do
-    before(:each) do
-      ActiveRecord::Base.connection.drop_view(:new_product_users)
-
-      ActiveRecord::Base.connection.create_view(:new_product_users) do
-        "SELECT name AS product_name, first_name AS username FROM
-        products JOIN users ON users.id = products.user_id"
-      end
-
-      if ActiveRecord::Base.connection.supports_materialized_views?
-        ActiveRecord::Base.connection.drop_materialized_view(:materialized_product_users)
-        ActiveRecord::Base.connection.drop_materialized_view(:empty_materialized_product_users)
-
-        ActiveRecord::Base.connection.create_materialized_view(:materialized_product_users, force: true) do
-          "SELECT name AS product_name, first_name AS username FROM
-          products JOIN users ON users.id = products.user_id"
-        end
-
-        ActiveRecord::Base.connection.add_index :materialized_product_users, :product_name
-
-        ActiveRecord::Base.connection.create_materialized_view(:empty_materialized_product_users, storage: { fillfactor: 50 }, data: false, force: true) do
-          "SELECT name AS product_name, first_name AS username FROM
-          products JOIN users ON users.id = products.user_id"
-        end
-      end
-    end
-
-    it "should return create_view in dump stream" do
-      stream = StringIO.new
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-      _(stream.string).must_match(/create_view/)
-    end
-
-    if ActiveRecord::Base.connection.supports_materialized_views?
-      it "should return create_materialized_view in dump stream" do
-        stream = StringIO.new
-        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-        _(stream.string).must_match(/create_materialized_view/)
-      end
-
-      it "should return add_index in dump stream" do
-        stream = StringIO.new
-        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-        _(stream.string).must_match(/add_index/)
-      end
-
-      it "should include options for create_materialized_view" do
-        stream = StringIO.new
-        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-        _(stream.string).must_match(/create_materialized_view.*fillfactor: 50/)
-        _(stream.string).must_match(/create_materialized_view.*data: false/)
-      end
-    end
-
-    it "should rebuild views in dump stream" do
-      stream = StringIO.new
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-
-      if ActiveRecord::Base.connection.supports_materialized_views?
-        ActiveRecord::Base.connection.materialized_views.each do |view|
-          ActiveRecord::Base.connection.drop_materialized_view(view)
-        end
-      end
-
-      ActiveRecord::Base.connection.views.each do |view|
-        ActiveRecord::Base.connection.drop_view(view)
-      end
-
-      ActiveRecord::Base.connection.tables.each do |table|
-        ActiveRecord::Base.connection.drop_table(table)
-      end
-
-      eval(stream.string)
-
-      _(ActiveRecord::Base.connection.views).must_include('new_product_users')
-
-      if ActiveRecord::Base.connection.supports_materialized_views?
-        _(ActiveRecord::Base.connection.materialized_views).must_include('materialized_product_users')
-      end
-    end
-  end
-
-  describe "#create_view" do
-    let(:view_name) { :view_name }
-
-    it "throws error when block not given and no build_query" do
-      _(lambda { shared_base.create_view(view_name) }).must_raise(RuntimeError)
-    end
-
-    describe "view_name" do
-      it "takes a symbol as the view_name" do
-        _(shared_base.create_view(view_name.to_sym, Product.all)).must_match(/#{view_name}/)
-      end
-
-      it "takes a string as the view_name" do
-        _(shared_base.create_view(view_name.to_s, Product.all)).must_match(/#{view_name}/)
-      end
-    end
-
-    describe "build_query" do
-      it "uses a string if passed" do
-        select_statement = "SELECT * FROM products"
-        _(shared_base.create_view(view_name, select_statement)).must_match(/#{Regexp.escape(select_statement)}/)
-      end
-
-      it "uses an Arel::Relation if passed" do
-        select_statement = Product.all.to_sql
-        _(shared_base.create_view(view_name, Product.all)).must_match(/#{Regexp.escape(select_statement)}/)
-      end
-    end
-
-    describe "block" do
-      it "can use an Arel::Relation from the yield" do
-        select_statement = Product.all.to_sql
-        _(shared_base.create_view(view_name) { Product.all }).must_match(/#{Regexp.escape(select_statement)}/)
-      end
-
-      it "can use a String from the yield" do
-        select_statement = "SELECT * FROM products"
-        _(shared_base.create_view(view_name) { "SELECT * FROM products" }).must_match(/#{Regexp.escape(select_statement)}/)
-      end
-    end
-  end
-
-  describe "#drop_view" do
-    let(:view_name) { :view_name }
-
-    describe "view_name" do
-      it "takes a symbol as the view_name" do
-        _(shared_base.drop_view(view_name.to_sym)).must_match(/#{view_name}/)
-      end
-
-      it "takes a string as the view_name" do
-        _(shared_base.drop_view(view_name.to_s)).must_match(/#{view_name}/)
-      end
-    end
-  end
-
-  describe "#tables" do
-    it "returns an array of all table names" do
-      _(ActiveRecord::Base.connection.tables).must_include("products")
-      _(ActiveRecord::Base.connection.tables).must_include("users")
-    end
-
-    it "does not include the names of the views" do
-      _(ActiveRecord::Base.connection.tables).wont_include("new_product_users")
-    end
-  end
-
-  describe "#views" do
-    it "returns an array of all views" do
-      _(ActiveRecord::Base.connection.views).must_include("new_product_users")
-    end
-  end
-
-  if shared_base.supports_materialized_views?
-    describe "#create_materialized_view" do
-      let(:view_name) { :view_name }
-
-      it "throws error when block not given and no build_query" do
-        _(lambda { shared_base.create_materialized_view(view_name) }).must_raise(RuntimeError)
-      end
-
-      describe "view_name" do
-        it "takes a symbol as the view_name" do
-          _(shared_base.create_materialized_view(view_name.to_sym, Product.all)).must_match(/#{view_name}/)
-        end
-
-        it "takes a string as the view_name" do
-          _(shared_base.create_materialized_view(view_name.to_s, Product.all)).must_match(/#{view_name}/)
-        end
-      end
-
-      describe "build_query" do
-        it "uses a string if passed" do
-          select_statement = "SELECT * FROM products"
-          _(shared_base.create_materialized_view(view_name, select_statement)).must_match(/#{Regexp.escape(select_statement)}/)
-        end
-
-        it "uses an Arel::Relation if passed" do
-          select_statement = Product.all.to_sql
-          _(shared_base.create_materialized_view(view_name, Product.all)).must_match(/#{Regexp.escape(select_statement)}/)
-        end
-      end
-
-      describe "block" do
-        it "can use an Arel::Relation from the yield" do
-          select_statement = Product.all.to_sql
-          _(shared_base.create_materialized_view(view_name) { Product.all }).must_match(/#{Regexp.escape(select_statement)}/)
-        end
-
-        it "can use a String from the yield" do
-          select_statement = "SELECT * FROM products"
-          _(shared_base.create_materialized_view(view_name) { "SELECT * FROM products" }).must_match(/#{Regexp.escape(select_statement)}/)
-        end
-      end
-    end
-
-    describe "#drop_materialized_view" do
-      let(:view_name) { :view_name }
-
-      describe "view_name" do
-        it "takes a symbol as the view_name" do
-          _(shared_base.drop_materialized_view(view_name.to_sym)).must_match(/#{view_name}/)
-        end
-
-        it "takes a string as the view_name" do
-          _(shared_base.drop_materialized_view(view_name.to_s)).must_match(/#{view_name}/)
-        end
-      end
-    end
-
-    describe "#refresh_materialized_view" do
-      let(:view_name) { :view_name }
-
-      describe "view_name" do
-        it "takes a symbol as the view_name" do
-          _(shared_base.refresh_materialized_view(view_name.to_sym)).must_match(/#{view_name}/)
-        end
-
-        it "takes a string as the view_name" do
-          _(shared_base.refresh_materialized_view(view_name.to_s)).must_match(/#{view_name}/)
-        end
-      end
-    end
-  else
-    describe "#materialized_views" do
-      it "should not be supported by #{adapter}" do
-        _(lambda { shared_base.materialized_views }).must_raise(NotImplementedError)
-      end
-    end
-  end
-end

data/specs/support/view_examples.rb

@@ -1,62 +0,0 @@
-shared_examples_for "a view model" do
-  ActiveRecord::Base.connection.create_view(:new_product_users) do
-    "SELECT name AS product_name, first_name AS username FROM
-    products JOIN users ON users.id = products.user_id"
-  end
-
-  class NewProductUser < Spectacles::View
-    scope :duck_lovers, lambda { where(:product_name => 'Rubber Duck') }
-  end
-
-  describe "Spectacles::View" do
-    describe "inherited class" do
-      before(:each) do
-        User.destroy_all
-        Product.destroy_all
-        @john = User.create(:first_name => 'John', :last_name => 'Doe')
-        @john.products.create(:name => 'Rubber Duck', :value => 10)
-      end
-
-      let(:new_product_user) { NewProductUser.duck_lovers.load.first }
-
-      it "can have scopes" do
-        _(new_product_user.username).must_be @john.first_name
-      end
-
-      describe "an instance" do
-        it "is readonly" do
-          _(new_product_user.readonly?).must_be true
-        end
-      end
-    end
-  end
-
-  if ActiveRecord::Base.connection.supports_materialized_views?
-    ActiveRecord::Base.connection.create_materialized_view(:materialized_product_users) do
-      "SELECT name AS product_name, first_name AS username FROM
-      products JOIN users ON users.id = products.user_id"
-    end
-
-    class MaterializedProductUser < Spectacles::MaterializedView
-      scope :duck_lovers, lambda { where(:product_name => 'Rubber Duck') }
-    end
-
-    describe "Spectacles::MaterializedView" do
-      before(:each) do
-        User.delete_all
-        Product.delete_all
-        @john = User.create(:first_name => 'John', :last_name => 'Doe')
-        @duck = @john.products.create(:name => 'Rubber Duck', :value => 10)
-        MaterializedProductUser.refresh!
-      end
-
-      it "can have scopes" do
-        _(MaterializedProductUser.duck_lovers.load.first.username).must_be @john.first_name
-      end
-
-      it "is readonly" do
-        _(MaterializedProductUser.first.readonly?).must_be true
-      end
-    end
-  end
-end

data/spectacles.gemspec

@@ -1,33 +0,0 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "spectacles/version"
-
-Gem::Specification.new do |gem|
-  gem.version     = Spectacles::VERSION
-  gem.name        = "spectacles"
-  gem.authors     = ["Adam Hutchison, Brandon Dewitt"]
-  gem.email       = ["liveh2o@gmail.com, brandonsdewitt@gmail.com"]
-  gem.homepage    = "http://github.com/liveh2o/spectacles"
-  gem.summary     = %q{Spectacles (derived from RailsSQLViews) adds database view functionality to ActiveRecord.}
-  gem.description = %q{Spectacles adds database view functionality to ActiveRecord. Current supported adapters include Postgres, SQLite, Vertica, and MySQL.}
-  gem.license     = 'MIT'
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
-
-  ##
-  # Dependencies
-  #
-  gem.required_ruby_version = ">= 2.2.0"
-  gem.add_dependency "activerecord", ">= 3.2.0", "~> 6.1.0"
-  gem.add_dependency "activesupport", ">= 3.2.0", "~> 6.1.0"
-
-  ##
-  # Development dependencies
-  #
-  gem.add_development_dependency "rake"
-  gem.add_development_dependency "minitest"
-end