mobility 0.8.13 → 1.0.0

data/lib/mobility/sequel/sql.rb

@@ -1,16 +0,0 @@
-module Mobility
-  module Sequel
-    module SQL
-      class QualifiedIdentifier < ::Sequel::SQL::QualifiedIdentifier
-        attr_reader :backend_class, :locale, :attribute_name
-
-        def initialize(table, column, locale, backend_class, attribute_name: nil)
-          @backend_class = backend_class
-          @locale = locale
-          @attribute_name = attribute_name || column
-          super(table, column)
-        end
-      end
-    end
-  end
-end

data/lib/mobility/sequel/string_translation.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "mobility/sequel/translation"
-
-module Mobility
-  module Sequel
-    class StringTranslation < ::Sequel::Model(:mobility_string_translations)
-      include Translation
-    end
-  end
-end

data/lib/mobility/sequel/text_translation.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-require "mobility/sequel/translation"
-
-module Mobility
-  module Sequel
-    class TextTranslation < ::Sequel::Model(:mobility_text_translations)
-      include Translation
-    end
-  end
-end

data/lib/mobility/sequel/translation.rb

@@ -1,53 +0,0 @@
-module Mobility
-  module Sequel
-    module Translation
-      def self.included(base)
-        base.class_eval do
-          plugin :validation_helpers
-
-          # Paraphased from sequel_polymorphic gem
-          #
-          model = underscore(self.to_s)
-          plural_model = pluralize(model)
-          many_to_one :translatable,
-            reciprocal: plural_model.to_sym,
-            reciprocal_type: :many_to_one,
-            setter: (proc do |able_instance|
-              self[:translatable_id]   = (able_instance.pk if able_instance)
-              self[:translatable_type] = (able_instance.class.name if able_instance)
-            end),
-            dataset: (proc do
-              translatable_type = send :translatable_type
-              translatable_id   = send :translatable_id
-              return if translatable_type.nil? || translatable_id.nil?
-              klass = self.class.send(:constantize, translatable_type)
-              klass.where(klass.primary_key => translatable_id)
-            end),
-            eager_loader: (proc do |eo|
-              id_map = {}
-              eo[:rows].each do |model|
-                model_able_type = model.send :translatable_type
-                model_able_id = model.send :translatable_id
-                model.associations[:translatable] = nil
-                ((id_map[model_able_type] ||= {})[model_able_id] ||= []) << model if !model_able_type.nil? && !model_able_id.nil?
-              end
-              id_map.each do |klass_name, id_map|
-                klass = constantize(camelize(klass_name))
-                klass.where(klass.primary_key=>id_map.keys).all do |related_obj|
-                  id_map[related_obj.pk].each do |model|
-                    model.associations[:translatable] = related_obj
-                  end
-                end
-              end
-            end)
-
-          def validate
-            super
-            validates_presence [:locale, :key, :translatable_id, :translatable_type]
-            validates_unique   [:locale, :key, :translatable_id, :translatable_type]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mobility/translates.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Mobility
-=begin
-
-Defines methods for attaching backends to a class. A block can optionally be
-passed to accessors to configure backend (see example below).
-
-@example Defining backend on a class
-  class MyClass
-    extend Translates
-    mobility_accessor :foo, option: :value
-  end
-
-@example Passing backend to a block
-  class MyClass
-    extend Translates
-    mobility_accessor :foo, option: :value do
-      # add custom code to backend class for this attribute only
-    end
-  end
-
-@example Defining only a backend reader and presence method
-  class MyClass
-    extend Translates
-    mobility_reader :foo
-  end
-
-  instance = MyClass.new
-  instance.foo         #=> (some value)
-  instance.foo?        #=> true
-  instance.foo = "foo" #=> NoMethodError
-
-@example Defining only a backend writer
-  class MyClass
-    extend Translates
-    mobility_writer :foo
-  end
-
-  instance = MyClass.new
-  instance.foo         #=> NoMethodError
-  instance.foo?        #=> NoMethodError
-  instance.foo = "foo" #=> (sets attribute to value "foo")
-=end
-  module Translates
-    # Defines mobility accessor on model class.
-    # @!method mobility_accessor(*attributes, **options)
-    #   @param [Array<String>] attributes
-    #   @param [Hash] options
-    #   @yield Yields to block with backend as context
-
-    # Defines mobility reader and presence method on model class.
-    # @!method mobility_reader(*attributes, **options)
-    #   @param [Array<String>] attributes
-    #   @param [Hash] options
-    #   @yield Yields to block with backend as context
-
-    # Defines mobility writer on model class.
-    # @!method mobility_writer(*attributes, **options)
-    #   @param [Array<String>] attributes
-    #   @param [Hash] options
-    #   @yield Yields to block with backend as context
-    %w[accessor reader writer].each do |method|
-      class_eval <<-EOM, __FILE__, __LINE__ + 1
-        def mobility_#{method}(*args, **options, &block)
-          attributes = Attributes.new(*args, method: :#{method}, **options)
-          attributes.backend.instance_eval(&block) if block_given?
-          include attributes
-        end
-      EOM
-    end
-  end
-end