views_in_migrations 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 ASEE
+
+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.

data/README.rdoc

@@ -0,0 +1,24 @@
+= Views In Migrations
+
+Use MySQL views to back ActiveRecord models, and define them in your migrations.
+
+ViewsInMigrations provides helper methods for using MySQL views behind ActiveRecord models. It helps you define, modify, test, and refresh your views. And it also handles correctly dumping the definitions to schema.rb.
+
+
+= Running the Specs
+
+1. adjust the database connection in spec_helper.rb to match your system.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 ASEE. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "views_in_migrations"
+    gem.summary = %Q{Use MySQL views to back ActiveRecord models, and define them in your migrations.}
+    gem.description = %Q{ViewsInMigrations provides helper methods for using MySQL views behind ActiveRecord models. It helps you define, modify, test, and refresh your views. And it also handles correctly dumping the definitions to schema.rb.}
+    gem.email = "asolove@gmail.com"
+    gem.homepage = "http://github.com/asolove/views_in_migrations"
+    gem.authors = ["asolove"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_dependency('active_record', '>= 2.3.2')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "views_in_migrations #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/views_in_migrations.rb

@@ -0,0 +1,171 @@
+require 'rubygems'
+require 'active_record'
+
+module ViewsInMigrations
+  
+  def self.views_supported?
+    ActiveRecord::Base.connection.send(:supports_views?)
+  rescue
+    false
+  end
+  
+  module SchemaStatements
+    def drop_view(view_name, options = {})
+      execute "DROP VIEW IF EXISTS #{quote_table_name(view_name)}"
+    end
+    
+    def create_view(view_name, *args)
+      options = {}
+      
+      if args.first.kind_of?(String)
+        select_statement = args.first
+        options = args.extract_options!
+      end
+      
+      if options[:force] && table_exists?(view_name)
+        drop_view(view_name, options)
+      end
+      
+      if select_statement
+        options[:options] ||= " WITH CHECK OPTION"
+        view_sql =  "CREATE VIEW #{quote_table_name(view_name)} AS "
+        view_sql << select_statement
+        view_sql << "#{options[:options]}"
+        execute view_sql
+      end
+    end
+    
+    def view_definition(view_name) 
+      select_value(%{
+        SELECT view_definition FROM information_schema.views 
+        WHERE table_name = #{view_name.inspect} 
+        AND table_schema = #{current_database.inspect}
+      })      
+    end
+    
+    def define_view(view_name, for_dump = false)
+      sanitize_view_sql(view_definition(view_name), for_dump)
+    end
+    
+    def sanitize_view_sql(view_sql, for_dump = false)
+      sql = view_sql.dup
+
+      # remove newlines
+      sql.gsub!(/\n|^\s*|\s*$/,'')
+      # we can just use SELECT *...
+      sql.gsub!(/SELECT .* FROM/i, "SELECT * FROM" )
+      sql.gsub!('where', 'WHERE')   
+      
+      if for_dump
+        #insert newlines for readability
+        sql.gsub!(/(from|where|in|\() /i, '\n\1 ')
+      end
+      
+      sql
+    end
+    
+    def views
+      select_values( %{
+        select table_name 
+        FROM information_schema.views 
+        WHERE table_schema = #{current_database.inspect}
+      }) 
+    end
+    
+    def table_is_view?(table_name)
+      views.include?(table_name)
+    end
+    
+    def refresh_view(view_name)
+      raise "#{view_name.inspect} is not a view" unless table_is_view?(view_name)
+      sql = define_view(view_name)
+      drop_view(view_name)
+      create_view(view_name,sql)      
+    end
+    
+    def refresh_views
+      views.each{|view| refresh_view!(view)}     
+    end
+    
+    def assert_presence_of_column(klass_name, column)
+      unless current_column_names_for(klass_name).include?(column.to_s)
+        raise Mysql::Error.new("Invalid view on #{klass_name}, missing required column: #{column}")
+      end
+    end
+    
+    def assert_absence_of_column(klass_name, column)
+      if current_column_names_for(klass_name).include?(column.to_s)
+        raise Mysql::Error.new("Invalid view on #{klass_name}, has invalid column: #{column}")
+      end
+    end
+    
+    def current_column_names_for(klass_name)
+      klass = klass_name.to_s.classify.constantize
+      klass.reset_column_information
+      klass.column_names
+    end
+  end
+  
+  module SchemaDumper
+    # Only output normal tables in the body of the schema
+    def table_with_views_in_migrations(table, stream)
+      table_without_views_in_migrations(table, stream) unless @connection.table_is_view?(table)
+    end
+    
+    # After all table definitions, print view definitions
+    def trailer_with_views_in_migrations(stream)
+      views(stream)
+      
+      trailer_without_views_in_migrations(stream)
+    end
+    
+    def views(stream)
+      @connection.views.each do |table|
+        stream.puts "if ViewsInMigrations.use_views?(current_database)"        
+          view(table,stream)        
+        stream.puts "else\n\n"        
+          table_without_views_in_migrations(table, stream)        
+        stream.puts "end\n\n"
+      end
+    end
+    
+    def view(view_name, stream)      
+      stream.puts <<-WARNING
+  #############################################################
+  # Warning: SchemaDumper cannot determine view dependencies! #
+  #   You may have to manually reorder your views to run      #
+  # `rake db:schema:load` successfully.                       #
+  #############################################################
+  
+  WARNING
+  
+      out = StringIO.new
+      out.puts "  create_view #{view_name.inspect}, %{"   
+  
+      sql = @connection.define_view(view_name, true)  
+  
+      sql.split('\n').each do |line|
+        out.puts "    #{line}"
+      end
+  
+      out.puts "  }, :force => true\n\n"
+  
+      out.rewind
+      stream.print out.read      
+    end
+  end
+end
+
+if ViewsInMigrations.views_supported?
+
+  ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
+    include ViewsInMigrations::SchemaStatements  
+  end
+
+  ActiveRecord::SchemaDumper.class_eval do
+    include ViewsInMigrations::SchemaDumper  
+    alias_method_chain :table, :views_in_migrations
+    alias_method_chain :trailer, :views_in_migrations
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+# Find source files
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'spec'
+require 'spec/autorun'
+
+require 'rubygems'
+require 'active_record'
+
+# Establish connection 
+conn = { :adapter => 'mysql',
+  :database => '',
+  :username => 'root', 
+  :password => '',
+  :encoding => 'utf8' }
+
+conn[:socket] = Pathname.glob(%w[
+  /opt/local/var/run/mysql5/mysqld.sock
+  /tmp/mysqld.sock
+  /tmp/mysql.sock
+  /var/mysql/mysql.sock
+  /var/run/mysqld/mysqld.sock
+]).find { |path| path.socket? }
+
+ActiveRecord::Base.establish_connection(conn)
+ActiveRecord::Base.connection.recreate_database("views_in_migrations_test")
+
+conn[:database] = "views_in_migrations_test"
+ActiveRecord::Base.establish_connection(conn)
+
+# Must be required after AR connection is established
+require 'views_in_migrations'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/views_in_migrations_spec.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "ViewsInMigrations" do
+  before(:all) do
+    ActiveRecord::Base.connection.create_table("people") do |t|
+      t.id
+      t.string :name
+      t.boolean :manager
+    end
+    
+    ActiveRecord::Base.connection.create_view("managers", "SELECT * from people where manager IS TRUE")
+    class Person < ActiveRecord::Base; end;
+    class Manager < ActiveRecord::Base; end;
+    
+    @conn = ActiveRecord::Base.connection
+  end
+  
+  it "can use views with mysql" do
+    ViewsInMigrations.views_supported?.should == true
+  end
+  
+  it "knows a view from a table" do
+    @conn.table_is_view?("people").should == false
+    @conn.table_is_view?("managers").should == true
+  end
+  
+  it "quietly drops a non-existing view" do
+    @conn.drop_view("doesn't_exist")
+  end
+  
+  it "creates a view" do
+    lambda { @conn.create_view("drones", "SELECT * from people where manager IS FALSE") }.should_not raise_error()
+    @conn.views.should include("drones")
+  end
+  
+  it "drops an existing view" do
+    lambda { @conn.drop_view("drones")}.should_not raise_error()
+    @conn.views.should_not include("drones")
+  end
+  
+  it "finds view rows and creates AR instances" do
+    @bob = Person.create :name => "Bob", :manager => true
+    @bob.id.should == Manager.find_by_name("Bob").id
+  end
+  
+  it "gets column names from the database" do
+    Manager.should_receive(:reset_column_information).and_return(true)
+    Manager.should_receive(:column_names).and_return(["a"])
+    
+    @conn.current_column_names_for(Manager).should == ["a"]
+  end
+  
+  it "asserts the presence and absence of columns" do
+    lambda { @conn.assert_presence_of_column Manager, :name
+             @conn.assert_absence_of_column  Manager, :fake }.should_not raise_error
+    lambda { @conn.assert_presence_of_column Manager, :fake }.should raise_error(Mysql::Error)
+    lambda { @conn.assert_absence_of_column  Manager, :name }.should raise_error(Mysql::Error)
+  end
+  
+  it "returns the definition of a view" do
+    # @conn.view_definition('managers').should ??
+  end
+  
+  it "dumps views after tables" do
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(@conn, stream)
+    stream.rewind
+    schema = stream.read
+    schema.index("managers").should > schema.index("people")
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: views_in_migrations
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- asolove
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-25 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: active_record
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 3
+        - 2
+        version: 2.3.2
+  type: :runtime
+  version_requirements: *id002
+description: ViewsInMigrations provides helper methods for using MySQL views behind ActiveRecord models. It helps you define, modify, test, and refresh your views. And it also handles correctly dumping the definitions to schema.rb.
+email: asolove@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/views_in_migrations.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/views_in_migrations_spec.rb
+has_rdoc: true
+homepage: http://github.com/asolove/views_in_migrations
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Use MySQL views to back ActiveRecord models, and define them in your migrations.
+test_files: 
+- spec/spec_helper.rb
+- spec/views_in_migrations_spec.rb