countrizable 0.1.1

data/lib/countrizable/active_record/country_attributes_query.rb

@@ -0,0 +1,181 @@
+module Countrizable
+  module ActiveRecord
+    module CountryAttributesQuery
+      class WhereChain < ::ActiveRecord::QueryMethods::WhereChain
+        def not(opts, *rest)
+          if parsed = @scope.clone.parse_country_conditions(opts)
+            @scope.join_country_values.where.not(parsed, *rest)
+          else
+            super
+          end
+        end
+      end
+
+      def where(opts = :chain, *rest)
+        if opts == :chain
+          WhereChain.new(spawn)
+        elsif parsed = parse_country_conditions(opts)
+          join_country_values(super(parsed, *rest))
+        else
+          super
+        end
+      end
+
+      def having(opts, *rest)
+        if parsed = parse_country_conditions(opts)
+          join_country_values(super(parsed, *rest))
+        else
+          super
+        end
+      end
+
+      def order(opts, *rest)
+        if respond_to?(:country_attribute_names) && parsed = parse_countries_order(opts)
+          join_country_values super(parsed)
+        else
+          super
+        end
+      end
+
+      def reorder(opts, *rest)
+        if respond_to?(:country_attribute_names) && parsed = parse_countries_order(opts)
+          join_country_values super(parsed)
+        else
+          super
+        end
+      end
+
+      def group(*columns)
+        if respond_to?(:country_attribute_names) && parsed = parse_countries_columns(columns)
+          join_country_values super(parsed)
+        else
+          super
+        end
+      end
+
+      def select(*columns)
+        if respond_to?(:country_attribute_names) && parsed = parse_countries_columns(columns)
+          join_country_values super(parsed)
+        else
+          super
+        end
+      end
+
+      def exists?(conditions = :none)
+        if parsed = parse_country_conditions(conditions)
+          with_country_values_in_fallbacks.exists?(parsed)
+        else
+          super
+        end
+      end
+
+      def calculate(*args)
+        column_name = args[1]
+        if respond_to?(:country_attribute_names) && country_column?(column_name)
+          args[1] = country_column_name(column_name)
+          join_country_values.calculate(*args)
+        else
+          super
+        end
+      end
+
+      def pluck(*column_names)
+        if respond_to?(:country_values_attribute_names) && parsed = parse_countries_columns(column_names)
+          join_country_values.pluck(*parsed)
+        else
+          super
+        end
+      end
+
+      def with_country_values_in_fallbacks
+        with_country_values(Countrizable.fallbacks)
+      end
+
+      def parse_country_conditions(opts)
+        if opts.is_a?(Hash) && respond_to?(:country_attribute_names) && (keys = opts.symbolize_keys.keys & country_attribute_names).present?
+          opts = opts.dup
+          keys.each { |key| opts[country_column_name(key)] = opts.delete(key) || opts.delete(key.to_s) }
+          opts
+        end
+      end
+
+      if ::ActiveRecord::VERSION::STRING < "5.0.0"
+        def where_values_hash(*args)
+          return super unless respond_to?(:country_values_table_name)
+          equalities = respond_to?(:with_default_scope) ? with_default_scope.where_values : where_values
+          equalities = equalities.grep(Arel::Nodes::Equality).find_all { |node|
+            node.left.relation.name == country_values_table_name
+          }
+
+          binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
+
+          super.merge(Hash[equalities.map { |where|
+            name = where.left.name
+            [name, binds.fetch(name.to_s) { right = where.right; right.is_a?(Arel::Nodes::Casted) ? right.val : right }]
+          }])
+        end
+      end
+
+      def join_country_values(relation = self)
+        if relation.joins_values.include?(:country_values)
+          relation
+        else
+          relation.with_country_values_in_fallbacks
+        end
+      end
+
+      private
+
+      def arel_countries_order_node(column, direction)
+        unless countries_column?(column)
+          return self.arel_table[column].send(direction)
+        end
+
+        full_column = countries_column_name(column)
+
+        # Inject `full_column` to the select values to avoid
+        # PG::InvalidColumnReference errors with distinct queries on Postgres
+        if select_values.empty?
+          self.select_values = [self.arel_table[Arel.star], full_column]
+        else
+          self.select_values << full_column
+        end
+
+        country_value_class.arel_table[column].send(direction)
+      end
+
+      def parse_countries_order(opts)
+        case opts
+        when Hash
+          # Do not process nothing unless there is at least a country column
+          # so that the `order` statement will be processed by the original
+          # ActiveRecord method
+          return nil unless opts.find { |col, dir| country_column?(col) }
+
+          # Build order arel nodes for countrys and non-countries statements
+          ordering = opts.map do |column, direction|
+            arel_country_order_node(column, direction)
+          end
+
+          order(ordering).order_values
+        when Symbol
+          parse_countries_order({ opts => :asc })
+        when Array
+          parse_countries_order(Hash[opts.collect { |opt| [opt, :asc] } ])
+        else # failsafe returns nothing
+          nil
+        end
+      end
+
+      def parse_countries_columns(columns)
+        if columns.is_a?(Array) && (columns.flatten & country_attribute_names).present?
+          columns.flatten.map { |column| country_column?(column) ? country_column_name(column) : column }
+        end
+      end
+
+      def country_column?(column)
+        country_attribute_names.include?(column)
+      end
+    end
+  end
+end

data/lib/countrizable/active_record/country_value.rb

@@ -0,0 +1,45 @@
+module Countrizable
+  module ActiveRecord
+    class CountryValue < ::ActiveRecord::Base
+
+      validates :country_code, :presence => true
+
+      class << self
+        # Sometimes ActiveRecord queries .table_exists? before the table name
+        # has even been set which results in catastrophic failure.
+        def table_exists?
+          table_name.present? && super
+        end
+
+        def with_country_codes(*country_codes)
+          # Avoid using "IN" with SQL queries when only using one locale.
+          country_codes = country_codes.flatten.map(&:to_s)
+          country_codes = country_codes.first if country_codes.one?
+          where :country_code => country_codes
+        end
+        alias with_country_codes with_country_codes
+
+        def valued_country_codes #prev translated_locales
+          select('DISTINCT country_code').order(:country_code).map(&:country_code)
+        end
+      end
+
+      def country_code
+        _country_code = read_attribute :country_code
+        _country_code.present? ? _country_code.to_sym : _country_code
+      end
+
+      def country_code=(country_code)
+        write_attribute :country_code, country_code.to_s
+      end
+    end
+  end
+end
+
+# Setting this will force polymorphic associations to subclassed objects
+# to use their table_name rather than the parent object's table name,
+# which will allow you to get their models back in a more appropriate
+# format.
+#
+# See http://www.ruby-forum.com/topic/159894 for details.
+Countrizable::ActiveRecord::CountryValue.abstract_class = true

data/lib/countrizable/active_record/exceptions.rb

@@ -0,0 +1,13 @@
+module Countrizable
+  module ActiveRecord
+    module Exceptions
+      class MigrationError < StandardError; end
+
+      class BadFieldName < MigrationError
+        def initialize(field)
+          super("Missing country valued field #{field.inspect}")
+        end
+      end
+    end
+  end
+end

data/lib/countrizable/active_record/instance_methods.rb

@@ -0,0 +1,246 @@
+module Countrizable
+  module ActiveRecord
+    module InstanceMethods
+      delegate :values_country_codes, :to => :country_values
+
+      def countrizable
+        @countrizable ||= Adapter.new(self)
+      end
+
+      def attributes
+        super.merge(country_attributed_attributes)
+      end
+
+      def attributes=(new_attributes, *options)
+        super unless new_attributes.respond_to?(:stringify_keys) && new_attributes.present?
+        attributes = new_attributes.stringify_keys
+        with_given_country_code(attributes) { super(attributes.except("country_code"), *options) }
+      end
+
+      if Countrizable.rails_52?
+
+        # In Rails 5.2 we need to override *_assign_attributes* as it's called earlier
+        # in the stack (before *assign_attributes*)
+        # See https://github.com/rails/rails/blob/master/activerecord/lib/active_record/attribute_assignment.rb#L11
+        def _assign_attributes(new_attributes)
+          attributes = new_attributes.stringify_keys
+          with_given_country_code(attributes) { super(attributes.except("country_code")) }
+        end
+
+      else
+
+        def assign_attributes(new_attributes, *options)
+          super unless new_attributes.respond_to?(:stringify_keys) && new_attributes.present?
+          attributes = new_attributes.stringify_keys
+          with_given_country_code(attributes) { super(attributes.except("country_code"), *options) }
+        end
+
+      end
+
+      def write_attribute(name, value, *args, &block)
+        return super(name, value, *args, &block) unless country_attributed?(name)
+
+        options = {:country_code => Countrizable.country_code}.merge(args.first || {})
+
+        countrizable.write(options[:country_code], name, value)
+      end
+
+      def [](attr_name)
+        if country_attributed?(attr_name)
+          read_attribute(attr_name)
+        else
+          read_attribute(attr_name) { |n| missing_attribute(n, caller) }
+        end
+      end
+
+      def read_attribute(attr_name, options = {}, &block)
+        name = if self.class.attribute_alias?(attr_name)
+                 self.class.attribute_alias(attr_name).to_s
+               else
+                 attr_name.to_s
+               end
+
+        name = self.class.primary_key if name == "id".freeze && self.class.primary_key
+
+        _read_attribute(name, options, &block)
+      end
+
+      def _read_attribute(attr_name, options = {}, &block)
+        country_value = read_country_attribute(attr_name, options, &block)
+        country_value.nil? ? super(attr_name, &block) : country_value
+      end
+
+      def attribute_names
+        country_attribute_names.map(&:to_s) + super
+      end
+
+      delegate :country_attributed?, :to => :class
+
+      def country_attributed_attributes
+        country_attribute_names.inject({}) do |attributes, name|
+          attributes.merge(name.to_s => send(name))
+        end
+      end
+
+      # This method is basically the method built into Rails
+      # but we have to pass {:country_attributed => false}
+      def uncountry_attributes
+        attribute_names.inject({}) do |attrs, name|
+          attrs[name] = read_attribute(name, {:country_attributed => false}); attrs
+        end
+      end
+
+      def set_country_values(options)
+        options.keys.each do |country_code|
+          country_value = country_value_for(country_code) ||
+                        country_values.build(:country_code => country_code.to_s)
+
+          options[country_code].each do |key, value|
+            country_value.send :"#{key}=", value
+            country_value.countrizable_model.send :"#{key}=", value
+          end
+          country_value.save if persisted?
+        end
+        countrizable.reset
+      end
+
+      def reload(options = nil)
+        country_value_caches.clear
+        country_attribute_names.each { |name| @attributes.reset(name.to_s) }
+        countrizable.reset
+        super(options)
+      end
+
+      def initialize_dup(other)
+        @countrizable = nil
+        @country_value_caches = nil
+        super
+        other.each_country_code_and_country_attribute do |country_code, name|
+          countrizable.write(country_code, name, other.countrizable.fetch(country_code, name) )
+        end
+      end
+
+      def country_value
+        country_value_for(::Countrizable.country_code)
+      end
+
+      def country_value_for(country_code, build_if_missing = true)
+        unless country_value_caches[country_code]
+          # Fetch values from database as those in the country values collection may be incomplete
+          _country_value = country_values.detect{|t| t.country_code.to_s == country_code.to_s}
+          _country_value ||= country_values.with_country_code(country_code).first unless country_values.loaded?
+          _country_value ||= country_values.build(:country_code => country_code) if build_if_missing
+          country_value_caches[country_code] = _country_value if _country_value
+        end
+        country_value_caches[country_code]
+      end
+
+      def country_value_caches
+        @country_value_caches ||= {}
+      end
+
+      def country_values_by_country_code
+        country_values.each_with_object(HashWithIndifferentAccess.new) do |t, hash|
+          hash[t.country_code] = block_given? ? yield(t) : t
+        end
+      end
+
+      def country_attribute_by_country_code(name)
+        country_values_by_country_code(&:"#{name}")
+      end
+
+      # Get available country_codes from country_value association, without a separate distinct query
+      def available_country_codes
+        country_values.map(&:country_code).uniq
+      end
+
+      def countrizable_fallbacks(country_code)
+        Countrizable.fallbacks(country_code)
+      end
+
+      def save(*)
+        result = Countrizable.with_country_code(country_value.country_code || I18n.default_country_code) do
+          without_fallbacks do
+            super
+          end
+        end
+        if result
+          countrizable.clear_dirty
+        end
+
+        result
+      end
+
+      def column_for_attribute name
+        return super if country_attribute_names.exclude?(name)
+
+        countrizable.send(:column_for_attribute, name)
+      end
+
+      def cache_key
+        [super, country_value.cache_key].join("/")
+      end
+
+      def changed?
+        changed_attributes.present? || country_values.any?(&:changed?)
+      end
+
+      # need to access instance variable directly since changed_attributes
+      # is frozen as of Rails 4.2
+      def original_changed_attributes
+        @changed_attributes
+      end
+
+    protected
+
+      def each_country_code_and_country_attribute
+        used_country_codes.each do |country_code|
+          country_attribute_names.each do |name|
+            yield country_code, name
+          end
+        end
+      end
+
+      def used_country_codes
+        country_codes = countrizable.stash.keys.concat(countrizable.stash.keys).concat(country_values.valued_country_codes)
+        country_codes.uniq!
+        country_codes
+      end
+
+      def save_country_values!
+        countrizable.save_country_values!
+        country_value_caches.clear
+      end
+
+      def with_given_country_code(_attributes, &block)
+        attributes = _attributes.stringify_keys
+
+        if country_code = attributes.try(:delete, "country_code")
+          Countrizable.with_country_code(country_code, &block)
+        else
+          yield
+        end
+      end
+
+      def without_fallbacks
+        before = self.fallbacks_for_empty_country_values
+        self.fallbacks_for_empty_country_values = false
+        yield
+      ensure
+        self.fallbacks_for_empty_country_values = before
+      end
+
+      # nil or value
+      def read_country_attribute(name, options)
+        options = {:country_attributed => true, :country_code => nil}.merge(options) #:translated => true
+        return nil unless options[:country_attributed] #translated
+        return nil unless country_attributed?(name)
+
+        value = countrizable.fetch(options[:country_code] || Countrizable.country_code, name)
+        return nil if value.nil?
+
+        block_given? ? yield(value) : value
+      end
+    end
+  end
+end

data/lib/countrizable/active_record/migration.rb

@@ -0,0 +1,215 @@
+require 'digest/sha1'
+
+module Countrizable
+  module ActiveRecord
+    module Migration
+      def countrizable_migrator
+        @countrizable_migrator ||= Migrator.new(self)
+      end
+
+      delegate :create_country_values_table!, :add_country_value_fields!,
+        :drop_country_value_table!, :country_value_index_name,
+        :country_value_country_code_index_name, :to => :countrizable_migrator
+
+      class Migrator
+        include Countrizable::ActiveRecord::Exceptions
+
+        attr_reader :model
+        delegate :country_attribute_names, :connection, :table_name,
+          :table_name_prefix, :country_values_table_name, :columns, :to => :model
+
+        def initialize(model)
+          @model = model
+        end
+
+        def fields
+          @fields ||= complete_country_fields
+        end
+
+        def create_country_value_table!(fields = {}, options = {})
+          extra = options.keys - [:migrate_data, :remove_source_columns, :unique_index]
+          if extra.any?
+            raise ArgumentError, "Unknown migration #{'option'.pluralize(extra.size)}: #{extra}"
+          end
+          @fields = fields
+          # If we have fields we only want to create the country table with those fields
+          complete_country_fields if fields.blank?
+          validate_country_fields
+
+          create_country_value_table
+          add_country_value_fields!(fields, options)
+          create_country_values_index(options)
+          clear_schema_cache!
+        end
+
+        def add_country_value_fields!(fields, options = {})
+          @fields = fields
+          validate_country_fields
+          add_country_value_fields
+          clear_schema_cache!
+          move_data_to_country_table if options[:migrate_data]
+          remove_source_columns if options[:remove_source_columns]
+          clear_schema_cache!
+        end
+
+        def remove_source_columns
+          column_names = *fields.keys
+          column_names.each do |column|
+            if connection.column_exists?(table_name, column)
+              connection.remove_column(table_name, column)
+            end
+          end
+        end
+
+        def drop_country_table!(options = {})
+          move_data_to_model_table if options[:migrate_data]
+          drop_country_values_index
+          drop_country_value_table
+          clear_schema_cache!
+        end
+
+        # This adds all the current country attributes of the model
+        # It's a problem because in early migrations would add all the country attributes
+        def complete_country_fields
+          country_attribute_names.each do |name|
+            @fields[name] ||= column_type(name)
+          end
+        end
+
+        def create_country_value_table
+          connection.create_table(country_values_table_name) do |t|
+            t.references table_name.sub(/^#{table_name_prefix}/, '').singularize, :null => false, :index => false, :type => column_type(model.primary_key).to_sym
+            t.string :country_code, :null => false
+            t.timestamps :null => false
+          end
+        end
+
+        def add_country_value_fields
+          connection.change_table(country_values_table_name) do |t|
+            fields.each do |name, options|
+              if options.is_a? Hash
+                t.column name, options.delete(:type), options
+              else
+                t.column name, options
+              end
+            end
+          end
+        end
+
+        def create_country_values_index(options)
+          foreign_key = "#{table_name.sub(/^#{table_name_prefix}/, "").singularize}_id".to_sym
+          connection.add_index(
+            country_values_table_name,
+            foreign_key,
+            :name => country_value_index_name
+          )
+          # index for select('DISTINCT country_code') call in country_value.rb
+          connection.add_index(
+            country_values_table_name,
+            :country_code,
+            :name => country_value_country_code_index_name
+          )
+
+          if options[:unique_index]
+            connection.add_index(
+              country_values_table_name,
+              [foreign_key, :country_code],
+              :name => country_value_unique_index_name,
+              unique: true
+            )
+          end
+        end
+
+        def drop_country_value_table
+          connection.drop_table(country_values_table_name)
+        end
+
+        def drop_country_values_index
+          if connection.indexes(country_values_table_name).map(&:name).include?(country_value_index_name)
+            connection.remove_index(country_values_table_name, :name => country_value_index_name)
+          end
+          if connection.indexes(country_values_table_name).map(&:name).include?(country_value_country_code_index_name)
+            connection.remove_index(country_values_table_name, :name => country_value_country_code_index_name)
+          end
+        end
+
+        def move_data_to_country_value_table
+          model.find_each do |record|
+            country_value = record.country_value_for(I18n.country_code) || record.country_values.build(:country_code => I18n.country_code)
+            fields.each do |attribute_name, attribute_type|
+              country_value[attribute_name] = record.read_attribute(attribute_name, {:country_attributed => false})
+            end
+            country_value.save!
+          end
+        end
+
+        def move_data_to_model_table
+          add_missing_columns
+
+          # Find all of the country attributes for all records in the model.
+          all_country_attributes = model.all.collect{|m| m.attributes}
+          all_country_attributes.each do |country_record|
+            # Create a hash containing the country column names and their values.
+            country_attribute_names.inject(fields_to_update={}) do |f, name|
+              f.update({name.to_sym => country_record[name.to_s]})
+            end
+
+            # Now, update the actual model's record with the hash.
+            model.where(model.primary_key.to_sym => country_record[model.primary_key]).update_all(fields_to_update)
+          end
+        end
+
+        def validate_country_fields
+          fields.each do |name, options|
+            raise BadFieldName.new(name) unless valid_field_name?(name)
+          end
+        end
+
+        def column_type(name)
+          columns.detect { |c| c.name == name.to_s }.try(:type) || :string
+        end
+
+        def valid_field_name?(name)
+          country_attribute_names.include?(name)
+        end
+
+        def country_value_index_name
+          truncate_index_name "index_#{country_values_table_name}_on_#{table_name.singularize}_id"
+        end
+
+        def country_value_country_code_index_name
+          truncate_index_name "index_#{country_values_table_name}_on_country_code"
+        end
+
+        def country_value_unique_index_name
+          truncate_index_name "index_#{country_values_table_name}_on_#{table_name.singularize}_id_and_country_code"
+        end
+
+        def clear_schema_cache!
+          connection.schema_cache.clear! if connection.respond_to? :schema_cache
+          model::CountryValue.reset_column_information
+          model.reset_column_information
+        end
+
+        private
+
+        def truncate_index_name(index_name)
+          if index_name.size < connection.index_name_length
+            index_name
+          else
+            "index_#{Digest::SHA1.hexdigest(index_name)}"[0, connection.index_name_length]
+          end
+        end
+
+        def add_missing_columns
+          clear_schema_cache!
+          country_attribute_names.map(&:to_s).each do |attribute|
+            unless model.column_names.include?(attribute)
+              connection.add_column(table_name, attribute, model::CountryValue.columns_hash[attribute].type)
+            end
+          end
+        end
+      end
+    end
+  end
+end