spectacles 0.5.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 82b4f3a1f6c49ed3344c2785aa3df557cb0a6da2
-  data.tar.gz: 28c778a66c9db7be1675b40710b5050e2140689f
+  metadata.gz: e7e7045b1b35b15bf40def12928244509e55b708
+  data.tar.gz: 6b2ddd076d9ef8b34ba7d9da13a3f090366b23c4
 SHA512:
-  metadata.gz: 99068ef2f0a6ccaafe0a4893df24bed9746bd34c6e8c5578fabacd1a5697cd536c29ed621937f75ddbb017800c17f2561ee15eada168aee80a116fc0131b8110
-  data.tar.gz: 4bceebf90b0546a333c2317b5c786fcdb2bf72b0ca16c8af0e87334f4612db130eef94a3876840df96509b3d7cddebf45e1efe0997908988d9a60c564262757e
+  metadata.gz: 5601559ad5b5f928b6ef91f01df5296ef9969561feb4e2aad11c79fc112a3d5961e9fb0d4f0cf4688bc1f4488eb14fd2042e30d0114fda7320f257ff4004b00d
+  data.tar.gz: a47a95fae8d26bf30e6b37a5218557eee8e0f825dc54ab57f6da63d20a274df145a29bd24e3f5ba462c066eea34200909b6318ac3bf840296410ca89cc52eb95

data/Rakefile

@@ -2,7 +2,7 @@ require "bundler/gem_tasks"
 require 'rake/testtask'
 
 namespace :test do
-  adapters = [ :mysql, :mysql2, :postgresql, :sqlite, :sqlite3 ]
+  adapters = [ :mysql, :mysql2, :postgresql, :sqlite3 ]
   task :all => [ :spectacles ] + adapters
 
   adapters.each do |adapter|

data/Readme.rdoc

@@ -4,7 +4,7 @@ Spectacles adds database view functionality to ActiveRecord. It is heavily inspi
 
 Spectacles provides the ability to create views in migrations using a similar format to creating tables. It also provides an abstract view class that inherits from ActiveRecord::Base that can be used to create view-backed models.
 
-It currently only works with the SQLite, PostgreSQL, and Vertica drivers. MySQL & MySQL2 have a couple of issues that are still being worked out.
+It currently works with the SQLite, MySQL, MySQL2, PostgreSQL, and Vertica drivers.
 
 = Using Spectacles
   Install it
@@ -38,6 +38,81 @@ Create a migration from an ARel object:
     # Your fancy methods
   end
 
+== Materialized Views
+
+*This feature is only supported for PostgreSQL backends.*
+These are essentially views that cache their result set. In this way
+they are kind of a cross between tables (which persist data) and views
+(which are windows onto other tables).
+
+  create_materialized_view :product_users do
+    <<-SQL.squish
+      SELECT name AS product_name, first_name AS username
+        FROM products
+        JOIN users ON users.id = products.user_id
+    SQL
+  end
+
+  class ProductUser < Spectacles::MaterializedView
+    # just like Spectacles::View
+  end
+
+Because these materialized views cache a snapshot of the data as it
+exists at a point in time (typically when the view was created), you
+need to manually _refresh_ the view when new data is added to the
+original tables. You can do this with the +#refresh!+ method on
+the +Spectacles::MaterializedView+ subclass:
+
+  User.create(first_name: "Bob", email: "bob@example.com")
+  ProductUser.refresh!
+
+Also, you can specify a few different options to +create_materialized_view+
+to affect how the new view is created:
+
+* +:force+ - if +false+ (the default), the create will fail if a
+  materialized view with the given name already exists. If +true+,
+  any materialized view with that name will be dropped before the
+  create runs.
+
+    create_materialized_view :product_users, force: true do
+      # ...
+    end
+
+* +:data+ - if +true+ (the default), the view is immediately populated
+  with the corresponding data. If +false+, the view will be empty initially,
+  and must be populated by invoking the +#refresh!+ method.
+
+    create_materialized_view :product_users, data: false do
+      # ...
+    end
+
+* +:columns+ - an optional array of names to give the columns in the view.
+  By default, columns in the view will use the names given in the query.
+
+    create_materialized_view :product_users, columns: %i(product_name username) do
+      <<-SQL.squish
+        SELECT products.name, users.first_name
+          FROM products
+          JOIN users ON users.id = products.user_id
+      SQL
+    end
+
+* +:tablespace+ - an optional identifier (string or symbol) indicating
+  which namespace the materialized view ought to be created in.
+
+    create_materialized_view :product_users, tablespace: "awesomesauce" do
+      # ...
+    end
+
+* +:storage+ - an optional hash of (database-specific) storage parameters to
+  optimize how the materialized view is stored. (See
+  http://www.postgresql.org/docs/9.4/static/sql-createtable.html#SQL-CREATETABLE-STORAGE-PARAMETERS
+  for details.)
+
+    create_materialized_view :product_users, storage: { fillfactor: 70 } do
+      # ...
+    end
+
 = License
 
-Spectacles is licensed under MIT license (Read lib/spectactles.rb for full license)
+Spectacles is licensed under MIT license (Read lib/spectactles.rb for full license)

data/lib/spectacles.rb

@@ -3,6 +3,7 @@ require 'active_support/core_ext'
 require 'spectacles/schema_statements'
 require 'spectacles/schema_dumper'
 require 'spectacles/view'
+require 'spectacles/materialized_view'
 require 'spectacles/version'
 require 'spectacles/configuration'
 
@@ -36,6 +37,7 @@ ActiveRecord::SchemaDumper.class_eval do
 
   def trailer(stream)
     ::Spectacles::SchemaDumper.dump_views(stream, @connection)
+    ::Spectacles::SchemaDumper.dump_materialized_views(stream, @connection)
     _spectacles_orig_trailer(stream)
   end
 end

data/lib/spectacles/materialized_view.rb

@@ -0,0 +1,39 @@
+module Spectacles
+  class MaterializedView < ActiveRecord::Base
+    self.abstract_class = true
+
+    def self.new(*)
+      raise NotImplementedError
+    end
+
+    def self.materialized_view_exists?
+      self.connection.materialized_view_exists?(self.view_name)
+    end
+
+    def self.refresh!
+      self.connection.refresh_materialized_view(self.view_name)
+    end
+
+    class << self
+      alias_method :table_exists?, :materialized_view_exists?
+      alias_method :view_name, :table_name
+    end
+
+    def ==(comparison_object)
+      super ||
+        comparison_object.instance_of?(self.class) &&
+        attributes.present? &&
+        comparison_object.attributes == attributes
+    end
+
+    def persisted?
+      false
+    end
+
+    def readonly?
+      true
+    end
+  end
+
+  ::ActiveSupport.run_load_hooks(:spectacles, MaterializedView)
+end

data/lib/spectacles/schema_dumper.rb

@@ -8,12 +8,54 @@ module Spectacles
       end
     end
 
+    def self.dump_materialized_views(stream, connection)
+      unless (Spectacles.config.enable_schema_dump == false)
+        if connection.supports_materialized_views?
+          connection.materialized_views.sort.each do |view|
+            dump_materialized_view(stream, connection, view)
+          end
+        end
+      end
+    end
+
     def self.dump_view(stream, connection, view_name)
       stream.print <<-CREATEVIEW
+
   create_view :#{view_name}, :force => true do
     "#{connection.view_build_query(view_name)}"
   end
+
       CREATEVIEW
     end
+
+    def self.dump_materialized_view(stream, connection, view_name)
+      definition, options = connection.materialized_view_build_query(view_name)
+      options[:force] = true
+
+      stream.print <<-CREATEVIEW
+
+  create_materialized_view #{view_name.to_sym.inspect}, #{format_option_hash(options)} do
+    <<-SQL
+      #{definition}
+    SQL
+  end
+      CREATEVIEW
+    end
+
+    def self.format_option_hash(hash)
+      hash.map do |key, value|
+        "#{key}: #{format_option_value(value)}"
+      end.join(", ")
+    end
+
+    def self.format_option_value(value)
+      case value
+      when Hash then "{ #{format_option_hash(value)} }"
+      when /^\d+$/ then value.to_i
+      when /^\d+\.\d+$/ then value.to_f
+      when true, false then value.inspect
+      else raise "can't format #{value.inspect}"
+      end
+    end
   end
 end

data/lib/spectacles/schema_statements.rb

@@ -9,9 +9,11 @@ module Spectacles
 
       if ActiveRecord::ConnectionAdapters.const_defined?(adapter_class)
         require "spectacles/schema_statements/#{db.downcase}_adapter"
-        ActiveRecord::ConnectionAdapters.const_get(adapter_class).class_eval do
-          include Spectacles::SchemaStatements.const_get(adapter_class)
-        end
+
+        adapter = ActiveRecord::ConnectionAdapters.const_get(adapter_class)
+        extension = Spectacles::SchemaStatements.const_get(adapter_class)
+
+        adapter.send :prepend, extension
       end
     end
   end

data/lib/spectacles/schema_statements/abstract_adapter.rb

@@ -46,6 +46,34 @@ module Spectacles
       def views
         raise "Override view for your db adapter in #{self.class}"
       end
+
+      def supports_materialized_views?
+        false
+      end
+
+      def materialized_view_exists?(name)
+        return materialized_views.include?(name.to_s)
+      end
+
+      def materialized_views
+        raise NotImplementedError, "Override materialized_views for your db adapter in #{self.class}"
+      end
+
+      def materialized_view_build_query(view_name)
+        raise NotImplementedError, "Override materialized_view_build_query for your db adapter in #{self.class}"
+      end
+
+      def create_materialized_view(view_name, *args)
+        raise NotImplementedError, "Override create_materialized_view for your db adapter in #{self.class}"
+      end
+
+      def drop_materialized_view(view_name)
+        raise NotImplementedError, "Override drop_materialized_view for your db adapter in #{self.class}"
+      end
+
+      def refresh_materialized_view(view_name)
+        raise NotImplementedError, "Override refresh_materialized_view for your db adapter in #{self.class}"
+      end
     end
   end
 end

data/lib/spectacles/schema_statements/mysql_adapter.rb

@@ -4,7 +4,26 @@ module Spectacles
   module SchemaStatements
     module MysqlAdapter
       include Spectacles::SchemaStatements::AbstractAdapter
-      
+
+      # overrides the #tables method from ActiveRecord's MysqlAdapter
+      # to return only tables, and not views.
+      def tables(name = nil, database = nil, like = nil)
+        database = database ? quote_table_name(database) : "DATABASE()"
+        by_name  = like ? "AND table_name LIKE #{quote(like)}" : ""
+
+        sql = <<-SQL.squish
+          SELECT table_name, table_type
+            FROM information_schema.tables
+           WHERE table_schema = #{database}
+             AND table_type = 'BASE TABLE'
+             #{by_name}
+        SQL
+
+        execute_and_free(sql, 'SCHEMA') do |result|
+          result.collect(&:first)
+        end
+      end
+
       def views(name = nil) #:nodoc:
         execute("SHOW FULL TABLES WHERE TABLE_TYPE='VIEW'").map { |row| row[0] }
       end

data/lib/spectacles/schema_statements/postgresql_adapter.rb

@@ -28,6 +28,119 @@ module Spectacles
         view_sql = select_value(q, name) or raise "No view called #{view} found"
         view_sql.gsub("\"", "\\\"")
       end
+
+      def supports_materialized_views?
+        true
+      end
+
+      def materialized_views(name = nil)
+        query = <<-SQL.squish
+          SELECT relname
+            FROM pg_class
+           WHERE relnamespace IN (
+                    SELECT oid
+                      FROM pg_namespace
+                     WHERE nspname = ANY(current_schemas(false)))
+             AND relkind = 'm';
+        SQL
+
+        execute(query, name).map { |row| row['relname'] }
+      end
+
+      # Returns a tuple [string, hash], where string is the query used
+      # to construct the view, and hash contains the options given when
+      # the view was created.
+      def materialized_view_build_query(view, name = nil)
+        result = execute <<-SQL.squish, name
+          SELECT a.reloptions, b.tablespace, b.ispopulated, b.definition
+            FROM pg_class a, pg_matviews b
+           WHERE a.relname=#{quote(view)}
+             AND b.matviewname=a.relname
+        SQL
+
+        row = result[0]
+
+        storage = row["reloptions"]
+        tablespace = row["tablespace"]
+        ispopulated = row["ispopulated"]
+        definition = row["definition"].strip.sub(/;$/, "")
+
+        options = {}
+        options[:data] = false if ispopulated == 'f'
+        options[:storage] = parse_storage_definition(storage) if storage.present?
+        options[:tablespace] = tablespace if tablespace.present?
+
+        [definition, options]
+      end
+
+      def create_materialized_view_statement(view_name, query, options={})
+        columns = if options[:columns]
+            "(" + options[:columns].map { |c| quote_column_name(c) }.join(",") + ")"
+          else
+            ""
+          end
+
+        storage = if options[:storage] && options[:storage].any?
+            "WITH (" + options[:storage].map { |key, value| "#{key}=#{value}" }.join(", ") + ")"
+          else
+            ""
+          end
+
+        tablespace = if options[:tablespace]
+            "TABLESPACE #{quote_table_name(options[:tablespace])}"
+          else
+            ""
+          end
+
+        with_data = if options.fetch(:data, true)
+            "WITH DATA"
+          else
+            "WITH NO DATA"
+          end
+
+        <<-SQL.squish
+          CREATE MATERIALIZED VIEW #{quote_table_name(view_name)}
+            #{columns}
+            #{storage}
+            #{tablespace}
+            AS #{query}
+            #{with_data}
+        SQL
+      end
+
+      def create_materialized_view(view_name, *args)
+        options = args.extract_options!
+        build_query = args.shift
+
+        raise "#create_materialized_view requires a query or block" if build_query.nil? && !block_given?
+
+        build_query = yield if block_given?
+        build_query = build_query.to_sql if build_query.respond_to?(:to_sql)
+
+        if options[:force] && materialized_view_exists?(view_name)
+          drop_materialized_view(view_name)
+        end
+
+        query = create_materialized_view_statement(view_name, build_query, options)
+        execute(query)
+      end
+
+      def drop_materialized_view(view_name)
+        execute "DROP MATERIALIZED VIEW IF EXISTS #{quote_table_name(view_name)}"
+      end
+
+      def refresh_materialized_view(view_name)
+        execute "REFRESH MATERIALIZED VIEW #{quote_table_name(view_name)}"
+      end
+
+      def parse_storage_definition(storage)
+        storage = storage.gsub(/^{|}$/, "")
+        storage.split(/,/).inject({}) do |hash, item|
+          key, value = item.strip.split(/=/)
+          hash[key.to_sym] = value
+          hash
+        end
+      end
     end
   end
 end

data/lib/spectacles/schema_statements/sqlite3_adapter.rb

@@ -5,6 +5,21 @@ module Spectacles
     module SQLite3Adapter
       include Spectacles::SchemaStatements::AbstractAdapter
 
+      # overrides the #tables method from ActiveRecord's SQLite3Adapter
+      # to return only tables, and not views.
+      def tables(name = nil, table_name = nil)
+        sql = <<-SQL
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'table' AND NOT name = 'sqlite_sequence'
+        SQL
+        sql << " AND name = #{quote_table_name(table_name)}" if table_name
+
+        exec_query(sql, 'SCHEMA').map do |row|
+          row['name']
+        end
+      end
+
       def generate_view_query(*columns)
         sql = <<-SQL
           SELECT #{columns.join(',')}

data/lib/spectacles/version.rb

@@ -1,3 +1,3 @@
 module Spectacles
-  VERSION = "0.5.3"
+  VERSION = "1.0.0"
 end

data/specs/adapters/postgresql_adapter_spec.rb

@@ -15,15 +15,54 @@ describe "Spectacles::SchemaStatements::PostgreSQLAdapter" do
   it_behaves_like "an adapter", "PostgreSQLAdapter"
   it_behaves_like "a view model"
 
-  describe "#view_build_query" do
-    test_base = Class.new do
-      extend Spectacles::SchemaStatements::PostgreSQLAdapter
-      def self.schema_search_path; ""; end
-      def self.select_value(_, _); "\"products\""; end;
-    end
+  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/spectacles/schema_statements/abstract_adapter_spec.rb

@@ -3,6 +3,17 @@ require 'spec_helper'
 describe Spectacles::SchemaStatements::AbstractAdapter do 
   class TestBase
     extend Spectacles::SchemaStatements::AbstractAdapter
+
+    def self.materialized_views
+      @materialized_views || super
+    end
+
+    def self.with_materialized_views(list)
+      @materialized_views = list
+      yield
+    ensure
+      @materialized_views = nil
+    end
   end
 
   describe "#create_view" do
@@ -16,4 +27,55 @@ describe Spectacles::SchemaStatements::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/support/minitest_shared.rb

@@ -12,9 +12,8 @@ module MiniTest::Spec::SharedExamples
   end
 
   def it_behaves_like(desc, *args)
-    self.instance_eval do
-      MiniTest::Spec.shared_examples[desc].call(*args)
-    end
+    examples = MiniTest::Spec.shared_examples[desc]
+    instance_exec(*args, &examples)
   end
 end
 

data/specs/support/schema_statement_examples.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 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
 
@@ -14,6 +16,18 @@ shared_examples_for "an adapter" do |adapter|
         "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.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.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 
@@ -22,10 +36,31 @@ shared_examples_for "an adapter" do |adapter|
       stream.string.must_match(/create_view/)
     end
 
-    it "should return create_view in dump stream" do 
+    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 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
@@ -35,8 +70,12 @@ shared_examples_for "an adapter" do |adapter|
       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
 
@@ -95,4 +134,82 @@ shared_examples_for "an adapter" do |adapter|
       end
     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

@@ -28,4 +28,33 @@ shared_examples_for "a view model" do
       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 has 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

@@ -21,6 +21,7 @@ Gem::Specification.new do |gem|
   ##
   # Dependencies
   #
+  gem.required_ruby_version = ">= 2.0.0"
   gem.add_dependency "activerecord", ">= 3.2.0"
   gem.add_dependency "activesupport", ">= 3.2.0"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spectacles
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Adam Hutchison, Brandon Dewitt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-16 00:00:00.000000000 Z
+date: 2015-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -81,6 +81,7 @@ files:
 - Readme.rdoc
 - lib/spectacles.rb
 - lib/spectacles/configuration.rb
+- lib/spectacles/materialized_view.rb
 - lib/spectacles/railtie.rb
 - lib/spectacles/schema_dumper.rb
 - lib/spectacles/schema_statements.rb
@@ -89,7 +90,6 @@ files:
 - lib/spectacles/schema_statements/mysql_adapter.rb
 - lib/spectacles/schema_statements/postgresql_adapter.rb
 - lib/spectacles/schema_statements/sqlite3_adapter.rb
-- lib/spectacles/schema_statements/sqlite_adapter.rb
 - lib/spectacles/schema_statements/sqlserver_adapter.rb
 - lib/spectacles/schema_statements/vertica_adapter.rb
 - lib/spectacles/version.rb
@@ -98,7 +98,6 @@ files:
 - specs/adapters/mysql_adapter_spec.rb
 - specs/adapters/postgresql_adapter_spec.rb
 - specs/adapters/sqlite3_adapter_spec.rb
-- specs/adapters/sqlite_adapter_spec.rb
 - specs/spec_helper.rb
 - specs/spectacles/schema_statements/abstract_adapter_spec.rb
 - specs/spectacles/view_spec.rb
@@ -119,7 +118,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -133,3 +132,4 @@ specification_version: 4
 summary: Spectacles (derived from RailsSQLViews) adds database view functionality
   to ActiveRecord.
 test_files: []
+has_rdoc: 

data/lib/spectacles/schema_statements/sqlite_adapter.rb

@@ -1,33 +0,0 @@
-require 'spectacles/schema_statements/abstract_adapter'
-
-module Spectacles
-  module SchemaStatements
-    module SQLiteAdapter
-      include Spectacles::SchemaStatements::AbstractAdapter
-
-      def generate_view_query(*columns)
-        sql = <<-SQL
-          SELECT #{columns.join(',')}
-          FROM sqlite_master
-          WHERE type = 'view'
-        SQL
-      end
-      
-      def views #:nodoc:
-        sql = generate_view_query(:name)
-
-        exec_query(sql, "SCHEMA").map do |row|
-          row['name']
-        end
-      end
-
-      def view_build_query(table_name)
-        sql = generate_view_query(:sql)
-        sql << " AND name = #{quote_table_name(table_name)}"
-
-        row = exec_query(sql, "SCHEMA").first
-        row['sql'].gsub(/CREATE VIEW .*? AS/i, "") 
-      end
-    end
-  end
-end

data/specs/adapters/sqlite_adapter_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-
-describe "Spectacles::SchemaStatements::SQLiteAdapter" 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", "SQLiteAdapter"
-  it_behaves_like "a view model"
-end