mobility 0.0.1 → 0.1.0

data/Rakefile

@@ -1,6 +1,48 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "yaml"
 
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+task :load_path do
+  %w(lib spec).each do |path|
+    $LOAD_PATH.unshift(File.expand_path("../#{path}", __FILE__))
+  end
+end
+
+namespace :db do
+  desc "Create the database"
+  task :create => :load_path do
+    require "database"
+    driver = Mobility::Test::Database.driver
+    config = Mobility::Test::Database.config[driver]
+    commands = {
+      "mysql"    => "mysql -u #{config['username']} -e 'create database #{config["database"]};' >/dev/null",
+      "postgres" => "psql -c 'create database #{config['database']};' -U #{config['username']} >/dev/null"
+    }
+    %x{#{commands[driver] || true}}
+  end
+
+  desc "Drop the database"
+  task :drop => :load_path do
+    require "database"
+    driver = Mobility::Test::Database.driver
+    config = Mobility::Test::Database.config[driver]
+    commands = {
+      "mysql"    => "mysql -u #{config['username']} -e 'drop database #{config["database"]};' >/dev/null",
+      "postgres" => "psql -c 'drop database #{config['database']};' -U #{config['username']} >/dev/null"
+    }
+    %x{#{commands[driver] || true}}
+  end
+
+  desc "Set up the database schema"
+  task :up => :load_path do
+    require "spec_helper"
+    Mobility::Test::Schema.up
+  end
+
+  desc "Drop and recreate the database schema"
+  task :reset => [:drop, :create]
+end

data/lib/generators/mobility/install_generator.rb

@@ -0,0 +1,45 @@
+require "rails/generators"
+require "rails/generators/active_record"
+
+module Mobility
+  class InstallGenerator < ::Rails::Generators::Base
+    include ::Rails::Generators::Migration
+
+    desc "Generates migrations to add translations tables."
+
+    source_root File.expand_path("../templates", __FILE__)
+    class_option(
+      :without_tables,
+      type: :boolean,
+      default: false,
+      desc: "Skip creating translations tables."
+    )
+
+    def create_migration_file
+      add_mobility_migration("create_text_translations")   unless options.without_tables?
+      add_mobility_migration("create_string_translations") unless options.without_tables?
+    end
+
+    def create_initializer
+      create_file(
+        "config/initializers/mobility.rb",
+        "Mobility.config.default_backend = :key_value"
+      )
+    end
+
+    def self.next_migration_number(dirname)
+      ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    protected
+
+    def add_mobility_migration(template)
+      migration_dir = File.expand_path("db/migrate")
+      if self.class.migration_exists?(migration_dir, template)
+        ::Kernel.warn "Migration already exists: #{template}"
+      else
+        migration_template "#{template}.rb", "db/migrate/#{template}.rb"
+      end
+    end
+  end
+end

data/lib/generators/mobility/templates/create_string_translations.rb

@@ -0,0 +1,15 @@
+class CreateStringTranslations < ActiveRecord::Migration
+
+  def change
+    create_table :mobility_string_translations do |t|
+      t.string  :locale
+      t.string  :key
+      t.string  :value
+      t.integer :translatable_id
+      t.string  :translatable_type
+      t.timestamps
+    end
+    add_index :mobility_string_translations, [:translatable_id, :translatable_type, :locale, :key], unique: true, name: :index_mobility_string_translations_on_keys
+    add_index :mobility_string_translations, [:translatable_id, :translatable_type], name: :index_mobility_string_translations_on_translatable
+  end
+end

data/lib/generators/mobility/templates/create_text_translations.rb

@@ -0,0 +1,15 @@
+class CreateTextTranslations < ActiveRecord::Migration
+
+  def change
+    create_table :mobility_text_translations do |t|
+      t.string  :locale
+      t.string  :key
+      t.text    :value
+      t.integer :translatable_id
+      t.string  :translatable_type
+      t.timestamps
+    end
+    add_index :mobility_text_translations, [:translatable_id, :translatable_type, :locale, :key], unique: true, name: :index_mobility_text_translations_on_keys
+    add_index :mobility_text_translations, [:translatable_id, :translatable_type], name: :index_mobility_text_translations_on_translatable
+  end
+end

data/lib/mobility.rb

@@ -1,5 +1,206 @@
-require "mobility/version"
+require 'i18n'
+require 'request_store'
+require 'mobility/version'
 
+%w[object nil string].each do |type|
+  begin
+    require "active_support/core_ext/#{type}"
+  rescue LoadError
+    require "mobility/core_ext/#{type}"
+  end
+end
+
+=begin
+
+Mobility is a gem for storing and retrieving localized data through attributes
+on a class. The {Mobility} module includes all necessary methods and modules to
+support defining backend accessors on a class.
+
+To enable Mobility on a class, simply include or extend the {Mobility} module,
+and define any attribute accessors using {Translates#mobility_accessor} (aliased to the
+value of {Mobility.accessor_method}, which defaults to +translates+).
+
+  class MyClass
+    include Mobility
+    translates :title, backend: :key_value
+  end
+
+When defining this module, Mobility attempts to +require+ various gems (for
+example, +active_record+ and +sequel+) to evaluate which are loaded. Loaded
+gems are tracked with dynamic subclasses of the {Loaded} module and referenced
+in backends to define gem-dependent behavior.
+
+=end
 module Mobility
-  # Your code goes here...
+  autoload :Attributes,       "mobility/attributes"
+  autoload :Backend,          "mobility/backend"
+  autoload :BackendResetter,  "mobility/backend_resetter"
+  autoload :Configuration,    "mobility/configuration"
+  autoload :InstanceMethods,  "mobility/instance_methods"
+  autoload :Translates,       "mobility/translates"
+  autoload :Wrapper,          "mobility/wrapper"
+
+  require "mobility/orm"
+
+  # General error for version compatibility conflicts
+  class VersionNotSupportedError < ArgumentError; end
+
+  begin
+    require "active_record"
+    raise VersionNotSupportedError, "Mobility is only compatible with ActiveRecord 5.0 and greater" if ::ActiveRecord::VERSION::MAJOR < 5
+    autoload :ActiveModel,      "mobility/active_model"
+    autoload :ActiveRecord,     "mobility/active_record"
+    Loaded::ActiveRecord = true
+  rescue LoadError
+    Loaded::ActiveRecord = false
+  end
+
+  begin
+    require "rails"
+    autoload :InstallGenerator, "generators/mobility/install_generator"
+    Loaded::Rails = true
+  rescue LoadError
+    class InstallGenerator; end
+    Loaded::Rails = false
+  end
+
+  begin
+    require "sequel"
+    raise VersionNotSupportedError, "Mobility is only compatible with Sequel 4.0 and greater" if ::Sequel::MAJOR < 4
+    require "sequel/extensions/inflector"
+    require "sequel/plugins/dirty"
+    autoload :Sequel, "mobility/sequel"
+    Loaded::Sequel = true
+  rescue LoadError
+    Loaded::Sequel = false
+  end
+
+  class << self
+    def extended(model_class)
+      return if model_class.respond_to? :mobility_accessor
+      model_class.class_eval do
+        def self.mobility
+          @mobility ||= Mobility::Wrapper.new(self)
+        end
+        def self.translated_attribute_names
+          mobility.translated_attribute_names
+        end
+
+        class << self
+          include Translates
+          if translates = Mobility.config.accessor_method
+            alias_method translates, :mobility_accessor
+          end
+        end
+      end
+
+      model_class.include(InstanceMethods)
+
+      if Loaded::ActiveRecord
+        model_class.include(ActiveRecord)                   if model_class < ::ActiveRecord::Base
+        model_class.include(ActiveModel::AttributeMethods)  if model_class.ancestors.include?(::ActiveModel::AttributeMethods)
+      end
+
+      if Loaded::Sequel
+        model_class.include(Sequel) if model_class < ::Sequel::Model
+      end
+    end
+
+    # Extends model with this class so that +include Mobility+ is equivalent to
+    # +extend Mobility+
+    # @param model_class
+    def included(model_class)
+      model_class.extend self
+    end
+
+    # @!group Locale Accessors
+    # @return [Symbol] Mobility locale
+    def locale
+      read_locale || I18n.locale
+    end
+
+    # Sets Mobility locale
+    # @param [Symbol] locale Locale to set
+    # @raise [InvalidLocale] if locale is nil or not in +I18n.available_locales
+    # @return [Symbol] Locale
+    def locale=(locale)
+      set_locale(locale)
+    end
+
+    # Sets Mobility locale around block
+    # @param [Symbol] locale Locale to set in block
+    # @yield [Symbol] Locale
+    def with_locale(locale)
+      previous_locale = read_locale
+      begin
+        set_locale(locale)
+        yield(locale)
+      ensure
+        set_locale(previous_locale)
+      end
+    end
+    # @!endgroup
+
+    # @return [RequestStore] Request store
+    def storage
+      RequestStore.store
+    end
+
+    # @!group Configuration Methods
+    # @return [Mobility::Configuration] Mobility configuration
+    def config
+      storage[:mobility_configuration] ||= Mobility::Configuration.new
+    end
+
+    # (see Mobility::Configuration#accessor_method)
+    # @!method accessor_method
+
+    # (see Mobility::Configuration#default_fallbacks)
+    # @!method default_fallbacks
+
+    # (see Mobility::Configuration#default_backend)
+    # @!method default_backend
+
+    # (see Mobility::Configuration#default_accessor_locales)
+    # @!method default_accessor_locales
+    %w[accessor_method default_fallbacks default_backend default_accessor_locales].each do |method_name|
+      define_method method_name do
+        config.public_send(method_name)
+      end
+    end
+
+    # Configure Mobility
+    # @yield [Mobility::Configuration] Mobility configuration
+    def configure
+      yield config
+    end
+    # @!endgroup
+
+    # Return normalized locale
+    # @param [String,Symbol] locale
+    # @return [String] Normalized locale
+    # @example
+    #   Mobility.normalize_locale(:ja)
+    #   #=> "ja"
+    #   Mobility.normalize_locale("pt-BR")
+    #   #=> "pt_br"
+    def normalize_locale(locale)
+      "#{locale.to_s.downcase.sub("-", "_")}"
+    end
+
+    protected
+
+    def read_locale
+      storage[:mobility_locale]
+    end
+
+    def set_locale(locale)
+      locale = locale.to_sym if locale
+      raise Mobility::InvalidLocale.new(locale) unless I18n.available_locales.include?(locale) || locale.nil?
+      storage[:mobility_locale] = locale
+    end
+  end
+
+  class BackendRequired < ArgumentError; end
+  class InvalidLocale < I18n::InvalidLocale; end
 end

data/lib/mobility/active_model.rb

@@ -0,0 +1,6 @@
+module Mobility
+  module ActiveModel
+    autoload :AttributeMethods, "mobility/active_model/attribute_methods"
+    autoload :BackendResetter,  "mobility/active_model/backend_resetter"
+  end
+end

data/lib/mobility/active_model/attribute_methods.rb

@@ -0,0 +1,27 @@
+module Mobility
+  module ActiveModel
+=begin
+
+Included into model if model has +ActiveModel::AttributeMethods+ among its
+ancestors.
+
+=end
+    module AttributeMethods
+      delegate :translated_attribute_names, to: :class
+
+      # Adds translated attributes to +attributes+.
+      # @return [Array<String>] Model attributes
+      def attributes
+        super.merge(translated_attributes)
+      end
+
+      # Translated attributes defined on model.
+      # @return [Array<String>] Translated attributes
+      def translated_attributes
+        translated_attribute_names.inject({}) do |attributes, name|
+          attributes.merge(name.to_s => send(name))
+        end
+      end
+    end
+  end
+end

data/lib/mobility/active_model/backend_resetter.rb

@@ -0,0 +1,26 @@
+module Mobility
+  module ActiveModel
+=begin
+
+Backend resetter for ActiveModel models. Adds hook to reset backend when
++changes_applied+ or +clear_changes_information+ methods are called on model.
+
+=end
+    class BackendResetter < Mobility::BackendResetter
+
+      # (see Mobility::BackendResetter#initialize)
+      def initialize(attributes)
+        super
+
+        model_reset_method = @model_reset_method
+
+        %i[changes_applied clear_changes_information].each do |method|
+          define_method method do
+            super()
+            instance_eval &model_reset_method
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mobility/active_record.rb

@@ -0,0 +1,39 @@
+module Mobility
+=begin
+
+Module loading ActiveRecord-specific classes for Mobility models.
+
+=end
+  module ActiveRecord
+    autoload :BackendResetter,   "mobility/active_record/backend_resetter"
+    autoload :ModelTranslation,  "mobility/active_record/model_translation"
+    autoload :StringTranslation, "mobility/active_record/string_translation"
+    autoload :TextTranslation,   "mobility/active_record/text_translation"
+    autoload :Translation,       "mobility/active_record/translation"
+
+    def changes_applied
+      @previously_changed = changes
+      super
+    end
+
+    def clear_changes_information
+      @previously_changed = ActiveSupport::HashWithIndifferentAccess.new
+      super
+    end
+
+    def previous_changes
+      super.merge(@previously_changed ||= ActiveSupport::HashWithIndifferentAccess.new)
+    end
+
+    def self.included(model_class)
+      model_class.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # @return [ActiveRecord::Relation] relation extended with Mobility query methods.
+      def i18n
+        all
+      end
+    end
+  end
+end

data/lib/mobility/active_record/backend_resetter.rb

@@ -0,0 +1,26 @@
+module Mobility
+  module ActiveRecord
+=begin
+
+Backend resetter for ActiveRecord models. Adds hook on +reload+ event to
+{Mobility::ActiveModel::BackendResetter}.
+
+=end
+    class BackendResetter < Mobility::ActiveModel::BackendResetter
+
+      # @param [Class] model_class Class of model to which backend resetter will be applied
+      def included(model_class)
+        model_reset_method = @model_reset_method
+
+        model_class.class_eval do
+          mod = Module.new do
+            define_method :reload do
+              super().tap { instance_eval &model_reset_method }
+            end
+          end
+          include mod
+        end
+      end
+    end
+  end
+end