lolita-translation 0.3.3 → 0.5.0

data/.gitignore

@@ -0,0 +1,25 @@
+Gemfile.lock
+spec/database.log
+# rcov generated
+coverage
+coverage.data
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+.rvmrc
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+
+*.swp
+tmp
+
+spec/test_app/log/*.log
+spec/test_app/db/*.db

data/Gemfile

@@ -1,19 +1,3 @@
-source "http://rubygems.org"
+source :rubygems
+gemspec
 
-gem "lolita", ">=3.2.0.rc.3"
-group :development do
-  gem "shoulda", ">= 0"
-  gem "bundler", "~> 1.0.0"
-  gem "jeweler", "~> 1.5.2"
-  gem "rcov", ">= 0"
-end
-
-group :test do
-  gem "rails", "~>3.1.0"
-  gem "rspec","~>2.6.0"
-  gem "rspec-rails", "~>2.6.0"
-  gem "webmock", "~> 1.7.6"
-  gem "sqlite3"
-  gem "ffaker"
-  gem 'ruby-debug19', :require => 'ruby-debug'
-end

data/README.md

@@ -3,13 +3,12 @@
 
 ### Install
 
-    gem "lolita"
     gem "lolita-translation"
 
 ### Usage
     
 1. Add `include Lolita::Translation` in your model.
-2. Call `translations :title, :body` in your model and pass column names to translate.
+2. Call `translate :title, :body` in your model and pass column names to translate.
 3. Add `Article.sync_translation_table!` to your `db/seeds.rb` and run it.
 
 #### What it does?

data/Rakefile

@@ -1,53 +1,5 @@
 require 'rubygems'
 require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
 
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "lolita-translation"
-  gem.homepage = "http://github.com/ithouse/lolita-translations"
-  gem.license = "MIT"
-  gem.summary = %Q{Lolita models translation plugin}
-  gem.description = %Q{Translates models in Lolita}
-  gem.email = "support@ithouse.lv"
-  gem.authors = ["ITHouse", "Gatis Tomsons", "Arturs Meisters"]
-  # Include your dependencies below. Runtime dependencies are required when using your gem,
-  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
-  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
-  #  gem.add_development_dependency 'rspec', '> 1.2.3'
-end
-Jeweler::RubygemsDotOrgTasks.new
+Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'spec'
-  test.pattern = 'spec/**/*_spec.rb'
-  test.verbose = true
-end
-
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |test|
-  test.libs << 'spec'
-  test.pattern = 'spec/**/*_spec.rb'
-  test.verbose = true
-end
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "lolita-translation #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/app/assets/javascripts/lolita/translation/application.js

@@ -2,9 +2,10 @@ $(function(){
   $(".tab-language-switch li").live("click",function(){
     $(".tab-language-switch li").removeClass("active")
     $(this).addClass("active");
-    var locale = $(this).attr("data-locale")
-    var tab_name = $(this).attr("data-tab")
+    var locale = $(this).data("locale")
+    var tab_name = $(this).data("tab")
     $(".tab-content .language-wrap").hide(0)
-    $("#"+locale+"_attributes_for_"+tab_name).show(0)
+    $("#"+locale+"_for_"+tab_name).show(0)
+    resize_all_tinymce_editors()
   })
 })

data/app/assets/stylesheets/lolita/translation/application.css

@@ -3,7 +3,7 @@
   overflow: hidden;
   list-style: none;
   margin-right: 25px;
-  top: 28px;
+  margin-top: -10px;
 	position: relative;
 }
 .tab-language-switch li{
@@ -17,3 +17,9 @@
   font-weight: bold;
   cursor:default;
 }
+.language-wrap{
+  display:none;
+}
+.language-wrap.active{
+  display:block;
+}

data/app/views/components/lolita/translation/_assets.html.haml

@@ -0,0 +1,4 @@
+- content_for :script do 
+  = javascript_include_tag 'lolita/translation/application.js'
+- content_for :style do 
+  = stylesheet_link_tag 'lolita/translation/application.css', :media => 'screen, projection'

data/app/views/components/lolita/translation/_language_wrap.html.haml

@@ -0,0 +1,2 @@
+.language-wrap{ :id => "#{translation_locale}_for_#{tab.name}", :class => active && "active"}
+  = content

data/app/views/components/lolita/translation/_switch.html.haml

@@ -0,0 +1,4 @@
+%ul{:class => "tab-language-switch", :id => "#{tab.name}_language_switch"}
+  - resource.translations_configuration.locales.by_resource_locale(resource).each do |locale|
+    %li{ :class => resource.original_locale.to_s == locale.name.to_s && "active" || "", :"data-locale" => locale.short_name, :"data-tab" => tab.name}= locale.humanized_short_name
+.clear

data/lib/lolita-translation.rb

@@ -1,46 +1,53 @@
-
+$:<<File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
 require 'lolita'
-require 'lolita-translation/string.rb'
-require 'lolita-translation/modules'
-require 'lolita-translation/model'
-require 'lolita-translation/configuration'
-if Lolita.rails3?
-  require 'lolita-translation/rails'
-end
+
 
 module Lolita
+  # Lolita::Translation is module for all classes and module for data translation in Lolita. 
+  # It have #locales method, that is is used to get all configured locales or all available locales.
   module Translation
 
-    def self.included(base_class)
-      base_class.extend(Lolita::Translation::SingletonMethods)
+    def self.locales
+      unless @locales
+        defined_locales = Lolita.locales.any? && Lolita.locales || ::I18n.available_locales
+        @locales = Lolita::Translation::Locales.new(defined_locales)
+      end
+      @locales
     end
 
-    class << self
-      # Determine whether tab is translatable. When there is one or more fields in tab, that are defined with #translates.
-      def translatable?(tab)
-        fields = tab.fields.reject{|field|
-          field.dbi!=tab.dbi
-        } 
-        tab.dbi.klass.respond_to?(:translation_attrs) &&
-        tab.dbi.klass.respond_to?(:translations) && (fields.map(&:name) & tab.dbi.klass.translation_attrs).any?
+    def self.load!
+      load_base!
+      load_orm!
+      load_lolita_extensions!
+      if Lolita.rails3?
+        load_rails_engine!
       end
+    end
 
-      # Create nested form configuration for views.
-      def create_translations_nested_form(resource,tab)
-        resource.build_nested_translations 
-        nested_form = Lolita::Configuration::NestedForm.new(tab,:translations) 
-        nested_form.expandable = false
-        nested_form.field_style = :normal
-        
-        fields = tab.fields.reject{|field|
-          !resource.class.translation_attrs.include?(field.name.to_sym)
-        }
-        fields << Lolita::Configuration::Factory::Field.add(nested_form.dbi,:locale,:hidden)
-        nested_form.fields=fields
-        nested_form
-      end
+    def self.load_base!
+      require 'lolita-translation/version'
+      require 'lolita-translation/errors'
+      require 'lolita-translation/utils'
+      require 'lolita-translation/configuration'
+      require 'lolita-translation/locales'
+      require 'lolita-translation/translation_class_builder'
+      require 'lolita-translation/record'
+    end
+
+    def self.load_orm!
+      require 'lolita-translation/migrator'
+      require 'lolita-translation/orm/mixin'
+    end
+
+    def self.load_lolita_extensions!
+      require 'lolita-translation/lolita/tab_extension'
+    end
+
+    def self.load_rails_engine!
+      require 'lolita-translation/rails'
     end
+    
   end
 end
 
-Lolita.add_module Lolita::Translation
+Lolita::Translation.load!

data/lib/lolita-translation/builder/abstract_builder.rb

@@ -0,0 +1,103 @@
+module Lolita
+  module Translation
+    module Builder
+
+      class AbstractBuilder
+        attr_reader :base_klass, :klass, :configuration
+
+        def initialize(base_class, configuration = nil, superclass = nil)
+          @superclass     = superclass
+          @base_klass     = base_class
+          @configuration  = configuration
+          @klass          = create_klass
+        end
+
+        def class_name
+          "#{@base_klass.to_s}Translation"
+        end
+
+        def build
+          implementation_warn
+        end
+
+        def association_name
+          @configuration && @configuration.demodulized_class_name
+        end
+
+        def association_key
+          @configuration && @configuration.association_key
+        end
+
+        def translations_association_name
+          @configuration && @configuration.association_name
+        end
+
+        def locale_field_name
+          @configuration && @configuration.locale_field_name
+        end
+
+        def table_name
+          @configuration && @configuration.table_name
+        end
+
+        def override_klass_attributes method_names
+          method_names.each do |method_name, attribute|
+            validate_attribute_method_and_attribute(method_name, attribute)
+            base_klass.instance_eval do 
+              define_method(method_name) do 
+                translation_record.attribute(attribute)
+              end
+            end
+          end
+        end 
+
+        private
+
+        def configuration_attributes
+          @configuration && @configuration.attributes
+        end
+
+        def validate_attribute_method_and_attribute(method_name, attribute)
+          raise ArgumentError.new("#{method_name} is not valid attribute reader name") unless method_name
+          raise ArgumentError.new("#{attribute} is not valid attribute name") unless attribute 
+        end
+
+        def implementation_warn
+          warn("No implementation for #{self}")
+        end
+
+        def create_klass
+          new_klass = Class.new(@superclass || Object)
+          link_klass_with_constant(new_klass)
+          new_klass
+        end
+
+        def link_klass_with_constant(new_klass)
+          unless new_klass.name == self.class_name
+            name_parts = class_name.split("::")
+            new_class_name = name_parts.pop
+            parent_object = find_parent_object(Object,name_parts)
+            assign_class_to_constant(parent_object,new_class_name, new_klass)
+          end
+        end
+
+        def assign_class_to_constant parent_object, new_class_name, new_klass
+          new_class_name = new_class_name.to_sym
+          if parent_object.const_defined?(new_class_name)
+            parent_object.send(:remove_const,new_class_name)
+          end
+          parent_object.const_set(new_class_name.to_sym, new_klass)
+        end
+
+        def find_parent_object parent_object, name_parts
+          name_parts.each do |const_name|
+            parent_object = parent_object.const_get(const_name.to_sym)
+          end
+          parent_object
+        end
+
+      end
+
+    end
+  end
+end 

data/lib/lolita-translation/builder/active_record_builder.rb

@@ -0,0 +1,106 @@
+require 'lolita-translation/builder/abstract_builder'
+
+module Lolita
+  module Translation
+
+    module Builder
+      class ActiveRecordBuilder < Lolita::Translation::Builder::AbstractBuilder
+
+        def initialize base_klass, configuration = nil
+          super(base_klass,configuration, ActiveRecord::Base)
+        end
+
+        def build
+          add_ar_klass_class_methods
+          add_ar_klass_associations
+          add_ar_klass_validations
+          call_base_klass_class_methods
+          add_validations_to_base_klass
+        end
+
+        def override_klass_attributes(attributes)
+          add_ar_klass_attr_accessible(attributes + default_attributes)
+          expanded_attributes = attributes.inject({}){|hsh,attribute| 
+            hsh[attribute] = attribute 
+            hsh
+          }
+          super(expanded_attributes)
+        end
+
+        private
+
+        def default_attributes
+          [:locale]
+        end
+
+        def add_ar_klass_attr_accessible attributes
+          klass.class_eval do 
+            attr_accessible :locale, *attributes
+          end
+        end
+
+        def add_ar_klass_associations
+          if self.configuration
+            klass.belongs_to association_name, :inverse_of => translations_association_name
+          end
+        end
+
+        def add_ar_klass_validations
+          if self.configuration
+            ar_translation_builder = self
+
+            klass.validates(:locale,{
+              :presence => true, 
+              :uniqueness => {:scope => association_key},
+            })
+            klass.validates(association_name, :presence => true, :on => :update)
+            klass.validates_each(:locale) do |record, attr, value|
+              original_record = record.send(ar_translation_builder.association_name)
+              if original_record && original_record.original_locale.to_s == value.to_s 
+                record.errors.add(attr, 'is used as default locale')
+              end
+            end
+          end
+        end
+
+        def add_ar_klass_class_methods
+          ar_translation_builder = self
+          klass.singleton_class.instance_eval do 
+            define_method(:table_name) do 
+              ar_translation_builder.table_name
+            end
+          end
+        end
+
+        def call_base_klass_class_methods
+          if self.configuration
+            base_klass.has_many(translations_association_name, {
+              :class_name => class_name, 
+              :foreign_key => association_key, 
+              :dependent => :destroy,
+              :inverse_of => association_name
+            })
+            base_klass.accepts_nested_attributes_for translations_association_name, :allow_destroy => true, :reject_if => nested_attributes_rejection_proc
+          end
+        end
+
+        def nested_attributes_rejection_proc
+          Proc.new{|attrs|
+            !configuration_attributes.detect{|attr| !attrs[attr].blank? }
+          }
+        end
+
+        def add_validations_to_base_klass
+          if base_klass.column_names.include?("default_locale")
+            base_klass.validates locale_field_name, :presence => true
+            base_klass.before_validation do 
+              self.default_locale ||= self.translation_record.system_current_locale
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+end