voltron-translate 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 496b01a5fc6aef8382150266d811b2b0feddbd4e
-  data.tar.gz: 6db2b1e2291a17e376c74cee8744a674632c17d7
+  metadata.gz: 979979611ec2a7d4eac3353ae47a0caa509bbef5
+  data.tar.gz: 65497650f47fa5723f1725b7562ff38e99e13db2
 SHA512:
-  metadata.gz: eef4569dd7db4562ceed56dce7154fe081708b4f975b0b5b600a973bf68b30caf347cd8799a8a1253b87c22542ed69668da41e1501027ed9c04200b52313bd99
-  data.tar.gz: e27b55db4f9163ec69576d22a89845dff355f01a52d55dffa16705311cb5ed41d296924b8e878f7984cb8310e64901aedfd291d3542d769b25b187eec08130f4
+  metadata.gz: 18db3717e361b952ada8f4a11fa03b9fb54432810e9adb613959c50028b69e802a1dd57b7eabee78b1125fdc3edce2dfc335a4f079906e9ac31efa1d547f9652
+  data.tar.gz: 46759ab9a35119a2957b965d38984711d15f233d9fa37181bcf7532f750132a7fd1696df2ee12ae579d2a1d4cec7031f520c2ca23d66b644ce7de001451b6375

data/.travis.yml

@@ -3,4 +3,6 @@ language: ruby
 rvm:
   - 2.2.3
   - 2.3.1
+  - 2.3.3
+  - 2.4.1
 before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -3,3 +3,7 @@ source 'http://gem.minow.io'
 
 # Specify your gem's dependencies in voltron-translate.gemspec
 gemspec
+
+group :test do
+  gem 'coveralls', require: false
+end

data/README.md

@@ -1,36 +1,42 @@
+[![Coverage Status](https://coveralls.io/repos/github/ehainer/voltron-translate/badge.svg?branch=master)](https://coveralls.io/github/ehainer/voltron-translate?branch=master)
 [![Build Status](https://travis-ci.org/ehainer/voltron-translate.svg?branch=master)](https://travis-ci.org/ehainer/voltron-translate)
+[![License: GPL v3](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](http://www.gnu.org/licenses/gpl-3.0)
 
 # Voltron::Translate
 
-Voltron Translate is a different, in my mind more logical way of dealing with internationalization in rails, largely inspired by the Magento framework's __() method.
+Voltron Translate is a different, in my mind more logical way of dealing with internationalization in rails, largely inspired by the Magento framework's `__()` helper method.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'voltron-translate'
+gem 'voltron-translate', '~> 0.2.1'
 ```
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
     $ gem install voltron-translate
 
-Then run the following to create the voltron.rb initializer (if not exists already) and add the translate config:
+Then run the following to create the voltron.rb initializer (if not exists already), add the translate config, and generate the database migration:
 
     $ rails g voltron:translate:install
 
+Then run the migrations to add the table to support backend translations:
+
+    $ bundle exec rake db:migrate
+
 ## Usage
 
 ### The Double Underscore Method
 
 Voltron Translate extends ActiveRecord::Base, ActionController::Base, ActionMailer::Base, and ActionView::Base with a __ (double underscore) method that makes internationalization and/or translating static phrases easier.
 
-Once installed, from any class that extends from any of the three rails classes you can use the double underscore method to allow for real time text translation. For example:
+Once installed, from any class that extends from any of the four rails classes listed you can use the double underscore method to allow for text translation. For example:
 
 ```ruby
 @user = User.new(user_params)
@@ -117,10 +123,12 @@ class Company < ActiveRecord::Base
 end
 ```
 
-Options to the `translates` method are optional, and, if any/all or omitted, the defaults are as follows:
+Options to the `translates` method are optional, details of which are:
 
-locales -> Defaults to Voltron.config.translates.locales, which itself defaults to Rails.application.config.i18n.available_locales
-default -> nil, will just return the value of the original attribute, i.e. - "name" or "greeting"
+| Option  | Default                                                                                                                       | Comment                                                                                                                                                                                                                                                                            |
+|---------|-------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| locales | `Voltron.config.translates.locales`, whose default is actually the value of `Rails.application.config.i18n.available_locales` | Should be an array of locale names, as strings or symbols. Each locale defined will extend the original attribute to make locale specific methods. i.e. - Locales `[:en, :es]` on attribute `name` would generate methods for `name_en`, `name_es`, `name_en=`, `name_es=`, etc... |
+| default | nil                                                                                                                           | Should be a string or symbol of the default locale you'd like to use. This default overrides the value of `I18n.locale`, so should really only be used if the attribute in question needs to default to a different language.                                                      |
 
 The `translates` method adds locale specific version of the attribute(s) to the model with the following methods:
 
@@ -193,11 +201,11 @@ Should go without saying, but to set the translation text on the frontend, you'd
 
 Add the appropriate attributes to your strong params, so on, so on...
 
-## Things to Note
+## Note
 
-Setting `Voltron.config.translate.enabled` to `false` will never break any __() call, it simply causes it to ignore the locale argument (if specified) and return the interpolated string using the latter arguments (again, if any)
+Setting `Voltron.config.translate.enabled` to `false` will never break any `__()` call, it simply causes it to ignore the locale argument (if specified) and return the interpolated string using the latter arguments (again, if any)
 
-Disabling translations simply disables any IO related actions that would occur normally, like building or looking up translations when __() methods are called.
+Disabling translations simply disables any IO related actions that would occur normally, like building or looking up translations when `__()` methods are called.
 
 It also disables the locale specific text translation on any method call that was targeted with `translates`, meaning `@company.name(:es)` would be the equivalent of calling `@company.name`. Note that `@company.name_es` would still work as it normally would.
 
@@ -211,5 +219,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/ehaine
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
+The gem is available as open source under the terms of the [GNU General Public License](https://www.gnu.org/licenses/gpl-3.0.en.html).

data/lib/voltron/translatable.rb

@@ -7,60 +7,62 @@ module Voltron
       options = (attributes.extract_options!).with_indifferent_access
       locales = Array.wrap(options[:locales] || Voltron.config.translate.locales).map(&:to_s).map(&:underscore)
 
-      attributes.each do |attribute|
+      attributes.each do |attrib|
 
-        column = self.columns_hash[attribute.to_s]
+        column = self.columns_hash[attrib.to_s]
 
-        raise ::ActiveRecord::UnknownAttributeError.new(self.new, attribute) if column.nil?
+        raise ::ActiveRecord::UnknownAttributeError.new(self.new, attrib) if column.nil?
 
-        raise ::Voltron::Translate::InvalidColumnTypeError.new("Invalid type '#{column.type}' for attribute: #{attribute}. Translations only work on string and text attribute types.") unless [:string, :text].include?(column.type)
+        raise ::Voltron::Translate::InvalidColumnTypeError.new("Invalid type '#{column.type}' for attribute: #{attrib}. Translations only work on string and text attribute types.") unless [:string, :text].include?(column.type)
 
         # Override the attribute with a method that accepts a specific locale as an argument
         # If specified, will attempt to fetch that locale's translation, otherwise the default
         # locale specified for the attribute, and ultimately the current locale translation
         # If still nil, returns the value from super
-        define_method :"#{attribute}" do |locale=nil|
+        define_method :"#{attrib}" do |locale=nil|
           # +action_view/helpers/targs+ exist when this method is called from within
           # ActionView::Helpers. In other words, form helper tags. In that
           # case we want the actual value of the attribute, not whatever the locale is
           return super() if caller.any? { |l| /action_view\/helpers\/tags/.match(l) } || !Voltron.config.translate.enabled?
-          try(:"#{attribute}_#{locale.to_s.underscore}") || try(:"#{attribute}_#{options[:default].to_s.underscore}") || try(:"#{attribute}_#{I18n.locale.to_s.underscore}") || super()
+          try(:"#{attrib}_#{locale.to_s.underscore}") || try(:"#{attrib}_#{options[:default].to_s.underscore}") || try(:"#{attrib}_#{I18n.locale.to_s.underscore}") || super()
         end
 
         locales.each do |locale|
 
+          attribute :"#{attrib}_#{locale}"
+
           # Define setter, i.e. - +attribute_es=+
-          define_method :"#{attribute}_#{locale}=" do |val|
-            attribute_will_change! "#{attribute}_#{locale}"
-            instance_variable_set("@#{attribute}_#{locale}", val)
+          define_method :"#{attrib}_#{locale}=" do |val|
+            attribute_will_change! "#{attrib}_#{locale}"
+            instance_variable_set("@#{attrib}_#{locale}", val)
           end
 
           # Define getter, i.e - +attribute_es+
           # If nil, calling this method will attempt to fetch the value
           # We do this to avoid preloading the translations association records
-          define_method :"#{attribute}_#{locale}" do
-            if instance_variable_get("@#{attribute}_#{locale}").nil?
-              instance_variable_set("@#{attribute}_#{locale}", send(:"#{attribute}_#{locale}_was"))
+          define_method :"#{attrib}_#{locale}" do
+            if instance_variable_get("@#{attrib}_#{locale}").nil?
+              instance_variable_set("@#{attrib}_#{locale}", send(:"#{attrib}_#{locale}_was"))
             end
-            instance_variable_get("@#{attribute}_#{locale}")
+            instance_variable_get("@#{attrib}_#{locale}")
           end
 
           # Define the changed? method, i.e. - +attribute_es_changed?+
-          define_method :"#{attribute}_#{locale}_changed?" do
-            changed.include?("#{attribute}_#{locale}")
+          define_method :"#{attrib}_#{locale}_changed?" do
+            changed.include?("#{attrib}_#{locale}")
           end
 
           # Define the was method, i.e. - +attribute_es_was+
-          define_method :"#{attribute}_#{locale}_was" do
-            translations.find_by(attribute_name: attribute, locale: locale).try(:translation)
+          define_method :"#{attrib}_#{locale}_was" do
+            translations.find_by(attribute_name: attrib, locale: locale).try(:translation)
           end
 
-          define_method :"#{attribute}_#{locale}_will_change!" do
-            attribute_will_change! "#{attribute}_#{locale}"
+          define_method :"#{attrib}_#{locale}_will_change!" do
+            attribute_will_change! "#{attrib}_#{locale}"
           end
 
-          define_method :"#{attribute}_#{locale}?" do
-            instance_variable_get("@#{attribute}_#{locale}").present?
+          define_method :"#{attrib}_#{locale}?" do
+            instance_variable_get("@#{attrib}_#{locale}").present?
           end
 
         end

data/lib/voltron/translate/version.rb

@@ -1,5 +1,5 @@
 module Voltron
   module Translate
-    VERSION = '0.2.0'.freeze
+    VERSION = '0.2.1'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: voltron-translate
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Eric Hainer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-17 00:00:00.000000000 Z
+date: 2017-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -210,7 +210,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Implements double underscore method for translating and interpolating phrases