countrizable 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '039886e40e62d429443e1ade142f7ed8a6b5b3e83a12b7a7fca4fa109b5b3aff'
+  data.tar.gz: 51e4c3986a33eef57b917eceaa7fd6fb882ffcaabd66ff796fa2e33e72fd48bc
+SHA512:
+  metadata.gz: d76198119c24f64c9c77b27bd0c45d77c224001f2c443b8ffacc1e8913406fbb09ae72b4c115c28ba46e98fa04f320389b3f8b1b735fd8c14d90ed083fb7eba1
+  data.tar.gz: 0ffc9b2df18f3d71f878f2ddde6eaea2f4c0d65a33aeb67dd5965ca4a704b8bdba8866be1bf997f63eb864a035bd05d74b5d54c53893b841fb1424f3583af110

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+# Declare your gem's dependencies in countrizable.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use a debugger
+# gem 'byebug', group: [:development, :test]

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 zeopix
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Countrizable
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'countrizable'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install countrizable
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,27 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Countrizable'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/countrizable/active_record/act_macro.rb

@@ -0,0 +1,116 @@
+module Countrizable
+  module ActiveRecord
+    module ActMacro
+      def country_attribute(*attr_names)
+        options = attr_names.extract_options!
+        # Bypass setup_countries! if the initial bootstrapping is done already.
+        setup_countries!(options) unless country_attribute?
+        check_columns!(attr_names)
+
+        # Add any extra country attributes.
+        attr_names = attr_names.map(&:to_sym)
+        attr_names -= country_attribute_names if defined?(country_attribute_names)
+
+        allow_country_of_attributes(attr_names) if attr_names.present?
+      end
+
+      def class_name
+        @class_name ||= begin
+          class_name = table_name[table_name_prefix.length..-(table_name_suffix.length + 1)].downcase.camelize
+          pluralize_table_names ? class_name.singularize : class_name
+        end
+      end
+
+      def country_attribute?
+        included_modules.include?(InstanceMethods)
+      end
+
+      protected
+
+      def allow_country_of_attributes(attr_names)
+        attr_names.each do |attr_name|
+          # Detect and apply serialization.
+          enable_serializable_attribute(attr_name)
+
+          # Create accessors for the attribute.
+          define_country_attr_accessor(attr_name)
+          define_country_values_accessor(attr_name)
+
+          # Add attribute to the list.
+          self.country_attribute_names << attr_name
+        end
+
+        begin
+          if ::ActiveRecord::VERSION::STRING > "5.0" && table_exists? && country_value_class.table_exists?
+            self.ignored_columns += country_attribute_names.map(&:to_s)
+            reset_column_information
+          end
+        rescue ::ActiveRecord::NoDatabaseError
+          warn 'Unable to connect to a database. Countrizable skipped ignoring columns of country attributes.'
+        end
+      end
+
+      def check_columns!(attr_names)
+        # If tables do not exist or Rails version is greater than 5, do not warn about conflicting columns
+        return unless ::ActiveRecord::VERSION::STRING < "5.0" && table_exists? && country_value_class.table_exists?
+        if (overlap = attr_names.map(&:to_s) & column_names).present?
+          ActiveSupport::Deprecation.warn(
+            ["You have defined one or more country attributes with names that conflict with column(s) on the model table. ",
+             "Countrizable does not support this configuration anymore, remove or rename column(s) on the model table.\n",
+             "Model name (table name): #{model_name} (#{table_name})\n",
+             "Attribute name(s): #{overlap.join(', ')}\n"].join
+          )
+        end
+      rescue ::ActiveRecord::NoDatabaseError
+        warn 'Unable to connect to a database. Countrizable skipped checking attributes with conflicting column names.'
+      end
+
+      def apply_countrizable_options(options)
+        options[:table_name] ||= "#{table_name.singularize}_country_values"
+        options[:foreign_key] ||= class_name.foreign_key
+
+        class_attribute :country_attribute_names, :country_value_options, :fallbacks_for_empty_country_values
+        self.country_attribute_names = []
+        self.country_value_options        = options
+        self.fallbacks_for_empty_country_values = options[:fallbacks_for_empty_country_values]
+      end
+
+      def enable_serializable_attribute(attr_name)
+        serializer = self.countrizable_serialized_attributes[attr_name]
+        if serializer.present?
+          if defined?(::ActiveRecord::Coders::YAMLColumn) &&
+            serializer.is_a?(::ActiveRecord::Coders::YAMLColumn)
+            serializer = serializer.object_class
+          end
+
+          country_value_class.send :serialize, attr_name, serializer
+        end
+      end
+
+      def setup_countries!(options)
+        apply_countrizable_options(options)
+
+        include InstanceMethods
+        extend  ClassMethods, Migration
+
+        country_value_class.table_name = options[:table_name]
+
+        has_many :country_values, :class_name  => country_value_class.name,
+                                :foreign_key => options[:foreign_key],
+                                :dependent   => :destroy,
+                                :extend      => HasManyExtensions,
+                                :autosave    => false,
+                                :inverse_of  => :countrizable_model
+
+        after_create :save_country_values!
+        after_update :save_country_values!
+      end
+    end
+
+    module HasManyExtensions
+      def find_or_initialize_by_country_code(country_code)
+        with_country_code(country_code.to_s).first || build(:country_code => country_code.to_s)
+      end
+    end
+  end
+end

data/lib/countrizable/active_record/adapter.rb

@@ -0,0 +1,108 @@
+module Countrizable
+  module ActiveRecord
+    class Adapter
+      # The cache caches attributes that already were looked up for read access.
+      # The stash keeps track of new or changed values that need to be saved.
+      attr_accessor :record, :stash
+      private :record=, :stash=
+
+      delegate :country_value_class, :to => :'record.class'
+
+      def initialize(record)
+        @record = record
+        @stash = Attributes.new
+      end
+
+      def fetch_stash(country_code, name)
+        stash.read(country_code, name)
+      end
+
+      delegate :contains?, :to => :stash, :prefix => :stash
+      delegate :write, :to => :stash
+
+      def fetch(country_code, name)
+        record.countrizable_fallbacks(country_code).each do |fallback|
+          value = stash.contains?(fallback, name) ? fetch_stash(fallback, name) : fetch_attribute(fallback, name)
+
+          unless fallbacks_for?(value)
+            set_metadata(value, :country_code => fallback, :requested_country_code => country_code)
+            return value
+          end
+        end
+
+        return nil
+      end
+
+      def save_country_values!
+        stash.each do |country_code, attrs|
+          next if attrs.empty?
+
+          country_value = record.country_values_by_country_code[country_code] ||
+                        record.country_values.build(country_code: country_code.to_s)
+          attrs.each do |name, value|
+            value = value.val if value.is_a?(Arel::Nodes::Casted)
+            country_value[name] = value
+          end
+
+          ensure_foreign_key_for(country_value)
+          country_value.save!
+        end
+
+        reset
+      end
+
+      def reset
+        stash.clear
+      end
+
+      protected
+
+      # Sometimes the country_values is initialised before a foreign key can be set.
+      def ensure_foreign_key_for(country_value)
+        # AR >= 4.1 reflections renamed to _reflections
+        country_value[country_value.class.reflections.stringify_keys["countrizable_model"].foreign_key] = record.id
+      end
+
+      def type_cast(name, value)
+        return value.presence unless column = column_for_attribute(name)
+
+        column.type_cast value
+      end
+
+      def column_for_attribute(name)
+        country_value_class.columns_hash[name.to_s]
+      end
+
+      def unserializable_attribute?(name, column)
+        column.text? && country_value_class.serialized_attributes[name.to_s]
+      end
+
+      def fetch_attribute(country_code, name)
+        country_value = record.country_value_for(country_code, false)
+        if country_value
+          country_value.send(name)
+        else
+          record.class.country_value_class.new.send(name)
+        end
+      end
+
+      def set_metadata(object, metadata)
+        object.country_value_metadata.merge!(metadata) if object.respond_to?(:country_value_metadata)
+        object
+      end
+
+      def country_value_metadata_accessor(object)
+        return if obj.respond_to?(:country_value_metadata)
+        class << object; attr_accessor :country_value_metadata end
+        object.country_value_metadata ||= {}
+      end
+
+      def fallbacks_for?(object)
+        object.nil? || (fallbacks_for_empty_country_values? && object.blank?)
+      end
+
+      delegate :fallbacks_for_empty_country_values?, :to => :record, :prefix => false
+      prepend AdapterDirty
+    end
+  end
+end

data/lib/countrizable/active_record/adapter_dirty.rb

@@ -0,0 +1,56 @@
+module Countrizable
+  module ActiveRecord
+    module AdapterDirty
+      def write country_code, name, value
+        # Dirty tracking, paraphrased from
+        # ActiveRecord::AttributeMethods::Dirty#write_attribute.
+        name = name.to_s
+        store_old_value name, country_code
+        old_values = dirty[name]
+        old_value = old_values[country_code]
+        is_changed = record.send :attribute_changed?, name
+        if is_changed && value == old_value
+          # If there's already a change, delete it if this undoes the change.
+          old_values.delete country_code
+          if old_values.empty?
+            _reset_attribute name
+          end
+        elsif !is_changed
+          # If there's not a change yet, record it.
+          record.send(:attribute_will_change!, name) if old_value != value
+        end
+
+        super country_code, name, value
+      end
+
+      attr_writer :dirty
+      def dirty
+        @dirty ||= {}
+      end
+
+      def store_old_value name, country_code
+        dirty[name] ||= {}
+        unless dirty[name].key? country_code
+          old = fetch(country_code, name)
+          old = old.dup if old.duplicable?
+          dirty[name][country_code] = old
+        end
+      end
+
+      def clear_dirty
+        self.dirty = {}
+      end
+
+      def _reset_attribute name
+        record.send("#{name}=", record.changed_attributes[name])
+        record.send(:clear_attribute_changes, [name])
+      end
+
+      def reset
+        clear_dirty
+        super
+      end
+
+    end
+  end
+end

data/lib/countrizable/active_record/attributes.rb

@@ -0,0 +1,26 @@
+# Helper class for storing values per country_codes. Used by Countrizable::Adapter
+# to stash and cache attribute values.
+
+module Countrizable
+  module ActiveRecord
+    class Attributes < Hash # TODO: Think about using HashWithIndifferentAccess ?
+      def [](country_code)
+        country_code = country_code.to_sym
+        self[country_code] = {} unless has_key?(country_code)
+        self.fetch(country_code)
+      end
+
+      def contains?(country_code, name)
+        self[country_code].has_key?(name.to_s)
+      end
+
+      def read(country_code, name)
+        self[country_code][name.to_s]
+      end
+
+      def write(country_code, name, value)
+        self[country_code][name.to_s] = value
+      end
+    end
+  end
+end

data/lib/countrizable/active_record/class_methods.rb

@@ -0,0 +1,129 @@
+module Countrizable
+  module ActiveRecord
+    module ClassMethods
+      delegate :values_country_codes, :set_country_values_table_name, :to => :country_value_class
+
+      if ::ActiveRecord::VERSION::STRING < "5.0.0"
+        def columns_hash
+          super.except(*country_attribute_names.map(&:to_s))
+        end
+      end
+
+      def with_country_codes(*country_code)
+        all.merge country_value_class.with_country_codes(*country_codes)
+      end
+
+      def with_country_values(*country_codes)
+        country_codes = values_country_codes if country_codes.empty?
+        preload(:country_values).joins(:country_values).readonly(false).with_country_codes(country_codes).tap do |query|
+          query.distinct! unless country_codes.flatten.one?
+        end
+      end
+
+      def with_required_attributes
+        warn 'with_required_attributes is deprecated and will be removed in the next release of Countrizable.'
+        required_country_attributes.inject(all) do |scope, name|
+          scope.where("#{country_column_name(name)} IS NOT NULL")
+        end
+      end
+
+      def with_country_attribute(name, value, country = Countrizable.fallbacks)
+        with_country_values.where(
+          country_column_name(name)    => value,
+          country_column_name(:country_code) => Array(country_codes).map(&:to_s)
+        )
+      end
+
+      def country_attributed?(name)
+        country_attribute_names.include?(name.to_sym)
+      end
+
+      def required_attributes
+        warn 'required_attributes is deprecated and will be removed in the next release of Countrizable.'
+        validators.map { |v| v.attributes if v.is_a?(ActiveModel::Validations::PresenceValidator) }.flatten
+      end
+
+      def required_country_attributes
+        warn 'required_country_attributes is deprecated and will be removed in the next release of Countrizable.'
+        country_attribute_names & required_attributes
+      end
+
+      def country_value_class
+        @country_value_class ||= begin
+          if self.const_defined?(:CountryValue, false)
+            klass = self.const_get(:CountryValue, false)
+          else
+            klass = self.const_set(:CountryValue, Class.new(Countrizable::ActiveRecord::CountryValue))
+          end
+
+          klass.belongs_to :countrizable_model,
+            class_name: self.name,
+            foreign_key: country_value_options[:foreign_key],
+            inverse_of: :country_values,
+            touch: country_value_options.fetch(:touch, false)
+          klass
+        end
+      end
+
+      def country_values_table_name
+        country_value_class.table_name
+      end
+
+      def country_column_name(name)
+        "#{country_value_class.table_name}.#{name}"
+      end
+
+      private
+
+      # Override the default relation method in order to return a subclass
+      # of ActiveRecord::Relation with custom finder and calculation methods
+      # for country attributes.
+      def relation
+        super.extending!(CountryAttributesQuery)
+      end
+
+      protected
+
+      def define_country_attr_reader(name)
+        define_method(name) do |*args|
+          Countrizable::Interpolation.interpolate(name, self, args)
+        end
+        alias_method :"#{name}_before_type_cast", name
+      end
+
+      def define_country_attr_writer(name)
+        define_method(:"#{name}=") do |value|
+          write_attribute(name, value)
+        end
+      end
+
+      def define_country_attr_accessor(name)
+        attribute(name, ::ActiveRecord::Type::Value.new)
+        define_country_attr_reader(name)
+        define_country_attr_writer(name)
+      end
+
+      def define_country_values_reader(name)
+        define_method(:"#{name}_country_values") do
+          hash = country_attribute_by_country_code(name)
+          countrizable.stash.keys.each_with_object(hash) do |country_code, result|
+            result[country_code] = countrizable.fetch_stash(country_code, name) if countrizable.stash_contains?(country_code, name)
+          end
+        end
+      end
+
+      def define_country_values_writer(name)
+        define_method(:"#{name}_country_values=") do |value|
+          value.each do |(country_code, _value)|
+            write_attribute name, _value, :country_code => country_code
+          end
+        end
+      end
+
+      def define_country_values_accessor(name)
+        define_country_values_reader(name)
+        define_country_values_writer(name)
+      end
+    end
+  end
+end