copycopter_client 1.0.0.beta6 → 1.0.0.beta7

data/features/rails.feature

@@ -264,7 +264,6 @@ Feature: Using copycopter in a rails app
       | key                        | draft content  |
       | user.attributes.name.blank | can't be blank |
 
-
   Scenario: ensure keys are synced with short lived processes
     When I configure the copycopter client to have a polling delay of 86400 seconds
     And I start the application
@@ -273,3 +272,28 @@ Feature: Using copycopter in a rails app
       | key             | draft content |
       | en.threaded.key | all your base |
 
+  Scenario: support pluralization
+    When I write to "app/controllers/users_controller.rb" with:
+    """
+    class UsersController < ActionController::Base
+      def index
+        render
+      end
+    end
+    """
+    When I route the "users" resource
+    And I write to "app/views/users/index.html.erb" with:
+    """
+    <%= time_ago_in_words(1.hour.ago) %> ago
+    <%= time_ago_in_words(2.hours.ago) %> ago
+    """
+    When I start the application
+    And I visit /users/
+    Then the response should contain "1 hour ago"
+    And the response should contain "2 hours ago"
+    When I wait for changes to be synchronized
+    Then the "abc123" project should have the following blurbs:
+      | key                                               | draft content        |
+      | en.datetime.distance_in_words.about_x_hours.one   | about 1 hour         |
+      | en.datetime.distance_in_words.about_x_hours.other | about %{count} hours |
+

data/lib/copycopter_client/configuration.rb

@@ -13,7 +13,7 @@ module CopycopterClient
         :http_open_timeout, :http_read_timeout, :client_name, :client_url,
         :client_version, :port, :protocol, :proxy_host, :proxy_pass,
         :proxy_port, :proxy_user, :secure, :polling_delay, :logger,
-        :framework, :fallback_backend].freeze
+        :framework].freeze
 
     # @return [String] The API key for your project, found on the project edit form.
     attr_accessor :api_key
@@ -72,9 +72,6 @@ module CopycopterClient
     # @return [Logger] Where to log messages. Must respond to same interface as Logger.
     attr_reader :logger
 
-    # @return [I18n::Backend::Base] where to look for translations missing on the Copycopter server
-    attr_accessor :fallback_backend
-
     alias_method :secure?, :secure
 
     # Instantiated from {CopycopterClient.configure}. Sets defaults.
@@ -147,7 +144,7 @@ module CopycopterClient
     def apply
       client = Client.new(to_hash)
       sync = Sync.new(client, to_hash)
-      I18n.backend = I18nBackend.new(sync, to_hash)
+      I18n.backend = I18nBackend.new(sync)
       CopycopterClient.client = client
       CopycopterClient.sync = sync
       @applied = true

data/lib/copycopter_client/i18n_backend.rb

@@ -1,54 +1,29 @@
 require 'i18n'
 
 module CopycopterClient
-  # I81n implementation designed to synchronize with Copycopter.
+  # I18n implementation designed to synchronize with Copycopter.
   #
   # Expects an object that acts like a Hash, responding to +[]+, +[]=+, and +keys+.
   #
-  # This backend will be used as the default I81n backend when the client is
+  # This backend will be used as the default I18n backend when the client is
   # configured, so you will not need to instantiate this class from the
-  # application. Instead, just use methods on the I81n class.
+  # application. Instead, just use methods on the I18n class.
   #
-  # If a fallback backend is provided, keys available in the fallback backend
-  # will be used as defaults when those keys aren't available on the Copycopter
-  # server.
+  # This implementation will also load translations from locale files.
   class I18nBackend
-    include I18n::Backend::Base
-
-    # These keys aren't used in interpolation
-    RESERVED_KEYS = [:scope, :default, :separator, :resolve, :object,
-      :fallback, :format, :cascade, :raise, :rescue_format].freeze
+    include I18n::Backend::Simple::Implementation
 
     # Usually instantiated when {Configuration#apply} is invoked.
     # @param sync [Sync] must act like a hash, returning and accept blurbs by key.
-    # @param options [Hash]
-    # @option options [I18n::Backend::Base] :fallback_backend I18n backend where missing translations can be found
-    def initialize(sync, options)
-      @sync     = sync
-      @base_url = URI.parse("#{options[:protocol]}://#{options[:host]}:#{options[:port]}")
-      @fallback = options[:fallback_backend]
+    def initialize(sync)
+      @sync = sync
     end
 
-    # This is invoked by frameworks when locales should be loaded. The
-    # Copycopter client loads content in the background, so this method waits
-    # until the first download is complete.
-    def reload!
-      sync.wait_for_download
-    end
-
-    # Translates the given local and key. See the I81n API documentation for details.
-    #
-    # Because the Copycopter API only supports copy text and doesn't support
-    # nested structures or arrays, the fallback value will be returned without
-    # using the Copycopter API if that value doesn't respond to to_str.
+    # Translates the given local and key. See the I18n API documentation for details.
     #
     # @return [Object] the translated key (usually a String)
     def translate(locale, key, options = {})
-      fallback_value = fallback(locale, key, options)
-      return fallback_value if fallback_value && !fallback_value.respond_to?(:to_str)
-
-      default = fallback_value || options.delete(:default)
-      content = super(locale, key, options.update(:default => default, :fallback => true))
+      content = super(locale, key, options.merge(:fallback => true))
       if content.respond_to?(:html_safe)
         content.html_safe
       else
@@ -59,32 +34,47 @@ module CopycopterClient
     # Returns locales availabile for this Copycopter project.
     # @return [Array<String>] available locales
     def available_locales
-      sync.keys.map { |key| key.split('.').first }.uniq
+      sync_locales = sync.keys.map { |key| key.split('.').first }
+      (sync_locales + super).uniq.map { |locale| locale.to_sym }
+    end
+
+    # Stores the given translations.
+    #
+    # Updates will be visible in the current process immediately, and will
+    # propagate to Copycopter during the next sync.
+    #
+    # @param [String] locale the locale (ie "en") to store translations for
+    # @param [Hash] data nested key-value pairs to be added as blurbs
+    # @param [Hash] options unused part of the I18n API
+    def store_translations(locale, data, options = {})
+      super
+      store_item(locale, data)
     end
 
     private
 
     def lookup(locale, key, scope = [], options = {})
       parts = I18n.normalize_keys(locale, key, scope, options[:separator])
-      key = parts.join('.')
-      content = sync[key]
-      sync[key] = "" if content.nil?
+      key_with_locale = parts.join('.')
+      content = sync[key_with_locale] || super
+      sync[key_with_locale] = "" if content.nil?
       content
     end
 
-    attr_reader :sync
-
-    def fallback(locale, key, options)
-      if @fallback
-        fallback_options = options.dup
-        (fallback_options.keys - RESERVED_KEYS).each do |interpolated_key|
-          fallback_options[interpolated_key] = "%{#{interpolated_key}}"
+    def store_item(locale, data, scope = [])
+      if data.respond_to?(:to_hash)
+        data.to_hash.each do |key, value|
+          store_item(locale, value, scope + [key])
         end
-
-        @fallback.translate(locale, key, fallback_options)
+      elsif data.respond_to?(:to_str)
+        key = ([locale] + scope).join('.')
+        sync[key] = data.to_str
       end
-    rescue I18n::MissingTranslationData
-      nil
+    end
+
+    def load_translations(*filenames)
+      super
+      sync.wait_for_download
     end
 
     def default(locale, object, subject, options = {})
@@ -96,5 +86,7 @@ module CopycopterClient
       end
       content
     end
+
+    attr_reader :sync
   end
 end

data/lib/copycopter_client/rails.rb

@@ -17,7 +17,6 @@ module CopycopterClient
         config.environment_name = ::Rails.env
         config.logger           = ::Rails.logger
         config.framework        = "Rails: #{::Rails::VERSION::STRING}"
-        config.fallback_backend = I18n.backend
       end
     end
   end

data/lib/copycopter_client/version.rb

@@ -1,6 +1,6 @@
 module CopycopterClient
   # Client version
-  VERSION = "1.0.0.beta6"
+  VERSION = "1.0.0.beta7"
 
   # API version being used to communicate with the server
   API_VERSION = "2.0"

data/spec/copycopter_client/configuration_spec.rb

@@ -42,7 +42,6 @@ describe CopycopterClient::Configuration do
   it { should have_config_option(:api_key).                 overridable }
   it { should have_config_option(:polling_delay).           overridable.default(300) }
   it { should have_config_option(:framework).               overridable }
-  it { should have_config_option(:fallback_backend).        overridable }
 
   it "should provide default values for secure connections" do
     config = CopycopterClient::Configuration.new
@@ -72,7 +71,7 @@ describe CopycopterClient::Configuration do
     [:api_key, :environment_name, :host, :http_open_timeout,
       :http_read_timeout, :client_name, :client_url, :client_version, :port,
       :protocol, :proxy_host, :proxy_pass, :proxy_port, :proxy_user, :secure,
-      :development_environments, :logger, :framework, :fallback_backend].each do |option|
+      :development_environments, :logger, :framework].each do |option|
       hash[option].should == config[option]
     end
     hash[:public].should == config.public?
@@ -203,7 +202,7 @@ share_examples_for "applied configuration" do
   it "builds and assigns an I18n backend" do
     CopycopterClient::Client.should have_received(:new).with(subject.to_hash)
     CopycopterClient::Sync.should have_received(:new).with(client, subject.to_hash)
-    CopycopterClient::I18nBackend.should have_received(:new).with(sync, subject.to_hash)
+    CopycopterClient::I18nBackend.should have_received(:new).with(sync)
     I18n.backend.should == backend
   end
 

data/spec/copycopter_client/i18n_backend_spec.rb

@@ -3,24 +3,28 @@ require 'spec_helper'
 describe CopycopterClient::I18nBackend do
   let(:sync) { {} }
 
-  def build_backend(config = {})
-    default_config = CopycopterClient::Configuration.new.to_hash
-    backend = CopycopterClient::I18nBackend.new(sync, default_config.update(config))
+  def build_backend
+    backend = CopycopterClient::I18nBackend.new(sync)
     I18n.backend = backend
     backend
   end
 
-  before { @default_backend = I18n.backend }
+  before do
+    @default_backend = I18n.backend
+    sync.stubs(:wait_for_download)
+  end
+
   after { I18n.backend = @default_backend }
 
   subject { build_backend }
 
-  it "waits until the first download when reloaded" do
-    sync.stubs(:wait_for_download)
-
+  it "reloads locale files and waits for the sync to complete" do
+    I18n.stubs(:load_path => [])
     subject.reload!
+    subject.translate('en', 'test.key', :default => 'something')
 
     sync.should have_received(:wait_for_download)
+    I18n.should have_received(:load_path)
   end
 
   it "includes the base i18n backend" do
@@ -36,11 +40,14 @@ describe CopycopterClient::I18nBackend do
     backend.translate('en', 'test.key', :scope => 'prefix').should == value
   end
 
-  it "finds available locales" do
+  it "finds available locales from locale files and sync" do
+    YAML.stubs(:load_file => { 'es' => { 'key' => 'value' } })
+    I18n.stubs(:load_path => ["test.yml"])
+
     sync['en.key'] = ''
     sync['fr.key'] = ''
 
-    subject.available_locales.should =~ %w(en fr)
+    subject.available_locales.should =~ [:en, :es, :fr]
   end
 
   it "queues missing keys with default" do
@@ -80,52 +87,51 @@ describe CopycopterClient::I18nBackend do
       should == 'Expected'
   end
 
-  describe "with a fallback" do
-    let(:fallback) { I18n::Backend::Simple.new }
-    subject { build_backend(:fallback_backend => fallback) }
+  describe "with stored translations" do
+    subject { build_backend }
 
-    it "uses the fallback as a default" do
-      fallback.store_translations('en', 'test' => { 'key' => 'Expected' })
+    it "uses stored translations as a default" do
+      subject.store_translations('en', 'test' => { 'key' => 'Expected' })
       subject.translate('en', 'test.key', :default => 'Unexpected').
         should include('Expected')
       sync['en.test.key'].should == 'Expected'
     end
 
-    it "preserves interpolation markers in the fallback" do
-      fallback.store_translations('en', 'test' => { 'key' => '%{interpolate}' })
+    it "preserves interpolation markers in the stored translation" do
+      subject.store_translations('en', 'test' => { 'key' => '%{interpolate}' })
       subject.translate('en', 'test.key', :interpolate => 'interpolated').
         should include('interpolated')
       sync['en.test.key'].should == '%{interpolate}'
     end
 
-    it "uses the default if the fallback doesn't have the key" do
+    it "uses the default if the stored translations don't have the key" do
       subject.translate('en', 'test.key', :default => 'Expected').
         should include('Expected')
     end
 
     it "uses the syncd key when present" do
-      fallback.store_translations('en', 'test' => { 'key' => 'Unexpected' })
+      subject.store_translations('en', 'test' => { 'key' => 'Unexpected' })
       sync['en.test.key'] = 'Expected'
       subject.translate('en', 'test.key', :default => 'default').
         should include('Expected')
     end
 
-    it "returns a hash directly without storing" do
+    it "stores a nested hash" do
       nested = { :nested => 'value' }
-      fallback.store_translations('en', 'key' => nested)
+      subject.store_translations('en', 'key' => nested)
       subject.translate('en', 'key', :default => 'Unexpected').should == nested
-      sync['en.key'].should be_nil
+      sync['en.key.nested'].should == 'value'
     end
 
     it "returns an array directly without storing" do
       array = ['value']
-      fallback.store_translations('en', 'key' => array)
+      subject.store_translations('en', 'key' => array)
       subject.translate('en', 'key', :default => 'Unexpected').should == array
       sync['en.key'].should be_nil
     end
 
     it "looks up an array of defaults" do
-      fallback.store_translations('en', 'key' => { 'one' => 'Expected' })
+      subject.store_translations('en', 'key' => { 'one' => 'Expected' })
       subject.translate('en', 'key.three', :default => [:"key.two", :"key.one"]).
         should include('Expected')
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: copycopter_client
 version: !ruby/object:Gem::Version 
-  hash: 299253590
+  hash: 299253591
   prerelease: true
   segments: 
   - 1
   - 0
   - 0
-  - beta6
-  version: 1.0.0.beta6
+  - beta7
+  version: 1.0.0.beta7
 platform: ruby
 authors: 
 - thoughtbot