wakari 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wakari.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Valery Kvon
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Wakari
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wakari'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wakari
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/controllers/wakari_controller.rb

@@ -0,0 +1,18 @@
+class WakariController < ApplicationController
+  
+  def self.controller_path
+    unless anonymous?
+      @controller_path ||= begin
+        model_name = name.sub(/Controller$/, '').singularize
+        model_name.constantize.model_name.collection.tap do |t|
+          t.instance_eval do
+            def include?(arg)  # Rails hack! actionpack/lib/action_view/renderer/partial_renderer.rb
+              arg == "/" ? false : super
+            end
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/wakari.rb

@@ -0,0 +1,11 @@
+require "wakari/version"
+
+module Wakari
+  def self.load!
+    require 'wakari/engine'
+    require 'wakari/railtie'
+  end
+
+end
+
+Wakari.load!

data/lib/wakari/bundle.rb

@@ -0,0 +1,136 @@
+require 'wakari/models/content'
+require 'wakari/models/proxy'
+require 'wakari/models/translation'
+require 'wakari/models/meta'
+
+module Wakari
+  
+  class Bundle
+
+    attr_reader :content_class, :proxy_class, :translation_class, :meta_class, :options
+
+    def initialize(content_class, *args)
+      @content_class = content_class
+      @name = args.first
+      @options = args.extract_options!
+    end
+
+    def name
+      @name.to_s.underscore if @name
+    end
+
+    def translation_name
+      name||"translation"
+    end
+
+    def full_translation_name
+      [content_class.model_name.param_key, translation_name].join("_")
+    end
+
+    def translation_class
+      @translation_class ||= case options[:class_name]
+      when nil then
+        content_class.const_set(translation_name.classify, Class.new(Wakari::Translation::Base))
+      when String, Symbol then
+        options[:class_name].to_s.constantize
+      end
+    end
+    
+    def meta_class
+      @meta_class ||= case options[:meta]
+      when :text then
+        translation_class.const_set("Meta", Class.new(Wakari::Meta::Text))
+      when :string then
+        translation_class.const_set("Meta", Class.new(Wakari::Meta::String))
+      when String, Symbol then
+        options[:meta].to_s.constantize
+      else
+        raise "#{content_class.name}: Meta model expected for multilang definition#{" :" + name if name }."
+      end
+    end
+    
+    def proxy_class
+      if proxy_need?
+        @proxy_class ||= content_class.const_set("#{name.classify}Proxy", Class.new(Wakari::Proxy::Base))
+      end
+    end
+    
+    def prepare!
+      meta_class.send(:include, Wakari::Meta::Model)
+      meta_class.send(:acts_as_meta_class, *meta_class_args)
+      
+      translation_class.send(:include, Wakari::Translation::Model)
+      translation_class.send(:acts_as_translation_class, *translation_class_args)
+      
+      content_class.send(:include, Wakari::Content::Model)
+      content_class.send(:acts_as_content_class, *content_class_args)
+            
+      if proxy_class
+        proxy_class.send(:include, Wakari::Proxy::Model)
+        proxy_class.send(:acts_as_proxy, *proxy_class_args)
+        content_class.class_eval <<-EOV
+          attr_accessible :#{name}
+          
+          def #{name}
+            #{proxy_class}.new(self)
+          end
+          def #{name}=(*args)
+            #{proxy_class}.new(self).write(*args)
+          end
+        EOV
+       else
+        content_class.send(:include, Wakari::Proxy::Model) unless content_class < Wakari::Proxy::Model
+        content_class.send(:acts_as_proxy, *proxy_class_args)
+      end
+    end
+    
+    private
+    
+    def proxy_need?
+      name.present?
+    end
+    
+    def association_name
+      translation_name.pluralize.to_sym
+    end
+    
+    def full_association_name
+      full_translation_name.pluralize.to_sym
+    end
+    
+    def translation_class_options
+      options
+    end
+    
+    def translation_class_args
+      [content_class, association_name, meta_class, full_association_name, translation_class_options]
+    end
+    
+    def meta_class_options
+      options
+    end
+    
+    def meta_class_args
+      [translation_class, full_association_name, meta_class_options]
+    end
+    
+    def proxy_class_options
+      options
+    end
+    
+    def proxy_class_args
+      [translation_class, association_name, proxy_class_options]
+    end
+    
+    def content_class_options
+      options
+    end
+    
+    def content_class_args
+      [translation_class, association_name, content_class_options]
+    end
+    
+  end
+
+  
+end

data/lib/wakari/controllers/action_controller_extension.rb

@@ -0,0 +1,16 @@
+require 'wakari/controllers/controller'
+
+module Wakari
+  
+  module ActionControllerExtension
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    module ClassMethods
+      
+    end
+  end
+
+end

data/lib/wakari/controllers/controller.rb

@@ -0,0 +1,14 @@
+module Wakari
+  
+  module Controller
+    module Model
+      extend ActiveSupport::Concern
+  
+      module ClassMethods
+      
+      end
+    end
+    
+  end
+
+end

data/lib/wakari/engine.rb

@@ -0,0 +1,4 @@
+module Wakari #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/wakari/helpers/action_view_extension.rb

@@ -0,0 +1,10 @@
+module Wakari
+  
+  module ActionViewExtension
+    extend ActiveSupport::Concern
+  
+    included do
+    end
+  end
+
+end

data/lib/wakari/models/active_record_extension.rb

@@ -0,0 +1,15 @@
+require 'wakari/multilang'
+
+module Wakari
+
+  module ActiveRecordExtension
+    extend ActiveSupport::Concern
+  
+    module ClassMethods
+      class_eval do
+        include Wakari::Multilang
+      end
+    end
+  end
+  
+end

data/lib/wakari/models/content.rb

@@ -0,0 +1,7 @@
+require 'wakari/models/content/model'
+
+module Wakari
+  module Content
+    
+  end
+end

data/lib/wakari/models/content/model.rb

@@ -0,0 +1,45 @@
+module Wakari
+  module Content
+    module Model
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      module ClassMethods
+    
+        def acts_as_content_class(translation_class, association_name, options)
+          has_many association_name, :class_name => translation_class.name, :inverse_of => :content, :order => :position, :autosave => true, :foreign_key => :content_id
+          default_scope { includes(association_name) }
+        end
+    
+        def i18n_namespaced_scope(resource) #:nodoc:
+          :"#{self.i18n_scope}.#{resource}.#{self.model_name.i18n_key.to_s.gsub(/\//,".")}"
+        end
+
+        def i18n_default_scope(resource) #:nodoc:
+          :"#{self.i18n_scope}.#{resource}.#{self.model_name.i18n_key.to_s}"
+        end
+    
+        def dom_class
+          model_name.param_key
+        end
+    
+      end
+
+      def dom_id(prefix = nil)
+        [prefix, self.class.dom_class, to_key].compact.join("_")
+      end
+
+      def current_locale
+        I18n.locale.to_s
+      end
+
+      def current_lang
+        Gaigo::LANGS.get(current_locale)
+      end
+
+
+    end
+  end
+end

data/lib/wakari/models/meta.rb

@@ -0,0 +1,31 @@
+require 'wakari/models/meta/model'
+require 'wakari/models/meta/reference'
+
+module Wakari
+  module Meta
+    class String < ActiveRecord::Base
+      self.table_name = "meta_strings"
+      attr_accessible :value
+      validates_presence_of :value
+    end
+    
+    class Text < ActiveRecord::Base
+      self.table_name = "meta_texts"
+      attr_accessible :value
+      validates_presence_of :value
+    end
+
+    # class StringReference < ActiveRecord::Base
+    #   self.table_name = "references"
+    #   attr_accessible :meta_id, :reference_id
+    #   include Meta::Reference  
+    # end
+    # 
+    # class TextReference < ActiveRecord::Base
+    #   self.table_name = "references"
+    #   attr_accessible :meta_id, :reference_id
+    #   include Meta::Reference  
+    # end
+
+  end
+end

data/lib/wakari/models/meta/model.rb

@@ -0,0 +1,22 @@
+module Wakari
+  module Meta
+    
+    module Model
+      extend ActiveSupport::Concern
+    
+      included do
+      end
+    
+      module ClassMethods
+        def acts_as_meta_class(translation_class, full_association_name, options)
+          has_many full_association_name, :class_name => translation_class.name, :inverse_of => :meta, :order => :created_at, :foreign_key => :meta_id
+        end
+      end
+    
+      def to_s
+        value
+      end
+      
+    end
+  end
+end

data/lib/wakari/models/meta/reference.rb

@@ -0,0 +1,14 @@
+module Wakari
+  module Meta
+  
+    module Reference
+      module Model
+        extend ActiveSupport::Concern
+    
+        included do
+        end
+      end
+
+    end
+  end
+end

data/lib/wakari/models/proxy.rb

@@ -0,0 +1,42 @@
+require 'wakari/models/proxy/model'
+
+module Wakari
+  module Proxy
+    class Base
+      #include ActiveModel::AttributeMethods
+      include ActiveModel::MassAssignmentSecurity
+      attr_reader :content
+      delegate :current_locale, :current_lang, :to => :content
+      delegate :==, :nil?, :present?, :to => :current_translation
+      
+      extend ActiveModel::Naming
+      
+      def initialize(content)
+        @content = content
+      end
+      
+      # def translations
+      #   _translations_proc.call(content)
+      # end
+      
+      def write(params={})
+        detect_current_translation.tap do |t|
+          t.attributes = params.delete_if {|k| k.to_s == "locale"}
+        end
+      end
+      
+      def inspect
+        translations.inspect
+      end
+      
+      def method_missing(*args, &block)
+        current_translation.send(*args, &block)
+      end
+
+      def dom_id(prefix = nil)
+        [prefix, content.dom_id, translations.klass.dom_class].compact.join("_")
+      end
+      
+    end
+  end
+end

data/lib/wakari/models/proxy/model.rb

@@ -0,0 +1,113 @@
+require 'wakari/models/support/errors'
+
+module Wakari
+  module Proxy
+    module Model
+      extend ActiveSupport::Concern
+    
+      included do
+      end
+
+      module ClassMethods
+        def acts_as_proxy(translation_class, association_name, options)
+          lang_methods = translation_class._locales.collect do |lang|
+                           method = lang.to_method
+                           class_eval <<-EOV
+                             def #{method}
+                               translation?(\"#{lang.code}\")
+                             end
+                             def #{method}=(params={})
+                               detect_translation(\"#{lang.code}\").tap do |t|
+                                 t.attributes = params.delete_if {|k| k.to_s == \"locale\"}
+                               end
+                             end
+                           EOV
+                            method
+                         end
+          attr_accessible *lang_methods
+          delegate *translation_class._meta_attributes, :to => :current_translation, :allow_nil => true
+          delegate *translation_class._meta_attributes.collect {|attribute| "#{attribute}="}, :to => :detect_current_translation, :allow_nil => true
+          
+          if self < Wakari::Proxy::Base
+            define_method :translations do |*args|
+              content.send(association_name, *args)
+            end
+          end
+          
+        end
+      end
+
+      def translations_attributes
+        Hash[translations.map do |t|
+               if (lang = t.lang) && (attributes = t.meta_attributes).present?
+                 [lang.to_method, attributes]
+               end
+             end.compact]
+      end
+
+      def possible_langs
+        translations.klass._locales
+      end
+
+      def used_langs
+        translations.map {|t| t.lang}
+      end
+
+      def available_langs
+        possible_langs - used_langs
+      end
+
+      def default_translation
+        translations.min_by {|t| t.position}
+      end
+
+      def translation(locale)
+        find_translation(:locale => locale)
+      end
+      
+      def translation?(locale)
+        begin
+          translation(locale)
+        rescue TranslationNotFound
+          nil
+        end
+      end
+
+      def detect_translation(locale)
+        find_or_build_translation(:locale => locale)
+      end
+
+      def current_translation
+         translation?(current_locale)||translations.first
+      end
+      
+      def detect_current_translation
+        detect_translation(current_locale)
+      end
+            
+      def to_s(locale = nil)
+        (locale ? translation?(locale) : current_translation).try(:to_s)
+      end
+
+      private
+
+      def build_translation(params = {})
+        translations.build(params)
+      end
+
+      def find_or_build_translation(params = {})
+        begin
+          find_translation(params)
+        rescue TranslationNotFound
+          build_translation(params)
+        end
+      end
+
+      def find_translation(params = {})
+        translations.find {|t| t.match?(params)} || raise(TranslationNotFound, params)
+      end
+
+    end
+    
+  end
+end

data/lib/wakari/models/support/errors.rb

@@ -0,0 +1,4 @@
+module Wakari
+  class TranslationNotFound < StandardError
+  end
+end

data/lib/wakari/models/support/naming.rb

@@ -0,0 +1,53 @@
+module Wakari
+  module Support
+    module Naming
+      extend ActiveSupport::Concern
+    
+      class Name < ActiveModel::Name
+        attr_reader :parent_class
+
+        def initialize(parent_class, klass, namespace = nil, name = nil)
+          super(klass, namespace, name)
+          @parent_class = parent_class
+          @clear_name   = (Rails.version <= "3.2.8" ? (name||klass.name) : @name).sub(/^#{parent_class.name}\W*/,'')
+          @singular     = _singularize(@clear_name)
+          @plural       = ActiveSupport::Inflector.pluralize(@singular)
+          @element       = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(@clear_name))
+          @collection   = @parent_class.model_name.collection + "/" + ActiveSupport::Inflector.tableize(@clear_name)
+          @param_key    = (namespace ? _singularize(@unnamespaced) : @singular)
+          @i18n_key     = (@parent_class.model_name.i18n_key.to_s + "/" + @clear_name.underscore).to_sym
+          @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key) : @plural.dup)
+          @singular_route_key = ActiveSupport::Inflector.singularize(@route_key)
+          @route_key << "_index" if @plural == @singular
+        end
+        
+        def human(options = {})
+          try_human(options)
+        end
+        
+      end
+    
+      module ClassMethods
+        def parent_class
+          self.name.split("::")[0..-2].join("::").constantize
+        end
+  
+        def _to_partial_path #:nodoc:
+          @_to_partial_path ||= begin
+            "#{model_name.collection}/#{model_name.element}".freeze
+          end
+        end
+  
+        def model_name
+          @_model_name ||= begin
+            namespace = self.parents.detect do |n|
+              n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+            end
+            Name.new(parent_class, self, namespace)
+          end
+        end
+      end
+    
+    end
+  end
+end

data/lib/wakari/models/translation.rb

@@ -0,0 +1,12 @@
+require 'wakari/models/translation/model'
+
+module Wakari
+  module Translation
+    
+    class Base < ActiveRecord::Base
+      self.table_name = "translations"
+    end
+        
+  end
+  
+end

data/lib/wakari/models/translation/model.rb

@@ -0,0 +1,223 @@
+require 'wakari/models/support/naming'
+
+module Wakari
+  module Translation
+    
+    module Model
+      extend ActiveSupport::Concern
+      include Wakari::Support::Naming
+      
+      included do
+        class_attribute :_meta_attributes unless defined?(_meta_attributes)
+        
+        validates_presence_of :locale
+        validates_uniqueness_of :locale, :scope => [:type, :content_id]
+        before_save :commit_meta
+        after_destroy :clear_meta
+        validate do
+          unless meta_valid?
+            template_meta.errors.messages.each do |attribute, suberrors|
+              suberrors.each do |suberror|
+                errors.add(attribute, suberror)
+              end
+            end
+          end
+        end       
+        after_initialize do
+          template_meta
+        end
+        acts_as_list :scope => [:type, :content_id]
+        default_scope { includes(:meta) }
+      end
+
+      module ClassMethods
+  
+        def dom_class
+          model_name.element
+        end
+
+        def acts_as_translation_class(content_class, association_name, meta_class, full_association_name, options)
+          has_locale! *Array.wrap(options[:locales])#, :accessible => false
+
+          belongs_to :content, :class_name => content_class.name, :inverse_of => association_name, :counter_cache => :"#{association_name}_count"
+          belongs_to :meta, :class_name => meta_class.name, :inverse_of => full_association_name, :counter_cache => :wakari_used
+
+          self._meta_attributes =
+          if meta_class < Wakari::Meta::Text || meta_class < Wakari::Meta::String
+            [:value]
+          else
+            Array.wrap(options[:attributes]).map {|a| a.to_sym}
+          end
+
+          attr_accessible *_meta_attributes, :content_id, :meta_id, :_destroy, :position
+          delegate *_meta_attributes, :to_s, :to => "(@_template_meta||meta)"
+          delegate *_meta_attributes.collect {|attribute| "#{attribute}="}, :to => :template_meta
+          
+          (class << self; self; end).instance_eval do
+            define_method :i18n_inherited_namespaced_scope do |resource| #:nodoc:
+              :"#{content_class.i18n_namespaced_scope(resource)}.#{model_name.element}"
+            end
+
+            define_method :i18n_inherited_default_scope do |resource| #:nodoc:
+              :"#{content_class.i18n_default_scope(resource)}.#{model_name.element}"
+            end
+          end
+
+          define_method :stack do
+            content.send(association_name)
+          end
+          
+         end
+
+        def try_human_attribute_name(attribute, options = {})
+          super(attribute, options) do |defaults|
+            defaults << :"#{i18n_inherited_namespaced_scope(:attributes)}.#{attribute}" ## added
+            defaults << :"#{i18n_inherited_default_scope(:attributes)}.#{attribute}" ## added
+          end
+        end
+        
+        def human_attribute_name(attribute, options = {})
+          try_human_attribute_name(attribute, options)
+        end
+        
+      end
+
+      def dom_id(prefix = nil)
+        [prefix, content.dom_id, self.class.dom_class, locale].compact.join("_")
+      end
+
+      def _destroy=(value)
+        case value
+        when 1, '1', true, 'true' then
+          mark_for_destruction
+        end
+      end
+
+      def siblings
+        stack - [self]
+      end
+
+      def meta_counter
+        counter = association(:meta).options[:counter_cache]
+        counter = self.class.model_name.plural + "_count" if counter == true
+        meta.send(counter) if counter
+      end
+
+      def only_once_used_meta?
+        meta_counter && meta_counter <= 1
+      end
+
+      def changed?
+        meta_changed? || super
+      end
+
+      def meta_changed?
+        eval(_meta_attributes.map {|a| "template_meta.send(:#{a}) != meta.send(:#{a})"}.join(" || ")) ## content changed?
+      end
+      
+      def meta_valid?
+        template_meta.valid?
+      end
+
+      def match?(params = {})
+        m = params.map {|key, value| send(key) == (value.is_a?(Symbol) ? value.to_s : value)}
+        (m.include?(false) || m.blank?) ? false : true
+      end
+
+      def meta_attributes
+        Hash[_meta_attributes.map {|attr| value = send(attr); [attr.to_s, value] if value}.compact]
+      end
+
+      def lang
+        Gaigo::LANGS.get(locale)
+      end
+
+      def to_param
+        locale
+      end
+
+      private
+    
+      def template_meta
+        @_template_meta ||= meta ? meta.dup : build_meta.dup
+      end
+    
+      def clear_meta
+        if only_once_used_meta?
+          destroy_meta
+        end
+      end
+    
+      def commit_meta
+        if meta_changed? ## writer attributes touched
+          attributes = extract_attributes(template_meta)
+          if meta.persisted?
+            if only_once_used_meta?
+              if exists_meta?(attributes)
+                destroy_meta
+                attach_or_create_meta(attributes)
+              else
+                update_meta(attributes)
+              end
+            else
+              attach_or_create_meta(attributes)
+            end
+          else
+            attach_or_create_meta(attributes)
+          end
+        end
+      end
+
+      def extract_attributes(object)
+        object.attributes.delete_if {|a| !a.to_sym.in?(_meta_attributes)}
+      end
+      
+      def destroy_meta
+        begin
+          meta.destroy
+          puts "Translation '#{locale}': PERSISTED META DESTROYED!"
+        rescue ActiveRecord::StaleObjectError
+          meta.reload
+          commit_meta
+        end
+      end
+      
+      def update_meta(attributes = {})
+        begin
+          meta.update_attributes(attributes)
+          puts "Translation '#{locale}': PERSISTED META UPDATED!"
+        rescue ActiveRecord::StaleObjectError
+          meta.reload
+          commit_meta
+        end
+      end
+
+      def find_existed_meta(attributes = {})
+        association(:meta).klass.where(attributes).limit(1).first
+      end
+
+      def create_new_meta(attributes = {})
+        create_meta(attributes).tap do |record|
+          record.send(:increment_lock) # Rails BUG! Counter caching process increments lock version in the DB table,
+                                       # but not in the associated object. So saving raises ActiveRecord::StaleObjectError.
+        end
+      end
+
+      def exists_meta?(attributes = {})
+        association(:meta).klass.exists?(attributes)
+      end
+
+      def attach_or_create_meta(attributes = {})
+        if existed = find_existed_meta(attributes)
+          self.meta = existed
+          puts "Translation '#{locale}': EXISTED META USED!"
+        else
+          self.meta = create_new_meta(attributes)
+          puts "Translation '#{locale}': NEW META CREATED!"
+        end
+      end
+    
+    end
+  end
+  
+end

data/lib/wakari/multilang.rb

@@ -0,0 +1,14 @@
+require 'wakari/bundle'
+
+module Wakari  
+  module Multilang
+    
+    def multilang(*args, &block)
+      bundle = Bundle.new(self, *args)
+      bundle.prepare!
+      yield bundle if block_given?
+    end
+    
+  end
+  
+end

data/lib/wakari/railtie.rb

@@ -0,0 +1,20 @@
+require 'rails'
+
+module Wakari
+  class Railtie < ::Rails::Railtie
+    config.before_initialize do
+      ActiveSupport.on_load :active_record do
+        require 'wakari/models/active_record_extension'
+        include Wakari::ActiveRecordExtension
+      end
+      ActiveSupport.on_load :action_controller do
+        require 'wakari/controllers/action_controller_extension'
+        include Wakari::ActionControllerExtension
+      end
+      ActiveSupport.on_load :action_view do
+        require 'wakari/helpers/action_view_extension'
+        include Wakari::ActionViewExtension
+      end
+    end
+  end
+end

data/lib/wakari/version.rb

@@ -0,0 +1,3 @@
+module Wakari
+  VERSION = "0.0.2"
+end

data/wakari.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wakari/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "wakari"
+  gem.version       = Wakari::VERSION
+  gem.authors       = ["Valery Kvon"]
+  gem.email         = ["addagger@gmail.com"]
+  gem.homepage      = %q{http://vkvon.ru/projects/wakari}
+  gem.description   = %q{Add translations for models}
+  gem.summary       = %q{Multilang assets for Rails}
+
+  gem.add_development_dependency "gaigo"
+  gem.add_development_dependency "acts_as_list"
+  gem.rubyforge_project = "wakari"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.licenses       = ['MIT']
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: wakari
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Valery Kvon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gaigo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: acts_as_list
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Add translations for models
+email:
+- addagger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/controllers/wakari_controller.rb
+- lib/wakari.rb
+- lib/wakari/bundle.rb
+- lib/wakari/controllers/action_controller_extension.rb
+- lib/wakari/controllers/controller.rb
+- lib/wakari/engine.rb
+- lib/wakari/helpers/action_view_extension.rb
+- lib/wakari/models/active_record_extension.rb
+- lib/wakari/models/content.rb
+- lib/wakari/models/content/model.rb
+- lib/wakari/models/meta.rb
+- lib/wakari/models/meta/model.rb
+- lib/wakari/models/meta/reference.rb
+- lib/wakari/models/proxy.rb
+- lib/wakari/models/proxy/model.rb
+- lib/wakari/models/support/errors.rb
+- lib/wakari/models/support/naming.rb
+- lib/wakari/models/translation.rb
+- lib/wakari/models/translation/model.rb
+- lib/wakari/multilang.rb
+- lib/wakari/railtie.rb
+- lib/wakari/version.rb
+- wakari.gemspec
+homepage: http://vkvon.ru/projects/wakari
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: wakari
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Multilang assets for Rails
+test_files: []