redhillonrails_core 1.0.9.1 → 1.1.0

data/Gemfile.lock

@@ -1,50 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activerecord (2.3.10)
-      activesupport (= 2.3.10)
-    activesupport (2.3.10)
-    archive-tar-minitar (0.5.2)
-    columnize (0.3.1)
-    gemcutter (0.6.1)
-    git (1.2.5)
-    jeweler (1.4.0)
-      gemcutter (>= 0.1.0)
-      git (>= 1.2.5)
-      rubyforge (>= 2.0.0)
-    json_pure (1.4.6)
-    linecache (0.43)
-    linecache19 (0.5.11)
-      ruby_core_source (>= 0.1.4)
-    micronaut (0.3.0)
-    pg (0.9.0)
-    rake (0.8.7)
-    ruby-debug (0.10.3)
-      columnize (>= 0.1)
-      ruby-debug-base (~> 0.10.3.0)
-    ruby-debug-base (0.10.3)
-      linecache (>= 0.3)
-    ruby-debug-base19 (0.11.24)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby_core_source (>= 0.1.4)
-    ruby-debug19 (0.11.6)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby-debug-base19 (>= 0.11.19)
-    ruby_core_source (0.1.4)
-      archive-tar-minitar (>= 0.5.2)
-    rubyforge (2.0.4)
-      json_pure (>= 1.1.7)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activerecord (< 3.0.0)
-  jeweler
-  micronaut
-  pg
-  rake
-  ruby-debug
-  ruby-debug19

data/Rakefile

@@ -1,76 +0,0 @@
-# encoding: utf-8
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "redhillonrails_core"
-    gem.summary = %Q{RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins}
-    gem.description = %Q{RedHill on Rails Core is a plugin that features to support other RedHill on Rails plugins. It creates and drops views and foreign-keys or obtains indexes directly from a model class.}
-    gem.email = "michal.lomnicki@gmail.com"
-    gem.homepage = "http://github.com/mlomnicki/redhillonrails_core"
-    gem.authors = ["Michał Łomnicki"]
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-
-    gem.add_dependency "activerecord"
-
-    gem.add_development_dependency "micronaut"
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
-end
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "redhillonrails_core #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
-require "micronaut/rake_task"
-Micronaut::RakeTask.new(:examples) do |examples|
-  examples.pattern = "examples/**/*_example.rb"
-  examples.ruby_opts << "-Ilib -Iexamples"
-end
-
-Micronaut::RakeTask.new(:rcov) do |examples|
-  examples.pattern = "examples/**/*_example.rb"
-  examples.rcov_opts = "-Ilib -Iexamples"
-  examples.rcov = true
-end
-
-task :examples => :check_dependencies
-
-task :default => :examples
-
-namespace :postgresql do
-  task :examples do
-    ENV["ADAPTER"] = "postgresql"
-    Rake::Task["examples"].invoke
-  end
-end

data/VERSION

@@ -1 +0,0 @@
-1.0.9.1

data/examples/example_helper.rb

@@ -1,44 +0,0 @@
-require "micronaut"
-require "active_record"
-require "redhillonrails_core"
-require "fileutils"
-
-begin
-  require "ruby-debug"
-rescue LoadError
-  # Don't care - debugging won't be available
-end
-
-# Log data somewhere interesting
-FileUtils.mkdir_p("log") rescue nil
-ActiveRecord::Base.logger = Logger.new("log/test.log")
-
-# The model we'll be playing along with. Nothing ActiveRecord-like is expected or required here.
-class User < ActiveRecord::Base
-end
-
-# We drop and reload the schema on all specs, to make it easier to know what'll be in the DB
-case ENV["ADAPTER"]
-when "postgresql"
-  ActiveRecord::Base.establish_connection :adapter => "postgresql", :database => "redhillonrails_core_test", :min_messages => "warning"
-else
-  raise ArgumentError, "ADAPTER environment variable left unset: run tests and set ADAPTER to a known value. Valid values are: postgresql"
-end
-
-Micronaut.configure do |c|
-  c.before :each do
-    @migrator.suppress_messages do
-      @migrator.up
-    end
-  end
-
-  c.before :each do
-    User.reset_column_information
-  end
-
-  c.after :each do
-    @migrator.suppress_messages do
-      @migrator.down
-    end
-  end
-end

data/examples/postgresql_index_parser_example.rb

@@ -1,198 +0,0 @@
-require "example_helper"
-require "red_hill_consulting/core/active_record/connection_adapters/postgresql_adapter"
-
-describe RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::PostgresqlAdapter, "simple indexes" do
-
-  before :all do
-    @migrator = Class.new(ActiveRecord::Migration) do
-      def self.up
-        create_table :users do |t|
-          t.string :username
-        end
-
-        add_index :users, :username
-      end
-
-      def self.down
-        drop_table :users
-      end
-    end
-  end
-
-  it "should parse the index and return appropriate information" do
-    indexes = User.indexes
-    indexes.length.should == 1
-
-    index = indexes.first
-    index.name.should == "index_users_on_username"
-    index.columns.should == ["username"]
-    index.unique.should == false
-    index.should be_case_sensitive
-    index.expression.should be_nil
-  end
-
-end
-
-describe RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::PostgresqlAdapter, "unique indexes" do
-
-  before :all do
-    @migrator = Class.new(ActiveRecord::Migration) do
-      def self.up
-        create_table :users do |t|
-          t.string :username
-        end
-
-        add_index :users, :username, :unique => true, :case_sensitive => true
-      end
-
-      def self.down
-        drop_table :users
-      end
-    end
-  end
-
-  it "should parse the index and return appropriate information" do
-    indexes = User.indexes
-    indexes.length.should == 1
-
-    index = indexes.first
-    index.name.should == "index_users_on_username"
-    index.columns.should == ["username"]
-    index.unique.should == true
-    index.should be_case_sensitive
-    index.expression.should be_nil
-  end
-
-end
-
-describe RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::PostgresqlAdapter, "case-insensitive indexes" do
-
-  before :all do
-    @migrator = Class.new(ActiveRecord::Migration) do
-      def self.up
-        create_table :users do |t|
-          t.string :username
-        end
-
-        add_index :users, :username, :case_sensitive => false
-      end
-
-      def self.down
-        drop_table :users
-      end
-    end
-  end
-
-  it "should parse the index and return appropriate information" do
-    indexes = User.indexes
-    indexes.length.should == 1
-
-    index = indexes.first
-    index.name.should == "index_users_on_username"
-    index.columns.should == ["username"]
-    index.unique.should == false
-    index.should_not be_case_sensitive
-    index.expression.should be_nil
-  end
-
-end
-
-describe RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::PostgresqlAdapter, "partial indexes" do
-
-  before :all do
-    @migrator = Class.new(ActiveRecord::Migration) do
-      def self.up
-        create_table :users do |t|
-          t.string :username, :state
-        end
-
-        add_index :users, :username, :unique => true, :name => "index_users_on_active_usernames", :conditions => {:state => "active"}
-      end
-
-      def self.down
-        drop_table :users
-      end
-    end
-  end
-
-  it "should parse conditional index and report conditions" do
-    indexes = User.indexes
-    indexes.length.should == 1
-
-    index = indexes.first
-    index.should be_case_sensitive
-    index.columns.should == ["username"]
-
-    # FIXME: This is subject to change depending on the PostgreSQL version
-    index.conditions.should == "state::text = 'active'::text"
-  end
-
-end
-
-describe RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::PostgresqlAdapter, "expression indexes" do
-
-  before :all do
-    @migrator = Class.new(ActiveRecord::Migration) do
-      def self.up
-        create_table :users do |t|
-          t.string :username, :state
-        end
-
-        add_index :users, :expression => "USING gin (to_tsvector('english', username))", :name => "index_users_full_text"
-      end
-
-      def self.down
-        drop_table :users
-      end
-    end
-  end
-
-  it "should parse conditional index and report conditions" do
-    indexes = User.indexes
-    indexes.length.should == 1
-
-    index = indexes.first
-    index.unique.should == false
-    index.should be_case_sensitive
-    index.columns.should be_nil
-
-    # FIXME: This is subject to change depending on the PostgreSQL version
-    index.conditions.should be_nil
-    index.expression.should == "gin (to_tsvector('english'::regconfig, username::text))"
-  end
-
-end
-
-describe RedHillConsulting::Core::ActiveRecord::ConnectionAdapters::PostgresqlAdapter, "case insensitive + partial index" do
-
-  before :all do
-    @migrator = Class.new(ActiveRecord::Migration) do
-      def self.up
-        create_table :users do |t|
-          t.string :username, :state
-        end
-
-        add_index :users, :username, :unique => true, :case_sensitive => false, :conditions => {:state => %w(active suspended invited)}
-      end
-
-      def self.down
-        drop_table :users
-      end
-    end
-  end
-
-  it "should parse as an expression index" do
-    indexes = User.indexes
-    indexes.length.should == 1
-
-    index = indexes.first
-    index.unique.should == false   # We don't attempt to determine if this is true/false when it's an expression index
-    index.should be_case_sensitive # Same here: return the default value - expression trumps all other values
-    index.columns.should be_nil    # And we know the columns aren't specified when it's an expression
-
-    # FIXME: This is subject to change depending on the PostgreSQL version
-    index.conditions.should be_nil
-    index.expression.should == "btree (lower(username::text)) WHERE state::text = ANY (ARRAY['active'::character varying, 'suspended'::character varying, 'invited'::character varying]::text[])"
-  end
-
-end

data/lib/red_hill_consulting/core/active_record/base.rb

@@ -1,61 +0,0 @@
-module RedHillConsulting::Core::ActiveRecord
-  module Base
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def self.extended(base)
-        class << base
-          alias_method_chain :columns, :redhillonrails_core
-          alias_method_chain :abstract_class?, :redhillonrails_core
-          alias_method_chain :reset_column_information, :redhillonrails_core
-        end
-      end
-
-      def base_class?
-        self == base_class
-      end
-
-      def abstract_class_with_redhillonrails_core?
-        abstract_class_without_redhillonrails_core? || !(name =~ /^Abstract/).nil?
-      end
-
-      def columns_with_redhillonrails_core
-        unless @columns
-          columns_without_redhillonrails_core
-          cols = columns_hash
-          indexes.each do |index|
-            next if index.columns.blank?
-            column_name = index.columns.reverse.detect { |name| name !~ /_id$/ } || index.columns.last
-            column = cols[column_name]
-            column.case_sensitive = index.case_sensitive?
-            column.unique_scope = index.columns.reject { |name| name == column_name } if index.unique
-          end
-        end
-        @columns
-      end
-
-      def reset_column_information_with_redhillonrails_core
-          reset_column_information_without_redhillonrails_core
-          @indexes = @foreign_keys = nil
-      end
-
-      def pluralized_table_name(table_name)
-        ActiveRecord::Base.pluralize_table_names ? table_name.to_s.pluralize : table_name
-      end
-
-      def indexes
-        @indexes ||= connection.indexes(table_name, "#{name} Indexes")
-      end
-
-      def foreign_keys
-        @foreign_keys ||= connection.foreign_keys(table_name, "#{name} Foreign Keys")
-      end
-
-      def reverse_foreign_keys
-        connection.reverse_foreign_keys(table_name, "#{name} Reverse Foreign Keys")
-      end
-    end
-  end
-end

data/lib/red_hill_consulting/core/active_record/connection_adapters/abstract_adapter.rb

@@ -1,71 +0,0 @@
-module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
-  module AbstractAdapter
-    def self.included(base)
-      base.alias_method_chain :initialize, :redhillonrails_core
-      base.alias_method_chain :drop_table, :redhillonrails_core
-    end
-    
-    def initialize_with_redhillonrails_core(*args)
-      initialize_without_redhillonrails_core(*args)
-      adapter = nil
-      case adapter_name
-      # name of MySQL adapter depends on mysql gem
-      # * with mysql gem adapter is named MySQL
-      # * with mysql2 gem adapter is named Mysql2
-      # Here we handle this and hopefully futher adapter names
-      when /^MySQL/i 
-        adapter = 'MysqlAdapter'
-      when 'PostgreSQL' 
-        adapter = 'PostgresqlAdapter'
-      when 'SQLite' 
-        adapter = 'SqliteAdapter'
-      end
-      if adapter 
-        adapter_module = RedHillConsulting::Core::ActiveRecord::ConnectionAdapters.const_get(adapter)
-        self.class.send(:include, adapter_module) unless self.class.include?(adapter_module)
-      end
-    end
-    
-    def create_view(view_name, definition)
-      execute "CREATE VIEW #{view_name} AS #{definition}"
-    end
-    
-    def drop_view(view_name)
-      execute "DROP VIEW #{view_name}"
-    end
-    
-    def views(name = nil)
-      []
-    end
-    
-    def view_definition(view_name, name = nil)
-    end
-
-    def foreign_keys(table_name, name = nil)
-      []
-    end
-
-    def reverse_foreign_keys(table_name, name = nil)
-      []
-    end
-
-    def add_foreign_key(table_name, column_names, references_table_name, references_column_names, options = {})
-      foreign_key = ForeignKeyDefinition.new(options[:name], table_name, column_names, ActiveRecord::Migrator.proper_table_name(references_table_name), references_column_names, options[:on_update], options[:on_delete], options[:deferrable])
-      execute "ALTER TABLE #{table_name} ADD #{foreign_key}"
-    end
-
-    def remove_foreign_key(table_name, foreign_key_name, options = {})
-      execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{foreign_key_name}"
-    end
-
-    def drop_table_with_redhillonrails_core(name, options = {})
-      reverse_foreign_keys(name).each { |foreign_key| remove_foreign_key(foreign_key.table_name, foreign_key.name, options) }
-      drop_table_without_redhillonrails_core(name, options)
-    end
-
-    def supports_partial_indexes?
-      false
-    end
-
-  end
-end

data/lib/red_hill_consulting/core/active_record/connection_adapters/column.rb

@@ -1,21 +0,0 @@
-module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
-	module Column
-	  attr_accessor :unique_scope
-	  attr_accessor :case_sensitive
-	  alias case_sensitive? case_sensitive
-
-	  def unique?
-	    !unique_scope.nil?
-	  end
-
-	  def required_on
-	    if null
-	      nil
-	    elsif default.nil?
-	      :save
-	    else
-	      :update
-	    end
-	  end
-	end
-end

data/lib/red_hill_consulting/core/active_record/connection_adapters/foreign_key_definition.rb

@@ -1,26 +0,0 @@
-module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
-  class ForeignKeyDefinition < Struct.new(:name, :table_name, :column_names, :references_table_name, :references_column_names, :on_update, :on_delete, :deferrable)
-    ACTIONS = { :cascade => "CASCADE", :restrict => "RESTRICT", :set_null => "SET NULL", :set_default => "SET DEFAULT", :no_action => "NO ACTION" }.freeze
-
-    def to_dump
-      dump = "add_foreign_key"
-      dump << " #{table_name.inspect}, [#{Array(column_names).collect{ |name| name.inspect }.join(', ')}]"
-      dump << ", #{references_table_name.inspect}, [#{Array(references_column_names).collect{ |name| name.inspect }.join(', ')}]"
-      dump << ", :on_update => :#{on_update}" if on_update
-      dump << ", :on_delete => :#{on_delete}" if on_delete
-      dump << ", :deferrable => #{deferrable}" if deferrable
-      dump << ", :name => #{name.inspect}" if name
-      dump
-    end
-
-    def to_sql
-      sql = name ? "CONSTRAINT #{name} " : ""
-      sql << "FOREIGN KEY (#{Array(column_names).join(", ")}) REFERENCES #{references_table_name} (#{Array(references_column_names).join(", ")})"
-      sql << " ON UPDATE #{ACTIONS[on_update]}" if on_update
-      sql << " ON DELETE #{ACTIONS[on_delete]}" if on_delete
-      sql << " DEFERRABLE" if deferrable
-      sql
-    end
-    alias :to_s :to_sql
-  end
-end

data/lib/red_hill_consulting/core/active_record/connection_adapters/index_definition.rb

@@ -1,13 +0,0 @@
-module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
-  module IndexDefinition
-    attr_accessor :conditions, :expression
-
-    def case_sensitive?
-      @case_sensitive.nil? ? true : @case_sensitive
-    end
-
-    def case_sensitive=(case_sensitive)
-      @case_sensitive = case_sensitive
-    end
-  end
-end

data/lib/red_hill_consulting/core/active_record/connection_adapters/mysql4_adapter.rb

@@ -1,37 +0,0 @@
-module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
-  # MySQL4-specific behaviors
-  module Mysql4Adapter
-    def reverse_foreign_keys(table_name, name = nil)
-      tables = execute("SHOW TABLES")
-
-      foreign_keys = []
-      
-      tables.each do |table|
-        results = execute("SHOW CREATE TABLE #{table}")
-        results.each do |row|
-          row[1].lines.each do |line|
-            if line =~ /^  CONSTRAINT [`"](.+?)[`"] FOREIGN KEY \([`"](.+?)[`"]\) REFERENCES [`"](.+?)[`"] \((.+?)\)( ON DELETE (.+?))?( ON UPDATE (.+?))?,?$/
-              name = $1
-              column_names = $2
-              references_table_name = $3
-              references_column_names = $4
-              on_update = $8
-              on_delete = $6
-              on_update = on_update.downcase.gsub(' ', '_').to_sym if on_update
-              on_delete = on_delete.downcase.gsub(' ', '_').to_sym if on_delete
-
-              if references_table_name == table_name
-                foreign_keys << ForeignKeyDefinition.new(name,
-                                               table, column_names.gsub('`', '').split(', '),
-                                               references_table_name, references_column_names.gsub('`', '').split(', '),
-                                               on_update, on_delete)
-              end
-            end
-          end
-        end
-      end
-
-      foreign_keys
-    end
-  end
-end

data/lib/red_hill_consulting/core/active_record/connection_adapters/mysql5_adapter.rb

@@ -1,40 +0,0 @@
-module RedHillConsulting::Core::ActiveRecord::ConnectionAdapters
-  # MySQL5-specific behaviors
-  module Mysql5Adapter
-    def reverse_foreign_keys(table_name, name = nil)
-      @@schema ||= nil
-      @@schema_version ||= 0
-      current_version = ActiveRecord::Migrator.current_version
-      if @@schema.nil? || @@schema_version != current_version
-        @@schema_version = current_version
-        ans = execute(<<-SQL, name)
-        SELECT constraint_name, table_name, column_name, referenced_table_name, referenced_column_name
-          FROM information_schema.key_column_usage
-         WHERE table_schema = SCHEMA()
-           AND referenced_table_schema = table_schema
-         ORDER BY constraint_name, ordinal_position;
-        SQL
-        @@schema = []
-        ans.each do | row |
-          @@schema << [row[0], row[1], row[2], row[3], row[4]]
-        end
-      end
-      results = @@schema
-      current_foreign_key = nil
-      foreign_keys = []
-
-      results.each do |row|
-        next unless table_name.casecmp(row[3]) == 0
-        if current_foreign_key != row[0]
-          foreign_keys << ForeignKeyDefinition.new(row[0], row[1], [], row[3], [])
-          current_foreign_key = row[0]
-        end
-
-        foreign_keys.last.column_names << row[2]
-        foreign_keys.last.references_column_names << row[4]
-      end
-
-      foreign_keys
-    end
-  end
-end