rubaidh-rails_sql_views 0.7.1

data/CHANGELOG

@@ -0,0 +1,25 @@
+0.1.0 - Released Dec 27, 2006
+ * Initial release
+
+0.5.0 - Released Dec 29, 2006
+ * Added support for PostgreSQL (Michael Schuerig)
+ * Fixed the schema dumper
+ 
+0.5.1 - Released Jan 10, 2007
+ * Patch by Clifford T. Matthews to use String.dump to dump out the view select statement
+ 
+0.6.0 - Released May 9, 2007
+ * Added support for SQL Server (Seth Ladd)-
+ * Added support for using views to map non-friendly database field names to AR-friendly names (Nathan Vack)
+ * Added support for Oracle (Alistair Davidson)
+
+0.6.1 - Released June 6, 2007
+ * Added test for union support
+ * Updated tests to include new table to support union test
+
+0.7.0
+ * Updated dependency versions to get on ActiveRecord 2.x. May not be compatible with Rails versions less than 2.x.
+ * Add nonview_tables support to *all* of the adapters (was missing from Postgres and SQLServer)
+
+0.7.1
+ * Strip the database name from the retrieved CREATE VIEW statements to support `rake db:test:prepare`, etc.

data/README

@@ -0,0 +1,51 @@
+== Rails SQL Views
+
+Library which adds SQL Views to Rails. Adds create_view and drop_view to the ActiveRecord::ConnectionAdapters::AbstractAdapter (which makes them available to migrations) and adds support for dumping views in the ActiveRecord::SchemaDumper.
+
+== Installation
+
+To install:
+
+  gem install rails_sql_views
+ 
+Then add the following to your Rails config/environment.rb:
+
+  require_gem 'rails_sql_views'
+  require 'rails_sql_views'
+
+== Usage
+
+You can then use create_view and drop_view in your migrations. For example:
+
+  class CreatePersonView < ActiveRecord::Migration
+    def self.up
+      create_view :v_people, "select * from people" do |t|
+        t.column :id
+        t.column :name
+        t.column :social_security
+      end
+    end
+
+    def self.down
+      drop_view :v_people
+    end
+  end
+  
+This extension also adds support for views in the ActiveRecord::SchemaDumper class.
+
+The following drivers are supported:
+
+ MySQL
+ PostgreSQL (Native and Pure Ruby)
+ Oracle
+ SQL Server
+
+== Known Issues
+
+* Drivers not mentioned above are not supported.
+
+If you find any issues please send an email to anthonyeden@gmail.com .
+
+== Contributing
+
+If you would like to implement view support for other adapters then please drop me an email. Better yet, write up the adapter modifications and send them to me. :-)

data/Rakefile

@@ -0,0 +1,146 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+require File.join(File.dirname(__FILE__), 'lib/rails_sql_views', 'version')
+
+PKG_BUILD       = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_FORK        = ENV['PKG_FORK'] ? "#{ENV['PKG_FORK']}-" : ''
+
+PKG_NAME        = "#{PKG_FORK}rails_sql_views"
+PKG_VERSION     = RailsSqlViews::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME   = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_DESTINATION = ENV["PKG_DESTINATION"] || "../#{PKG_NAME}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "activewarehouse"
+RUBY_FORGE_USER    = "aeden"
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the library.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+namespace :rcov do
+  desc 'Measures test coverage'
+  task :test do
+    rm_f 'coverage.data'
+    mkdir 'coverage' unless File.exist?('coverage')
+    rcov = "rcov --aggregate coverage.data --text-summary -Ilib"
+    system("#{rcov} test/*_test.rb test/**/*_test.rb")
+    system("open coverage/index.html") if PLATFORM['darwin']
+  end
+end
+
+desc 'Generate documentation library.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Rails SQL Views'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+PKG_FILES = FileList[
+  'CHANGELOG',
+  'README',
+  'Rakefile',
+  'bin/**/*',
+  'lib/**/*',
+] - [ 'test' ]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Adds SQL Views to Rails."
+  s.description = <<-EOF
+    Library which adds SQL Views to Rails.
+  EOF
+
+  s.add_dependency('activerecord', '>= 2.1.0')
+  s.add_dependency('rake', '>= 0.8.3')
+
+  s.rdoc_options << '--exclude' << '.'
+  s.has_rdoc = false
+
+  s.files = PKG_FILES.to_a.delete_if {|f| f.include?('.svn')}
+  s.require_path = 'lib'
+
+  s.author = "Anthony Eden"
+  s.email = "anthonyeden@gmail.com"
+  s.homepage = "http://activewarehouse.rubyforge.org/rails_sql_views"
+  s.rubyforge_project = "activewarehouse"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Generate code statistics"
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/**/*.rb"]
+    next if file_name =~ /vendor/
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+    
+    total_lines     += lines
+    total_codelines += codelines
+    
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [ :package ] do
+  `rubyforge login`
+
+  for ext in %w( gem tgz zip )
+    release_command = "rubyforge add_release activewarehouse #{PKG_NAME} 'REL #{PKG_VERSION}' pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}"
+    puts release_command
+    system(release_command)
+  end
+end
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  Rake::SshDirPublisher.new("aeden@rubyforge.org", "/var/www/gforge-projects/activewarehouse/rails_sql_views/rdoc", "rdoc").upload
+end
+
+desc "Install the gem from a local generated package"
+task :install => [:package] do
+  windows = RUBY_PLATFORM =~ /mswin/
+  sudo = windows ? '' : 'sudo'
+  gem = windows ? 'gem.bat' : 'gem'
+  `#{sudo} #{gem} install pkg/#{PKG_NAME}-#{PKG_VERSION}`
+end
+
+desc "Reinstall the gem from a local package copy"
+task :reinstall => [:package] do
+  windows = RUBY_PLATFORM =~ /mswin/
+  sudo = windows ? '' : 'sudo'
+  gem = windows ? 'gem.bat' : 'gem'
+  `#{sudo} #{gem} uninstall #{PKG_NAME} -x`
+  `#{sudo} #{gem} install pkg/#{PKG_NAME}-#{PKG_VERSION}`
+end

data/lib/active_record/view.rb

@@ -0,0 +1,76 @@
+
+# A base class for database views.
+# It is primarily useful for views that are centered around a single table/model.
+module ActiveRecord # :nodoc:
+  class View < Base
+    self.abstract_class = true
+    
+    def readonly?
+      true
+    end
+    
+    class << self
+      # Clones all applicable associations from +model+ to this view
+      # and provides an instance method
+      # <tt>to_<em>model</em></tt>
+      # that casts a view object to an object of the kind view is
+      # based on. This latter object may be missing attributes; to fill
+      # them in, call #reload.
+      def based_on(model)
+        define_method("to_#{model.name.demodulize.underscore}") do
+          becomes(model)
+        end
+        
+        model.reflect_on_all_associations.each do |assoc|
+          clone_association(model, assoc)
+        end
+      end
+      
+      # Clone one or more associations from +model+ to this view class.
+      #
+      # NOTE: Currently only <tt>belongs_to</tt>, <tt>has_many</tt> (withouth
+      # <tt>:through</tt>), and <tt>has_and_belongs_to_many</tt> associations
+      # are supported.
+      def clone_association(model, *associations)
+        associations.each do |association|
+          r = case association
+              when String, Symbol
+                model.reflect_on_association(association.to_sym)
+              when ActiveRecord::Reflection::AssociationReflection
+                association
+              else
+                raise ArgumentError, "Unrecognized association #{association.inspect}; must be a Symbol, String, or AssociationReflection."
+              end
+          case r.macro
+          when :belongs_to
+            if self.column_names.include?(r.primary_key_name.to_s)
+              if !r.options[:foreign_type] || self.column_names.include?(r.options[:foreign_type])
+                options = r.options.merge(
+                  :class_name => r.class_name,
+                  :foreign_key => r.primary_key_name
+                )
+                belongs_to r.name, options
+              end
+            end
+          when :has_many
+            ### TODO :through assocications
+            options = r.options.merge(
+              :class_name => r.class_name,
+              :foreign_key => r.primary_key_name
+            )
+            has_many r.name, options
+          when :has_and_belongs_to_many
+            options = r.options.merge(
+              :class_name => r.class_name,
+              :foreign_key => r.primary_key_name,
+              :association_foreign_key => r.association_foreign_key
+            )
+            has_and_belongs_to_many r.name, options
+          when :has_one
+            ### TODO
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core_ext/module.rb

@@ -0,0 +1,13 @@
+# This is required for 1.1.6 support
+unless Module.respond_to?(:alias_method_chain)
+  class Module
+    def alias_method_chain(target, feature)
+      # Strip out punctuation on predicates or bang methods since
+      # e.g. target?_without_feature is not a valid method name.
+      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+      yield(aliased_target, punctuation) if block_given?
+      alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
+      alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+    end
+  end
+end

data/lib/rails_sql_views.rb

@@ -0,0 +1,47 @@
+#--
+# Copyright (c) 2006 Anthony Eden
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+$:.unshift(File.dirname(__FILE__))
+
+require 'active_record'
+
+require 'core_ext/module'
+
+require 'rails_sql_views/connection_adapters/abstract/schema_definitions'
+require 'rails_sql_views/connection_adapters/abstract/schema_statements'
+require 'rails_sql_views/connection_adapters/abstract_adapter'
+require 'rails_sql_views/schema_dumper'
+require 'rails_sql_views/loader'
+
+ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
+  include RailsSqlViews::ConnectionAdapters::SchemaStatements
+  def self.inherited(sub)
+    RailsSqlViews::Loader.load_extensions
+  end
+end
+
+ActiveRecord::SchemaDumper.class_eval do
+  include RailsSqlViews::SchemaDumper
+end
+
+RailsSqlViews::Loader.load_extensions

data/lib/rails_sql_views/connection_adapters/abstract/schema_definitions.rb

@@ -0,0 +1,63 @@
+module RailsSqlViews
+  module ConnectionAdapters #:nodoc:
+    # Abstract definition of a View
+    class ViewDefinition
+      attr_accessor :columns, :select_query
+      
+      def initialize(base, select_query)
+        @columns = []
+        @base = base
+        @select_query = select_query
+      end
+      
+      def column(name)
+        column = name.to_s
+        @columns << column unless @columns.include? column
+        self
+      end
+      
+      def to_sql
+        @columns.collect { |c| @base.quote_column_name(c) } * ', '
+      end
+      
+    end
+    
+    class MappingDefinition
+      
+      # Generates a hash of the form :old_column => :new_column
+      # Initially, it'll map column names to themselves.
+      # use map_column to modify the list.
+      def initialize(columns)
+        @columns = columns
+        @map = Hash.new()
+        columns.each do |c|
+          @map[c] = c
+        end
+        
+      end
+      
+      # Create a mapping from an old column name to a new one.
+      # If the new name is nil, specify that the old column shouldn't
+      # appear in this new view.
+      def map_column(old_name, new_name)
+        unless @map.include?(old_name)
+          raise ActiveRecord::ActiveRecordError, "column #{old_name} not found, can't be mapped"
+        end
+        if new_name.nil?
+          @map.delete old_name
+          @columns.delete old_name
+        else
+          @map[old_name] = new_name
+        end
+      end
+      
+      def select_cols
+        @columns
+      end
+      
+      def view_cols
+        @columns.map { |c| @map[c] }
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/abstract/schema_statements.rb

@@ -0,0 +1,77 @@
+module RailsSqlViews
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+      def self.included(base)
+        base.alias_method_chain :drop_table, :cascade
+      end
+
+      # Create a view.
+      # The +options+ hash can include the following keys:
+      # [<tt>:check_option</tt>]
+      #   Specify restrictions for inserts or updates in updatable views. ANSI SQL 92 defines two check option
+      #   values: CASCADED and LOCAL. See your database documentation for allowed values.
+      def create_view(name, select_query, options={})
+        if supports_views?
+          view_definition = ViewDefinition.new(self, select_query)
+
+          yield view_definition
+
+          if options[:force]
+            drop_view(name) rescue nil
+          end
+
+          create_sql = "CREATE VIEW "
+          create_sql << "#{quote_table_name(name)} "
+          if supports_view_columns_definition? && !view_definition.to_sql.blank?
+            create_sql << "("
+            create_sql << view_definition.to_sql
+            create_sql << ") " 
+          end
+          create_sql << "AS #{view_definition.select_query}"
+          create_sql << " WITH #{options[:check_option]} CHECK OPTION" if options[:check_option]
+          execute create_sql
+        end
+      end
+
+      # Also creates a view, with the specific purpose of remapping column names
+      # to make non-ActiveRecord tables friendly with the naming
+      # conventions, while maintaining legacy app compatibility.
+      def create_mapping_view(old_name, new_name, options = {})
+        return unless supports_views?
+        
+        col_names = columns(old_name).collect { |col| col.name.to_sym }
+        mapper = MappingDefinition.new(col_names)
+        
+        yield mapper
+        
+        if options[:force]
+          drop_view(new_name) rescue nil
+        end
+
+        view_sql = "CREATE VIEW #{new_name} "
+        if supports_view_columns_definition?
+          view_sql << "(#{mapper.view_cols.collect { |c| quote_column_name(c) }.join(', ')}) "
+        end
+        view_sql << "AS SELECT #{mapper.select_cols.collect { |c| quote_column_name(c) }.join(', ')} FROM #{old_name}"
+        execute view_sql
+      end
+
+      def drop_table_with_cascade(table_name, options = {})
+        execute "DROP TABLE #{quote_table_name(table_name)} CASCADE"
+      end
+      
+      # Drop a view.
+      # The +options+ hash can include the following keys:
+      # [<tt>:drop_behavior</tt>]
+      #   Specify the drop behavior. ANSI SQL 92 defines two drop behaviors, CASCADE and RESTRICT. See your
+      #   database documentation to determine what drop behaviors are available.
+      def drop_view(name, options={})
+        if supports_views?
+          drop_sql = "DROP VIEW #{name}"
+          drop_sql << " #{options[:drop_behavior]}" if options[:drop_behavior]
+          execute drop_sql
+        end
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,35 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module AbstractAdapter
+      def self.included(base)
+        base.alias_method_chain :disable_referential_integrity, :views_excluded
+      end
+
+      # Subclasses should override and return true if they support views.
+      def supports_views?
+        return false
+      end
+      
+      def disable_referential_integrity_with_views_excluded(&block)
+        self.class.send(:alias_method, :tables, :base_tables)
+        disable_referential_integrity_without_views_excluded(&block)
+      ensure
+        self.class.send(:alias_method, :tables, :tables_with_views_included)
+      end
+      
+      def supports_view_columns_definition?
+        true
+      end
+      
+      # Get a list of all views for the current database
+      def views(name = nil)
+        raise NotImplementedError, "views is an abstract method"
+      end
+      
+      # Get the select statement for the specified view
+      def view_select_statement(view, name=nil)
+        raise NotImplementedError, "view_select_statement is an abstract method"
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,58 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module MysqlAdapter
+      def self.included(base)
+        if base.private_method_defined?(:supports_views?)
+          base.send(:public, :supports_views?)
+        end
+      end
+
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+      def base_tables(name = nil) #:nodoc:
+        tables = []
+        execute("SHOW FULL TABLES WHERE TABLE_TYPE='BASE TABLE'").each{|row| tables << row[0]}
+        tables
+      end
+      alias nonview_tables base_tables
+      
+      def views(name = nil) #:nodoc:
+        views = []
+        execute("SHOW FULL TABLES WHERE TABLE_TYPE='VIEW'").each{|row| views << row[0]}
+        views
+      end
+      
+      def structure_dump
+        structure = ""
+        base_tables.each do |table|
+          structure += select_one("SHOW CREATE TABLE #{quote_table_name(table)}")["Create Table"] + ";\n\n"
+        end
+
+        views.each do |view|
+          structure += select_one("SHOW CREATE VIEW #{quote_table_name(view)}")["Create View"] + ";\n\n"
+        end
+
+        return structure
+      end
+
+      # Get the view select statement for the specified table.
+      def view_select_statement(view, name=nil)
+        begin
+          execute("SHOW CREATE VIEW #{view}", name).each do |row|
+            return convert_statement(row[1]) if row[0] == view
+          end
+        rescue ActiveRecord::StatementInvalid => e
+          raise "No view called #{view} found"
+        end
+      end
+      
+      private
+      def convert_statement(s)
+        s.gsub(/.* AS (select .*)/, '\1').gsub(/#{quote_table_name(ActiveRecord::Base.configurations[Rails.env]["database"])}\./, '')
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/oci_adapter.rb

@@ -0,0 +1,33 @@
+module RailsSqlViews
+ module ConnectionAdapters
+   module OciAdapter
+     # Returns true as this adapter supports views.
+     def supports_views?
+       true
+     end
+
+     def base_tables(name = nil) #:nodoc:
+       tables = []
+       execute("SELECT TABLE_NAME FROM USER_TABLES", name).each { |row| tables << row[0]  }
+       tables
+     end
+     alias nonview_tables base_tables
+
+     def views(name = nil) #:nodoc:
+       views = []
+       execute("SELECT VIEW_NAME FROM USER_VIEWS", name).each { |row| views << row[0] }
+       views
+     end
+
+     # Get the view select statement for the specified table.
+     def view_select_statement(view, name=nil)
+       row = execute("SELECT TEXT FROM USER_VIEWS WHERE VIEW_NAME = '#{view}'", name).each do |row|
+         return row[0]
+       end
+       raise "No view called #{view} found"
+     end
+
+
+   end
+ end
+end

data/lib/rails_sql_views/connection_adapters/oracle_adapter.rb

@@ -0,0 +1,33 @@
+module RailsSqlViews
+ module ConnectionAdapters
+   module OracleAdapter
+     # Returns true as this adapter supports views.
+     def supports_views?
+       true
+     end
+
+     def base_tables(name = nil) #:nodoc:
+       tables = []
+       execute("SELECT TABLE_NAME FROM USER_TABLES", name).each { |row| tables << row[0]  }
+       tables
+     end
+     alias nonview_tables base_tables
+
+     def views(name = nil) #:nodoc:
+       views = []
+       execute("SELECT VIEW_NAME FROM USER_VIEWS", name).each { |row| views << row[0] }
+       views
+     end
+
+     # Get the view select statement for the specified table.
+     def view_select_statement(view, name=nil)
+       row = execute("SELECT TEXT FROM USER_VIEWS WHERE VIEW_NAME = '#{view}'", name).each do |row|
+         return row[0]
+       end
+       raise "No view called #{view} found"
+     end
+
+
+   end
+ end
+end

data/lib/rails_sql_views/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,65 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module PostgreSQLAdapter
+      def self.included(base)
+        base.alias_method_chain :tables, :views_included
+      end
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+      def tables_with_views_included(name = nil)
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type IN ('BASE TABLE', 'VIEW')
+        SQL
+
+        query(q, name).map { |row| row[0] }
+      end
+      
+      def base_tables(name = nil)
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type = 'BASE TABLE'
+        SQL
+        
+        query(q, name).map { |row| row[0] }
+      end
+      alias nonview_tables base_tables
+      
+      def views(name = nil) #:nodoc:
+        q = <<-SQL
+        SELECT table_name, table_type
+          FROM information_schema.tables
+         WHERE table_schema IN (#{schemas})
+           AND table_type = 'VIEW'
+        SQL
+        
+        query(q, name).map { |row| row[0] }
+      end
+
+      def view_select_statement(view, name = nil)
+        q = <<-SQL
+        SELECT view_definition
+          FROM information_schema.views 
+         WHERE table_catalog = (SELECT catalog_name FROM information_schema.information_schema_catalog_name)
+           AND table_schema IN (#{schemas})
+           AND table_name = '#{view}'
+        SQL
+        
+        select_value(q, name) or raise "No view called #{view} found"
+      end
+
+      private
+        
+      def schemas
+        schema_search_path.split(/,/).map { |p| quote(p) }.join(',')
+      end
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/sqlite_adapter.rb

@@ -0,0 +1,62 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module SQLiteAdapter
+      def supports_views?
+        true
+      end
+      
+      def tables(name = nil) #:nodoc:
+        sql = <<-SQL
+          SELECT name
+          FROM sqlite_master
+          WHERE (type = 'table' OR type = 'view') AND NOT name = 'sqlite_sequence'
+        SQL
+
+        execute(sql, name).map do |row|
+          row[0]
+        end
+      end
+
+      def base_tables(name = nil)
+        sql = <<-SQL
+          SELECT name
+          FROM sqlite_master
+          WHERE (type = 'table') AND NOT name = 'sqlite_sequence'
+        SQL
+
+        execute(sql, name).map do |row|
+          row[0]
+        end        
+      end
+      alias nonview_tables base_tables
+      
+      def views(name = nil)
+        sql = <<-SQL
+          SELECT name
+          FROM sqlite_master
+          WHERE type = 'view' AND NOT name = 'sqlite_sequence'
+        SQL
+
+        execute(sql, name).map do |row|
+          row[0]
+        end
+      end
+      
+      # Get the view select statement for the specified table.
+      def view_select_statement(view, name = nil)
+        sql = <<-SQL
+          SELECT sql
+          FROM sqlite_master
+          WHERE name = '#{view}' AND NOT name = 'sqlite_sequence'
+        SQL
+        
+        select_value(sql, name) or raise "No view called #{view} found"
+      end
+      
+      def supports_view_columns_definition?
+        false
+      end
+      
+    end
+  end
+end

data/lib/rails_sql_views/connection_adapters/sqlserver_adapter.rb

@@ -0,0 +1,43 @@
+module RailsSqlViews
+  module ConnectionAdapters
+    module SQLServerAdapter
+      # Returns true as this adapter supports views.
+      def supports_views?
+        true
+      end
+      
+      # Get all of the non-view tables from the currently connected schema
+      def base_tables(name = nil)
+        # this is untested
+        select_values("SELECT table_name FROM information_schema.tables", name)
+      end
+      alias nonview_tables base_tables
+      
+      # Returns all the view names from the currently connected schema.
+      def views(name = nil)
+        select_values("SELECT table_name FROM information_schema.views", name)
+      end
+      
+      # Get the view select statement for the specified view.
+      def view_select_statement(view, name=nil)
+        q =<<-ENDSQL
+          SELECT view_definition FROM information_schema.views
+          WHERE table_name = '#{view}'
+        ENDSQL
+        
+        view_def = select_value(q, name)
+        
+        if view_def
+          return convert_statement(view_def)
+        else
+          raise "No view called #{view} found"
+        end
+      end
+      
+      private
+      def convert_statement(s)
+        s.sub(/^CREATE.* AS (select .*)/i, '\1').gsub(/\n/, '')
+      end
+    end
+  end
+end

data/lib/rails_sql_views/loader.rb

@@ -0,0 +1,18 @@
+
+module RailsSqlViews
+  module Loader
+    SUPPORTED_ADAPTERS = %w( Mysql PostgreSQL SQLServer SQLite )
+
+    def self.load_extensions
+      SUPPORTED_ADAPTERS.each do |db|
+        if ActiveRecord::ConnectionAdapters.const_defined?("#{db}Adapter")
+          require "rails_sql_views/connection_adapters/#{db.downcase}_adapter"
+          ActiveRecord::ConnectionAdapters.const_get("#{db}Adapter").class_eval do
+            include RailsSqlViews::ConnectionAdapters::AbstractAdapter
+            include RailsSqlViews::ConnectionAdapters.const_get("#{db}Adapter")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_sql_views/schema_dumper.rb

@@ -0,0 +1,98 @@
+module RailsSqlViews
+  module SchemaDumper
+    def self.included(base)
+      base.alias_method_chain :trailer, :views
+      base.alias_method_chain :dump, :views
+      base.alias_method_chain :tables, :views_excluded
+      
+      # A list of views which should not be dumped to the schema. 
+      # Acceptable values are strings as well as regexp.
+      # This setting is only used if ActiveRecord::Base.schema_format == :ruby
+      base.cattr_accessor :ignore_views
+      base.ignore_views = []
+    end
+    
+    def trailer_with_views(stream)
+      # do nothing...we'll call this later
+    end
+    
+    # Add views to the end of the dump stream
+    def dump_with_views(stream)
+      dump_without_views(stream)
+      begin
+        if @connection.supports_views?
+          views(stream)
+        end
+      rescue => e
+        if ActiveRecord::Base.logger
+          ActiveRecord::Base.logger.error "Unable to dump views: #{e}"
+        else
+          raise e
+        end
+      end
+      trailer_without_views(stream)
+      stream
+    end
+    
+    # Add views to the stream
+    def views(stream)
+      @connection.views.sort.each do |v|
+        next if [ActiveRecord::Migrator.schema_migrations_table_name, ignore_views].flatten.any? do |ignored|
+          case ignored
+          when String then v == ignored
+          when Symbol then v == ignored.to_s
+          when Regexp then v =~ ignored
+          else
+            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_views accepts an array of String and / or Regexp values.'
+          end
+        end 
+        view(v, stream)
+      end
+    end
+    
+    # Add the specified view to the stream
+    def view(view, stream)
+      columns = @connection.columns(view).collect { |c| c.name }
+      begin
+        v = StringIO.new
+
+        v.print "  create_view #{view.inspect}"
+        v.print ", #{@connection.view_select_statement(view).dump}"
+        v.print ", :force => true"
+        v.puts " do |v|"
+
+        columns.each do |column|
+          v.print "    v.column :#{column}"
+          v.puts
+        end
+
+        v.puts "  end"
+        v.puts
+        
+        v.rewind
+        stream.print v.read
+      rescue => e
+        stream.puts "# Could not dump view #{view.inspect} because of following #{e.class}"
+        stream.puts "#   #{e.message}"
+        stream.puts
+      end
+      
+      stream
+    end
+
+    def tables_with_views_excluded(stream)
+      @connection.base_tables.sort.each do |tbl|
+        next if [ActiveRecord::Migrator.schema_migrations_table_name, ignore_tables].flatten.any? do |ignored|
+          case ignored
+          when String then tbl == ignored
+          when Regexp then tbl =~ ignored
+          else
+            raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+          end
+        end
+        table(tbl, stream)
+      end
+    end
+
+  end
+end

data/lib/rails_sql_views/version.rb

@@ -0,0 +1,9 @@
+module RailsSqlViews
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: rubaidh-rails_sql_views
+version: !ruby/object:Gem::Version 
+  version: 0.7.1
+platform: ruby
+authors: 
+- Anthony Eden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-10 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.3
+    version: 
+description: "    Library which adds SQL Views to Rails.\n"
+email: anthonyeden@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- README
+- Rakefile
+- lib/active_record/view.rb
+- lib/core_ext/module.rb
+- lib/rails_sql_views/connection_adapters/abstract/schema_definitions.rb
+- lib/rails_sql_views/connection_adapters/abstract/schema_statements.rb
+- lib/rails_sql_views/connection_adapters/abstract_adapter.rb
+- lib/rails_sql_views/connection_adapters/mysql_adapter.rb
+- lib/rails_sql_views/connection_adapters/oci_adapter.rb
+- lib/rails_sql_views/connection_adapters/oracle_adapter.rb
+- lib/rails_sql_views/connection_adapters/postgresql_adapter.rb
+- lib/rails_sql_views/connection_adapters/sqlite_adapter.rb
+- lib/rails_sql_views/connection_adapters/sqlserver_adapter.rb
+- lib/rails_sql_views/loader.rb
+- lib/rails_sql_views/schema_dumper.rb
+- lib/rails_sql_views/version.rb
+- lib/rails_sql_views.rb
+has_rdoc: false
+homepage: http://activewarehouse.rubyforge.org/rails_sql_views
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --exclude
+- .
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: activewarehouse
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Adds SQL Views to Rails.
+test_files: []
+