countrizable 0.1.1

data/lib/countrizable/active_record.rb

@@ -0,0 +1,14 @@
+module Countrizable
+  module ActiveRecord
+    autoload :ActMacro,                     'countrizable/active_record/act_macro'
+    autoload :Adapter,                      'countrizable/active_record/adapter'
+    autoload :AdapterDirty,                 'countrizable/active_record/adapter_dirty'
+    autoload :Attributes,                   'countrizable/active_record/attributes'
+    autoload :ClassMethods,                 'countrizable/active_record/class_methods'
+    autoload :Exceptions,                   'countrizable/active_record/exceptions'
+    autoload :InstanceMethods,              'countrizable/active_record/instance_methods'
+    autoload :Migration,                    'countrizable/active_record/migration'
+    autoload :CountryValue,                  'countrizable/active_record/country_value'
+    autoload :CountryAttributesQuery,    'countrizable/active_record/country_attributes_query'
+  end
+end

data/lib/countrizable/i18n/country_code.rb

@@ -0,0 +1,9 @@
+module Countrizable
+  module I18n
+    class << self
+      def country_code
+        "es"
+      end
+    end
+  end
+end

data/lib/countrizable/i18n.rb

@@ -0,0 +1,5 @@
+module Countrizable
+  module I18n
+    autoload :CountryCode,                     'countrizable/i18n/country_code'
+  end
+end

data/lib/countrizable/interpolation.rb

@@ -0,0 +1,28 @@
+module Countrizable
+  module Interpolation
+    def interpolate(name, model, args)
+      country_value = model.read_attribute(name, {:country_code => country_code_from(args)})
+      try_interpolation country_value, interpolation_args_from(args)
+    end
+
+    private
+
+    def interpolation_args_from(args)
+      args.detect {|a| a.is_a? Hash }
+    end
+
+    def country_code_from(args)
+      args.detect {|a| !a.is_a? Hash }
+    end
+
+    def try_interpolation(country_value,args)
+      if args
+        I18n.interpolate(country_value,args)
+      else
+        country_value
+      end
+    end
+
+    extend self
+  end
+end

data/lib/countrizable/railtie.rb

@@ -0,0 +1,4 @@
+module Countrizable
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/countrizable/version.rb

@@ -0,0 +1,3 @@
+module Countrizable
+  VERSION = '0.1.1'
+end

data/lib/countrizable.rb

@@ -0,0 +1,95 @@
+require "countrizable/railtie"
+require 'request_store'
+require 'active_record'
+require 'patches/active_record/xml_attribute_serializer'
+require 'patches/active_record/query_method'
+require 'patches/active_record/relation'
+require 'patches/active_record/serialization'
+require 'patches/active_record/uniqueness_validator'
+require 'patches/active_record/persistence'
+
+module Countrizable
+  autoload :ActiveRecord, 'countrizable/active_record'
+  autoload :Interpolation,   'countrizable/interpolation'
+
+  class << self
+    def country_code
+      read_country_code || 'es'
+    end
+
+    def country_code=(country_code)
+      set_country_code(country_code)
+    end
+
+    def with_country_code(country_code, &block)
+      previous_country_code = read_country_code
+      begin
+        set_country_code(country_code)
+        result = yield(country_code)
+      ensure
+        set_country_code(previous_country_code)
+      end
+      result
+    end
+
+    def with_country_codes(*country_codes, &block)
+      country_codes.flatten.map do |country_code|
+        with_country_code(country_code, &block)
+      end
+    end
+
+    def fallbacks=(country_codes)
+      set_fallbacks(country_codes)
+    end
+
+    def fallbacks(for_country_code = self.country_code)
+      read_fallbacks[for_country_code] || default_fallbacks(for_country_code)
+    end
+
+    def default_fallbacks(for_country_code = self.country_code)
+      [for_country_code.to_sym]
+    end
+
+    # Thread-safe global storage
+    def storage
+      RequestStore.store
+    end
+
+    def rails_5?
+      ::ActiveRecord.version >= Gem::Version.new('5.1.0')
+    end
+
+    def rails_52?
+      ::ActiveRecord.version >= Gem::Version.new('5.2.0')
+    end
+
+  protected
+
+    def read_country_code
+      storage[:countrizable_country_code]
+    end
+
+    def set_country_code(country_code)
+      storage[:countrizable_country_code] = country_code.try(:to_sym)
+    end
+
+    def read_fallbacks
+      storage[:countrizable_fallbacks] || HashWithIndifferentAccess.new
+    end
+
+    def set_fallbacks(country_codes)
+      fallback_hash = HashWithIndifferentAccess.new
+
+      country_codes.each do |key, value|
+        fallback_hash[key] = value.presence || [key]
+      end if country_codes.present?
+
+      storage[:countrizable_country_code] = fallback_hash
+    end
+  end
+end
+
+ActiveRecord::Base.class_attribute :countrizable_serialized_attributes, instance_writer: false
+ActiveRecord::Base.countrizable_serialized_attributes = {}
+
+ActiveRecord::Base.extend(Countrizable::ActiveRecord::ActMacro)

data/lib/i18n/country_code.rb

@@ -0,0 +1,7 @@
+module I18n
+  class << self
+    def country_code
+      "es2"
+    end
+  end
+end

data/lib/patches/active_record/persistence.rb

@@ -0,0 +1,17 @@
+module Countrizable
+  module Persistence
+    # Updates the associated record with values matching those of the instance attributes.
+    # Returns the number of affected rows.
+    def _update_record(attribute_names = self.attribute_names)
+      attribute_names_without_country_attributed = attribute_names.select{ |k| not respond_to?('country_attributed?') or not country_attributed?(k) }
+      super(attribute_names_without_country_attributed)
+    end
+
+    def _create_record(attribute_names = self.attribute_names)
+      attribute_names_without_country_attributed = attribute_names.select{ |k| not respond_to?('country_attributed?') or not country_attributed?(k) }
+      super(attribute_names_without_country_attributed)
+    end
+  end
+end
+
+ActiveRecord::Persistence.send(:prepend, Countrizable::Persistence)

data/lib/patches/active_record/query_method.rb

@@ -0,0 +1,3 @@
+if ::ActiveRecord::VERSION::STRING < "5.0.0"
+  require_relative 'rails4/query_method'
+end

data/lib/patches/active_record/rails4/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

data/lib/patches/active_record/rails4/serialization.rb

@@ -0,0 +1,22 @@
+module Countrizable
+  module AttributeMethods
+    module Serialization
+      def serialize(attr_name, class_name_or_coder = Object)
+        super(attr_name, class_name_or_coder)
+
+        coder = if class_name_or_coder == ::JSON
+                  ::ActiveRecord::Coders::JSON
+                elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+                  class_name_or_coder
+                else
+                  ::ActiveRecord::Coders::YAMLColumn.new(class_name_or_coder)
+                end
+
+        self.countrizable_serialized_attributes = countrizable_serialized_attributes.dup
+        self.countrizable_serialized_attributes[attr_name] = coder
+      end
+    end
+  end
+end
+
+ActiveRecord::AttributeMethods::Serialization::ClassMethods.send(:prepend, Countrizable::AttributeMethods::Serialization)

data/lib/patches/active_record/rails4/uniqueness_validator.rb

@@ -0,0 +1,42 @@
+require 'active_record/validations/uniqueness.rb'
+
+module Countrizable
+  module UniquenessValidatorOverride
+    def validate_each(record, attribute, value)
+      klass = record.class
+      if klass.country_attributes? && klass.country_attributed?(attribute)
+        finder_class = klass.country_value_class
+        table = finder_class.arel_table
+
+        relation = build_relation(finder_class, table, attribute, value).and(table[:locale].eq(Countrizable.locale))
+        relation = relation.and(table[klass.reflect_on_association(:country_values).foreign_key].not_eq(record.send(:id))) if record.persisted?
+
+        country_scopes = Array(options[:scope]) & klass.country_attribute_names
+        uncountry_scopes = Array(options[:scope]) - country_scopes
+
+        uncountry_scopes.each do |scope_item|
+          scope_value = record.send(scope_item)
+          reflection = klass.reflect_on_association(scope_item)
+          if reflection
+            scope_value = record.send(reflection.foreign_key)
+            scope_item = reflection.foreign_key
+          end
+          relation = relation.and(find_finder_class_for(record).arel_table[scope_item].eq(scope_value))
+        end
+
+        country_scopes.each do |scope_item|
+          scope_value = record.send(scope_item)
+          relation = relation.and(table[scope_item].eq(scope_value))
+        end
+
+        if klass.unscoped.with_country_values.where(relation).exists?
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
+        end
+      else
+        super
+      end
+    end
+  end
+end
+
+ActiveRecord::Validations::UniquenessValidator.send :prepend, Countrizable::UniquenessValidatorOverride

data/lib/patches/active_record/rails5/uniqueness_validator.rb

@@ -0,0 +1,47 @@
+module Countrizable
+  module Validations
+    module UniquenessValidator
+      def validate_each(record, attribute, value)
+        klass = record.class
+        if klass.country_attributes? && klass.country_attributed?(attribute)
+          finder_class = klass.country_value_class
+          finder_table = finder_class.arel_table
+          relation = build_relation(finder_class, finder_table, attribute, value).where(country_code: Countrizable.country_code)
+          relation = relation.where.not(klass.reflect_on_association(:country_values).foreign_key => record.send(:id)) if record.persisted?
+
+
+          country_scopes = Array(options[:scope]) & klass.country_attribute_names
+          uncountry_scopes = Array(options[:scope]) - country_scopes
+
+          relation = relation.joins(:countrizable_model) if uncountry_scopes.present?
+          uncountry_scopes.each do |scope_item|
+            scope_value = record.send(scope_item)
+            reflection = klass.reflect_on_association(scope_item)
+            if reflection
+              scope_value = record.send(reflection.foreign_key)
+              scope_item = reflection.foreign_key
+            end
+            relation = relation.where(find_finder_class_for(record).table_name => { scope_item => scope_value })
+          end
+
+          country_scopes.each do |scope_item|
+            scope_value = record.send(scope_item)
+            relation = relation.where(scope_item => scope_value)
+          end
+          relation = relation.merge(options[:conditions]) if options[:conditions]
+
+          # if klass.unscoped.with_country_values.where(relation).exists?
+          if relation.exists?
+            error_options = options.except(:case_sensitive, :scope, :conditions)
+            error_options[:value] = value
+            record.errors.add(attribute, :taken, error_options)
+          end
+        else
+          super(record, attribute, value)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Validations::UniquenessValidator.prepend Countrizable::Validations::UniquenessValidator

data/lib/patches/active_record/rails5_1/serialization.rb

@@ -0,0 +1,22 @@
+module Countrizable
+  module AttributeMethods
+    module Serialization
+      def serialize(attr_name, class_name_or_coder = Object)
+        super(attr_name, class_name_or_coder)
+
+        coder = if class_name_or_coder == ::JSON
+                  ::ActiveRecord::Coders::JSON
+                elsif [:load, :dump].all? { |x| class_name_or_coder.respond_to?(x) }
+                  class_name_or_coder
+                else
+                  ::ActiveRecord::Coders::YAMLColumn.new(attr_name, class_name_or_coder)
+                end
+
+        self.countrizable_serialized_attributes = countrizable_serialized_attributes.dup
+        self.countrizable_serialized_attributes[attr_name] = coder
+      end
+    end
+  end
+end
+
+ActiveRecord::AttributeMethods::Serialization::ClassMethods.send(:prepend, Countrizable::AttributeMethods::Serialization)

data/lib/patches/active_record/rails5_1/uniqueness_validator.rb

@@ -0,0 +1,45 @@
+module Countrizable
+  module Validations
+    module UniquenessValidator
+      def validate_each(record, attribute, value)
+        klass = record.class
+        if klass.country_attributes? && klass.country_attributed?(attribute)
+          finder_class = klass.country_value_class
+          relation = build_relation(finder_class, attribute, value).where(country_code: Countrizable.country_code)
+          relation = relation.where.not(klass.reflect_on_association(:country_values).foreign_key => record.send(:id)) if record.persisted?
+
+
+          country_scopes = Array(options[:scope]) & klass.country_attribute_names
+          uncountry_scopes = Array(options[:scope]) - country_scopes
+
+          relation = relation.joins(:countrizable_model) if uncountry_scopes.present?
+          uncountry_scopes.each do |scope_item|
+            scope_value = record.send(scope_item)
+            reflection = klass.reflect_on_association(scope_item)
+            if reflection
+              scope_value = record.send(reflection.foreign_key)
+              scope_item = reflection.foreign_key
+            end
+            relation = relation.where(find_finder_class_for(record).table_name => { scope_item => scope_value })
+          end
+
+          country_scopes.each do |scope_item|
+            scope_value = record.send(scope_item)
+            relation = relation.where(scope_item => scope_value)
+          end
+          relation = relation.merge(options[:conditions]) if options[:conditions]
+
+          if relation.exists?
+            error_options = options.except(:case_sensitive, :scope, :conditions)
+            error_options[:value] = value
+            record.errors.add(attribute, :taken, error_options)
+          end
+        else
+          super(record, attribute, value)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Validations::UniquenessValidator.prepend Countrizable::Validations::UniquenessValidator

data/lib/patches/active_record/relation.rb

@@ -0,0 +1,12 @@
+if ::ActiveRecord::VERSION::STRING >= "5.0.0"
+  module Countrizable
+    module Relation
+      def where_values_hash(relation_table_name = table_name)
+        return super unless respond_to?(:country_values_table_name)
+        super.merge(super(country_values_table_name))
+      end
+    end
+  end
+
+  ActiveRecord::Relation.prepend Countrizable::Relation
+end

data/lib/patches/active_record/serialization.rb

@@ -0,0 +1,5 @@
+if ::ActiveRecord::VERSION::STRING < "5.1.0"
+  require_relative 'rails4/serialization'
+else
+  require_relative 'rails5_1/serialization'
+end

data/lib/patches/active_record/uniqueness_validator.rb

@@ -0,0 +1,7 @@
+if ::ActiveRecord::VERSION::STRING < "5.0.0"
+  require_relative 'rails4/uniqueness_validator'
+elsif ::ActiveRecord::VERSION::STRING < "5.1.0"
+  require_relative 'rails5/uniqueness_validator'
+else
+  require_relative 'rails5_1/uniqueness_validator'
+end

data/lib/patches/active_record/xml_attribute_serializer.rb

@@ -0,0 +1,23 @@
+begin
+  require 'active_record/serializers/xml_serializer'
+rescue LoadError
+end
+
+module Countrizable
+  module XmlSerializer
+    module Attribute
+      def compute_type
+        klass = @serializable.class
+        if klass.country_attributes? && klass.country_attribute_names.include?(name.to_sym)
+          :string
+        else
+          super
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActiveRecord::XmlSerializer)
+  ActiveRecord::XmlSerializer::Attribute.send(:prepend, Countrizable::XmlSerializer::Attribute)
+end

data/lib/tasks/countrizable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :countrizable do
+#   # Task goes here
+# end