lolita-translation 0.3.3 → 0.5.0

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/VERSION

@@ -1 +0,0 @@
-0.3.3

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

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

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

@@ -1,4 +0,0 @@
-<% locale = tab_form.object.respond_to?(:locale) ? tab_form.object.locale : ::I18n.default_locale %>
-<div class="language-wrap" id="<%=locale%>_attributes_for_<%= tab.name %>" style="display:<%=locale == ::I18n.default_locale ? "block" : "none"%>">
-  <%=content %>
-</div>

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

@@ -1,8 +0,0 @@
-<ul class="tab-language-switch" id="<%=tab.name%>_language_swith">
-  <% I18n.available_locales.sort.each do |short_locale| %>
-    <%  active = I18n.default_locale == short_locale %>
-    <li class="<%=active ? "active" : ""%>" data-locale="<%=short_locale%>" data-tab="<%=tab.name%>">
-      <%= short_locale.to_s.capitalize %>
-    </li>
-  <% end %>
-</ul>

data/lib/generators/lolita_translation/USAGE

@@ -1,8 +0,0 @@
-Description:
-    Explain the generator
-
-Example:
-    ./script/generate has_translations Thing
-
-    This will create:
-        what/will/it/create

data/lib/generators/lolita_translation/has_translations_generator.rb

@@ -1,8 +0,0 @@
-class HasTranslationsGenerator < Rails::Generator::NamedBase
-  def manifest
-    record do |m|
-      # m.directory "lib"
-      # m.template 'README', "README"
-    end
-  end
-end

data/lib/lolita-translation/model.rb

@@ -1,100 +0,0 @@
-module Lolita
-  module Translation
-    class ClassFactory
-
-      def self.create(class_name, parent, superclass=nil, &block)
-        first,*other = class_name.split("::")
-        if other.empty?
-          klass = superclass ? Class.new(superclass, &block) : Class.new(&block)
-          parent.const_set(first, klass)
-        else
-          klass = Class.new
-          parent = unless parent.const_defined?(first)
-            parent.const_set(first, klass)
-          else
-            first.constantize
-          end
-          self.create(other.join('::'), parent, superclass, &block)
-        end
-      end
-    end
-
-    module ModelInstanceMethods
-      # override validate to vaidate only translate fields from master Class
-      def validate
-        item = self.class.name.sub('Translation','').constantize.new(self.attributes.clone.delete_if{|k,_| !self.class.translate_attrs.include?(k.to_sym)})
-        item_adapter = Lolita::DBI::Base.create(item.class)
-        self_adapter = Lolita::DBI::Base.create(self.class)
-        was_table_name = item_adapter.collection_name
-        item_adapter.collection_name = self_adapter.collection_name
-        item.valid? rescue
-        self.class.translate_attrs.each do |attr|
-          errors_on_attr = item.errors.on(attr)
-          self.errors.add(attr,errors_on_attr) if errors_on_attr
-        end
-        item_adapter.collection_name = was_table_name
-      end
-    end
-
-    module ModelClassMethods
-      # sets real master_id it's aware of STI
-      def extract_master_id name
-        master_class = name.sub('Translation','').constantize
-        #FIXME why need to check superclass ?
-        class_name = master_class.name #!master_class.superclass.abstract_class? ? master_class.superclass.name : master_class.name
-        self.master_id = :"#{class_name.demodulize.underscore}_id"
-      end
-    end
-
-    class TranslationModel
-
-      attr_reader :adapter,:klass
-
-      def initialize(config)
-        @config = config
-        @adapter =  Lolita::DBI::Base.create(@config.klass)
-        @klass = begin
-          @config.translation_class_name.constantize 
-        rescue
-          self.create
-        end
-        fix_class_attrs
-        @klass.extract_master_id(@config.translation_class_name)
-      end
-
-      def create
-        translation_model = self
-        config = @config
-        new_klass = Lolita::Translation::ClassFactory.create(@config.translation_class_name, Object, get_orm_class) do
-            if translation_model.adapter.dbi.adapter_name == :mongoid
-              include Mongoid::Document
-            end
-            # set's real table name
-            translation_adapter = Lolita::DBI::Base.create(self)
-            translation_adapter.collection_name = config.options[:table_name] || translation_model.adapter.collection_name.to_s + "_translations"
-           
-            cattr_accessor :translate_attrs, :master_id
-
-            include Lolita::Translation::ModelInstanceMethods
-            extend Lolita::Translation::ModelClassMethods
-        end
-        new_klass.translate_attrs = @config.attrs
-        new_klass
-      end
-
-      private
-
-      def get_orm_class()
-        @adapter.dbi.adapter_name == :active_record ?  ActiveRecord::Base : nil
-      end
-
-      def fix_class_attrs
-        unless @klass.respond_to?(:translate_attrs)
-          @klass.send(:cattr_accessor, :translate_attrs, :master_id)
-          @klass.send(:extend,Lolita::Translation::ModelClassMethods)
-          @klass.translate_attrs = @config.attrs            
-        end
-      end
-    end
-  end
-end

data/lib/lolita-translation/modules.rb

@@ -1,130 +0,0 @@
-module Lolita
-  module Translation
-    module ClassMethods
-      
-      def find_with_translations(*args,&block)
-        unless ::I18n.locale == ::I18n.default_locale
-          if args && args[0].kind_of?(Hash)
-            args[0][:include] ||=[]
-            args[0][:include] << :translations
-          end
-        end
-        find_without_translations *args, &block
-      end
-      # creates translation table and adds missing fields
-      # So at first add the "translations :name, :desc" in your model
-      # then put YourModel.sync_translation_table! in db/seed.rb and run "rake db:seed"
-      # Later adding more fields in translations array, just run agin "rake db:seed"
-      # If you want to remove fields do it manualy, it's safer
-      def sync_translation_table!
-        out = StringIO.new
-        $stdout = out
-        self_adapter = Lolita::DBI::Base.create(self)
-        translations_class = self.reflect_on_association(:translations).klass
-        translations_adapter = Lolita::DBI::Base.create(translations_class)
-
-        if translations_adapter.dbi.adapter_name == :active_record
-          translations_table = translations_adapter.collection_name
-
-          unless ActiveRecord::Migration::table_exists?(translations_table)
-            ActiveRecord::Migration.create_table translations_table do |t|
-              t.integer translations_class.master_id, :null => false
-              t.string :locale, :null => false, :limit => 5
-              columns_has_translations.each do |col|
-                t.send(col.type,col.name)
-              end
-            end
-            ActiveRecord::Migration.add_index translations_table, [translations_class.master_id, :locale], :unique => true, :name => "#{self_adapter.collection_name}_master"
-            translations_class.reset_column_information
-          else
-            changes = false
-            columns_has_translations.each do |col|
-              unless translations_class.columns_hash.has_key?(col.name)
-                ActiveRecord::Migration.add_column(translations_table, col.name, col.type)
-                changes = true
-              end
-            end
-            translations_class.reset_column_information if changes
-          end
-        elsif translations_adapter.dbi.adapter_name == :mongoid
-          unless translations_class.fields["locale"]
-            translations_class.class_eval do
-              field(self.master_id, :type => Integer)
-              field :locale, :type => String
-              columns_has_translations.each do |col|
-                field col.name, :type => col.type
-              end
-              index(
-                [
-                  [ self.master_id, Mongo::ASCENDING ],
-                  [ :locale, Mongo::ASCENDING ]
-                ],
-                unique: true
-              )
-            end
-          else
-            columns_has_translations.each do |col|
-              unless translations_class.fields[col.name.to_s]
-                translations_class.field(col.name,:type => col.type)
-              end
-            end
-          end
-        end
-        $stdout = STDOUT
-      end
-    end
-
-    module InstanceMethods
-
-      # forces given locale
-      # I18n.locale = :lv
-      # a = Article.find 18
-      # a.title
-      # => "LV title"
-      # a.in(:en).title
-      # => "EN title"
-      def in locale
-        locale.to_sym == ::I18n.default_locale ? self : find_translation(locale)
-      end
-      
-      def find_or_build_translation(*args)
-        locale = args.first.to_s
-        build = args.second.present?
-        find_translation(locale) || (build ? self.translations.build(:locale => locale) : self.translations.new(:locale => locale))
-      end
-
-      def translation(locale)
-        find_translation(locale.to_s)
-      end
-
-      def all_translations
-        t = ::I18n.available_locales.map do |locale|
-          [locale, find_or_build_translation(locale)]
-        end
-        ActiveSupport::OrderedHash[t]
-      end
-
-      def has_translation?(locale)
-        return true if locale == ::I18n.default_locale
-        find_translation(locale).present?
-      end
-
-      # if object is new, then nested slaves ar built for all available locales
-      def build_nested_translations
-        if (::I18n.available_locales.size - 1) > self.translations.size
-          ::I18n.available_locales.clone.delete_if{|l| l == ::I18n.default_locale}.each do |l|
-            options = {:locale => l.to_s}
-            self_adapter = Lolita::DBI::Base.create(self.class)
-            options[self_adapter.reflect_on_association(:translations).klass.master_id] = self.id unless self.new_record?
-            self.translations.build(options) unless self.translations.map(&:locale).include?(l.to_s)
-          end
-        end
-      end
-
-      def find_translation(locale)
-        locale = locale.to_s
-        translations.detect { |t| t.locale == locale }
-      end
-    end
-  end
-end

data/lib/lolita-translation/string.rb

@@ -1,19 +0,0 @@
-class String
-  attr_accessor :origin_model, :origin_name
-  def set_origins obj, name
-    self.origin_model = obj
-    self.origin_name = name
-    self
-  end
-  # forces given locale
-  # I18n.locale = :lv
-  # a = Article.find 18
-  # a.title
-  # => "LV title"
-  # a.title.in(:en)
-  # => "EN title"
-  def in locale
-    return self unless self.origin_model
-    translation = self.origin_model.in(locale) and translation.send(self.origin_name)
-  end
-end

data/lib/tasks/has_translations_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :has_translations do
-#   # Task goes here
-# end

data/spec/has_translations_spec.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe 'HasTranslations' do
-  it "should switch locales" do
-    g = Group.create!(:name => "Sport")
-    c = Category.create!(:name => "Golf", :groups => [g])
-    z = News.create!(:title => "Tiger Woods sucks", :body => Faker::Lorem::paragraphs(10).join, :category_id => c.id)
-    # translate
-    g.translations.create!(:locale => 'lv', :name => "Sports")
-    c.translations.create!(:locale => 'lv', :name => "Golfs")
-    z.translations.create!(:locale => 'lv', :title => "Taigers Vuds nekam neder")
-    
-    g.name.should == "Sport"
-    c.name.should == "Golf"
-    z.title.should == "Tiger Woods sucks"
-
-    I18n.locale = :lv
-    
-    g.name.should == "Sports"
-    c.name.should == "Golfs"
-    z.title.should == "Taigers Vuds nekam neder"
-
-    z.category.name.should == "Golfs"
-    z.category.groups.first.name.should == "Sports"
-
-    z.destroy
-    c.destroy
-    g.destroy
-    #--------------------------------
-    I18n.locale = I18n.default_locale
-  end
-
-  it "should load requested locale with 'in' method" do
-    g = Group.create!(:name => "Sport")
-    g.translations.create!(:locale => 'lv', :name => "Sports")
-
-    g = Group.find_by_name "Sport"    
-    g.name.should == "Sport"
-    g.name.in(:lv).should == "Sports"
-    g.name.should == "Sport"
-  end
-end