vex 0.2

data/lib/vex/active_record.rb

@@ -0,0 +1,3 @@
+require "#{File.dirname(__FILE__)}/boot"
+Vex.load_directory "base"
+Vex.load_directory "active_record"

data/lib/vex/active_record/advisory_lock.rb

@@ -0,0 +1,11 @@
+require "active_record/connection_adapters/abstract_adapter"
+
+module ActiveRecord::AdvisoryLock
+  TIMEOUT=10
+end
+
+# --- load advisory lock extensions -----------------------------------
+
+load "#{File.dirname(__FILE__)}/advisory_lock/mysql_adapter.rb"
+# load "#{File.dirname(__FILE__)}/advisory_lock/postgresql_adapter.rb"
+load "#{File.dirname(__FILE__)}/advisory_lock/sqlite_adapter.rb"

data/lib/vex/active_record/advisory_lock/mysql_adapter.rb

@@ -0,0 +1,16 @@
+module ActiveRecord::ConnectionAdapters
+  class MysqlAdapter < AbstractAdapter
+    TIMEOUT=5
+    
+    def locked(lock, opts = {})
+      lock = "#{current_database}.rails.#{lock}"
+
+      begin
+        execute "SELECT GET_LOCK(#{quote(lock)},#{opts[:timeout] || TIMEOUT})"
+        yield
+      ensure
+        execute "SELECT RELEASE_LOCK(#{quote(lock)})"
+      end
+    end
+  end
+end

data/lib/vex/active_record/advisory_lock/sqlite_adapter.rb

@@ -0,0 +1,78 @@
+module ActiveRecord::ConnectionAdapters
+  class SQLiteAdapter < AbstractAdapter
+    def locked(lock, opts = {}, &block)
+      database = instance_variable_get("@config")[:database]
+      return yield if database == ":memory:"
+
+      File.locked("#{database}.#{lock}", &block)
+    end
+  end
+end
+
+#
+# Note: these tests are un within multiple threads of a single application.
+# This is not the usual intention of locking code: AbstractAdapter#lock
+# should be used to lock across processes!
+#
+# Consequently locking does not work on in-memory sqlite databases.
+module ActiveRecord::AdvisoryLock::Etest
+  class Test < ActiveRecord::Base
+    establish_connection :adapter => "sqlite3",
+      :database => "#{App.tmpdir}/lock.sqlite3"
+  end
+  
+  def test_sqlite
+    @run = 0
+
+    connection = Test.connection
+
+    #
+    # In this example th2 would run first, because th1 goes to sleep
+    # first.
+    th1 = Thread.new { 
+      Thread.sleep 0.1
+      connection.locked("etest") do
+        assert_equal(2, @run)
+        @run = 1
+      end
+    }
+
+    th2 = Thread.new { 
+      Thread.sleep 0.05
+      connection.locked("etest") do
+        @run = 2
+      end
+    }
+
+    th1.join
+    th2.join
+    
+    assert_equal(1, @run)
+
+    #
+    # In this example th1 would lock using the connection before th2 tries to
+    # lock it. Consequenty the th1 action would run first.
+    @run = 0
+    
+    th1 = Thread.new { 
+      connection.locked("etest") do
+        Thread.sleep 0.1
+        assert_equal(0, @run)
+        @run = 1
+      end
+    }
+
+    th2 = Thread.new { 
+      Thread.sleep 0.05
+      connection.locked("etest") do
+        assert_equal(1, @run)
+        @run = 2
+      end
+    }
+
+    th1.join
+    th2.join
+    
+    assert_equal(2, @run)
+  end
+end

data/lib/vex/active_record/belongs_to_many.rb

@@ -0,0 +1,143 @@
+# belongs_to_many gives you a behaviour that you would typically (and 
+# for a reason) do via has_and_belongs_to_many or has_many. You would
+# do this for performance reasons under a quite small set of circumstances:
+#
+# * your habtm code runs slow, because of the huge number of database
+#   transactions involved
+# * you will never search by the associated data
+#
+# In these cases belongs_to_many might help. It not only denormalizes the 
+# database structure, it uses a single text column in the host table to 
+# hold the referenced ids, and uses ActiveRecord's read_attribute and 
+# write_attribute methods to automatically convert between IDs involved 
+# and actual objects.
+# 
+# belongs_to_many has a number of limitations over AR' has_and_belongs_to_many
+# and has_many associations:
+#
+# * it is not an association proxy: that means you cannot extend it, 
+#   cannot search through it, etc.
+# * The '<<' operator is not allowed and throws an exceptions: As
+#   we wanted to stay pretty close to rails default behaviour we had
+#   to disable that method. Otherwise all performance gain would be
+#   lost anyways.
+# * You cannot search via the associated data, because there is no
+#   easy way to join the associated tables.
+# * There might be a bogus write when setting the column
+#   
+# ONCE MORE! THIS IS NOT A MORE PERFORMANT replacement for
+# has_and_belongs_to_many or has_many!
+#
+module BelongsToMany
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    #
+    # define a belongs_to_many pseudo-association. 
+    # Supported options:
+    #
+    # :class_name .. The name of the class that is referenced
+    # :supersedes .. code to roll out the old behaviour. This is needed
+    #    for the model to survive migrations and to semi-automatically
+    #    migrate the data.
+    #
+    # Example:
+=begin
+    belongs_to_many :havings,
+      :supersedes => lambda { |name|
+        has_and_belongs_to_many name, :join_table => :belongings_havings, :class_name => "Having"
+      }
+=end
+    #
+    def belongs_to_many(name, opts = {})
+      s = name.to_s.singularize
+      ids_name = "#{s}_ids"
+      
+      if supersedes = opts.delete(:supersedes)
+        # if the belongs_to_many column exists we instanciate the superseded
+        # association with the name + "_superseded" and build the belongs_to_many 
+        # association; if not, we only build the old association with the 
+        # current name.
+        #
+        
+        if column_names.include?(ids_name)
+          supersedes.call("#{name}_superseded")
+          belongs_to_many(name, opts)
+        else
+          supersedes.call(name)
+        end
+
+        return
+      end
+      
+      #
+      class_name = opts[:class_name] || s.camelize.constantize
+
+      self.class_eval code = <<RUBY
+      def #{name}
+        #{class_name}.find(#{ids_name}).freeze
+      end
+
+      def #{name}=(array)
+        self.#{ids_name} = array.collect(&:id).uniq
+        save! unless new_record?
+      end
+
+      def #{ids_name}
+        read_attribute(:#{ids_name}).to_s.split(/[^0-9]+/).reject(&:blank?).collect { |s| Integer(s) }
+      end
+
+      def #{ids_name}=(array)
+        write_attribute(:#{ids_name}, array.empty? ? nil : "/" + array.join("/") + "/")
+      end
+RUBY
+    end
+  end
+
+  module Migrations
+    #
+    # e.g. 
+    # 
+    #  migrate_belongs_to_many(:old_belongings => :belongings)
+    #
+    def migrate(klass, up_or_down, *assocs)
+      klass.reset_column_information
+
+      case up_or_down
+      when :down  then assocs.map! { |assoc| [ "#{assoc}", "#{assoc}_superseded" ] }
+      when :up    then assocs.map! { |assoc| [ "#{assoc}_superseded", "#{assoc}" ] }
+      end
+      
+      klass.all.with_progress.each do |model|
+        assocs.each do |from, to|
+          model.send "#{to}=", model.send(from)
+        end
+
+        # Try to save. Warn, if that fails.
+        unless model.save
+          STDERR.puts "#{model.class}##{model.id}: #{errors.full_messages.join(", ")}"
+          model.save_without_validation
+        end
+
+        # verify migration...
+
+        new_model = klass.find(model.id)
+
+        assocs.each do |from, to|
+          next if new_model.send(to) == model.send(from)
+          STDERR.puts "#{model.class}##{model.id}: Mismatch on ##{from.inspect} -> #{to.inspect}" 
+        end
+
+        self
+      end
+    end
+  end
+
+  extend Migrations
+end
+
+class ActiveRecord::Base
+  include BelongsToMany
+end

data/lib/vex/active_record/find_by_extension.rb

@@ -0,0 +1,70 @@
+module ActiveRecord::FindByExtension
+  def find_all_by(args, opts = nil)
+    return find(:all, :conditions => args) if opts.nil?
+
+    with_scope(:find => opts) do find_all_by(args) end
+  end
+
+  def find_by(args, opts = nil)
+    return find(:first, :conditions => args) if opts.nil?
+
+    with_scope(:find => opts) do find_by(args) end
+  end
+
+  def find_by!(args, opts = nil)
+    find_by(args, opts) || 
+      raise(ActiveRecord::RecordNotFound, "Couldn't find #{self} with #{args.inspect}")
+  end
+end
+
+class ActiveRecord::Base
+  extend ActiveRecord::FindByExtension
+end
+
+module ActiveRecord::FindByExtension::Etest
+  class Data < ActiveRecord::Base
+  end
+
+  def setup
+    Data.lite_table do
+      string :name
+      string :age
+    end
+
+    Data.create! :name => "name", :age => 2
+    Data.create! :name => "name", :age => 3
+    Data.create! :name => "name", :age => 4
+    Data.create! :name => "name2", :age => 2
+    Data.create! :name => "name2", :age => 3
+    Data.create! :name => "name2", :age => 4
+
+    assert_equal(6, Data.count)
+  end
+  
+  def teardown
+    Data.destroy_all
+  end
+  
+  def test_find_all_by
+    assert_equal(3, Data.find_all_by(:name => "name").length)
+    assert_equal(3, Data.find_all_by(:name => [ "name" ]).length)
+    assert_raise(ActiveRecord::StatementInvalid) {
+      assert_equal(3, Data.find_all_by(:unknown => [ "name" ]).length)
+    }
+
+    assert_equal(2, Data.find_all_by(:name => [ "name" ], :age => [1, 2, 3]).length)
+    assert_equal(2, Data.find_all_by({:name => [ "name" ]}, :conditions => { :age => [1, 2, 3]}).length)
+  end
+
+  def test_find_by
+    assert_equal("name", Data.find_by(:name => "name").name)
+    assert_equal(nil, Data.find_by(:name => "namex"))
+  end
+
+  def test_find_by!
+    assert_equal("name", Data.find_by!(:name => "name").name)
+    assert_raise(ActiveRecord::RecordNotFound) do
+      Data.find_by!(:name => "namex")
+    end
+  end
+end

data/lib/vex/active_record/gem.rb

@@ -0,0 +1,8 @@
+#
+# Initialize the gem
+
+require "active_record"
+
+if defined?(ActiveRecord)
+  load "#{File.dirname(__FILE__)}/plugins/default_value_for/init.rb"
+end

data/lib/vex/active_record/lite_table.rb

@@ -0,0 +1,139 @@
+module ActiveRecord::LiteTable
+  class ColumnTypeMismatch < RuntimeError; end
+  
+  class Validator
+    attr :klass
+    attr :options
+    
+    def initialize(klass, options)
+      @klass = klass
+      @options = options
+    end
+
+    def column(name, type, opts = {})
+      if !existing_column = klass.columns_hash[name.to_s]
+        index_opt = opts.delete :index
+        klass.connection.add_column(klass.table_name, name, type, opts)
+        klass.reset_column_information
+        
+        index(name, :unique => (index == :unique)) if index_opt 
+        return
+      end
+      
+      return if existing_column.type == type
+      
+      raise ColumnTypeMismatch, 
+        "Column type mismatch on #{klass}##{name}: is #{existing_column.type}, but should be #{type}"
+    end
+
+    def timestamps(*cols)
+      opts = cols.extract_options!
+      cols = [ :created_at, :updated_at ] if cols.empty?
+
+      index_opts = case index_opts = opts[:index]
+      when Symbol then [ index_opts ]
+      when Array  then index_opts
+      when true   then [:created_at, :updated_at]
+      else []
+      end
+      
+      index_opts &= cols
+      
+      cols.each do |col|
+        column(col, :datetime, :index => index_opts.include?(col))
+      end
+    end
+
+    SHORTCUTS=%w(primary_key string text integer float
+      decimal datetime timestamp time date binary boolean)
+
+    SHORTCUTS.map(&:to_sym).each do |shortcut| 
+      define_method(shortcut) do |name, *opts|
+        column(name, shortcut, *opts)
+      end
+    end
+    
+    def index(column_name, options={})
+      begin
+        klass.connection.add_index klass.table_name, column_name, options
+      rescue
+        # TODO: It would be *great* to have a unique exception type here!
+        # But even in this case we have to check the options for identity!
+        case $!
+        when ActiveRecord::StatementInvalid, SQLite3::SQLException
+          return if $!.to_s =~ /Duplicate key name/       # for MySQL
+          return if $!.to_s =~ /index .* already exists/  # for Sqlite3
+        end
+        
+        raise
+      end
+    end
+  end
+  
+  def lite_table(opts={}, &block)
+    # if table does not exist: create it, according to specs.
+    connection.tables.include?(table_name) || 
+      connection.create_table(table_name, opts) {}
+
+    # run validator: This creates missing columns and indices. It never drops
+    # any data from the database, though. 
+    validator = Validator.new(self, opts)
+    Proc.new.bind(validator).call
+  end
+  
+  def remove_columns(*columns)
+    connection.remove_columns table_name, *columns
+    reset_column_information
+  end
+end
+
+ActiveRecord::Base.extend ActiveRecord::LiteTable
+
+module ActiveRecord::LiteTable::Etest
+  class TestLiteModel < ActiveRecord::Base
+  end
+  
+  def test_lite_table
+    TestLiteModel.lite_table do
+    end
+    
+    assert_equal(%w(id), TestLiteModel.column_names.sort)
+
+    # we can use this class.
+    m = TestLiteModel.create!
+    assert_not_nil(m)
+    assert_not_nil(m.id)
+    
+    # we cannot change a column type
+    assert_raise(ActiveRecord::LiteTable::ColumnTypeMismatch) {  
+      TestLiteModel.lite_table do
+        string :id
+      end
+    }
+
+    # we can add additional columns
+    TestLiteModel.lite_table do
+      string :name
+    end
+    
+    # we can use this class.
+    m = TestLiteModel.create! :name => "name"
+    assert_not_nil(m)
+    assert_not_nil(m.id)
+    assert_equal("name", m.name)
+
+    # we can add indices: we test index creation by creating a unique index
+    # on a column that contains two identical entries.
+    m = TestLiteModel.create! :name => "name"
+
+    assert_raises(ActiveRecord::StatementInvalid) {  
+      TestLiteModel.lite_table do
+        index :name, :unique => true
+      end
+    }
+
+    TestLiteModel.lite_table do
+      index :name
+    end
+  end
+end