single_table_globalize3 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d9d9b6bb1b7c9a01b80fa37c207d172b26bf321
-  data.tar.gz: 1f6344d88c60c9a226491d3280b2e23ae639e621
+  metadata.gz: 26717252049728b19cb768820301e55d01b6d0d9
+  data.tar.gz: ddd3692c29e5a96c960150c36209df54ee1c0286
 SHA512:
-  metadata.gz: 3c82d94486a79cd745cdba46ca13463ad2cda67b321b654263c9e598a4bdb3422a9e286125c61407827c2d55068d1558b0b0c5d421a3b9302ce7ffdce0f2f45e
-  data.tar.gz: b22a0c72c1cad41885978ebe89b389afbd727e3bdeb230467beea39f2a3e54c694c76a6be52f30583a8cc01fe820fa077b7ab71b5456a1152a3200ff4050d74d
+  metadata.gz: b73332cb50bfe6a2d706a6ad4450fb471c64dc102264a2310171e12f1ee78d43dfaf59ed8fe8bc14ebddc26cbbcbea5e711b4638057c38168a06266bc90d4745
+  data.tar.gz: 238fbd2b8c9bb11dec4c5cc3a58a8d529f734171f896d86f1109dd66d38248b31ba36c196b35d6567253ac55d49aec26dcd1ba276245f285dfc6fa906fe33475

data/Gemfile

@@ -1,4 +1,4 @@
-source :rubygems
+source 'https://rubygems.org'
 
 gemspec
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    single_table_globalize3 (0.3.0)
+    single_table_globalize3 (0.0.1)
       activemodel (>= 3.0.0)
       activerecord (>= 3.0.0)
 
@@ -21,26 +21,17 @@ GEM
       multi_json (~> 1.0)
     arel (3.0.2)
     builder (3.0.4)
-    coderay (1.0.8)
     database_cleaner (0.6.7)
     i18n (0.6.1)
     json (1.7.7)
     metaclass (0.0.1)
-    method_source (0.8.1)
     mocha (0.13.2)
       metaclass (~> 0.0.1)
     multi_json (1.6.1)
     pathname_local (0.0.2)
-    pry (0.9.12)
-      coderay (~> 1.0.5)
-      method_source (~> 0.8)
-      slop (~> 3.4)
-    pry-nav (0.2.3)
-      pry (~> 0.9.10)
     rake (10.0.3)
     rdoc (3.12.1)
       json (~> 1.4)
-    slop (3.4.3)
     sqlite3 (1.3.7)
     test_declarative (0.0.5)
     tzinfo (0.3.35)
@@ -52,8 +43,6 @@ DEPENDENCIES
   database_cleaner (~> 0.6.0)
   mocha
   pathname_local
-  pry
-  pry-nav
   rake
   rdoc
   single_table_globalize3!

data/lib/generators/single_table_globalize3/migration_generator.rb

@@ -0,0 +1,12 @@
+require 'rails/generators/active_record'
+
+module SingleTableGlobalize3
+  class MigrationGenerator < ::ActiveRecord::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+    argument :name, :type => :string, :default => "application"
+
+    def copy_devise_migration
+      migration_template "migration.rb", "db/migrate/create_globalize_translations"
+    end
+  end
+end

data/lib/i18n/missing_translations_log_handler.rb

@@ -5,7 +5,7 @@
 #
 # E.g.
 #
-#   require 'globalize/i18n/missing_translations_log_handler'
+#   require 'single_table_globalize3/i18n/missing_translations_log_handler'
 #   I18n.missing_translations_logger = RAILS_DEFAULT_LOGGER
 #   I18n.exception_handler = :missing_translations_log_handler
 #

data/lib/i18n/missing_translations_raise_handler.rb

@@ -5,7 +5,7 @@
 #
 # E.g.
 #
-#   require 'globalize/i18n/missing_translations_raise_handler'
+#   require 'single_table_globalize3/i18n/missing_translations_raise_handler'
 #   I18n.exception_handler = :missing_translations_raise_handler
 module I18n
   class << self

data/lib/patches/active_record/uniqueness_validator.rb

@@ -9,7 +9,7 @@ ActiveRecord::Validations::UniquenessValidator.class_eval do
         table = finder_class.arel_table
 
         relation = build_relation(finder_class, table, 'attribute_name', attribute).
-          and(table[:locale].eq(Globalize.locale)).
+          and(table[:locale].eq(SingleTableGlobalize3.locale)).
           and(table[:value].eq(value)).
           and(table[:translatable_type].eq(klass.name))
         relation = relation.and(table[klass.reflect_on_association(:translations).foreign_key].not_eq(record.send(:id))) if record.persisted?
@@ -35,7 +35,7 @@ ActiveRecord::Validations::UniquenessValidator.class_eval do
         sql, params  = mount_sql_and_params(finder_class, table_name, 'value', value)
 
         relation = table.where(sql, *params).
-          where(:locale => Globalize.locale).
+          where(:locale => SingleTableGlobalize3.locale).
           where(:attribute_name => attribute).
           where(:translatable_type => klass.name)
 

data/lib/{globalize → single_table_globalize3}/active_record/act_macro.rb

@@ -1,4 +1,4 @@
-module Globalize
+module SingleTableGlobalize3
   module ActiveRecord
     module ActMacro
       def translates(*attr_names)
@@ -9,31 +9,13 @@ module Globalize
         attr_names = attr_names.map(&:to_sym)
         attr_names -= translated_attribute_names if defined?(translated_attribute_names)
 
-        if attr_names.present?
-          translation_class.instance_eval %{
-            attr_accessible :#{attr_names.join(', :')}
-          }
+        attr_names.each do |attr_name|
+          # Create accessors for the attribute.
+          translated_attr_accessor(attr_name)
+          translations_accessor(attr_name)
 
-          attr_names.each do |attr_name|
-            # Detect and apply serialization.
-            serializer = self.serialized_attributes[attr_name.to_s]
-            if serializer.present?
-              if defined?(::ActiveRecord::Coders::YAMLColumn) &&
-                 serializer.is_a?(::ActiveRecord::Coders::YAMLColumn)
-
-                serializer = serializer.object_class
-              end
-
-              translation_class.send :serialize, attr_name, serializer
-            end
-
-            # Create accessors for the attribute.
-            translated_attr_accessor(attr_name)
-            translations_accessor(attr_name)
-
-            # Add attribute to the list.
-            self.translated_attribute_names << attr_name
-          end
+          # Add attribute to the list.
+          self.translated_attribute_names << attr_name
         end
       end
 
@@ -58,8 +40,8 @@ module Globalize
 
         after_create :save_translations!
         after_update :save_translations!
-
-        translation_class.instance_eval %{ attr_accessible :locale }
+        # if attr_accessible is explicitly defined in the class, add locale to it
+        attr_accessible :locale if self.accessible_attributes.to_a.present?
       end
     end
   end

data/lib/{globalize → single_table_globalize3}/active_record/adapter.rb

@@ -1,4 +1,4 @@
-module Globalize
+module SingleTableGlobalize3
   module ActiveRecord
     class Adapter
       # The cache caches attributes that already were looked up for read access.
@@ -14,9 +14,17 @@ module Globalize
       end
 
       def fetch_stash(locale, name)
-        value = stash.read(locale, name)
-        return value if value
-        return nil
+        stash.read(locale, name)
+      end
+
+      def fetch_locales(name)
+        stash.keys.inject({}) do |result, locale|
+          if stash_contains?(locale, name)
+            result.update(locale => fetch_stash(locale, name))
+          else
+            result
+          end
+        end
       end
 
       def stash_contains?(locale, name)
@@ -41,17 +49,10 @@ module Globalize
       end
 
       def save_translations!
-        existing_translations = {}
-        record.translations.each do |t|
-          locale_str = t.locale.to_s
-          existing_translations[locale_str] ||= {}
-          existing_translations[locale_str][t.attribute_name] = t
-        end
-
         stash.each do |locale, attrs|
           locale_str = locale.to_s
           attrs.each do |name, value|
-            translation = existing_translations[locale_str].try('[]', name) ||
+            translation = record.translations.detect {|t| t.locale.to_s == locale_str && t.attribute_name == name } ||
               record.translations.build(:locale => locale_str, :attribute_name => name)
             translation.update_attribute(:value, value)
           end

data/lib/single_table_globalize3/active_record/attribute_read_write.rb

@@ -0,0 +1,75 @@
+module SingleTableGlobalize3
+  module ActiveRecord
+    module AttributeReadWrite
+      delegate :translated_locales, :to => :translations
+      def attributes
+        super.merge(translated_attributes)
+      end
+
+      # Deprecate old use of locale
+      def deprecated_options(options)
+        unless options.is_a?(Hash)
+          warn "[DEPRECATION] passing 'locale' as #{options.inspect} is deprecated. Please use {:locale => #{options.inspect}} instead."
+          {:locale => options}
+        else
+          options
+        end
+      end
+
+      def write_attribute(name, value, options = {})
+        if translated?(name)
+          options = {:locale => SingleTableGlobalize3.locale}.merge(deprecated_options(options))
+
+          # Dirty tracking, paraphrased from
+          # ActiveRecord::AttributeMethods::Dirty#write_attribute.
+          name_str = name.to_s
+          # If there's already a change, delete it if this undoes the change.
+          if attribute_changed?(name_str) && value == changed_attributes[name_str]
+            changed_attributes.delete(name_str)
+          elsif !attribute_changed?(name_str) && value != (old = globalize.fetch(options[:locale], name))
+            changed_attributes[name_str] = old
+          end
+
+          globalize.write(options[:locale], name, value)
+        else
+          super(name, value)
+        end
+      end
+
+      def read_attribute(name, options = {})
+        options = {:translated => true, :locale => nil}.merge(deprecated_options(options))
+        if (self.class.translated?(name) && options[:translated]) && (value = globalize.fetch(options[:locale] || SingleTableGlobalize3.locale, name))
+          value
+        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|
+          attributes.merge(name.to_s => translation[name.to_s].try(:value))
+        end
+      end
+
+      # This method is basically the method built into Rails
+      # but we have to pass {:translated => false}
+      def untranslated_attributes
+        attrs = {}
+        attribute_names.each do |name|
+          attrs[name] = read_attribute(name, {:translated => false})
+        end
+        attrs
+      end
+
+
+    end
+  end
+end

data/lib/{globalize → single_table_globalize3}/active_record/attributes.rb

@@ -1,7 +1,7 @@
-# Helper class for storing values per locale. Used by Globalize::Adapter
+# Helper class for storing values per locale. Used by SingleTableGlobalize3::Adapter
 # to stash and cache attribute values.
 
-module Globalize
+module SingleTableGlobalize3
   module ActiveRecord
     class Attributes < Hash # TODO: Think about using HashWithIndifferentAccess ?
       def [](locale)

data/lib/{globalize → single_table_globalize3}/active_record/class_methods.rb

@@ -1,49 +1,7 @@
-module Globalize
+module SingleTableGlobalize3
   module ActiveRecord
     module ClassMethods
-      delegate :translated_locales, :to => :translation_class
-
-      def with_translations(*locales)
-        locales = [locales].flatten
-        index = locales.pop if locales.last.is_a?(Fixnum)
-        locales = Globalize.fallbacks if locales.empty?
-        joins("LEFT OUTER JOIN #{translation_class.table_name} #{translations_table_name(index)} ON #{translations_table_name(index)}.translatable_id = #{self.table_name}.id").
-        select("distinct #{table_name}.*").
-        where(translated_column_name('locale', index) => locales)
-      end
-
-      def with_translated_attribute(name, value, locales = nil)
-        locales ||= Globalize.fallbacks
-        self.join_index = self.join_index + 1
-        with_translations(locales, self.join_index).where(
-          translated_column_name('attribute_name', self.join_index) => name.to_s,
-          translated_column_name('value', self.join_index) => Array(value).map(&:to_s)
-        )
-      end
-
-      def translated?(name)
-        translated_attribute_names.include?(name.to_sym)
-      end
-
-      def required_attributes
-        validators.map { |v| v.attributes if v.is_a?(ActiveModel::Validations::PresenceValidator) }.flatten
-      end
-
-      def required_translated_attributes
-        translated_attribute_names & required_attributes
-      end
-
-      def translation_class
-        Globalize::ActiveRecord::Translation
-      end
-
-      def translations_table_name(index = nil)
-        "#{translation_class.table_name}#{index}"
-      end
-
-      def translated_column_name(name, index = nil)
-        "#{translations_table_name(index)}.#{name}"
-      end
+      include WithTranslations
 
       if RUBY_VERSION < '1.9'
         def respond_to?(method_id, *args, &block)
@@ -139,12 +97,7 @@ module Globalize
 
       def translations_accessor(name)
         define_method(:"#{name}_translations") do
-          result = translations.each_with_object(HashWithIndifferentAccess.new) do |translation, result|
-            result[translation.locale] = translation.value
-          end
-          globalize.stash.keys.each_with_object(result) do |locale, result|
-            result[locale] = globalize.fetch_stash(locale, name) if globalize.stash_contains?(locale, name)
-          end
+          translations.attribute_translations(name).merge(globalize.fetch_locales(name))
         end
         define_method(:"#{name}_translations=") do |value|
           value.each do |(locale, value)|
@@ -152,17 +105,6 @@ module Globalize
           end
         end
       end
-
-      def join_index
-        @join_index = 0 if @join_index.nil? || @join_index > 100
-        @join_index
-      end
-
-      def join_index=(value)
-        @join_index = value
-      end
     end
-
   end
-
 end

data/lib/{globalize → single_table_globalize3}/active_record/exceptions.rb

@@ -1,14 +1,14 @@
-module Globalize
+module SingleTableGlobalize3
   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")
@@ -16,4 +16,4 @@ module Globalize
       end
     end
   end
-end
+end

data/lib/{globalize → single_table_globalize3}/active_record/instance_methods.rb

@@ -1,16 +1,12 @@
-module Globalize
+module SingleTableGlobalize3
   module ActiveRecord
     module InstanceMethods
-      delegate :translated_locales, :to => :translations
+      include AttributeReadWrite
 
       def globalize
         @globalize ||= Adapter.new(self)
       end
 
-      def attributes
-        super.merge(translated_attributes)
-      end
-
       def self.included(base)
         # Maintain Rails 3.0.x compatibility while adding Rails 3.1.x compatibility
         if base.method_defined?(:assign_attributes)
@@ -36,76 +32,13 @@ module Globalize
         end
       end
 
-      # Deprecate old use of locale
-      def deprecated_options(options)
-        unless options.is_a?(Hash)
-          warn "[DEPRECATION] passing 'locale' as #{options.inspect} is deprecated. Please use {:locale => #{options.inspect}} instead."
-          {:locale => options}
-        else
-          options
-        end
-      end
-
-      def write_attribute(name, value, options = {})
-        if translated?(name)
-          options = {:locale => Globalize.locale}.merge(deprecated_options(options))
-
-          # Dirty tracking, paraphrased from
-          # ActiveRecord::AttributeMethods::Dirty#write_attribute.
-          name_str = name.to_s
-          # If there's already a change, delete it if this undoes the change.
-          if attribute_changed?(name_str) && value == changed_attributes[name_str]
-            changed_attributes.delete(name_str)
-          elsif !attribute_changed?(name_str) && value != (old = globalize.fetch(options[:locale], name))
-            changed_attributes[name_str] = old
-          end
-
-          globalize.write(options[:locale], name, value)
-        else
-          super(name, value)
-        end
-      end
-
-      def read_attribute(name, options = {})
-        options = {:translated => true, :locale => nil}.merge(deprecated_options(options))
-        if (self.class.translated?(name) && options[:translated]) && (value = globalize.fetch(options[:locale] || Globalize.locale, name))
-          value
-        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|
-          attributes.merge(name.to_s => translation[name.to_s].try(:value))
-        end
-      end
-
-      # This method is basically the method built into Rails
-      # but we have to pass {:translated => false}
-      def untranslated_attributes
-        attrs = {}
-        attribute_names.each do |name|
-          attrs[name] = read_attribute(name, {:translated => false})
-        end
-        attrs
-      end
-
       def set_translations(options)
         options.keys.each do |locale|
           options[locale].each do |key, value|
             raise NoMethodError.new("unknown attribute: #{key}") unless attribute_names.flatten.include?(key.to_s)
             translation = translation_for(locale, key.to_s)
             translation.value = value
-            translation.save
+            translation.save!
           end
         end
         globalize.reset
@@ -132,7 +65,7 @@ module Globalize
       end
 
       def translation
-        translations_for_locale(::Globalize.locale)
+        translations_for_locale(::SingleTableGlobalize3.locale)
       end
 
       def translation_for(locale, name, build_if_missing = true)
@@ -157,7 +90,7 @@ module Globalize
       end
 
       def globalize_fallbacks(locale)
-        Globalize.fallbacks(locale)
+        SingleTableGlobalize3.fallbacks(locale)
       end
 
       private
@@ -200,7 +133,7 @@ module Globalize
           attributes.try(:delete, :locale)
 
         if locale
-          Globalize.with_locale(locale, &block)
+          SingleTableGlobalize3.with_locale(locale, &block)
         else
           yield
         end

data/lib/{globalize → single_table_globalize3}/active_record/translation.rb

@@ -1,4 +1,4 @@
-module Globalize
+module SingleTableGlobalize3
   module ActiveRecord
     class Translation < ::ActiveRecord::Base
       if self.respond_to?(:table_name=)
@@ -28,6 +28,12 @@ module Globalize
           attribute = attribute.to_s
           where :attribute_name => attribute
         end
+
+        def attribute_translations(attribute)
+          attribute(attribute).inject(HashWithIndifferentAccess.new) do |hash, translation|
+            hash.update(translation.locale => translation.value)
+          end
+        end
       end
 
       def locale

data/lib/single_table_globalize3/active_record/with_translations.rb

@@ -0,0 +1,59 @@
+module SingleTableGlobalize3
+  module ActiveRecord
+    module WithTranslations
+      delegate :translated_locales, :to => :translation_class
+
+      def with_translations(*locales)
+        index = locales.pop if locales.last.is_a?(Fixnum)
+        locales = locales.concat(SingleTableGlobalize3.fallbacks).flatten.map(&:to_s)
+        alias_table_name = translations_table_name(index)
+
+        joins("LEFT OUTER JOIN #{translation_class.table_name} #{alias_table_name} ON #{alias_table_name}.translatable_id = #{table_name}.id").
+        select("distinct #{table_name}.*").
+        where(translated_column_name('locale', index) => locales)
+      end
+
+      def with_translated_attribute(name, value, locales = nil)
+        locales ||= SingleTableGlobalize3.fallbacks
+        self.join_index = self.join_index + 1
+        with_translations(locales, self.join_index).where(
+          translated_column_name('attribute_name', self.join_index) => name.to_s,
+          translated_column_name('value', self.join_index) => Array(value).map(&:to_s)
+        )
+      end
+
+      def translated?(name)
+        translated_attribute_names.include?(name.to_sym)
+      end
+
+      def required_attributes
+        validators.map { |v| v.attributes if v.is_a?(ActiveModel::Validations::PresenceValidator) }.flatten
+      end
+
+      def required_translated_attributes
+        translated_attribute_names & required_attributes
+      end
+
+      def translation_class
+        SingleTableGlobalize3::ActiveRecord::Translation
+      end
+
+      def translations_table_name(index = nil)
+        "#{translation_class.table_name}#{index}"
+      end
+
+      def translated_column_name(name, index = nil)
+        "#{translations_table_name(index)}.#{name}"
+      end
+      protected
+      def join_index
+        @join_index = 0 if @join_index.nil? || @join_index > 100
+        @join_index
+      end
+
+      def join_index=(value)
+        @join_index = value
+      end
+    end
+  end
+end

data/lib/single_table_globalize3/active_record.rb

@@ -0,0 +1,14 @@
+module SingleTableGlobalize3
+  module ActiveRecord
+    autoload :ActMacro,           'single_table_globalize3/active_record/act_macro'
+    autoload :Adapter,            'single_table_globalize3/active_record/adapter'
+    autoload :AttributeReadWrite, 'single_table_globalize3/active_record/attribute_read_write'
+    autoload :Attributes,         'single_table_globalize3/active_record/attributes'
+    autoload :ClassMethods,       'single_table_globalize3/active_record/class_methods'
+    autoload :WithTranslations,   'single_table_globalize3/active_record/with_translations'
+    autoload :Exceptions,         'single_table_globalize3/active_record/exceptions'
+    autoload :InstanceMethods,    'single_table_globalize3/active_record/instance_methods'
+    autoload :Migration,          'single_table_globalize3/active_record/migration'
+    autoload :Translation,        'single_table_globalize3/active_record/translation'
+  end
+end

data/lib/single_table_globalize3/version.rb

@@ -1,3 +1,3 @@
 module SingleTableGlobalize3
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/single_table_globalize3.rb

@@ -1 +1,73 @@
-require 'globalize'
+require 'active_record'
+require 'patches/active_record/xml_attribute_serializer'
+require 'patches/active_record/uniqueness_validator'
+
+module SingleTableGlobalize3
+  autoload :ActiveRecord, 'single_table_globalize3/active_record'
+
+  class << self
+    def locale
+      read_locale || I18n.locale
+    end
+
+    def locale=(locale)
+      set_locale(locale)
+    end
+
+    def with_locale(locale, &block)
+      previous_locale = read_locale
+      set_locale(locale)
+      result = yield(locale)
+      set_locale(previous_locale)
+      result
+    end
+
+    def with_locales(*locales, &block)
+      locales.flatten.map do |locale|
+        with_locale(locale, &block)
+      end
+    end
+
+    def fallbacks=(locales)
+      set_fallbacks(locales)
+    end
+
+    def i18n_fallbacks?
+      I18n.respond_to?(:fallbacks)
+    end
+
+    def fallbacks(for_locale = self.locale)
+      read_fallbacks[for_locale] || default_fallbacks(for_locale)
+    end
+
+    def default_fallbacks(for_locale = self.locale)
+      i18n_fallbacks? ? I18n.fallbacks[for_locale] : [for_locale.to_sym]
+    end
+
+  protected
+
+    def read_locale
+      Thread.current[:globalize_locale]
+    end
+
+    def set_locale(locale)
+      Thread.current[:globalize_locale] = locale.try(:to_sym)
+    end
+
+    def read_fallbacks
+      Thread.current[:fallbacks] || HashWithIndifferentAccess.new
+    end
+
+    def set_fallbacks(locales)
+      fallback_hash = HashWithIndifferentAccess.new
+
+      locales.each do |key, value|
+        fallback_hash[key] = value.presence || [key]
+      end if locales.present?
+
+      Thread.current[:fallbacks] = fallback_hash
+    end
+  end
+end
+
+ActiveRecord::Base.extend(SingleTableGlobalize3::ActiveRecord::ActMacro)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: single_table_globalize3
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Sven Fuchs
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-04 00:00:00.000000000 Z
+date: 2013-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -143,28 +143,28 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Rails I18n de-facto standard library for ActiveRecord 3 model/data translation
-  with single table.
+  with a single table.
 email: trong.v.tran@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/generators/globalize3/migration_generator.rb
-- lib/generators/globalize3/templates/migration.rb
-- lib/globalize/active_record/act_macro.rb
-- 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/translation.rb
-- lib/globalize/active_record.rb
-- lib/globalize.rb
+- lib/generators/single_table_globalize3/migration_generator.rb
+- lib/generators/single_table_globalize3/templates/migration.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/uniqueness_validator.rb
 - lib/patches/active_record/xml_attribute_serializer.rb
+- lib/single_table_globalize3/active_record/act_macro.rb
+- lib/single_table_globalize3/active_record/adapter.rb
+- lib/single_table_globalize3/active_record/attribute_read_write.rb
+- lib/single_table_globalize3/active_record/attributes.rb
+- lib/single_table_globalize3/active_record/class_methods.rb
+- lib/single_table_globalize3/active_record/exceptions.rb
+- lib/single_table_globalize3/active_record/instance_methods.rb
+- lib/single_table_globalize3/active_record/translation.rb
+- lib/single_table_globalize3/active_record/with_translations.rb
+- lib/single_table_globalize3/active_record.rb
 - lib/single_table_globalize3/version.rb
 - lib/single_table_globalize3.rb
 - Gemfile
@@ -194,5 +194,5 @@ rubygems_version: 2.0.0
 signing_key: 
 specification_version: 4
 summary: Rails I18n de-facto standard library for ActiveRecord 3 model/data translation
-  with single table
+  with a single table
 test_files: []

data/lib/generators/globalize3/migration_generator.rb

@@ -1,14 +0,0 @@
-require 'rails/generators/active_record'
-
-module SingleTableGlobalize3
-  module Generators
-    class MigrationGenerator < ActiveRecord::Generators::Base
-      source_root File.expand_path("../templates", __FILE__)
-      argument :name, :type => :string, :default => "application"
-
-      def copy_devise_migration
-        migration_template "migration.rb", "db/migrate/create_globalize_translations"
-      end
-    end
-  end
-end

data/lib/globalize/active_record.rb

@@ -1,12 +0,0 @@
-module Globalize
-  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'
-  end
-end

data/lib/globalize.rb

@@ -1,74 +0,0 @@
-require 'active_record'
-require 'patches/active_record/xml_attribute_serializer'
-require 'patches/active_record/query_method'
-require 'patches/active_record/uniqueness_validator'
-
-module Globalize
-  autoload :ActiveRecord, 'globalize/active_record'
-
-  class << self
-    def locale
-      read_locale || I18n.locale
-    end
-
-    def locale=(locale)
-      set_locale(locale)
-    end
-
-    def with_locale(locale, &block)
-      previous_locale = read_locale
-      set_locale(locale)
-      result = yield(locale)
-      set_locale(previous_locale)
-      result
-    end
-
-    def with_locales(*locales, &block)
-      locales.flatten.map do |locale|
-        with_locale(locale, &block)
-      end
-    end
-
-    def fallbacks=(locales)
-      set_fallbacks(locales)
-    end
-
-    def i18n_fallbacks?
-      I18n.respond_to?(:fallbacks)
-    end
-
-    def fallbacks(for_locale = self.locale)
-      read_fallbacks[for_locale] || default_fallbacks(for_locale)
-    end
-
-    def default_fallbacks(for_locale = self.locale)
-      i18n_fallbacks? ? I18n.fallbacks[for_locale] : [for_locale.to_sym]
-    end
-
-  protected
-
-    def read_locale
-      Thread.current[:globalize_locale]
-    end
-
-    def set_locale(locale)
-      Thread.current[:globalize_locale] = locale.try(:to_sym)
-    end
-
-    def read_fallbacks
-      Thread.current[:fallbacks] || HashWithIndifferentAccess.new
-    end
-
-    def set_fallbacks(locales)
-      fallback_hash = HashWithIndifferentAccess.new
-
-      locales.each do |key, value|
-        fallback_hash[key] = value.presence || [key]
-      end if locales.present?
-
-      Thread.current[:fallbacks] = fallback_hash
-    end
-  end
-end
-
-ActiveRecord::Base.extend(Globalize::ActiveRecord::ActMacro)

data/lib/patches/active_record/query_method.rb

@@ -1,35 +0,0 @@
-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