activegroonga 0.0.7 → 1.0.0

data/lib/active_groonga/callbacks.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -15,12 +15,31 @@
 
 module ActiveGroonga
   module Callbacks
-    class << self
-      def included(base)
-        base.class_eval do
-          include ActiveRecord::Callbacks
-        end
-      end
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :find, :only => :after
+      define_model_callbacks :save, :create, :update, :destory
+    end
+
+    def destroy #:nodoc:
+      run_callbacks(:destory) {super}
+    end
+
+    private
+    def create_or_update #:nodoc:
+      run_callbacks(:save) {super}
+    end
+
+    def create #:nodoc:
+      run_callbacks(:create) {super}
+    end
+
+    def update #:nodoc:
+      run_callbacks(:update) {super}
     end
   end
 end

data/lib/active_groonga/database.rb

@@ -0,0 +1,55 @@
+# Copyright (C) 2010  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require 'fileutils'
+
+module ActiveGroonga
+  class Database
+    def initialize(path)
+      @path = path
+      @database = nil
+    end
+
+    def ensure_available
+      return if @database
+      if @path.exist?
+        @database = Groonga::Database.open(@path.to_s,
+                                           :context => Base.context)
+      else
+        FileUtils.mkdir_p(@path.dirname) unless @path.dirname.exist?
+        @database = Groonga::Database.create(:path => @path.to_s,
+                                             :context => Base.context)
+      end
+    end
+
+    def remove
+      ensure_available if @path.exist?
+      return if @database.nil?
+      @database.remove
+      @database = nil
+    end
+
+    def close
+      return if @database.nil?
+      @database.close
+      @database = nil
+    end
+
+    def reopen
+      close
+      ensure_available
+    end
+  end
+end

data/lib/active_groonga/{dirty.rb → error.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -14,17 +14,27 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 module ActiveGroonga
-  module Dirty
-    class << self
-      def included(base)
-        base.class_eval do
-          include(ActiveRecord::Dirty)
-          extend(ClassMethods)
-        end
-      end
+  # Generic ActiveGroonga exception class.
+  class Error < StandardError
+  end
+
+  class RecordNotSaved < Error
+  end
+
+  class NoKeyTableError < Error
+    attr_reader :table
+    def initialize(table)
+      @table = table
+      super("table doesn't have key: #{@table}")
     end
+  end
 
-    module ClassMethods
+  class KeyOverrideError < Error
+    attr_reader :table, :key
+    def initialize(table, key)
+      @table = table
+      @key = key
+      super("can't override existing record key: #{@table}: <#{@key}>")
     end
   end
 end

data/lib/active_groonga/locale/en.yml

@@ -0,0 +1,5 @@
+en:
+  activegroonga:
+    errors:
+      messages:
+        missing: is missing

data/lib/active_groonga/migration.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -13,137 +13,68 @@
 # License along with this library; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-# This library includes ActiveRecord based codes temporary.
-# Here is their copyright and license:
-#
-#   Copyright (c) 2004-2009 David Heinemeier Hansson
-#
-#   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.
-
 module ActiveGroonga
-  class Migration < ActiveRecord::Migration
-    class << self
-      undef_method :connection
-
-      def method_missing(method, *arguments, &block)
-        arg_list = arguments.map(&:inspect) * ', '
-
-        say_with_time "#{method}(#{arg_list})" do
-          unless arguments.empty? || method == :execute
-            arguments[0] = Migrator.proper_table_name(arguments.first)
-          end
-          Schema.send(method, *arguments, &block)
-        end
-      end
-    end
-  end
-
-  class Migrator < ActiveRecord::Migrator
+  class Migration
+    @@migrations = []
     class << self
-      def schema_migrations_table_name
-        Base.table_name_prefix + 'schema_migrations' + Base.table_name_suffix
-      end
-
-      def groonga_schema_migrations_table_name
-        Base.groonga_metadata_table_name(schema_migrations_table_name)
+      def inherited(sub_class)
+        super
+        @@migrations << sub_class
       end
 
-      def get_all_versions
-        table = Base.context[groonga_schema_migrations_table_name]
-        table.records.collect {|record| record.key.to_i}.sort
+      def migrations
+        @@migrations
       end
 
-      def current_version
-        table = Base.context[groonga_schema_migrations_table_name]
-        if table.nil?
-          0
-        else
-          get_all_versions.max || 0
-        end
-      end
-
-      def proper_table_name(name)
-        begin
-          name.table_name
-        rescue
-          "#{Base.table_name_prefix}#{name}#{Base.table_name_suffix}"
-        end
+      def migration_name
+        name.split(/::/).last
       end
     end
 
-    def initialize(direction, migrations_path, target_version = nil)
-      Schema.initialize_schema_management_tables
-      @direction, @migrations_path, @target_version = direction, migrations_path, target_version
-      FileUtils.mkdir_p(@migrations_path) unless File.exist?(@migrations_path)
+    attr_reader :version, :path
+    def initialize(version, path, schema)
+      @version = version
+      @path = path
+      @schema = schema
     end
 
-    def migrate
-      current = migrations.detect { |m| m.version == current_version }
-      target = migrations.detect { |m| m.version == @target_version }
+    def name
+      self.class.migration_name
+    end
 
-      if target.nil? && !@target_version.nil? && @target_version > 0
-        raise UnknownMigrationVersionError.new(@target_version)
+    def migrate(direction)
+      result = nil
+      case direction
+      when :up
+        report("migrating")
+      when :down
+        report("reverting")
       end
-      
-      start = up? ? 0 : (migrations.index(current) || 0)
-      finish = migrations.index(target) || migrations.size - 1
-      runnable = migrations[start..finish]
-      
-      # skip the last migration if we're headed down, but not ALL the way down
-      runnable.pop if down? && !target.nil?
-      
-      runnable.each do |migration|
-        Base.logger.info "Migrating to #{migration.name} (#{migration.version})"
-
-        # On our way up, we skip migrating the ones we've already migrated
-        next if up? && migrated.include?(migration.version.to_i)
-
-        # On our way down, we skip reverting the ones we've never migrated
-        if down? && !migrated.include?(migration.version.to_i)
-          migration.announce 'never migrated, skipping'; migration.write
-          next
-        end
-
-        begin
-          migration.migrate(@direction)
-          record_version_state_after_migrating(migration.version)
-        rescue => e
-          raise StandardError, "An error has occurred, all later migrations canceled:\n\n#{e}", e.backtrace
-        end
+      time = Benchmark.measure do
+        result = send(direction)
       end
+      case direction
+      when :up
+        report("migrated (%.4fs)" % time.real)
+      when :down
+        report("reverted (%.4fs)" % time.real)
+      end
+      result
     end
 
     private
-    def record_version_state_after_migrating(version)
-      table_name = self.class.groonga_schema_migrations_table_name
-      table = Base.context[table_name]
+    def report(message)
+      relative_path = @path.relative_path_from(Rails.root)
+      text = "#{@version} #{name} (#{relative_path}): #{message}"
+      rest_length = [0, 75 - text.length].max
+      puts("== #{text} #{'=' * rest_length}")
+    end
 
-      @migrated_versions ||= []
-      if down?
-        @migrated_versions.delete(version.to_i)
-        table.records.each do |record|
-          record.delete if record.key == version.to_s
-        end
+    def method_missing(name, *args, &block)
+      if @schema.respond_to?(name)
+        @schema.send(name, *args, &block)
       else
-        @migrated_versions.push(version.to_i).sort!
-        table.add(version.to_s)
+        super
       end
     end
   end

data/lib/active_groonga/migrator.rb

@@ -0,0 +1,172 @@
+# Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+module ActiveGroonga
+  class DuplicateMigrationVersionError < Error #:nodoc:
+    attr_reader :version, :path
+    def initialize(version, path)
+      @version = version
+      @path = path
+      super("duplicated migration version exists: #{version}: <#{@path}>")
+    end
+  end
+
+  class MigrationEntry
+    attr_reader :version, :path
+    def initialize(migration, version, path)
+      @migration = migration
+      @version = version
+      @path = path
+    end
+
+    def name
+      @migration.migration_name
+    end
+
+    def migrate(direction, schema)
+      migration = @migration.new(@version, @path, schema)
+      migration.migrate(direction)
+    end
+  end
+
+  class SchemaManagementTable
+    TABLE_NAME = "schema_migrations"
+
+    def initialize
+      ensure_table
+      @table = Base.context[TABLE_NAME]
+    end
+
+    def current_version
+      @current_version ||= (migrated_versions.last || [0]).first
+    end
+
+    def migrated_versions
+      @migrated_versions ||= @table.collect do |record|
+        [record.key, record.migrated_at]
+      end.sort_by do |version, migrated_at|
+        version
+      end
+    end
+
+    def update_version(version)
+      @table.add(version, :migrated_at => Time.now)
+      clear_cache
+    end
+
+    def remove_version(version)
+      @table[version].delete
+      clear_cache
+    end
+
+    private
+    def ensure_table
+      Schema.define do |schema|
+        schema.create_table(TABLE_NAME,
+                            :type => :hash,
+                            :key_type => "UInt64") do |table|
+          table.time("migrated_at")
+        end
+      end
+    end
+
+    def clear_cache
+      @current_version = nil
+      @migrated_versions = nil
+    end
+  end
+
+  class Migrator
+    def initialize(direction, migrations_path)
+      @direction = direction
+      @migrations_path = migrations_path
+      unless @migrations_path.is_a?(Pathname)
+        @migrations_path = Pathanme(@migrations_path)
+      end
+    end
+
+    def migrate(target_version=nil)
+      _current_version = current_version
+      migration_entries.each do |entry|
+        if up?
+          next if entry.version <= _current_version
+        else
+          next if entry.version > _current_version
+        end
+        Base.logger.info("Migrating to #{entry.name} (#{entry.version})")
+        active_groonga_schema = Schema.new(:context => Base.context)
+        active_groonga_schema.define do |schema|
+          entry.migrate(@direction, schema)
+        end
+        if up?
+          management_table.update_version(entry.version)
+        else
+          management_table.remove_version(entry.version)
+        end
+        break if entry.version == target_version
+      end
+    end
+
+    def up?
+      @direction == :up
+    end
+
+    def down?
+      @direction == :down
+    end
+
+    def current_version
+      management_table.current_version
+    end
+
+    def migrated_versions
+      management_table.migrated_versions
+    end
+
+    def management_table
+      @management_table ||= SchemaManagementTable.new
+    end
+
+    private
+    def migration_entries
+      @migration_entries ||= collect_migration_entries
+    end
+
+    def collect_migration_entries
+      migration_entries = []
+      Pathname.glob(@migrations_path + "[0-9]*_[a-z]*.rb").each do |path|
+        if /\A([0-9]+)_([_a-z0-9]+)\.rb\z/ =~ path.basename.to_s
+          version = $1.to_i
+        else
+          next
+        end
+
+        if migration_entries.find {|entry| entry.version == version}
+          raise DuplicateMigrationVersionError.new(version, path)
+        end
+
+        migrations_before = Migration.migrations.dup
+        load(path, true)
+        defined_migrations = Migration.migrations - migrations_before
+        defined_migrations.each do |migration|
+          migration_entries << MigrationEntry.new(migration, version, path)
+        end
+      end
+
+      migration_entries = migration_entries.sort_by(&:version)
+      down? ? migration_entries.reverse : migration_entries
+    end
+  end
+end