activerecord_translatable 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a2305935744b3ad79c98ae02f539b3f46233727
-  data.tar.gz: 7da5ed33858f314a7721bc663dd3b09cb352a21d
+  metadata.gz: 718f885dad1df1a6ef66c4e00661c60ce7853238
+  data.tar.gz: 86226beac98c3c53e76ae0417470750a5370ce35
 SHA512:
-  metadata.gz: a386b24a17d2bfbb1b910fc0cbbffeccbc5488105a29b14de5ec2e192efbb1ddd6784b302076e4b08835d2c90cabc4001b1717e63dfd882404cf3f5330ea2477
-  data.tar.gz: e197e4a95c6efc56019718391de3e0877b7cea89fe7e0ad0416339aa41189941584e3276c81bf940fc9352c84cfcc7b39c98e73cf2dd1faf9f502f141a57b8b0
+  metadata.gz: d715d08d519140dd0cdded92914c3301fc03fa05aded68221bbc2e6c9bd43bda22e2ae9f9cb4b45d5512ef042f2347bfa7f7dcfb10af950bc9c7596f0f7abf52
+  data.tar.gz: c03b5a00ac340ddd8f111fdb959a07d68e204a4a2d1098795f220f696c230334ae2b974b9138815eec4bb94096b553a09c5607a572a189d225ab21e1f8ff7d94

data/README.rdoc

@@ -6,7 +6,16 @@ Make attributes of an ActiveRecord Model translatable, and store the
 translations in the provided I18n backend.  This is really helpful if there
 already is, a interface to provide ie missing translations for elements in I18n.
 
+== Install
+
+Add
+
+  gem "activerecord_translatable"
+
+to your gemfile, this should work for rails 3 and above.
+
 == Usage
+
 Use inside of the model
 
   class MyModel < ActiveRecord::Base
@@ -22,40 +31,47 @@ Use inside of the model
   mymodel.title_wk # => "Woohhaakkk"
 
 == Prerequisites
+
 To save the locales ActiveRecordTranslatable saves an array of the specified locale, for
-this to work, the database needs the ability to save arrays. The easiest way to
-handle this in postgres is via the postgres array
+this to work, the database needs the ability to save arrays.  The easiest way to
+handle this is to use ActiveRecords ability to serialize.
 
-gem 'activerecord-postgres-array'
+  class MyModel < ActiveRecord::Base
+    serialize :locales
+    translate :name
+  end
 
-To add the array to the model the migration looks like this
+And add the column as a string
 
   class CreateMyModel < ActiveRecord::Migration
     def change
       create_table :my_model do |t|
-        t.string_array :locales
+        t.string :locales
       end
     end
   end
 
-If your database does not support native array types you can use ActiveRecords
-ability to serialize the locales array
+If you are using postgres you can also use the native postgres array
 
-  class MyModel < ActiveRecord::Base
-    serialize :locales
-    translate :name
-  end
+  gem 'activerecord-postgres-array'
 
-And add the column as a string
+To add the array to the model the migration looks like this
 
   class CreateMyModel < ActiveRecord::Migration
     def change
       create_table :my_model do |t|
-        t.string :locales
+        t.string_array :locales
       end
     end
   end
 
+And the model does not need to know anything about this
+
+  class MyModel < ActiveRecord::Base
+    translate :name
+  end
+
+
 == How it works
 
 Translateable saves the translation via I18n.backend.store_translations, this
@@ -63,31 +79,14 @@ means that the backend has to be able to store new items. So backend needs to
 be for example the KeyValue or ActiveRecord one.
 More http://railscasts.com/episodes/256-i18n-backends
 
-== Miscellaneous
-
-=== Tests
-The tests are using rspec, and there is a dummy app setup in the spec directory.
-Since the example is using postgres, to get the tests working there needs to be
-a setup postgres user with the needed rights.
-
-  $ createuser -h localhost
-  Enter name of role to add: translatable
-  Shall the new role be a superuser? (y/n) n
-  Shall the new role be allowed to create databases? (y/n) y
-  Shall the new role be allowed to create more new roles? (y/n) n
-
-Afterwards the db needs to be setup
+== Tests
 
-  $ cd spec/dummy
-  $ rake db:create
-  $ rake db:migrate
-  $ rake db:test:prepare
+The tests are using rspec and an im memory sqlite database, so all that is needed is to run
 
-Now the test can be run via
+  $ rake spec
 
-  $ rspec
+== Current State
 
-=== Current State
-The gem is still in early development and has just been extracted from a
-project. So any bug reports and contributions are highly welcome.
+This has been extracted form an Rails application so it should be pretty stable
+by now. Any contributions and fixes are of course highly welcome!
 

data/Rakefile

@@ -1,19 +1,15 @@
-#!/usr/bin/env rake
 begin
   require 'bundler/setup'
 rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
-begin
-  require 'rdoc/task'
-  require 'rspec/core/rake_task'
-rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
-  RDoc::Task = Rake::RDocTask
-end
 
-RDoc::Task.new(:rdoc) do |rdoc|
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+
+require "rake/clean"
+
+RDoc::Task.new do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = 'Translatable'
   rdoc.options << '--line-numbers'
@@ -24,15 +20,9 @@ end
 Bundler::GemHelper.install_tasks
 
 desc 'Default: run the specs'
-task :default => 'spec:unit' 
+task :default => :spec
 
-namespace :spec do
-  desc "Run unit specs"
-  RSpec::Core::RakeTask.new('unit') do |t|
-    t.pattern = 'spec/{*_spec.rb}'
-  end
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/{*_spec.rb}'
 end
 
-desc "Run the unit specs"
-task :spec => ['spec:unit']
-

data/lib/activerecord_translatable.rb

@@ -1,26 +1,19 @@
 require "active_record"
 require "active_support/concern"
-require "rails"
 require "activerecord_translatable/extension"
 
 module ActiveRecordTranslatable
+  begin
+    require "rails"
 
-  class Railtie < Rails::Railtie
-    initializer "activerecord_translatable.load_into_active_record" do
-      ActiveSupport.on_load :active_record do
-        ActiveRecordTranslatable::Railtie.load
-      end
-    end
-  end
-
-  class Railtie
-    class << self
-      def load
-        if defined?(ActiveRecord)
+    class Railtie < Rails::Railtie
+      initializer "activerecord_translatable.load_into_active_record" do
+        ActiveSupport.on_load :active_record do
           ActiveRecord::Base.send(:include, ActiveRecordTranslatable)
         end
       end
     end
+  rescue LoadError
+    ActiveRecord::Base.send(:include, ActiveRecordTranslatable) if defined?(ActiveRecord)
   end
-
 end

data/lib/activerecord_translatable/extension.rb

@@ -7,7 +7,7 @@ module ActiveRecordTranslatable
   # Saving and loading translations works by using +<attribute>_<local>+ to
   # read and write the attribute
   #
-  #   class Thing
+  #   class Thing < ActiveRecord::Base
   #     translate :name
   #   end
   #

data/lib/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecordTranslatable
 
-  VERSION = "0.0.9" # :nodoc:
+  VERSION = "0.1.0" # :nodoc:
 
 end

data/spec/activerecord_translateable_spec.rb

@@ -1,124 +1,133 @@
 require 'spec_helper'
 
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+ActiveRecord::Schema.verbose = false
+
+def setup_db
+  ActiveRecord::Base.connection.create_table :somethings do |t|
+    t.string :locales
+  end
+
+  ActiveRecord::Base.connection.create_table :foos do |t|
+  end
+end
+
+class Something < ActiveRecord::Base
+  serialize :locales
+  translate :name
+end
+
+class Foo < ActiveRecord::Base
+end
+
 describe "ActiveRecordTranslateable" do
+  before(:all) { setup_db }
+
+  it "makes name translateable" do
+    Something.class_eval { translate :foo }
+    Something.translatable.should include(:foo)
+  end
+
+  context "class without translations" do
+    it "saves" do
+      foo = Foo.new
+      foo.save.should be_true
+    end
+    it "loads" do
+      foo = Foo.create!
+      Foo.find(foo.id).should_not be_nil
+    end
+  end
+
+  context "custom created methods" do
+    it "responds to translated attributes" do
+      something = Something.new
+      something.should respond_to(:name)
+      something.should respond_to(:name=)
+      something.should respond_to(:name_de)
+      something.should respond_to(:name_de=)
+    end
+  end
+
+  context "attributes" do
+    before(:each) do
+      @locale = I18n.locale
+    end
+
+    after(:each) do
+      I18n.locale = @locale
+    end
+
+    it "read/writes by hash assignment" do
+      something = Something.new(name: "Something", name_de: "Etwas")
+      something.name.should == "Something"
+      something.name_de.should == "Etwas"
+    end
+
+    it "read/writes from database" do
+      something = Something.create!(name: "Something", name_de: "Etwas")
+      something.reload
+      something.name.should == "Something"
+      something.name_de.should == "Etwas"
+    end
+
+    it "reads by locale" do
+      something = Something.create!(name_de: "Etwas")
+      I18n.locale = :de
+      something.name.should == "Etwas"
+    end
+
+    it "writes by locale" do
+      I18n.locale = :de
+      something = Something.create!(name: "Etwas", name_en: "Something")
+      I18n.locale = :en
+      something.name_de.should == "Etwas"
+      something.name.should == "Something"
+    end
+  end
+
+  context "store translations" do
+    let(:something) { Something.create(name: "Something") }
+
+    it "writes stored translations to the backend" do
+      i18n_key = "something.name-#{something.id}"
+      backend = double("Backend")
+      I18n.stub(:backend).and_return(backend)
+      backend.should_receive(:store_translations)
+      .with(:en, { i18n_key => "Something" }, escape: false)
+      something.save
+    end
+
+    it "should save the model without translations" do
+      something = Something.new
+      something.save.should be_true
+    end
+
+    it "should not include a read locale unless set to something" do
+      something.name_gr
+      something.locales.should_not include("gr")
+    end
+  end
+
+  context "translation store" do
+    before(:each) do
+      @backend = double("Backend")
+      I18n.stub(:backend).and_return(@backend)
+    end
+    it "is called on save" do
+      @backend.should_receive(:store_translations).twice
+      Something.new(name: 'something', name_de: 'etwas').save
+    end
+
+    it "is called on create" do
+      @backend.should_receive(:store_translations).twice
+      Something.create(name: 'something', name_de: 'etwas')
+    end
 
-    it "makes name translateable" do
-      Something.class_eval { translate :foo }
-      Something.translatable.should include(:foo)
-    end
-
-    context "class without translations" do
-      it "saves" do
-        foo = Foo.new
-        foo.save.should be_true
-      end
-      it "loads" do
-        foo = Foo.create!
-        Foo.find(foo.id).should_not be_nil
-      end
-    end
-
-    context "custom created methods" do
-      it "responds to translated attributes" do
-        something = Something.new
-        something.should respond_to(:name)
-        something.should respond_to(:name=)
-        something.should respond_to(:name_de)
-        something.should respond_to(:name_de=)
-      end
-    end
-
-    context "attributes" do
-      before(:each) do
-        @locale = I18n.locale
-      end
-
-      after(:each) do
-        I18n.locale = @locale
-      end
-
-      it "read/writes by hash assignment" do
-        something = Something.new(name: "Something", name_de: "Etwas")
-        something.name.should == "Something"
-        something.name_de.should == "Etwas"
-      end
-
-      it "read/writes from database" do
-        something = Something.create!(name: "Something", name_de: "Etwas")
-        something.reload
-        something.name.should == "Something"
-        something.name_de.should == "Etwas"
-      end
-
-      it "reads by locale" do
-        something = Something.create!(name_de: "Etwas")
-        I18n.locale = :de
-        something.name.should == "Etwas"
-      end
-
-      it "writes by locale" do
-        I18n.locale = :de
-        something = Something.create!(name: "Etwas", name_en: "Something")
-        I18n.locale = :en
-        something.name_de.should == "Etwas"
-        something.name.should == "Something"
-      end
-    end
-
-    context "store translations" do
-      let(:something) { Something.create(name: "Something") }
-
-      it "writes stored translations to the backend" do
-        i18n_key = "something.name-#{something.id}"
-        backend = double("Backend")
-        I18n.stub(:backend).and_return(backend)
-        backend.should_receive(:store_translations)
-               .with(:en, { i18n_key => "Something" }, escape: false)
-        something.save
-      end
-
-      it "should save the model without translations" do
-        something = Something.new
-        something.save.should be_true
-      end
-
-      it "should not include a read locale unless set to something" do
-        something.name_gr
-        something.locales.should_not include("gr")
-      end
-    end
-
-    context "translation store" do
-      before(:each) do
-        @backend = double("Backend")
-        I18n.stub(:backend).and_return(@backend)
-      end
-      it "is called on save" do
-        @backend.should_receive(:store_translations).twice
-        Something.new(name: 'something', name_de: 'etwas').save
-      end
-
-      it "is called on create" do
-        @backend.should_receive(:store_translations).twice
-        Something.create(name: 'something', name_de: 'etwas')
-      end
-
-      it "is called on update" do
-        @backend.should_receive(:store_translations).exactly(4)
-        sth = Something.create(name: 'something_old', name_de: 'etwas_old')
-        sth.update_attributes(name: 'something', name_de: 'etwas')
-      end
-    end
-
-    context "db array support" do
-      it "works with native support" do
-        something = Something.create!(name: "Something", name_de: "Etwas")
-        something.reload.available_locales.should include(:en, :de)
-      end
-
-      it "works with serialize" do
-        thing = Noarraything.create!(name: "thing", name_de: "ding")
-        thing.reload.available_locales.should include(:en, :de)
-      end
+    it "is called on update" do
+      @backend.should_receive(:store_translations).exactly(4)
+      sth = Something.create(name: 'something_old', name_de: 'etwas_old')
+      sth.update_attributes(name: 'something', name_de: 'etwas')
     end
+  end
 end