localizable_db 1.0.9 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 917295631d33c010de7203976ccaeb7a2ae5e9c0a202f7706c16f9bb336963bc
-  data.tar.gz: 43dbea407d477a837c10e763df32ce4e842e540427398d9f3cc264ce16b267d8
+  metadata.gz: 3a99073b188d1f8dca333d7d3f44e6ac410bfa910b2cfb599a295a560ae1253f
+  data.tar.gz: bd9fef76db1684201bf7a886be643fd7978d584302b524fdaded7f2a76a38a8b
 SHA512:
-  metadata.gz: acd94c123f9ddb1c24abeacf2d2a08c5d83bb6fcce4e9a0f4211ff2498526145cc4360956c18994acc4ddca9f55c396daf91bd6605a82e22988409cec2b6b6b6
-  data.tar.gz: 8c4162534f685f2d9009064b866ba79f0906449982bbadd77d4e23e0641165a955f63c9774ca213b1f5ba2b19b1181cc51dc37536e329f9c9c3ad3570e155372
+  metadata.gz: 342b8a4fed0728288bc2efbd50f9bf1d9bf14916f5ed9221f31f5c41ebf110d32c204399f85add85760792f85cea3caeacd4ab1b1cd23da1d35fd63456439a3a
+  data.tar.gz: 7c0d50374228b52e77278fc867ee68fa56da487428ae637966197b8113d04fc0ee7496cfd520c53bd3b67a576f5536a090530e0eaab693cb142b2646de4ca118

data/README.md

@@ -13,6 +13,10 @@ Product.where(id: 1)
 
 I18n.locale = :es
 
+Product.find(1) #=> <Product id: 1, name: "suerte">
+Product.where(id: 1)
+#=> <ActiveRecord::Relation [#<Product id: 1, name: "suerte">]>
+
 Product.l.find(1) #=> <Product id: 1, name: "suerte">
 Product.l.where(id: 1)
 #=> <ActiveRecord::Relation [#<Product id: 1, name: "suerte">]>
@@ -26,17 +30,14 @@ Product.where(id: 1)
 #=> <ActiveRecord::Relation [#<Product id: 1, name: "luck">]>
 
 Product.l(:es).find(1) #=> <Product id: 1, name: "suerte">
-Product.find(1).l(:es) #=> <Product id: 1, name: "suerte">
 Product.l(:es).where(id: 1)
 #=> <ActiveRecord::Relation [#<Product id: 1, name: "suerte">]>
 
 Product.l(:pt).find(1) #=> <Product id: 1, name: "sortudo">
-Product.find(1).l(:pt) #=> <Product id: 1, name: "sortudo">
 Product.l(:pt).where(id: 1)
 #=> <ActiveRecord::Relation [#<Product id: 1, name: "sortudo">]>
 
 Product.l(:fr).find(1) #=> <Product id: 1, name: "heureux">
-Product.find(1).l(:fr) #=> <Product id: 1, name: "heureux">
 Product.l(:fr).where(id: 1)
 #=> <ActiveRecord::Relation [#<Product id: 1, name: "heureux">]>
 ````
@@ -45,39 +46,43 @@ Localize multiple languages
 products = Product.where(id: 1)
 products.inspect
 #=> <ActiveRecord::Relation [#<Product id: 1, name: "luck">]>
-products = Product.wl(:es,:pt,:fr).where(id: 1)
+products = Product.l(:es,:pt,:fr).where(id: 1)
 products.inspect
 #=> <ActiveRecord::Relation [#<Product id: 1, name: "luck", es_name: "suerte", pt_name: "sortudo", fr_name: "heureux">]>
 
 products.first.name #=> luck
+products.first.get_name #=> luck
+products.first.get_name(:es) #=> suerte
+products.first.get_name(:pt) #=> sortudo
+products.first.get_name(:fr) #=> heureux
 products.first.attributes["es_name"] #=> suerte
 products.first.attributes["pt_name"] #=> sortudo
 products.first.attributes["fr_name"] #=> heureux
 ````
 Creating
 ````ruby
-Product.create(name: "something", languages: {
-	es: {name: "algo"},
-    pt: {name: "alguma cosia"},
-    fr: {name: "quelque chose"}
-})
+Product.create(name: "something", product_languages_attributes: [{
+		{name: "algo", locale: "es"},
+    {name: "alguma cosia", locale: "pt"},
+    {name: "quelque chose", locale: "fr"}
+}])
 #=> #<Product id:2, name: "something">
 ````
 Saving
 ````ruby
-Product.new(name: "love", languages: {
-	es: {name: "amor"},
-    pt: {name: "amor"},
-    fr: {name: "amour"}
-}).save
+Product.new(name: "love", product_languages_attributes: [{
+		{name: "algo", locale: "es"},
+    {name: "alguma cosia", locale: "pt"},
+    {name: "quelque chose", locale: "fr"}
+}]).save
 #=> #<Product id:3, name: "love">
 
 love = Product.last
-love.set_languages({
-	es: {name: "amor :D"},
-    pt: {name: "amor :D"},
-    fr: {name: "amouuurt"}
-})
+love.product_languages.build([
+	{name: "algo", locale: "es"},
+	{name: "alguma cosia", locale: "pt"},
+	{name: "quelque chose", locale: "fr"}
+])
 love.save
 #=> #<Product id: 3, name: "love">
 love =  Product.l(:fr).find(3)
@@ -87,11 +92,11 @@ love.inspect
 Updating
 ````ruby
 product = Product.find(3)
-product.update(name: "the love", languages: {
-	es: {name: "el amor"},
-    pt: {name: "o amor"},
-    fr: {name: "l'amour"}
-})
+product.update(name: "the love", product_languages_attributes: [{
+		{name: "algo", locale: "es"},
+    {name: "alguma cosia", locale: "pt"},
+    {name: "quelque chose", locale: "fr"}
+}])
 #=> #<Product id:3, name: "the love">
 
 product = Product.l(:fr).find(3)
@@ -113,9 +118,7 @@ products = Product.includes(:features).where(id: 1)
 products.first.features.inspect
 #=> <ActiveRecord::Relation [#<Feature id: 1, desc: "Makes people happy">]>
 
-products = Product.l(:es) do |products|
-	products.includes(:features)
-end.where(id: 1)
+products = Product.l(:es).includes.where(id: 1)
 products.first.features.inspect
 #=> <ActiveRecord::Relation [#<Feature id: 1, desc: "Hace a la gente feliz">]>
 ````
@@ -125,15 +128,18 @@ products = Product.includes(:features).where(id: 1)
 products.first.features.inspect
 #=> <ActiveRecord::Relation [#<Feature id: 1, desc: "Makes people happy">]>
 
-products = Product.wl(:es,:pt,:fr) do |products|
-	products.includes(:features)
-end.where(id: 1)
+products = Product.l(:es,:pt,:fr).includes(:features).where(id: 1)
 products.first.features.inspect
 #=> <ActiveRecord::Relation [#<Feature id: 1, desc: "Makes people happy", es_desc: "Hace a la gente feliz", pt_desc: "Faz as pessoas felizes", fr_desc: "Rend les gens heureux">]>
 ````
-#### NOTE:
-If you need to use aggregation functions or grouping stuff, use the raw model without calling the localize method (.l), otherwise a syntax error will be raised from ActiveRecord. We still working on this feature, if you want to help us, feel free to make a pull request :)
+Aggregation and grouping stuff operations work as usual
+````ruby
+Product.count
+# => 3
 
+Product.l(:es,:pt,:fr).count
+# => 3
+````
 ## Installation
 Add this line to your application's Gemfile:
 ```ruby
@@ -150,14 +156,41 @@ Then Install it!
 $ rails g localizable_db:install
 ````
 
-Configure your supported languages
+Configure your supported languages, default language and other the behavior of the gem.
 ````ruby
 # config/initializers/localizable_db_initializer_.rb
-module LocalizableDb
-  module Languages
-    DEFAULT = :en
-    SUPPORTED = [:en, :es] #=> Add your locales to this array.
-  end
+LocalizableDb.config do |config|
+	# REQUIRED
+	
+	config.supported_languages = [:en, :es, :pt, :fr]
+	config.default_language = :en
+
+	# OPTIONAL
+
+	# config.enable_i18n_integration = true
+	# enable_i18n_integration Allow you to use the eager load methods (includes, preload and eager_load)
+	# as in the examples. If you set this option to false then eager load methods will not work and
+	# you will have to call the ::l method to localize the language you want.
+
+	# config.enable_getters = true
+	# enable_getters Allow you to use the getters methods to access the localized attributes.
+
+	# config.attributes_integration = true
+	# attributes_integration overrides the attributes of the model with the localized attributes.
+	# Example:
+	# Imagine you have a Product like this one
+	# #<Product id: 1, name: "love">
+	# with this configuration
+	# Product < ApplicationRecord
+	# 	localize :name
+	# end
+	# When you retrieve the product of name love in spanish from your database, and this option is set to true
+	# it will return
+	# #<Product id: 1, name: "amor">
+	# If this option is set to false, the retrieved object will be
+	# #<Product id: 1, name: "love">
+	# an you will find the "es_name" into the #attributes hash
+
 end
 ````
 

data/lib/generators/localizable_db/templates/initializer.rb

@@ -1,6 +1,7 @@
-module LocalizableDb
-  module Languages
-    DEFAULT = :en
-    SUPPORTED = [:en, :es]
-  end
+LocalizableDb.config do |config|
+  # config.supported_languages = [I18n.default_locale]
+  # config.default_language = I18n.default_locale
+  # config.enable_i18n_integration = true
+  # config.enable_getters = true
+  # config.attributes_integration = true
 end

data/lib/localizable_db/languages.rb

@@ -0,0 +1,19 @@
+module LocalizableDb
+  module Languages
+
+      def config
+        const_set("DEFAULT", LocalizableDb.configuration.default_language.to_sym || I18n.default_locale )
+        const_set(
+        "SUPPORTED",
+          (LocalizableDb.configuration.supported_languages.map do |language|
+            language.to_sym
+          end | [LocalizableDb.configuration.default_language.to_sym].flatten)
+        )
+        const_set(
+          "NOT_DEFAULT",
+          (SUPPORTED - [DEFAULT])
+        )
+      end
+      module_function :config
+  end
+end

data/lib/localizable_db/localizable.rb

@@ -1,231 +1,164 @@
 module LocalizableDb
   module Localizable
     extend ActiveSupport::Concern
-
     included do
 
-      def localize(language = nil)
-        self.class.l(language).find_by_id(self.id)
+      def is_localizable?
+        self.class.is_localizable?
       end
 
-      alias :l :localize
+    end
+
+    module ClassMethods
+
+      attr_accessor :is_localizable
 
-      def with_languages(*languages)
-        self.class.wl(languages).find_by_id(self.id)
+      def is_localizable?
+        self.is_localizable
       end
 
-      alias :wl :with_languages
-
-      def save_languages
-        if !self._locale and self.languages
-          self.languages.each do |language_key, language_values|
-              self.class.table_name = self.class.localized_table_name
-              aux_object = nil
-              aux_object = self.class.find_by(locale: language_key.to_s, localizable_object_id: self.id) if self.id
-              aux_object = self.class.new if !self.id or !aux_object
-              aux_object.locale = language_key.to_s
-              self.class.localized_attributes.each do |attribute|
-                aux_object.send(:"#{attribute}=", language_values[attribute.to_sym])
-              end
-              aux_object.localizable_object_id = self.id
-              not_localized_attributes = (self.attribute_names.map{|x| x.to_sym}-self.class.localized_attributes.map{|x| x.to_sym})
-              not_localized_attributes.each do |attribute|
-                aux_object.class_eval{ attr_accessor :"#{attribute}"}
-              end
-              aux_object._reflections.each do |reflection_key, reflection_value|
-                if reflection_value.class == ActiveRecord::Reflection::BelongsToReflection
-                  not_localized_attributes << reflection_key.to_sym
-                end
-              end
-              if !aux_object.valid?
-                not_localized_attributes.each{|attribute| aux_object.errors.delete(attribute) }
-              end
-              aux_object.save(validate: false) if aux_object.errors.empty?
-              not_localized_attributes.each do |attribute|
-                aux_object.class_eval do
-                  undef :"#{attribute}"
-                  undef :"#{attribute}="
+      def localize(*localizable_attributes)
+        self.is_localizable = true
+        class_eval do
+          default_scope(if: LocalizableDb.configuration.enable_i18n_integration) do
+            localized
+          end
+          mattr_accessor :localized_table_name
+          mattr_accessor :normalized_table_name
+          mattr_accessor :localizable_attributes
+        end
+        self.localized_table_name = "#{self.table_name.singularize}_languages"
+        self.normalized_table_name = self.table_name
+        self.localizable_attributes = localizable_attributes
+        aux_localized_table_name = self.localized_table_name
+        aux_model_name = self.name
+        self.const_set("#{self.name}Language", Class.new(ApplicationRecord) do
+            self.table_name = aux_localized_table_name
+            belongs_to aux_model_name.downcase.to_sym,
+              class_name: aux_model_name,
+              foreign_key: "localizable_object_id",
+              inverse_of: aux_localized_table_name.to_sym
+        end)
+        class_eval do
+          has_many self.localized_table_name.to_sym,
+          class_name: "#{self.name}Language",
+          foreign_key: "localizable_object_id",
+          inverse_of: aux_model_name.downcase.to_sym,
+          dependent: :destroy
+
+          accepts_nested_attributes_for self.localized_table_name.to_sym
+        end
+        if LocalizableDb.configuration.enable_getters
+          self.localizable_attributes.each do |attribute|
+            class_eval %Q{
+              def get_#{attribute}(language = LocalizableDb::Languages::DEFAULT)
+                if language == LocalizableDb::Languages::DEFAULT
+                  self.attributes["#{attribute.to_s}"]
+                else
+                  self.attributes[language.to_s + "_#{attribute.to_s}"]
                 end
               end
-              aux_object.errors.messages.each do |err_key,err_message|
-                self.errors.add("#{language_key}_#{err_key}", err_message)
-              end if aux_object.errors.any?
-              aux_object
+            }
           end
-          self.class.table_name = self.class.name.pluralize.dasherize.downcase
-          raise ActiveRecord::Rollback, "Languages error" if self.errors.any?
         end
-      ensure
-        self.class.table_name = self.class.name.pluralize.dasherize.downcase
-      end
-
-    end
-
-    module ClassMethods
+        class << self
 
-      def localize(*localizable_attributes)
-        localizable_attributes.flatten!
-        singularized_model_name = self.name.downcase.singularize.dasherize
-        class_eval %Q{
-
-          default_scope { localize_eager_load }
-          default_scope { with_languages_eager_load }
-
-          attr_accessor :languages, :_locale, :destroying_languages
-
-          after_save :save_languages
-          before_destroy do
-            if self.class.table_name != self.class.localized_table_name
-              self.destroying_languages = true
-              self.class.table_name = self.class.localized_table_name
-              self.class.where(localizable_object_id: self.id).destroy_all
-              self.class.table_name = self.class.name.pluralize.dasherize
-            end
-            self.class.table_name = self.class.name.pluralize.dasherize.downcase if self.destroying_languages
-            self.destroying_languages = false if self.destroying_languages
-          ensure
-          end
-          after_commit do
-            self.class.table_name = self.class.name.pluralize.dasherize.downcase
+          def get_locale
+            I18n.locale
           end
 
-          after_rollback do
-            self.class.table_name = self.class.name.pluralize.dasherize.downcase
+          def localized(*languages)
+            if(defined? LocalizableDb::Localizable and
+              ((LocalizableDb.configuration.enable_i18n_integration and self.get_locale != LocalizableDb::Languages::DEFAULT) or
+              (languages.any? and (languages-[LocalizableDb::Languages::DEFAULT]).any?)))
+              languages = LocalizableDb::Languages::SUPPORTED if(
+                languages.any? and languages.first == :all)
+              languages = [self.get_locale] if languages.empty? and LocalizableDb.configuration.enable_i18n_integration
+              languages.map!{|language| language.to_sym}
+              if languages.size == 1
+                language = languages.first
+                return one_language(language)
+              else
+               languages = languages.keep_if do |language|
+                 LocalizableDb::Languages::NOT_DEFAULT.include? language
+               end
+                return multiple_languages(languages)
+              end
+            else
+              ActiveRecord::Relation.new(self, self.table_name,self.predicate_builder)
+            end
           end
 
-          def set_languages(languages = {})
-            self.languages = languages
-          end
+          alias_method :l, :localized
 
           private
 
-          def self.localized_table_name
-            "#{singularized_model_name}_languages".freeze
+          def one_language(language)
+            attrs_to_select = single_languege_attrs_to_select_conf(language)
+            from("#{self.localized_table_name}").joins("
+              JOIN (
+                SELECT #{self.table_name}.id, #{attrs_to_select.join(',')}
+                FROM #{self.localized_table_name}, #{self.table_name}
+                WHERE #{self.localized_table_name}.locale = '#{language.to_s}'
+                AND #{self.localized_table_name}.localizable_object_id = #{self.table_name}.id
+              ) AS #{self.table_name}
+              ON #{self.localized_table_name}.locale = '#{language.to_s}'
+              AND #{self.localized_table_name}.localizable_object_id = #{self.table_name}.id
+            ")
           end
 
-          def self.localized_attributes
-            #{localizable_attributes}.map{|a| a.to_s}.freeze
-          end
-
-          def self.get_locale
-            I18n.locale
-          end
-
-        }
-
-        class << self
-
-          def localized(language = nil)
-            if defined? LocalizableDb::Localizable and
-              (self.get_locale != I18n.default_locale or
-              (language and language != I18n.default_locale))
-
-              language = self.get_locale unless language
-              raise "The locale :#{language} is not defined in the initialization file, please check config/initializers/localizable_db.rb to add it." if !LocalizableDb::Languages::SUPPORTED.include? language
-              attrs_to_select = ""
-              self.attribute_names.each do |attribute|
-                attrs_to_select += "#{self.table_name}.#{attribute}"
-                attrs_to_select += ", " if attribute != self.attribute_names.last
-              end
-              self.localized_attributes.each do |a|
-                attrs_to_select += ", " if a == self.localized_attributes.first
-                attrs_to_select += "#{self.localized_table_name}.#{a} as #{a}"
-                attrs_to_select += ", " if a != self.localized_attributes.last
-              end
-              aux_select_values = joins("
-                JOIN  #{self.localized_table_name}
-                ON    locale = '#{language.to_s}'
-                AND   #{self.table_name}.id = #{self.localized_table_name}.localizable_object_id
-              ").select_values.map{|select_value| select_value.to_s }.join(' ')
-              localized_chain = (aux_select_values.scan(/#{self.localized_table_name}/).any? ? true : false)
-              result = joins("
-                JOIN  #{self.localized_table_name}
-                ON    locale = '#{language.to_s}'
-                AND   #{self.table_name}.id = #{self.localized_table_name}.localizable_object_id
-              ").select(attrs_to_select) if !localized_chain
-              result = unscope(:joins, :select).joins("
-                JOIN  #{self.localized_table_name}
-                ON    locale = '#{language.to_s}'
-                AND   #{self.table_name}.id = #{self.localized_table_name}.localizable_object_id
-              ").select(attrs_to_select) if localized_chain
-              if block_given?
-                ActiveRecord::Base._localized_eager_load = true
-                result = yield(result).reload
-                ActiveRecord::Base._localized_eager_load = false
-              end
-              result
-            else
-              return where(id: nil).unscope(where: :id)
+          def multiple_languages(languages)
+            attrs_to_select = (self.attribute_names).map do |attribute|
+              "#{self.table_name}.#{attribute.to_s}"
             end
-          ensure
-            ActiveRecord::Base._localized_eager_load = false
-          end
-
-          def with_languages(*with_languages)
-            with_languages.flatten!
-            with_languages = with_languages - [LocalizableDb::Languages::DEFAULT] if with_languages.any?
-            with_languages = (LocalizableDb::Languages::SUPPORTED - [LocalizableDb::Languages::DEFAULT]) if with_languages.empty?
-            attrs_to_select = "#{self.table_name}.*, "
-            tables_to_select = "#{self.table_name}, "
+            tables_to_select = ""
             conditions_to_select = ""
-            with_languages.each do |language|
-              self.localized_attributes.each do |localized_attribute|
-                attrs_to_select += "#{language.to_s}_#{self.localized_table_name}.#{localized_attribute} as #{language.to_s}_#{localized_attribute}"
-                conditions_to_select += "#{language.to_s}_#{self.localized_table_name}.locale = '#{language.to_s}' AND "
-                conditions_to_select += "#{language.to_s}_#{self.localized_table_name}.localizable_object_id = #{self.table_name}.id "
-                attrs_to_select += ", " if localized_attribute != self.localized_attributes.last
-                conditions_to_select += "AND " if language != with_languages.last or localized_attribute != self.localized_attributes.last
+            languages.each do |language|
+              attrs_to_select = attrs_to_select | self.localizable_attributes.map do |attribute|
+                "#{language.to_s}_#{self.localized_table_name}.#{attribute.to_s} as #{language.to_s}_#{attribute.to_s}"
               end
+              tables_to_select += "," if language != languages.first
               tables_to_select += "#{self.localized_table_name} as #{language.to_s}_#{self.localized_table_name}"
-              attrs_to_select += ", " if language != with_languages.last
-              tables_to_select += ", " if language != with_languages.last
-            end
-            result = unscope(:joins).unscope(:select)
-            .select(attrs_to_select)
-            .from(tables_to_select)
-            .where(conditions_to_select)
-            # result = unscope(:joins).joins("
-            # JOIN  #{self.localized_table_name}
-            # ON    locale IN (#{with_languages.map{|l| '"' + l.to_s + '"' }.join(', ')})
-            # AND   #{self.table_name}.id = #{self.localized_table_name}.localizable_object_id
-            # ").select("products.*, product_languages.*")
-            if block_given?
-              ActiveRecord::Base._with_languages_eager_load = true
-              result = yield(result).reload
-              ActiveRecord::Base._with_languages_eager_load = false
+              conditions_to_select += "#{language.to_s}_#{self.localized_table_name}.locale = '#{language.to_s}'"
+              conditions_to_select += " AND #{language.to_s}_#{self.localized_table_name}.localizable_object_id = #{self.table_name}.id"
+              conditions_to_select += " AND " if language != languages.last
             end
-            result
-          ensure
-            ActiveRecord::Base._with_languages_eager_load = false
+            from("#{tables_to_select}").joins("
+              JOIN (
+                SELECT #{self.table_name}.id, #{attrs_to_select.join(',')}
+                FROM #{self.table_name}, #{tables_to_select}
+                WHERE #{conditions_to_select}
+              ) AS #{self.table_name}
+              ON #{conditions_to_select}
+            ")
           end
 
-          alias_method :l, :localized
-          alias_method :localized, :l
-          alias_method :wl, :with_languages
-          alias_method :with_languages, :wl
-
-          def localize_eager_load(language = nil)
-            if ActiveRecord::Base._localized_eager_load
-              l(language)
-            else
-              ActiveRecord::Relation.new(self, self.table_name,self.predicate_builder)
-            end
-          end
-
-          def with_languages_eager_load(with_languages = [])
-            if ActiveRecord::Base._with_languages_eager_load
-              wl(with_languages)
+          def single_languege_attrs_to_select_conf(language = nil)
+            if LocalizableDb.configuration.attributes_integration
+              attrs_to_select = self.attribute_names - ["id"] - self.localizable_attributes.map do |attribute|
+                attribute.to_s
+              end
+              attrs_to_select = attrs_to_select | self.localizable_attributes.map do |attribute|
+                ["#{self.localized_table_name}.#{attribute.to_s}","#{self.localized_table_name}.#{attribute.to_s} as #{language}_#{attribute}"]
+              end
+              attrs_to_select.flatten!
             else
-              ActiveRecord::Relation.new(self, self.table_name,self.predicate_builder)
+              attrs_to_select = self.attribute_names - ["id"]
+              attrs_to_select = attrs_to_select.map do |attribute|
+                "#{self.table_name}.#{attribute}"
+              end | self.localizable_attributes.map do |attribute|
+                "#{self.localized_table_name}.#{attribute.to_s} as #{language}_#{attribute}"
+              end
             end
+            attrs_to_select
           end
 
         end
-      end
 
+      end
     end
   end
 end
 
+
 ActiveRecord::Base.send(:include, LocalizableDb::Localizable)
-ActiveRecord::Base.class_eval{ mattr_accessor :_localized_eager_load, :_with_languages_eager_load}

data/lib/localizable_db/localizable_config.rb

@@ -0,0 +1,32 @@
+module LocalizableDb
+
+  mattr_accessor :configuration
+
+  def config
+    @@configuration ||= LocalizableConfig.new
+    yield(@@configuration) if block_given?
+    LocalizableDb::Languages.config if block_given?
+    @@configuration
+  end
+
+  module_function :config
+
+  private
+
+  class LocalizableConfig
+
+    attr_accessor :attributes_integration
+    attr_accessor :enable_getters
+    attr_accessor :enable_i18n_integration
+    attr_accessor :supported_languages
+    attr_accessor :default_language
+
+    def initialize()
+      @attributes_integration = true
+      @enable_getters = true
+      @enable_i18n_integration = true
+      @supported_languages = [I18n.default_locale]
+      @default_language = I18n.default_locale
+    end
+  end
+end

data/lib/localizable_db/version.rb

@@ -1,3 +1,3 @@
 module LocalizableDb
-  VERSION = '1.0.9'
+  VERSION = '2.0.0'
 end

data/lib/localizable_db.rb

@@ -1,3 +1,5 @@
+require 'localizable_db/languages'
+require 'localizable_db/localizable_config'
 require 'localizable_db/localizable'
 
 module LocalizableDb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: localizable_db
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 2.0.0
 platform: ruby
 authors:
 - yonga9121
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-13 00:00:00.000000000 Z
+date: 2018-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -62,7 +62,9 @@ files:
 - lib/generators/localizable_db/templates/initializer.rb
 - lib/generators/localizable_db/templates/migration_for.rb
 - lib/localizable_db.rb
+- lib/localizable_db/languages.rb
 - lib/localizable_db/localizable.rb
+- lib/localizable_db/localizable_config.rb
 - lib/localizable_db/version.rb
 - lib/tasks/localizable_db_tasks.rake
 homepage: https://yonga9121.github.io/localizable_db