multilang-hstore 0.1

data/README.rdoc

@@ -0,0 +1,134 @@
+== Multilang-hstore
+
+Multilang is a small translation library for translating database values for Rails 3 using the [Hstore datatype](http://www.postgresql.org/docs/9.0/static/hstore.html).
+
+This project is a fork of [artworklv/multilang](https://github.com/artworklv/multilang) with some remarkable differences:
+
+* Replaced YAML text fields in favor of Hstore fields.
+* The translation hash is no longer limited to locales in `I18n.available_locales`.
+
+It uses [engageis/activerecord-postgres-hstore](https://github.com/engageis/activerecord-postgres-hstore)
+
+== Installation
+
+You need configure the multilang gem inside your gemfile:
+
+  gem 'multilang-hstore'
+
+Do not forget to run
+
+  bundle install
+
+
+== Basic Usage
+
+This is a walkthrough with all steps you need to setup multilang translated attributes, including model and migration.
+
+We're assuming here you want a Post model with some multilang attributes, as outlined below:
+
+  class Post < ActiveRecord::Base
+    multilang :title, :accessible => true
+  end
+
+or
+
+  class Post < ActiveRecord::Base
+    multilang :title, :description, :required => true, :length => 100, :accessible => true
+  end
+
+The multilang translations are stored in the same model attributes (eg. title):
+
+You may need to create migration for Post as usual, but multilang attributes should be in hstore type:
+  
+  create_table(:posts) do |t|
+    t.hstore :title
+    t.timestamps
+  end
+
+Thats it!
+
+Now you are able to translate values for the attributes :title and :description per locale:
+
+  I18n.locale = :en
+  post.title = 'Multilang rocks!'
+  I18n.locale = :lv
+  post.title = 'Multilang rulle!'
+
+  I18n.locale = :en
+  post.title #=> Multilang rocks!
+  I18n.locale = :lv
+  post.title #=> Multilang rulle!
+
+
+You may assign attributes through auto generated methods (this methods depend from I18n.available_locales):
+
+  I18n.available_locales #=> [:en. :lv]
+
+  post.title_en = 'Multilang rocks!'
+  post.title_lv = 'Multilang rulle!'
+
+  post.title_en #=>  'Multilang rocks!'
+  post.title_lv #=>  'Multilang rulle!'
+
+You may use mass assignment on model creation (if :accessible param is defined):
+
+  Post.new(:title => {:en => 'Multilang rocks!', :lv => 'Multilang rulle!'})
+
+or
+
+  Post.new(:title_en => 'Multilang rocks!', :title_lv => 'Multilang rulle!')
+
+Also, you may ise same hashes with setters:
+
+  post.title = {:en => 'Multilang rocks!', :lv => 'Multilang rulle!'} 
+
+== Attribute methods
+
+You may get other translations via attribute translation method:
+
+  post.title.translation[:lv] #=> 'Multilang rocks!'
+  post.title.translation[:en] #=> 'Multilang rulle!'
+  post.title.translation.locales #=> [:en, :lv]
+
+If you have incomplete translations, you can get translation from other locale:
+
+  post.title = {:en => 'Multilang rocks!', :lv => ''}
+  I18n.locale = :lv
+  post.title.any #=> 'Multilang rocks!'
+
+The value from "any" method returns value for I18n.current_locale or, if value is empty, it searches through all locales. It takes searching order from I18n.available_locales array.
+
+== Validations
+Multilang has some validation features:
+
+  multilang :title, :length => 100  #define maximal length validator
+  multilang :title, :required => true #define requirement validator 
+  multilang :title, :format => /regexp/ #define validates_format_of validator
+
+== Tests
+
+Test runs using a temporary database in your local PostgreSQL server:
+
+Create a test database:
+
+  $ createdb multilang-hstore-test
+
+Create the [hstore extension](http://www.postgresql.org/docs/9.1/static/sql-createextension.html):
+  psql -d multilang-hstore-test -c "CREATE EXTENSION IF NOT EXISTS hstore"
+
+Create the role *postgres* if necessary:
+
+  $ createuser -s -r postgres 
+
+Finally, you can run your tests:
+  
+  rspec
+
+== Bugs and Feedback
+
+Use [http://github.com/artworklv/multilang/issues](http://github.com/artworklv/multilang/issues)
+
+== License(MIT)
+
+Copyright (c) 2010 Arthur Meinart
+Copyright (c) 2012 Firebase.co

data/lib/multilang-hstore/active_record_extensions.rb

@@ -0,0 +1,114 @@
+module Multilang
+  module ActiveRecordExtensions
+
+    module ClassMethods
+
+      def multilang_accessible_translations
+        class_variable_get(:@@multilang_accessible_translations)
+      end
+
+      def multilang(*args)
+
+        options = {
+          :required => false,
+          :length => nil,
+          :accessible => false,
+          :format => nil
+        }.merge(args.extract_options!)
+
+        options.assert_valid_keys([:required, :length, :accessible, :format, :nil])
+
+        define_translation_base! unless included_modules.include?(InstanceMethods)
+
+        args.each do |attribute|
+
+          define_method attribute do
+            multilang_translation_keeper(attribute).value
+          end
+
+          define_method "#{attribute}=" do |value|
+            multilang_translation_keeper(attribute).update(value)
+          end
+
+          #attribute accessibility for mass assignment
+          if options[:accessible]
+            matr = multilang_accessible_translations + [attribute.to_sym]
+            class_variable_set(:@@multilang_accessible_translations, matr)
+          end
+
+          module_eval do
+            serialize "#{attribute}", ActiveRecord::Coders::Hstore
+          end
+
+          I18n.available_locales.each do |locale|
+
+            define_method "#{attribute}_#{locale}" do
+              multilang_translation_keeper(attribute)[locale]
+            end
+
+            define_method "#{attribute}_#{locale}=" do |value|
+              multilang_translation_keeper(attribute)[locale] = value
+            end
+
+            # locale based attribute accessibility for mass assignment
+            if options[:accessible]
+              matr = multilang_accessible_translations + ["#{attribute}_#{locale}".to_sym]
+              class_variable_set(:@@multilang_accessible_translations, matr)
+            end
+
+            # attribute presence validator
+            if options[:required]
+              module_eval do
+                validates_presence_of "#{attribute}_#{locale}"
+              end
+            end
+
+            #attribute maximal length validator
+            if options[:length]
+              module_eval do
+                validates_length_of "#{attribute}_#{locale}", :maximum => options[:length]
+              end
+            end
+
+            #attribute format validator
+            if options[:format]
+              module_eval do
+                validates_format_of "#{attribute}_#{locale}", :with => options[:format]
+              end
+            end
+
+          end
+        end
+      end
+
+      private
+
+      def define_translation_base!
+        include InstanceMethods
+
+        define_method "multilang_translation_keeper" do |attribute|
+          unless instance_variable_defined?("@multilang_attribute_#{attribute}")
+            instance_variable_set("@multilang_attribute_#{attribute}", MultilangTranslationKeeper.new(self, attribute))
+          end
+          instance_variable_get "@multilang_attribute_#{attribute}"
+        end
+
+        unless class_variable_defined?(:@@multilang_accessible_translations)
+          class_variable_set(:@@multilang_accessible_translations, [])
+        end
+
+      end
+
+    end
+
+    module InstanceMethods
+      def mass_assignment_authorizer(role = :default)
+        super(role) + (self.class.multilang_accessible_translations || [])
+      end
+    end #module InstanceMethods
+
+  end #module ActiveRecordExtensions
+end ##module Multilang
+
+ActiveRecord::Base.extend Multilang::ActiveRecordExtensions::ClassMethods
+

data/lib/multilang-hstore/translation_keeper.rb

@@ -0,0 +1,103 @@
+module Multilang
+
+  class MultilangTranslationKeeper
+    attr_reader :model
+    attr_reader :attribute
+    attr_reader :translations
+
+    def initialize(model, attribute)
+      @model = model
+      @attribute = attribute
+      @translations = {}
+      load!
+    end
+
+    def value(locale = nil)
+      locale ||= actual_locale
+      read(locale)
+    end
+
+    def current_or_any_value
+      v = value
+      if v.empty?
+        reduced_locales = locales - [actual_locale]
+        reduced_locales.each do |locale|
+          v = value(locale)
+          return v unless v.empty?
+        end
+      else
+        return v
+      end
+      return ''
+    end
+
+    def to_s
+      raw_read(actual_locale)  
+    end
+
+    def to_str(locale = nil)
+      locale ||= actual_locale
+      raw_read(locale)
+    end
+
+    def update(value)
+      if value.is_a?(Hash)
+        clear
+        value.each{|k, v| write(k, v)}
+      elsif value.is_a?(String)
+        write(actual_locale, value)
+      end
+      flush!
+    end
+
+    def [](locale)
+      read(locale)
+    end
+
+    def []=(locale, value)
+      write(locale, value)
+      flush!
+    end
+
+    def locales
+      @translations.keys.map(&:to_sym)
+    end
+
+    def empty?
+      @translations.empty?
+    end
+
+    private
+
+    def actual_locale
+      I18n.locale
+    end
+
+    def write(locale, value)
+      @translations[locale.to_s] = value
+    end
+
+    def read(locale)
+      MultilangTranslationProxy.new(self, locale)
+    end
+
+    def raw_read(locale)
+      @translations[locale.to_s] || ''
+    end
+
+    def clear
+      @translations.clear
+    end
+
+    def load!
+      data = @model[@attribute]
+      data = data.blank? ? nil : data
+      @translations = data.is_a?(Hash) ? data : {}
+    end
+
+    def flush!
+      @model[@attribute] = @translations
+    end
+
+  end
+end 

data/lib/multilang-hstore/translation_proxy.rb

@@ -0,0 +1,22 @@
+module Multilang
+  class MultilangTranslationProxy < String
+    attr_reader :multilang_keeper
+
+    def initialize(multi_keeper, locale)
+      @multilang_keeper = multi_keeper
+      super(@multilang_keeper.to_str(locale))
+    end
+
+    def translation
+      @multilang_keeper
+    end
+
+    def to_s
+      String.new(self)
+    end
+
+    def any
+      @multilang_keeper.current_or_any_value
+    end
+  end
+end

data/lib/multilang-hstore/version.rb

@@ -0,0 +1,3 @@
+module Multilang
+  VERSION = "0.1"
+end

data/lib/multilang-hstore.rb

@@ -0,0 +1,7 @@
+require 'multilang-hstore/version'
+require 'multilang-hstore/translation_proxy'
+require 'multilang-hstore/translation_keeper'
+require 'multilang-hstore/active_record_extensions'
+
+module Multilang
+end

data/spec/multilang_spec.rb

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+$KCODE = "U"
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Multilang do
+  before :each do
+    setup_db
+    I18n.locale = :lv
+  end
+
+  after :each do
+    teardown_db
+  end
+
+  it "should test database connection" do
+    AbstractPost.create
+    AbstractPost.count.should == 1
+  end
+
+  it "should add getters/setters in RegularPost" do
+    regular_post = RegularPost.new
+    %w(title body).each do |attr|
+      regular_post.should respond_to(attr)
+      regular_post.should respond_to("#{attr}=")
+      I18n.available_locales.each do |loc|
+        regular_post.should respond_to("#{attr}_#{loc}")
+        regular_post.should respond_to("#{attr}_#{loc}=")
+      end
+    end
+  end
+
+  it "should set attributes in RegularPost" do
+    rp = RegularPost.new
+
+    # set
+    rp.title = "Latviešu nosaukums"
+    rp.body = "Latviešu apraksts"
+    I18n.locale = :ru
+    rp.title = "Русский заголовок"
+    rp.body = "Русский текст"
+    
+    # test
+    I18n.locale = :lv
+    rp.title.should == "Latviešu nosaukums"
+    rp.body.should == "Latviešu apraksts"
+    
+    I18n.locale = :ru
+    rp.title.should == "Русский заголовок"
+    rp.body.should == "Русский текст"
+  end
+
+  it "should set attributes through alternative setters in RegularPost" do
+    rp = RegularPost.new
+
+    # set
+    rp.title_lv = "Latviešu nosaukums"
+    rp.body_lv = "Latviešu apraksts"
+    rp.title_ru = "Русский заголовок"
+    rp.body_ru = "Русский текст"
+    
+    # test
+    rp.title_lv.should == "Latviešu nosaukums"
+    rp.body_lv.should == "Latviešu apraksts"
+    rp.title_ru.should == "Русский заголовок"
+    rp.body_ru.should == "Русский текст"
+
+    I18n.locale = :lv
+    rp.title.should == "Latviešu nosaukums"
+    rp.body.should == "Latviešu apraksts"
+    
+    I18n.locale = :ru
+    rp.title.should == "Русский заголовок"
+    rp.body.should == "Русский текст"
+  end
+
+  it "should set attributes through fullset hash in RegularPost" do
+    rp = RegularPost.new
+
+    # set
+    rp.title = {:lv => "Latviešu nosaukums", :ru => "Русский заголовок"}
+    rp.body = {:lv => "Latviešu apraksts", :ru => "Русский текст"}
+    
+    # test
+    rp.title_lv.should == "Latviešu nosaukums"
+    rp.body_lv.should == "Latviešu apraksts"
+    rp.title_ru.should == "Русский заголовок"
+    rp.body_ru.should == "Русский текст"
+  end
+
+  it "should set attributes through halfset hash in RegularPost" do
+    rp = RegularPost.new
+
+    # set
+    rp.title = {:lv => "Latviešu nosaukums"}
+    rp.body = {:lv => "Latviešu apraksts"}
+    
+    # test
+    rp.title_lv.should == "Latviešu nosaukums"
+    rp.body_lv.should == "Latviešu apraksts"
+    rp.title_ru.should == ""
+    rp.body_ru.should == ""
+  end
+  
+  it "should be validated in RegularPost" do
+    rp = RegularPost.new
+   
+    rp.title = "Latviešu nosaukums"
+    rp.body = "Latviešu apraksts"
+    I18n.locale = :ru
+    rp.title = "Русский заголовок"
+    rp.body = "Русский текст"
+
+    rp.should be_valid
+  end
+
+  it "should not be validated in RegularPost" do
+    rp = RegularPost.new
+    
+    rp.title_lv = "Latviešu nosaukums"*100  #too long
+    rp.body_lv = "" #empty
+    rp.title_ru = "" #empty
+    rp.body_ru = "Русский текст"*1000 #too long
+
+    rp.valid?
+    
+    rp.should have(4).errors
+  end
+
+  it "should mass assign attributes in RegularPost" do
+    rp = RegularPost.new( :title_lv => "Latviešu nosaukums",
+                          :title_ru => "Русский заголовок",
+                          :body_lv => "Latviešu apraksts",
+                          :body_ru => "Русский текст" )
+  
+    # test
+    rp.title_lv.should == "Latviešu nosaukums"
+    rp.body_lv.should == "Latviešu apraksts"
+    rp.title_ru.should == "Русский заголовок"
+    rp.body_ru.should == "Русский текст"
+  end
+
+  it "should not mass assign attributes in ProtectedPost" do
+    rp = ProtectedPost.new( :title_lv => "Latviešu nosaukums",
+                            :title_ru => "Русский заголовок",
+                            :body_lv => "Latviešu apraksts",
+                            :body_ru => "Русский текст" )
+    
+    # test
+    rp.title_lv.should_not == "Latviešu nosaukums"
+    rp.body_lv.should_not == "Latviešu apraksts"
+    rp.title_ru.should_not == "Русский заголовок"
+    rp.body_ru.should_not == "Русский текст"
+  end
+
+  
+  it "should mass assign attributes in RegulularPost, v2" do
+    rp = RegularPost.new( { :title => {
+                              :lv => "Latviešu nosaukums",
+                              :ru => "Русский заголовок"
+                            },
+                            :body => {:lv => "Latviešu apraksts",
+                              :ru => "Русский текст"
+                            }
+                          } )
+    
+    # test
+    rp.title_lv.should == "Latviešu nosaukums"
+    rp.body_lv.should == "Latviešu apraksts"
+    rp.title_ru.should == "Русский заголовок"
+    rp.body_ru.should == "Русский текст"
+  end
+
+  it "should not not mass assign attributes in ProtectedPost, v2" do
+    rp = ProtectedPost.new( { :title => {
+                                :lv => "Latviešu nosaukums",
+                                :ru => "Русский заголовок"
+                              },
+                              :body => {:lv => "Latviešu apraksts",
+                                :ru => "Русский текст"
+                              }
+                            } )
+    
+    # test
+    rp.title_lv.should_not == "Latviešu nosaukums"
+    rp.body_lv.should_not == "Latviešu apraksts"
+    rp.title_ru.should_not == "Русский заголовок"
+    rp.body_ru.should_not == "Русский текст"
+  end
+
+  it "should save/load attributes in RegularPost" do
+    rp = RegularPost.new( :title_lv => "Latviešu nosaukums",
+                          :title_ru => "Русский заголовок",
+                          :body_lv => "Latviešu apraksts",
+                          :body_ru => "Русский текст" )
+
+    rp.save
+
+    rp = RegularPost.last
+   
+    rp.title_lv.should == "Latviešu nosaukums"
+    rp.body_lv.should == "Latviešu apraksts"
+    rp.title_ru.should == "Русский заголовок"
+    rp.body_ru.should == "Русский текст"
+  end
+
+  it "should save attributes in db as indexable values" do
+    rp = RegularPost.new( :title_lv => "Latviešu nosaukums",
+                          :title_ru => "Русский заголовок",
+                          :body_lv => "Latviešu apraksts",
+                          :body_ru => "Русский текст" )
+
+    rp.save
+
+    rp = RegularPost.last
+
+    rp.title_before_type_cast.should == {"lv"=>"Latviešu nosaukums", "ru"=>"Русский заголовок"}
+    rp.body_before_type_cast.should == {"lv"=>"Latviešu apraksts", "ru"=>"Русский текст"}
+  end
+
+  it "should return proxied attribute" do
+    rp = RegularPost.new( :title_lv => "Latviešu nosaukums",
+                          :title_ru => "Русский заголовок",
+                          :body_lv => "Latviešu apraksts",
+                          :body_ru => "Русский текст" )
+
+
+    rp.title.should be_an_instance_of(Multilang::MultilangTranslationProxy)
+    rp.title.should be_a_kind_of(String)
+    
+    rp.body.should respond_to(:translation)
+    rp.title.translation[:lv].should == "Latviešu nosaukums"
+    rp.body.translation[:ru].should == "Русский текст"
+
+    rp.title.to_s.should be_an_instance_of(String)
+  end
+
+  it "should set/get some attributes in/from PartialrPost" do
+    rp = RegularPost.new
+
+    # set
+    rp.title = "Latviešu nosaukums"
+    rp.body = "Latviešu apraksts"
+    
+    # test
+    I18n.locale = :lv
+    rp.title.should == "Latviešu nosaukums"
+    rp.body.should == "Latviešu apraksts"
+    
+    I18n.locale = :ru
+    rp.title.should == ""
+    rp.body.should == ""
+
+    rp.title.any.should == "Latviešu nosaukums"
+    rp.body.any.should == "Latviešu apraksts"
+    
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :abstract_posts do |t|
+    t.hstore :title
+    t.hstore :body
+    t.integer :void, :default => 1
+  end
+
+  #create_table :posts do |t|
+  #  t.text :title
+  #  t.text :body
+  #  t.integer :void, :default => 1
+  #end
+
+  #create_table :pages do |t|
+  #  t.text :title
+  #  t.text :body
+  #  t.integer :void, :default => 1
+  #end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,63 @@
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'active_support'
+require 'active_record'
+require 'activerecord-postgres-hstore/activerecord'
+require 'activerecord-postgres-hstore/coder'
+require 'activerecord-postgres-hstore/hash'
+require 'activerecord-postgres-hstore/string'
+require 'multilang-hstore'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new(nil)
+ActiveRecord::Base.establish_connection(:adapter => "postgresql", :database => "multilang-hstore-test", :host=>'127.0.0.1', :user=>'postgres')
+
+I18n.available_locales = [:lv, :ru]
+I18n.locale = I18n.default_locale = :lv
+
+def setup_db
+  ActiveRecord::Migration.verbose = false
+  load "schema.rb"
+end
+
+def teardown_db
+  ActiveRecord::Base.connection.tables.each do |table|
+    ActiveRecord::Base.connection.drop_table(table)
+  end
+end
+
+#testable models
+class AbstractPost < ActiveRecord::Base
+  serialize :title, ActiveRecord::Coders::Hstore
+  serialize :body, ActiveRecord::Coders::Hstore
+end
+
+class MinimalPost < ActiveRecord::Base
+  self.table_name = 'abstract_posts'
+  multilang :title, :required => false,  :accessible => true
+  multilang :body,  :required => false, :accessible => true
+  attr_accessible :void
+end
+
+class RegularPost < ActiveRecord::Base
+  self.table_name = 'abstract_posts'
+  multilang :title, :required => true, :length => 25,   :accessible => true
+  multilang :body,  :required => true, :length => 1000, :accessible => true
+  attr_accessible :void
+end
+
+class ProtectedPost < ActiveRecord::Base
+  self.table_name = 'abstract_posts'
+  multilang :title, :accessible => false
+  multilang :body,  :accessible => false
+  attr_accessible :void
+end
+
+class PartialPost < ActiveRecord::Base
+  self.table_name = 'abstract_posts'
+  multilang :title
+  multilang :body
+  attr_accessible :void
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: multilang-hstore
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Arthur Meinart
+- Firebase.co
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-29 00:00:00.000000000 Z
+dependencies: []
+description: Model translations for Rails 3 backed by PostgreSQL and Hstore
+email: hello@firebase.co
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- lib/multilang-hstore.rb
+- lib/multilang-hstore/active_record_extensions.rb
+- lib/multilang-hstore/translation_keeper.rb
+- lib/multilang-hstore/translation_proxy.rb
+- lib/multilang-hstore/version.rb
+- README.rdoc
+- spec/multilang_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+homepage: http://github.com/firebaseco/multilang-hstore
+licenses: []
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Model translations for Rails 3 backed by PostgreSQL and Hstore
+test_files:
+- spec/multilang_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+has_rdoc: