babylonia 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ec84f550c2f0845d6b9a2b16ede6c04dcd8db75
-  data.tar.gz: e181bce61c3a830c95017a9464577a602a3917e9
+  metadata.gz: 471b84c7ea7c5f3e6a22c69a64b74438b159480c
+  data.tar.gz: 3895c1969ff6a922574c66123a819211e849f60f
 SHA512:
-  metadata.gz: bf514ab66051cf4c21a6068df9c2dba0bd6eeb41acddf838a32f03d4aae9a3ed6df0e990d05efab0560ecc09abe74a6f7c62006958edd3c458d9d8e011ea3346
-  data.tar.gz: cdb741ec672ca3f50c4072193c1d392ff9240a5a8fda1e9d44ced1001dbbd84b1c383cd518a0eaf438081ab23c32801363ef5a2cde7623efadd889bfbbf6e996
+  metadata.gz: 960ef518e49a6a76ab9fd5ac1a1016123b9b3a10cba86c2fb646f7ad2cdd03d52b55cdd1ad474c5b36c2188efeead630c238bf21ca42135cd1bc73538c9f8090
+  data.tar.gz: 1a0d5661cc64f338b0d83fac5bf1d8f370e4c33a526c65c749cd5a59f64262d3e168626aea25af7c7c13d98c3f609c921ab473acba4168553d9eb3722ae9925f

data/README.rdoc

@@ -66,6 +66,20 @@ Let's once assume a pretty basic class. Extend it with the Babylonian Class meth
                               fallback: false #=> will not fallback to default locale if no translation for locale is present
                               placeholder: "<span class='translation missing'>Translation missing in Transsylvania</span>" a placeholder if no translation is present
   end
+
+== Neat Helpers
+Got to have helpers to build that tower with: These come with every babylonian tower built:
+  t = Transsylvania.new
+  t.locale #=> returns the current locale
+  t.locales #=> returns every locale present in each(!) translated field
+  t.has_locale?(locale) #=> returns true if all(!) fields are translated in that locale
+  t.available_locales #=> returns the locales available for translation, but not necessarily present in each translated field
+  t.has_available_locale? #=> returns true if a locale is available for translation
+  t.default_locale #=> returns the current default locale
+  t.locale_fallback? #=> returns true if the translations will fall back to the default locale
+  t.missing_translation_placeholder(field) #=> Returns a placeholder for missing translation for field, if defined
+  t.localized?(attribute) #=> returns if attribute is localized
+  
 == Contributing to babylonia
 
 Please note that only open source APIs can be accepted as contributions to this gem. Private / Premium APIs have to be written as your own extension and will not be added to the gem code.

data/lib/babylonia/class_methods.rb

@@ -11,50 +11,34 @@ module Babylonia
   # Class methods to extend a class with in order to make it able to handle translatable attributes
   #
   module ClassMethods
-    
-    private
-
-    def add_to_handled_babylonian_fields data
-      instance_variable_set(:@handled_babylonian_fields, (instance_variable_get(:@handled_babylonian_fields) || []) + data.map(&:to_sym))
-    end
-  
-    public
-    # Store all handled fields in a class instance variable
-    #
-    def handled_babylonian_fields
-      instance_variable_get(:@handled_babylonian_fields) || instance_variable_set(:@handled_babylonian_fields, [])
-    end
     # Main class method ob Babylonia. Use to make attributes translatable
     # @param [Symbol] fields the attributes to translate
     # @param [Hash] options The options for translation
-    # @option [Symbol, Proc, String] locale The current locale - can be either a symbol that will be sent to the instance, a locale symbol that is included in available_locales or a proc that will get called with the instance and the attribute name. Defaults to I18n.locale at the time of use
-    # @option [Symbol, Proc, String] default_locale The fallback / default locale - can be either a symbol that will be sent to the instance, a locale symbol that is included in available_locales, a proc that will get called with the instance and the attribute name
-    # @option [Symbol, Proc, Array] available_locales The available locales - can be either a symbol that will be sent to the instance, a proc that will get called with the instance and the attribute name, or an Array of symbols of available locales. Defaults to I18n.available_locales at the time of use.
+    # @option [Symbol, Proc, String] locale The current locale - can be either a symbol that will be sent to the instance, a locale symbol that is included in available_locales or a proc that will get called with the instance. Defaults to I18n.locale at the time of use
+    # @option [Symbol, Proc, String] default_locale The fallback / default locale - can be either a symbol that will be sent to the instance, a locale symbol that is included in available_locales, a proc that will get called with the instance
+    # @option [Symbol, Proc, Array] available_locales The available locales - can be either a symbol that will be sent to the instance, a proc that will get called with the instance, or an Array of symbols of available locales. Defaults to I18n.available_locales at the time of use.
     # @option [Boolean] fallback Wheter to fallback to the default locale or not
     # @option [String] placeholder The placeholder to use for missing translations
     #
     def build_babylonian_tower_on(*fields)
-      babylonian_options = fields.last.is_a?(Hash) ? fields.pop : {}
-      add_to_handled_babylonian_fields fields
-      babylonian_options[:locale]          ||= lambda { |r, f| I18n.locale }
-      babylonian_options[:default_locale]  ||= lambda { |r, f| I18n.default_locale }
-      babylonian_options[:available_locales] ||= lambda { |r, f| I18n.available_locales }
-      babylonian_options[:fallback]        = true if babylonian_options[:fallback].nil?
+      options                     = fields.last.is_a?(Hash) ? fields.pop : {}
+      options[:locale]            ||= lambda { |r| I18n.locale }
+      options[:default_locale]    ||= lambda { |r| I18n.default_locale }
+      options[:available_locales] ||= lambda { |r| I18n.available_locales }
+      options[:fallback]          = true if options[:fallback].nil?
       
       fields.each do |field|
-        instance_variable_set(:"@babylonian_options_for_#{field}", babylonian_options)
-        
         # Alias method chain the field to a translated value
         # @param [Symbol] locale Pass a locale to get the field translation in this specific locale
         # @return [String, NilClass] Either the string with the translation, the fallback, the placeholder or nil
         # @example Call a field in italian
         #   your_instance.field(:it) #=> "Translation" 
         #
-        define_method :"#{field}_translated" do |locale=nil|
+        define_method :"#{field}_translated" do |l=nil|
           field_hash    = send(:"#{field}_hash")
-          translation   = field_hash[locale || evaluate_babylonian_option!(:locale, field)]
-          translation   = field_hash[evaluate_babylonian_option!(:default_locale, field)] if (translation.nil? or translation.empty?) and evaluate_babylonian_option!(:fallback, field)
-          (translation.nil? or translation.empty?) ? evaluate_babylonian_option!(:placeholder, field) : translation
+          translation   = field_hash[l || locale]
+          translation   = field_hash[default_locale] if translation.nil? or translation.empty? and locale_fallback?
+          (translation.nil? or translation.empty?) ? missing_translation_placeholder(field) : translation
         end
         alias_method :"#{field}_raw", field
         alias_method field, :"#{field}_translated"
@@ -67,31 +51,6 @@ module Babylonia
           field_content.is_a?(String) ? YAML.load(field_content) : {}
         end
         
-        # Return all the languages stored
-        # @return [Array] An array containing all languages stored in the field
-        #
-        define_method :"#{field}_languages" do
-          send(:"#{field}_hash").keys
-        end
-        
-        define_method :has_translated_attribute? do |attr|
-          self.class.handled_babylonian_fields.include?(attr.to_sym)
-        end
-        
-        # Return if a translation in the language is stored for the field
-        # @return [Boolean] True if a translation is stored
-        #
-        define_method :"#{field}_has_locale?" do |locale|
-          send(:"#{field}_languages").include?(locale.to_sym)
-        end
-        
-        # Return if a locale is theoretically available for the field
-        # @return [Boolean] True if the language is available
-        #
-        define_method :"#{field}_has_available_locale?" do |locale|
-          evaluate_babylonian_option!(:available_locales, field).include?(locale.to_sym)
-        end
-        
         # Set the field to a value. This either takes a string or a hash
         # If given a String, the current locale is set to this value
         # If given a Hash, the hash is merged into the current translation hash, and empty values are purged
@@ -105,34 +64,100 @@ module Babylonia
           current_hash = send(:"#{field}_hash")
           
           if data.is_a?(String)
-            current_hash.merge! evaluate_babylonian_option!(:locale, field) => data
+            current_hash.merge! locale => data
           elsif data.is_a?(Hash)
-            data.delete_if{|k,v| !send(:"#{field}_has_available_locale?", k) }
+            data.delete_if{|k,v| !has_available_locale?(k) }
             current_hash.merge! data
           end
           
-          send(:"#{field}_raw=", YAML.dump(current_hash.delete_if{|k,v| v.nil? || v.empty? }))
+          send(:"#{field}_raw=", YAML.dump(current_hash.delete_if{|k,v| v.nil? or v.empty? }))
         end
         alias_method :"#{field}_raw=", :"#{field}="
         alias_method :"#{field}=", :"#{field}_translated="
       end
       
+      # Return the currently active locale for the object
+      # @return [Symbol] The currently active locale
+      #
+      define_method :locale do
+        evaluate_localization_option!(:locale)
+      end
+      
+      # Return the default locale for the object
+      # @return [Symbol] The currently active locale
+      #
+      define_method :default_locale do
+        evaluate_localization_option!(:default_locale)
+      end
+      
+      # Return if the object falls back on translations
+      # @return [Boolean] if the translations fall back to the default locale
+      #
+      define_method :locale_fallback? do
+        evaluate_localization_option!(:fallback)
+      end
+      
+      # Return the missing translation placeholder
+      # @return [String] The missing translation placeholder
+      #
+      define_method :missing_translation_placeholder do |field|
+        evaluate_localization_option!(:placeholder, field)
+      end
+      
+      # Return languages stored in all translated fields
+      # @return [Array] An array containing all languages stored
+      #
+      define_method :locales do
+        first_field_locales = send(:"#{fields.first}_hash").keys
+        fields.inject(first_field_locales){|o, f| o & send(:"#{f}_hash").keys }
+      end
+      
+      # Return if a translation in the language is stored in all translated fields
+      # @return [Boolean] True if a translation is stored
+      #
+      define_method :has_locale? do |locale|
+        locales.include?(locale.to_sym)
+      end
+      
+      # Return all the available locales
+      # @return [Array] An array of symbols of all available locales
+      # 
+      define_method :available_locales do
+        evaluate_localization_option!(:available_locales)
+      end
+      
+      # Return if a locale is theoretically available in all translated fields
+      # @return [Boolean] True if the language is available
+      #
+      define_method :has_available_locale? do |locale|
+        available_locales.include?(locale.to_sym)
+      end
+      
+      # Return if an attribute is localized
+      # @return [Boolean] True if the attribute is localized
+      # 
+      define_method :localized? do |attr|
+        fields.include?(attr.to_sym)
+      end
+      
       # Define method missing to be able to access a language directly
       define_method :method_missing do |meth, *args, &block|
-        if (m = meth.to_s.match(/\A([^_]+)_(\w+)(=)?\z/).to_a[1..3]) && has_translated_attribute?(m[0]) && send(:"#{m[0]}_has_available_locale?", m[1])
+        if (m = meth.to_s.match(/\A([^_]+)_(\w+)(=)?\z/).to_a[1..3]) && localized?(m[0]) && has_available_locale?(m[1])
           send(m[0] + m[2].to_s, m[2] ? {m[1].to_sym => args.first} : m[1].to_sym)
         else
           super(meth, *args, &block)
         end
       end
       
-      define_method :evaluate_babylonian_option! do |option, field, recursion=false|
-        options = self.class.instance_variable_get :"@babylonian_options_for_#{field}"
-
+      # Evaluate a localization option
+      #
+      define_method :evaluate_localization_option! do |option, field=nil, recursion=false|
         o = options[option]
-        if o.is_a?(Proc)
+        if o.is_a?(Proc) && field
           o.call self, field
-        elsif o.is_a?(Symbol) && (recursion || !evaluate_babylonian_option!(:available_locales, field, true).include?(o))
+        elsif o.is_a?(Proc)
+          o.call self
+        elsif o.is_a?(Symbol) && (recursion || !evaluate_localization_option!(:available_locales, nil, true).include?(o))
           send o
         else
           o

data/lib/babylonia/version.rb

@@ -1,5 +1,5 @@
 module Babylonia
   # The current gem version
   #
-  VERSION = '0.0.3'
+  VERSION = '0.1.0'
 end

data/spec/babylonia/class_methods_spec.rb

@@ -1,27 +1,16 @@
 require 'spec_helper'
 
-describe Babylonia::ClassMethods do
-  
-  class BabylonianFields
-    extend Babylonia::ClassMethods
+describe Babylonia::ClassMethods do  
+  context "without options" do
+    subject { BabylonianFields.new }
+    class BabylonianFields
+      extend Babylonia::ClassMethods
     
-    attr_accessor :marshes, :grasslands, :desert, :sky
+      attr_accessor :marshes, :sky
     
-    build_babylonian_tower_on :marshes
-    build_babylonian_tower_on :grasslands, available_locales: [:pi, :de, :en, :it], locale: :architects_tongue, default_locale: lambda {|r, f| r.builders_tongue || :en }
-    build_babylonian_tower_on :desert, :sky, fallback: false, placeholder: lambda {|r, field| "<span class='missing translation'>Translation missing for " + field.to_s + "</span>"}
-  
-    def architects_tongue
-      :pi
+      build_babylonian_tower_on :marshes, :sky
     end
     
-    def builders_tongue
-      nil
-    end
-  end
-  
-  context "without options" do
-    subject { BabylonianFields.new }
     before(:each) do
       I18n.stub locale: :en, default_locale: :de, available_locales: [:de, :en, :it]
     end
@@ -116,7 +105,7 @@ describe Babylonia::ClassMethods do
         end
       end
     end
-    describe "marshes=" do
+    describe "#marshes=" do
       context "with no existing data" do
         context "with a string" do
           it "should set the current locales data" do
@@ -157,7 +146,7 @@ describe Babylonia::ClassMethods do
         end
       end
     end
-    describe "marshes_hash" do
+    describe "#marshes_hash" do
       before(:each) do
         subject.marshes_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
       end
@@ -165,26 +154,109 @@ describe Babylonia::ClassMethods do
         subject.marshes_hash.should == {it: 'SOME ITALIAN', en: 'SOME ENGLISH', de: 'SOME DEUTSCH'}
       end
     end
-    describe "marshes_languages" do
+    describe "#locales" do
       before(:each) do
         subject.marshes_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
+        subject.sky_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
       end
       it "should return the translated languages of the field" do
-        subject.marshes_languages.sort.should == [:de, :en, :it]
+        subject.locales.sort.should == [:de, :en, :it]
+      end
+    end
+    describe "#has_locale?" do
+      before(:each) do
+        subject.marshes_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
+        subject.sky_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
+      end
+      context "with the locale present in the translation hashes" do
+        it "should return true" do
+          subject.should be_has_locale(:it)
+        end
+      end
+      context "with the locale not present in the translation hashes" do
+        it "should return true" do
+          subject.should_not be_has_locale(:pi)
+        end
+      end
+    end
+    describe "#available_locales" do
+      before(:each) do
+        I18n.stub available_locales: [:de, :en]
+      end
+      it "should return available locales" do
+        subject.available_locales.sort.should == [:de, :en]
+      end
+    end
+    describe "#has_available_locale" do
+      before(:each) do
+        I18n.stub available_locales: [:de, :en]
+      end
+      context "with an available locale" do
+        it "should return true" do
+          subject.should be_has_available_locale(:de)
+        end
+      end
+      context "with an available locale" do
+        it "should return true" do
+          subject.should_not be_has_available_locale(:it)
+        end
+      end
+    end
+    describe "#localized?" do
+      context "with a localized attribute" do
+        it "should return true" do
+          subject.should be_localized(:sky)
+        end
+      end
+      context "with a unlocalized attribute" do
+        it "should return true" do
+          subject.should_not be_localized(:desert)
+        end
+      end
+    end
+    describe "#missing_translation_placeholder" do
+      it "should return nil" do
+        subject.missing_translation_placeholder('FIELD').should be_nil
+      end
+    end
+    describe "#locale_fallback?" do
+      it "should return false" do
+        subject.should be_locale_fallback
       end
     end
   end
   
-  context "with options" do
-    subject { BabylonianFields.new }
+  context "with options opposite the defaults" do
+    class BabylonianFieldsWithOptions
+      extend Babylonia::ClassMethods
+    
+      attr_accessor :grasslands, :desert
+    
+      build_babylonian_tower_on :grasslands, :desert,
+                                available_locales: [:pi, :de, :en, :it],
+                                locale: :architects_tongue,
+                                default_locale: lambda {|r| r.builders_tongue || :en },
+                                fallback: false,
+                                placeholder: lambda {|r, field| "<span class='missing translation'>Translation missing for " + field.to_s + "</span>"}
+  
+      def architects_tongue
+        :pi
+      end
+    
+      def builders_tongue
+        nil
+      end
+    end
+    
+    subject { BabylonianFieldsWithOptions.new }
     before(:each) do
       I18n.stub locale: :en, default_locale: :de
     end
     
     describe "#grasslands" do
       context "with no data" do
-        it "should return nil" do
-          subject.grasslands.should be_nil
+        it "should return the placeholder" do
+          subject.grasslands.should == "<span class='missing translation'>Translation missing for grasslands</span>"
         end
       end
       context "with some raw data" do
@@ -204,12 +276,12 @@ describe Babylonia::ClassMethods do
         before(:each) do
           subject.stub grasslands_raw: "---\n:en: FALLBACK"
         end
-        it "should return the fallback data" do
-          subject.grasslands.should == "FALLBACK"
+        it "should not return the fallback data" do
+          subject.grasslands.should == "<span class='missing translation'>Translation missing for grasslands</span>"
         end
         context "with a locale argument" do
-          it "should return the fallback" do
-            subject.grasslands(:pi).should == 'FALLBACK'
+          it "should return the not return the fallback" do
+            subject.grasslands(:pi).should == "<span class='missing translation'>Translation missing for grasslands</span>"
           end
         end
       end
@@ -218,11 +290,11 @@ describe Babylonia::ClassMethods do
           subject.stub grasslands_raw: "---\n:it: NO_FALLBACK"
         end
         it "should return the fallback data" do
-          subject.grasslands.should be_nil
+          subject.grasslands.should == "<span class='missing translation'>Translation missing for grasslands</span>"
         end
         context "with a locale argument" do
           it "should return the fallback" do
-            subject.grasslands(:en).should be_nil
+            subject.grasslands(:en).should == "<span class='missing translation'>Translation missing for grasslands</span>"
           end
         end
       end
@@ -283,31 +355,93 @@ describe Babylonia::ClassMethods do
           context "with a string" do
             it "should be deleted" do
               subject.grasslands = ''
-              subject.grasslands.should be_nil
+              subject.grasslands.should == "<span class='missing translation'>Translation missing for grasslands</span>"
             end
           end
           context "with nil" do
             it "should be deleted" do
               subject.grasslands = nil
-              subject.grasslands.should be_nil
+              subject.grasslands.should == "<span class='missing translation'>Translation missing for grasslands</span>"
             end 
           end
           context "with a hash containing an empty string" do
             it "should be deleted" do
               subject.grasslands = {it: ''}
-              subject.grasslands(:it).should be_nil
+              subject.grasslands(:it).should == "<span class='missing translation'>Translation missing for grasslands</span>"
             end 
           end
           context "with a hash containing nil" do
             it "should be deleted" do
               subject.grasslands = {it: nil}
-              subject.grasslands(:it).should be_nil
+              subject.grasslands(:it).should == "<span class='missing translation'>Translation missing for grasslands</span>"
             end 
           end
         end
       end
     end
+    describe "#locales" do
+      before(:each) do
+        subject.grasslands_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
+        subject.desert_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
+      end
+      it "should return the translated languages of the field" do
+        subject.locales.sort.should == [:de, :en, :it]
+      end
+    end
+    describe "#has_locale?" do
+      before(:each) do
+        subject.grasslands_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
+        subject.desert_raw = "---\n:it: SOME ITALIAN\n:en: SOME ENGLISH\n:de: SOME DEUTSCH\n"
+      end
+      context "with the locale present in the translation hashes" do
+        it "should return true" do
+          subject.should be_has_locale(:it)
+        end
+      end
+      context "with the locale not present in the translation hashes" do
+        it "should return true" do
+          subject.should_not be_has_locale(:pi)
+        end
+      end
+    end
+    describe "#available_locales" do
+      it "should return available locales" do
+        subject.available_locales.sort.should == [:de, :en, :it, :pi]
+      end
+    end
+    describe "#has_available_locale" do
+      context "with an available locale" do
+        it "should return true" do
+          subject.should be_has_available_locale(:pi)
+        end
+      end
+      context "with an available locale" do
+        it "should return true" do
+          subject.should_not be_has_available_locale(:gb)
+        end
+      end
+    end
+    describe "#localized?" do
+      context "with a localized attribute" do
+        it "should return true" do
+          subject.should be_localized(:grasslands)
+        end
+      end
+      context "with a unlocalized attribute" do
+        it "should return true" do
+          subject.should_not be_localized(:fields)
+        end
+      end
+    end
+    describe "#missing_translation_placeholder" do
+      it "should return the defined placeholder for the field" do
+        subject.missing_translation_placeholder('FIELD').should == "<span class='missing translation'>Translation missing for FIELD</span>"
+      end
+    end
+    describe "#locale_fallback?" do
+      it "should return false" do
+        subject.should_not be_locale_fallback
+      end
+    end
   end
-  
-  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: babylonia
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Beat Richartz