globalize3 0.0.4 → 0.0.5

data/Gemfile

@@ -0,0 +1,14 @@
+source :rubygems
+
+gem 'activerecord', '>= 3.0.0.rc'
+
+group :test do
+  gem 'test_declarative'
+  gem 'database_cleaner'
+  gem 'pathname_local'
+  gem 'mocha'
+  # gem 'vestal_versions', :git => 'git@github.com:svenfuchs/vestal_versions.git'
+  gem 'vestal_versions', :path => '/Volumes/Users/sven/Development/projects/vestal_versions'
+  gem 'ruby-debug'
+  gem 'sqlite3-ruby'
+end

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: /Volumes/Users/sven/Development/projects/vestal_versions
+  specs:
+    vestal_versions (1.0.2)
+      activerecord (>= 2.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.0.rc)
+      activesupport (= 3.0.0.rc)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activerecord (3.0.0.rc)
+      activemodel (= 3.0.0.rc)
+      activesupport (= 3.0.0.rc)
+      arel (~> 0.4.0)
+      tzinfo (~> 0.3.22)
+    activesupport (3.0.0.rc)
+    arel (0.4.0)
+      activesupport (>= 3.0.0.beta)
+    builder (2.1.2)
+    columnize (0.3.1)
+    database_cleaner (0.5.2)
+    i18n (0.4.1)
+    linecache (0.43)
+    mocha (0.9.8)
+      rake
+    pathname_local (0.0.2)
+    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)
+    sqlite3-ruby (1.3.1)
+    test_declarative (0.0.3)
+    tzinfo (0.3.22)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 3.0.0.rc)
+  database_cleaner
+  mocha
+  pathname_local
+  ruby-debug
+  sqlite3-ruby
+  test_declarative
+  vestal_versions!

data/README.textile

@@ -56,6 +56,20 @@ end
 
 Note that the ActiveRecord model @Post@ must already exist and have a @translates@ directive listing the translated fields.
 
+h2. Versioning with Globalize3
+
+Globalize3 nicely integrates with "vestal_versions":http://github.com/laserlemon/vestal_versions:
+
+<pre><code>
+require 'globalize/versioning/vestal_versions'
+</code></pre>
+
+As of writing (2010-08-05) the original vestal_versions respository has not been updated to be compatible with Rails 3 though. You can use "this fork":http://github.com/svenfuchs/vestal_versions though. "Globalize3's Gemfile":http://github.com/svenfuchs/globalize3/blob/master/Gemfile#L10 is currently set up accordingly.
+
+Please also note that @update_attribute@ currently hides itself from dirty tracking in ActiveRecord >= 3.0.0.beta (which is considered a "regression":http://github.com/rails/rails/commit/01629d180468049d17a8be6900e27a4f0d2b18c4#commitcomment-123199). That means that you currently need to use attribute writers or @update_attributes@ in order to track changes/versions for your models.
+
+Also, please see the tests in test/globalize3/versioning_test.rb for some current gotchas.
+
 h2. Changes since Globalize2
 
 * `translation_table_name` was renamed to `translations_table_name`

data/lib/globalize/active_record/act_macro.rb

@@ -7,13 +7,13 @@ module Globalize
         options = attr_names.extract_options!
         options[:table_name] ||= "#{table_name.singularize}_translations"
 
-        include InstanceMethods
-        extend  ClassMethods, Migration
-
         class_inheritable_accessor :translated_attribute_names, :translation_options
         self.translated_attribute_names = attr_names.map(&:to_sym)
         self.translation_options        = options
 
+        include InstanceMethods
+        extend  ClassMethods, Migration
+
         has_many :translations, :class_name  => translation_class.name,
                                 :foreign_key => class_name.foreign_key,
                                 :dependent   => :delete_all,

data/lib/globalize/active_record/adapter.rb

@@ -5,27 +5,29 @@ module Globalize
       # The stash keeps track of new or changed values that need to be saved.
       attr_reader :record, :cache, :stash
 
+      delegate :translation_class, :to => :'record.class'
+
       def initialize(record)
         @record = record
         @cache = Attributes.new
         @stash = Attributes.new
       end
 
-      def fetch(locale, attr_name)
-        cache.contains?(locale, attr_name) ?
-          cache.read(locale, attr_name) :
-          cache.write(locale, attr_name, fetch_attribute(locale, attr_name))
+      def fetch(locale, name)
+        cache.contains?(locale, name) ?
+          type_cast(name, cache.read(locale, name)) :
+          cache.write(locale, name, fetch_attribute(locale, name))
       end
 
-      def write(locale, attr_name, value)
-        stash.write(locale, attr_name, value)
-        cache.write(locale, attr_name, value)
+      def write(locale, name, value)
+        stash.write(locale, name, value)
+        cache.write(locale, name, value)
       end
 
       def save_translations!
         stash.each do |locale, attrs|
           translation = record.translations.find_or_initialize_by_locale(locale.to_s)
-          attrs.each { |attr_name, value| translation[attr_name] = value }
+          attrs.each { |name, value| translation[name] = value }
           translation.save!
         end
         stash.clear
@@ -37,6 +39,24 @@ module Globalize
 
       protected
 
+        def type_cast(name, value)
+          if value.nil?
+            nil
+          elsif column = column_for_attribute(name)
+            column.type_cast(value)
+          else
+            value
+          end
+        end
+
+        def column_for_attribute(name)
+          translation_class.columns_hash[name.to_s]
+        end
+
+        def unserializable_attribute?(name, column)
+          column.text? && translation_class.serialized_attributes[name.to_s]
+        end
+
         def fetch_translation(locale)
           locale = locale.to_sym
           record.translations.loaded? ? record.translations.detect { |t| t.locale == locale } :
@@ -49,13 +69,13 @@ module Globalize
             record.translations.with_locales(Globalize.fallbacks(locale))
         end
 
-        def fetch_attribute(locale, attr_name)
+        def fetch_attribute(locale, name)
           translations = fetch_translations(locale)
           value, requested_locale = nil, locale
 
           Globalize.fallbacks(locale).each do |fallback|
             translation = translations.detect { |t| t.locale == fallback }
-            value  = translation && translation.send(attr_name)
+            value  = translation && translation.send(name)
             locale = fallback && break if value
           end
 

data/lib/globalize/active_record/attributes.rb

@@ -10,16 +10,16 @@ module Globalize
         self.fetch(locale)
       end
 
-      def contains?(locale, attr_name)
-        self[locale].has_key?(attr_name)
+      def contains?(locale, name)
+        self[locale].has_key?(name.to_s)
       end
 
-      def read(locale, attr_name)
-        self[locale][attr_name]
+      def read(locale, name)
+        self[locale][name.to_s]
       end
 
-      def write(locale, attr_name, value)
-        self[locale][attr_name] = value
+      def write(locale, name, value)
+        self[locale][name.to_s] = value
       end
     end
   end

data/lib/globalize/active_record/class_methods.rb

@@ -27,7 +27,7 @@ module Globalize
       end
 
       def translated?(name)
-        translated_attribute_names.include?(name)
+        translated_attribute_names.include?(name.to_sym)
       end
 
       def required_attributes
@@ -72,10 +72,10 @@ module Globalize
 
         def translated_attr_accessor(name)
           define_method(:"#{name}=") do |value|
-            self[name] = globalize.write(Globalize.locale, name, value)
+            write_attribute(name, value, Globalize.locale)
           end
           define_method(name) do |*args|
-            globalize.fetch(args.first || Globalize.locale, name)
+            read_attribute(name, args.first || Globalize.locale)
           end
           alias_method :"#{name}_before_type_cast", name
         end

data/lib/globalize/active_record/exceptions.rb

@@ -0,0 +1,19 @@
+module Globalize
+  module ActiveRecord
+    module Exceptions
+      class MigrationError < StandardError; end
+  
+      class BadFieldName < MigrationError
+        def initialize(field)
+          super("Missing translated field #{field.inspect}")
+        end
+      end
+  
+      class BadFieldType < MigrationError
+        def initialize(name, type)
+          super("Bad field type for field #{name.inspect} (#{type.inspect}), should be :string or :text")
+        end
+      end
+    end
+  end
+end

data/lib/globalize/active_record/instance_methods.rb

@@ -4,7 +4,7 @@ module Globalize
       delegate :translated_locales, :to => :translations
 
       def globalize
-        @globalize ||= Adapter.new self
+        @globalize ||= Adapter.new(self)
       end
 
       def attributes
@@ -15,13 +15,34 @@ module Globalize
         with_given_locale(attributes) { super }
       end
 
+      def update_attributes!(attributes, *args)
+        with_given_locale(attributes) { super }
+      end
+
       def update_attributes(attributes, *args)
         with_given_locale(attributes) { super }
       end
 
+      def write_attribute(name, value, locale = nil)
+        super(name, value)
+        globalize.write(locale || Globalize.locale, name, value) if translated?(name)
+      end
+
+      def read_attribute(name, locale = nil)
+        if self.class.translated?(name)
+          globalize.fetch(locale || Globalize.locale, name)
+        else
+          super(name)
+        end
+      end
+          
       def attribute_names
         translated_attribute_names.map(&:to_s) + super
       end
+      
+      def translated?(name)
+        self.class.translated?(name)
+      end
 
       def translated_attributes
         translated_attribute_names.inject({}) do |attributes, name|

data/lib/globalize/active_record/migration.rb

@@ -1,44 +1,108 @@
+require 'digest/sha1'
+
 module Globalize
   module ActiveRecord
     module Migration
-      def create_translation_table!(fields)
-        translated_attribute_names.each do |f|
-          raise MigrationMissingTranslatedField, "Missing translated field #{f}" unless fields[f]
+      attr_reader :globalize_migrator
+
+      def globalize_migrator
+        @globalize_migrator ||= Migrator.new(self)
+      end
+
+      delegate :create_translation_table!, :drop_translation_table!,
+        :translation_index_name, :to => :globalize_migrator
+
+      class Migrator
+        include Globalize::ActiveRecord::Exceptions
+
+        attr_reader :model, :fields
+        delegate :translated_attribute_names, :connection, :table_name,
+          :table_name_prefix, :translations_table_name, :columns, :to => :model
+
+        def initialize(model)
+          @model = model
+        end
+
+        def create_translation_table!(fields = {}, options = {})
+          @fields = fields
+          complete_translated_fields
+          validate_translated_fields
+
+          create_translation_table
+          move_data_to_translation_table if options[:migrate_data]
+          create_translations_index
+        end
+
+        def drop_translation_table!(options = {})
+          move_data_to_model_table if options[:migrate_data]
+          drop_translations_index
+          drop_translation_table
         end
 
-        fields.each do |name, type|
-          if translated_attribute_names.include?(name) && ![:string, :text].include?(type)
-            raise BadMigrationFieldType, "Bad field type for #{name}, should be :string or :text"
+        def complete_translated_fields
+          translated_attribute_names.each do |name|
+            fields[name] = column_type(name) unless fields[name]
           end
         end
 
-        self.connection.create_table(translations_table_name) do |t|
-          t.references table_name.sub(/^#{table_name_prefix}/, "").singularize
-          t.string :locale
+        def create_translation_table
+          connection.create_table(translations_table_name) do |t|
+            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize
+            t.string :locale
+            fields.each { |name, type| t.column name, type }
+            t.timestamps
+          end
+        end
+
+        def create_translations_index
+          connection.add_index(
+            translations_table_name,
+            "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id",
+            :name => translation_index_name
+          )
+        end
+
+        def drop_translation_table
+          connection.drop_table(translations_table_name)
+        end
+
+        def drop_translations_index
+          connection.remove_index(translations_table_name, :name => translation_index_name) rescue nil
+        end
+
+        def move_data_to_translation_table
+          # TODO
+        end
+
+        def move_data_to_model_table
+          # TODO
+        end
+
+        def validate_translated_fields
           fields.each do |name, type|
-            t.column name, type
+            raise BadFieldName.new(name) unless valid_field_name?(name)
+            raise BadFieldType.new(name, type) unless valid_field_type?(name, type)
           end
-          t.timestamps
         end
 
-        self.connection.add_index(
-          translations_table_name, 
-          "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id",
-          :name => translation_index_name
-        )
-      end
+        def column_type(name)
+          columns.detect { |c| c.name == name.to_s }.try(:type)
+        end
 
-      def translation_index_name
-        require 'digest/sha1'
-        # FIXME what's the max size of an index name?
-        index_name = "index_#{translations_table_name}_on_#{self.table_name.singularize}_id"
-        index_name.size < 50 ? index_name : "index_#{Digest::SHA1.hexdigest(index_name)}"
-      end
+        def valid_field_name?(name)
+          translated_attribute_names.include?(name)
+        end
+
+        def valid_field_type?(name, type)
+          !translated_attribute_names.include?(name) || [:string, :text].include?(type)
+        end
 
-      def drop_translation_table!
-        self.connection.remove_index(translations_table_name, :name => translation_index_name) rescue nil
-        self.connection.drop_table(translations_table_name)
+        def translation_index_name
+          # FIXME what's the max size of an index name?
+          index_name = "index_#{translations_table_name}_on_#{table_name.singularize}_id"
+          index_name.size < 50 ? index_name : "index_#{Digest::SHA1.hexdigest(index_name)}"
+        end
       end
     end
   end
-end
+end

data/lib/globalize/active_record.rb

@@ -1,13 +1,10 @@
 module Globalize
-  class MigrationError < StandardError; end
-  class MigrationMissingTranslatedField < MigrationError; end
-  class BadMigrationFieldType < MigrationError; end
-
   module ActiveRecord
     autoload :ActMacro,        'globalize/active_record/act_macro'
     autoload :Adapter,         'globalize/active_record/adapter'
     autoload :Attributes,      'globalize/active_record/attributes'
     autoload :ClassMethods,    'globalize/active_record/class_methods'
+    autoload :Exceptions,      'globalize/active_record/exceptions'
     autoload :InstanceMethods, 'globalize/active_record/instance_methods'
     autoload :Migration,       'globalize/active_record/migration'
     autoload :Translation,     'globalize/active_record/translation'

data/lib/globalize/version.rb

@@ -1,3 +1,3 @@
 module Globalize
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/globalize/versioning/vestal_versions.rb

@@ -0,0 +1,35 @@
+require 'vestal_versions'
+
+module Globalize
+  module Versioning
+    module VestalVersions
+      def versioned_columns
+        super + self.class.translated_attribute_names
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  class << self
+    def versioned_with_globalize(*args)
+      versioned_without_globalize(*args)
+      include Globalize::Versioning::VestalVersions
+    end
+    alias_method_chain :versioned, :globalize
+  end
+end
+
+VestalVersions::Version.class_eval do
+  before_save do |version|
+    version.locale = Globalize.locale.to_s
+  end
+
+  class Condition
+    def to_sql
+      "locale = '#{Globalize.locale.to_s}'"
+    end
+  end
+
+  default_scope(:conditions => Condition.new)
+end

data/lib/globalize/versioning.rb

@@ -0,0 +1,5 @@
+module Globalize
+  module Versioning
+    autoload :VestalVersions, 'globalize/versioning/vestal_versions'
+  end
+end

data/lib/globalize.rb

@@ -1,22 +1,24 @@
 require 'patches/active_record/xml_attribute_serializer'
+require 'patches/active_record/query_method'
 
 module Globalize
   autoload :ActiveRecord, 'globalize/active_record'
+  autoload :Versioning,   'globalize/versioning'
 
   class << self
     def locale
-      defined?(@@locale) && @@locale || I18n.locale
+      read_locale || I18n.locale
     end
 
     def locale=(locale)
-      @@locale = locale
+      set_locale(locale)
     end
 
     def with_locale(locale, &block)
-      previous_locale = defined?(@@locale) && @@locale || nil
-      self.locale = locale
+      previous_locale = read_locale
+      set_locale(locale)
       result = yield
-      self.locale = previous_locale
+      set_locale(previous_locale)
       result
     end
 
@@ -27,6 +29,16 @@ module Globalize
     def fallbacks(locale = self.locale)
       fallbacks? ? I18n.fallbacks[locale] : [locale.to_sym]
     end
+    
+    protected
+    
+      def read_locale
+        Thread.current[:globalize_locale]
+      end
+    
+      def set_locale(locale)
+        Thread.current[:globalize_locale] = locale
+      end
   end
 end
 

data/lib/patches/active_record/query_method.rb

@@ -0,0 +1,35 @@
+require 'active_record/attribute_methods/query'
+
+module ActiveRecord
+  module AttributeMethods
+    module Query
+      def query_attribute(attr_name)
+        unless value = read_attribute(attr_name)
+          false
+        else
+          column = self.class.columns_hash[attr_name]
+          if column.nil?
+            
+            # TODO submit a rails patch
+
+            # not sure what active_record tests say but i guess this should mean:
+            # call to_i and check zero? if the value is a Numeric or starts with
+            # a digit, so it can meaningfully be typecasted by to_i
+
+            # if Numeric === value || value !~ /[^0-9]/
+            if Numeric === value || value.to_s =~ /^[0-9]/
+              !value.to_i.zero?
+            else
+              return false if ActiveRecord::ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+              !value.blank?
+            end
+          elsif column.number?
+            !value.zero?
+          else
+            !value.blank?
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: globalize3
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 21
   prerelease: false
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -18,7 +18,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-04 00:00:00 +02:00
+date: 2010-08-15 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,6 +38,104 @@ dependencies:
         version: 3.0.0.rc
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: pathname_local
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: test_declarative
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: vestal_versions
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: ruby-debug
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
 description: "Rails I18n: de-facto standard library for ActiveRecord 3 model/data translation."
 email: nobody@globalize-rails.org
 executables: []
@@ -51,16 +149,22 @@ files:
 - lib/globalize/active_record/adapter.rb
 - lib/globalize/active_record/attributes.rb
 - lib/globalize/active_record/class_methods.rb
+- lib/globalize/active_record/exceptions.rb
 - lib/globalize/active_record/instance_methods.rb
 - lib/globalize/active_record/migration.rb
 - lib/globalize/active_record/translation.rb
 - lib/globalize/active_record.rb
 - lib/globalize/version.rb
+- lib/globalize/versioning/vestal_versions.rb
+- lib/globalize/versioning.rb
 - lib/globalize.rb
 - lib/globalize3.rb
 - lib/i18n/missing_translations_log_handler.rb
 - lib/i18n/missing_translations_raise_handler.rb
+- lib/patches/active_record/query_method.rb
 - lib/patches/active_record/xml_attribute_serializer.rb
+- Gemfile
+- Gemfile.lock
 - LICENSE
 - Rakefile
 - README.textile