mova 0.1.0

data/test/storage/chain_test.rb

@@ -0,0 +1,100 @@
+require "test_helper"
+require "mova/storage/chain"
+
+module Mova
+  class ChainTest < Minitest::Test
+    def storage1
+      @storage1 ||= double("Storage 1")
+    end
+
+    def storage2
+      @storage2 ||= double("Storage 2")
+    end
+
+    def chain
+      @chain ||= Storage::Chain.new(storage1, storage2)
+    end
+
+    def test_read_from_storage1
+      expect(storage1).to receive(:read).with(:hello).and_return("hello")
+      assert_equal "hello", chain.read(:hello)
+    end
+
+    def test_read_from_storage2
+      expect(storage1).to receive(:read).with(:hello).ordered.and_return(nil)
+      expect(storage2).to receive(:read).with(:hello).ordered.and_return("hi")
+      assert_equal "hi", chain.read(:hello)
+    end
+
+    def test_read_from_storage2_when_empty_string_is_returned_from_storage2
+      expect(storage1).to receive(:read).with(:hello).ordered.and_return("")
+      expect(storage2).to receive(:read).with(:hello).ordered.and_return("hi")
+      assert_equal "hi", chain.read(:hello)
+    end
+
+    def test_read_multi_from_storage1_only
+      expected = {"hello" => "world", "foo" => "bar"}
+      expect(storage1).to receive(:read_multi).with("hello", "foo").and_return(expected)
+      assert_equal expected, chain.read_multi("hello", "foo")
+    end
+
+    def test_read_multi_from_storage2_only
+      expected = {"hello" => "world", "foo" => "bar"}
+      expect(storage1).to receive(:read_multi).with("hello", "foo").and_return({})
+      expect(storage2).to receive(:read_multi).with("hello", "foo").and_return(expected)
+      assert_equal expected, chain.read_multi("hello", "foo")
+    end
+
+    def test_read_multi_from_storage1_and_storage2_with_preserved_key_order
+      expected = {"hello" => "world", "foo" => "bar"}
+      expect(storage1).to receive(:read_multi).with("hello", "foo").and_return("hello" => "world")
+      expect(storage2).to receive(:read_multi).with("hello", "foo").and_return("foo" => "bar")
+      result = chain.read_multi("hello", "foo")
+      assert_equal expected, result
+      assert_equal expected.keys, result.keys
+    end
+
+    def test_read_multi_from_second_storage_has_priority_for_non_empty_values
+      expected = {"hello" => "world"}
+      expect(storage1).to receive(:read_multi).with("hello").and_return("hello" => "")
+      expect(storage2).to receive(:read_multi).with("hello").and_return("hello" => "world")
+      assert_equal expected, chain.read_multi("hello")
+    end
+
+    def test_read_multi_doesnt_return_nils
+      expected = {"hello" => "world"}
+      expect(storage1).to receive(:read_multi).with("hello", "foo").and_return("hello" => "world")
+      expect(storage2).to receive(:read_multi).with("hello", "foo").and_return({})
+      assert_equal expected, chain.read_multi("hello", "foo")
+    end
+
+    def test_write
+      expect(storage1).to receive(:write).with("hello", "world")
+      expect(storage2).to receive(:write).with("hello", "world")
+      chain.write("hello", "world")
+    end
+
+    def test_clear
+      expect(storage1).to receive(:clear)
+      expect(storage2).to receive(:clear)
+      chain.clear
+    end
+
+    def test_exist_for_non_existing_value
+      expect(storage1).to receive(:exist?).with("hello").and_return(false)
+      expect(storage2).to receive(:exist?).with("hello").and_return(false)
+      refute chain.exist?("hello")
+    end
+
+    def test_exist_in_first_storage
+      expect(storage1).to receive(:exist?).with("hello").and_return(true)
+      assert chain.exist?("hello")
+    end
+
+    def test_exist_in_second_storage
+      expect(storage1).to receive(:exist?).with("hello").and_return(false)
+      expect(storage2).to receive(:exist?).with("hello").and_return(true)
+      assert chain.exist?("hello")
+    end
+  end
+end

data/test/storage/memory_test.rb

@@ -0,0 +1,52 @@
+require "test_helper"
+require "mova/storage/memory"
+
+module Mova
+  class MemoryTest < Minitest::Test
+    def storage
+      @storage ||= Storage::Memory.new
+    end
+
+    def test_read_for_non_existing_value
+      assert_nil storage.read("hello")
+    end
+
+    def test_read
+      storage.write("hello", "world")
+      assert_equal "world", storage.read("hello")
+    end
+
+    def test_read_multi
+      storage.write("hello", "world")
+      storage.write("foo", "bar")
+      expected = {"hello" => "world", "foo" => "bar"}
+      assert_equal expected, storage.read_multi("hello", "foo")
+    end
+
+    def test_read_multi_doesnt_return_nils
+      storage.write("hello", "world")
+      expected = {"hello" => "world"}
+      assert_equal expected, storage.read_multi("hello", "foo")
+    end
+
+    def test_exist_for_non_existing_value
+      refute storage.exist?("hello")
+    end
+
+    def test_exist
+      storage.write("hello", "world")
+      assert storage.exist?("hello")
+    end
+
+    def test_exist_for_nil_value
+      storage.write("hello", nil)
+      assert storage.exist?("hello")
+    end
+
+    def test_clear
+      storage.write("hello", "world")
+      storage.clear
+      assert_nil storage.read("hello")
+    end
+  end
+end

data/test/storage/readonly_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+require "mova/storage/readonly"
+
+module Mova
+  class ReadonlyTest < Minitest::Test
+    include Test::Doubles
+
+    def readonly
+      @readonly ||= Storage::Readonly.new(storage)
+    end
+
+    def test_read
+      expect(storage).to receive(:read).with("hello").and_return("world")
+      assert_equal "world", readonly.read("hello")
+    end
+
+    def test_read_multi
+      expected = {"hello" => "world"}
+      expect(storage).to receive(:read_multi).with("hello").and_return(expected)
+      assert_equal expected, readonly.read_multi("hello")
+    end
+
+    def test_write
+      assert_nil readonly.write("hello", "world")
+    end
+
+    def test_exist
+      expect(storage).to receive(:exist?).with("hello").and_return(true)
+      assert readonly.exist?("hello")
+    end
+
+    def test_clear
+      assert_nil readonly.clear
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,47 @@
+require "bundler/setup"
+require "mova"
+
+require "minitest"
+Minitest.autorun
+
+require "rspec/mocks"
+
+RSpec::Mocks.configuration.syntax = :expect
+
+module RSpec::Mocks
+  remove_const :MockExpectationError
+  # treat as Minitest failure, not an exception
+  MockExpectationError = Class.new(Minitest::Assertion)
+end
+
+module Mova
+  module Test
+    module Doubles
+      def storage
+        @storage ||= double("Storage")
+      end
+    end
+
+    module RSpecMocksForMinitest
+      include RSpec::Mocks::ExampleMethods
+
+      def before_setup
+        RSpec::Mocks.setup
+        super
+      end
+
+      def after_teardown
+        begin
+          RSpec::Mocks.verify
+        ensure
+          RSpec::Mocks.teardown
+        end
+        super
+      end
+    end
+  end
+end
+
+class Minitest::Test
+  include Mova::Test::RSpecMocksForMinitest
+end

data/test/translator/get_test.rb

@@ -0,0 +1,55 @@
+require "test_helper"
+
+module Mova
+  class TranslatorGetTest < Minitest::Test
+    def translator
+      @translator ||= Translator.new
+    end
+
+    def test_get
+      expect(translator).to receive(:locales_to_try).with(:en).and_return([:en])
+      expect(translator).to receive(:keys_to_try).with(:hello).and_return([:hello])
+      expect(translator).to receive(:read_first).with([:en], [:hello]).and_return("Hello")
+      assert_equal "Hello", translator.get(:hello, :en)
+    end
+
+    def test_get_allows_to_override_locales_to_try
+      expect(translator).to receive(:keys_to_try).with(:hello).and_return([:hello])
+      expect(translator).to receive(:read_first).with([:de, :en], [:hello]).and_return("Hello")
+      assert_equal "Hello", translator.get(:hello, [:de, :en])
+    end
+
+    def test_get_allows_to_override_keys_to_try
+      expect(translator).to receive(:locales_to_try).with(:en).and_return([:en])
+      expect(translator).to receive(:read_first).with([:en], [:hi, :hello]).and_return("Hello")
+      assert_equal "Hello", translator.get([:hi, :hello], :en)
+    end
+
+    def test_get_uses_default_when_read_first_returns_nil
+      expect(translator).to receive(:read_first).and_return(nil)
+      expect(translator).to receive(:default).and_return("hi")
+      assert_equal "hi", translator.get(:hello, :en)
+    end
+
+    def test_get_passes_to_default_locales_keys_and_its_options
+      expect(translator).to receive(:locales_to_try).with(:en).and_return([:en])
+      expect(translator).to receive(:keys_to_try).with(:hello).and_return([:hello])
+      expect(translator).to receive(:read_first).with([:en], [:hello]).and_return(nil)
+      expect(translator).to receive(:default).with([:en], [:hello], my: "option")
+      translator.get(:hello, :en, my: "option")
+    end
+
+    def test_get_passes_its_options_to_default
+      expect(translator).to receive(:read_first).and_return(nil)
+      expect(translator).to receive(:default).with(instance_of(Array), instance_of(Array), {my: "option"}).and_return("hi")
+      assert_equal "hi", translator.get(:hello, :en, my: "option")
+    end
+
+    def test_get_uses_option_default_first
+      expect(translator).to receive(:locales_to_try).with(:en).and_return([:en])
+      expect(translator).to receive(:keys_to_try).with(:hello).and_return([:hello])
+      expect(translator).to receive(:read_first).with([:en], [:hello]).and_return(nil)
+      assert_equal "hi", translator.get(:hello, :en, default: "hi")
+    end
+  end
+end

data/test/translator/initialize_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+module Mova
+  class TranslatorInitializeTest < Minitest::Test
+    include Test::Doubles
+
+    def translator
+      @translator ||= Translator.new
+    end
+
+    def test_assigns_storage
+      translator = Translator.new(storage: storage)
+      assert_equal storage, translator.storage
+    end
+
+    def test_assigns_default_storage
+      assert_respond_to translator.storage, :read
+      assert_respond_to translator.storage, :read_multi
+      assert_respond_to translator.storage, :write
+      assert_respond_to translator.storage, :exist?
+    end
+  end
+end

data/test/translator/put_test.rb

@@ -0,0 +1,27 @@
+require "test_helper"
+
+module Mova
+  class TranslatorPutTest < Minitest::Test
+    include Test::Doubles
+
+    def translator
+      @translator ||= Translator.new(storage: storage)
+    end
+
+    def test_put_writes_key_if_it_doesnt_exist
+      expect(storage).to receive(:exist?).with("en.hello").and_return(false)
+      expect(storage).to receive(:write).with("en.hello", "world")
+      translator.put(en: {hello: "world"})
+    end
+
+    def test_put_doesnt_write_key_if_it_exists
+      expect(storage).to receive(:exist?).with("en.hello").and_return(true)
+      translator.put(en: {hello: "world"})
+    end
+
+    def test_put_bang_writes_key_if_it_exists
+      expect(storage).to receive(:write).with("en.hello", "world")
+      translator.put!(en: {hello: "world"})
+    end
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: mova
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrii Malyshko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Translation and localization library
+email:
+- mail@nashbridges.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".yardopts"
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmarks/compare/locale_fallbacks.rb
+- benchmarks/compare/long_scope.rb
+- benchmarks/each_vs_or.rb
+- benchmarks/fallbacks_with_local_storage.rb
+- benchmarks/fallbacks_with_remote_storage.rb
+- lib/mova.rb
+- lib/mova/interpolation/sprintf.rb
+- lib/mova/read_strategy/eager.rb
+- lib/mova/read_strategy/lazy.rb
+- lib/mova/scope.rb
+- lib/mova/storage/chain.rb
+- lib/mova/storage/memory.rb
+- lib/mova/storage/readonly.rb
+- lib/mova/translator.rb
+- mova.gemspec
+- test/acceptance_test.rb
+- test/interpolation/sprintf_test.rb
+- test/mova_test.rb
+- test/read_strategy/eager_test.rb
+- test/read_strategy/lazy_test.rb
+- test/scope_test.rb
+- test/storage/chain_test.rb
+- test/storage/memory_test.rb
+- test/storage/readonly_test.rb
+- test/test_helper.rb
+- test/translator/get_test.rb
+- test/translator/initialize_test.rb
+- test/translator/put_test.rb
+homepage: https://github.com/mova-rb/mova
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Translation and localization library
+test_files:
+- test/acceptance_test.rb
+- test/interpolation/sprintf_test.rb
+- test/mova_test.rb
+- test/read_strategy/eager_test.rb
+- test/read_strategy/lazy_test.rb
+- test/scope_test.rb
+- test/storage/chain_test.rb
+- test/storage/memory_test.rb
+- test/storage/readonly_test.rb
+- test/test_helper.rb
+- test/translator/get_test.rb
+- test/translator/initialize_test.rb
+- test/translator/put_test.rb
+has_rdoc: