langulator 0.0.3 → 0.0.4

data/README.md

@@ -4,6 +4,16 @@ Manage your i18n.
 
 Or rather: compile it into a single managable file and give it to the translator, so you don't have to deal with it.
 
+For example, given that you've written the original translations in English and also need French and Norwegian versions, and that you have multiple paths that contain i18n yml files named per the convention `<iso-language-code>.yml` (don't get me started on the Norwegian iso language code), then this will give you a single output file where each key is listed with the translations immediately below it.
+
+If you have partial translations in the target languages, these will be included.
+
+Any extraneous translations (i.e. keys that may have been in use previously but are no longer referenced in the original language) will be discarded.
+
+Any missing translations will be given keys with an empty spot, ready for translation.
+
+It handles arbitrarily deep nestings.
+
 ## Caveats
 
 If you need something other than US-ASCII, you may want to consider using ruby 1.9.3.
@@ -30,65 +40,126 @@ Or install it yourself as:
 
     $ gem install langulator
 
+
 ## Usage
 
-Given that you've written the original translations in English and also need French and German versions, and that you have multiple paths that contain i18n yml files named per the convention `<iso-language-code>.yml`, then this will give you a single output file where each key is listed with the translations immediately below it.
+### Compile
 
-If you have partial translations in the target languages, these will be included.
+* load individual translations
+* combine into aggregated translations
+* write to an aggregate file
 
-Any extraneous translations (i.e. keys that may have been in use previously but are no longer referenced in the original language) will be discarded.
+    Langulator.compile(:source_language => :en, :target_languages => [:fr, :no], :base_path => '**/i18n/', :to => '/tmp/translations.yml')
 
-Any missing translations will be given keys with an empty spot, ready for translation.
+Input:
 
-It handles arbitrarily deep nestings.
+    # config/i18n/en.yml
+    ---
+    food:
+      breakfast: Eggs
+      lunch: Sandwich
+      dinner:
+        main_course: Steak
+        desert: Chocolate mousse
+
+    # config/i18n/fr.yml
+    ---
+    food:
+      breakfast: Des oeufs
+    thank_you: Merci
 
-This first version doesn't handle yml files that are namespaced by the language, but I anticipate needing it very soon.
+    # missing no.yml file
 
-Also, this first version doesn't actually decompile the finished product. Come back tomorrow for that one.
+Outputs:
 
-e.g.
+      # tmp/translations.yml
+      config/i18n/:
+        food:
+          breakfast:
+            en: Eggs
+            fr: Des oeufs
+            no: 
+          lunch:
+            en: Sandwich
+            fr: 
+            no: 
+          dinner:
+            main_course:
+              en: Steak
+              fr: 
+              no: 
+            desert:
+              en: Chocolate pudding
+              fr: 
+              no: 
+
+### Decompile
+
+* load an aggregate file
+* separate into individual translations
+* write to individual translation files
+
+    Langulator.decompile(:from => './tmp/translations.yml', :languages => [:en, :fr, :no])
 
 Input:
 
-    # en.yml
+      config/i18n/:
+        food:
+          breakfast:
+            en: Eggs
+            fr: Des oeufs
+            no: Egg
+          lunch:
+            en: Sandwich
+            fr: Sandwich
+            no: Ostesmørbrød
+          dinner:
+            main_course:
+              en: Steak
+              fr: Biffteak
+              no: Steak
+            desert:
+              en: Chocolate mousse
+              fr: Mousse au chocolat
+              no: Sjokolademousse
+
+Output:
+
+    # config/i18n/en.yml
     ---
     food:
       breakfast: Eggs
       lunch: Sandwich
       dinner:
         main_course: Steak
-        desert: Chocolate pudding
+        desert: Chocolate mousse
 
-    # fr.yml
+    # config/i18n/fr.yml
     ---
     food:
       breakfast: Des oeufs
-    thank_you: Merci
-
-    # no de.yml file
-
-    Langulator.write(:language => 'en', :alternates => ['fr', 'de'], :base_path => '**/i18n/', :to => '/tmp/translations.yml')
-
-Outputs:
+      lunch: Sandwich
+      dinner:
+        main_course: Biffteak
+        desert: Mousse au chocolat
 
+    # config/i18n/no.yml
+    ---
     food:
-      breakfast:
-        en: Eggs
-        fr: Des oeufs
-        de: 
-      lunch:
-        en: Sandwich
-        fr: 
-        de: 
+      breakfast: Egg
+      lunch: Sandwich
       dinner:
-        main_course:
-          en: Steak
-          fr: 
-          de: 
-        desert:
-          en: Chocolate pudding
-          fr: 
-          de: 
+        main_course: Steak
+        desert: Sjokolademousse
+
+## TODO
+
+* handle yml files that are namespaced by the language, e.g.
+```
+---
+en:
+  stuff: "whatever"
+```
 
 ## Contributing
 

data/langulator.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "langulator"
   gem.require_paths = ["lib"]
-  gem.version       = "0.0.3"
+  gem.version       = "0.0.4"
 
   gem.add_development_dependency "rspec"
 end

data/lib/langulator/aggregate.rb

@@ -0,0 +1,124 @@
+require 'langulator/loader'
+
+module Langulator
+  class Aggregate
+
+    class << self
+      def from_file(options)
+        translations = YAML.load(File.read(options[:from]))
+        new options.merge(:aggregate_translations => translations)
+      end
+
+      def from_files(options)
+        loader = Loader.new(options)
+        new options.merge(:individual_translations => loader.translations)
+      end
+    end
+
+    attr_reader :languages, :source_language, :target_languages, :aggregate_file_path
+    def initialize(options = {})
+      @aggregate_file_path = options[:to]
+      @aggregate = options[:aggregate_translations]
+      @individual_translations = options[:individual_translations]
+      @source_language = options[:source_language]
+      @target_languages = Array(options[:target_languages])
+      @languages = options[:languages] || [source_language] + target_languages
+    end
+
+    def individual_translations
+      @individual_translations ||= separate
+    end
+
+    def aggregate
+      @aggregate ||= combine
+    end
+
+    def extract(language, tangled)
+      separated = {}
+      tangled.keys.each do |key|
+        values = tangled[key]
+        if translations?(values)
+          separated[key] = values[language]
+        else
+          separated[key] = extract(language, values)
+        end
+      end
+      separated
+    end
+
+    def compile
+      write(aggregate_file_path, aggregate)
+    end
+
+    def decompile
+      individual_translations.each do |language, translations|
+        translations.each do |path, translation|
+          filename = "#{path}#{language}.yml"
+          write filename, translation
+        end
+      end
+    end
+
+    # TODO: find a good name for this
+    def to_aggregate(language, translations)
+      dictionary = {}
+      translations.each do |key, value|
+        dictionary[key] ||= {}
+        if value.is_a?(Hash)
+          dictionary[key] = to_aggregate(language, value)
+        else
+          dictionary[key][language] = value
+        end
+      end
+      dictionary
+    end
+
+    def insert(language, translations, dictionary)
+      dictionary.dup.each do |key, value|
+        if value.is_a?(Hash)
+          insert(language, (translations || {})[key], value)
+        else
+          dictionary[language] = translations
+        end
+      end
+      dictionary
+    end
+
+    private
+
+    def translations?(values)
+      !values.keys.select {|key| languages.include?(key) }.empty?
+    end
+
+    def write(filename, content)
+      File.open(filename, 'w:utf-8') do |file|
+        file.write content.to_yaml
+      end
+    end
+
+    def separate
+      separated = {}
+      languages.each do |language|
+        separated[language] = extract(language, aggregate)
+      end
+      separated
+    end
+
+    def combine
+      source_translations = individual_translations[source_language]
+
+      target_translations = {}
+      target_languages.each do |language|
+        target_translations[language] = individual_translations[language]
+      end
+
+      dictionary = to_aggregate(source_language, source_translations)
+      target_translations.each do |language, translations|
+        dictionary = insert(language, translations, dictionary)
+      end
+
+      dictionary
+    end
+
+  end
+end

data/lib/langulator/loader.rb

@@ -1,24 +1,23 @@
 module Langulator
   class Loader
 
-    attr_reader :base_path, :origin, :alternates
+    attr_reader :base_path, :languages
     def initialize(options = {})
       @base_path = options[:base_path]
-      @origin = options[:origin]
-      @alternates = options[:alternates]
+      @languages = [options[:source_language]] + options[:target_languages]
     end
 
     def paths
-      @paths ||= Dir.glob("#{base_path}#{origin}.yml").map {|file| file.gsub("#{origin}.yml", '') }.sort
-    end
-
-    def source_translations
-      translations = load_translations(origin)
+      unless @paths
+        filename = "#{languages.first}.yml"
+        @paths = Dir.glob("#{base_path}#{filename}").map {|file| file.gsub(filename, '') }.sort
+      end
+      @paths
     end
 
-    def destination_translations
+    def translations
       translations = {}
-      alternates.each do |language|
+      languages.each do |language|
         translations[language] = load_translations(language)
       end
       translations

data/lib/langulator.rb

@@ -1,46 +1,17 @@
 # encoding: utf-8
 require 'yaml'
-require 'langulator/loader'
-require 'langulator/munger'
-require 'langulator/untangler'
+require 'langulator/aggregate'
 
 module Langulator
-  class << self
-    def munge(options = {})
-      loader = Loader.new(options)
-      munger = Munger.new(:language => loader.origin, :translations => loader.source_translations, :alternates => loader.destination_translations)
-
-      munger.munge
-    end
 
+  class << self
     def compile(options)
-      filename = options[:to]
-      translations = munge(options)
-      write filename, translations
-    end
-
-    def untangle(aggregate, options)
-      Untangler.new(aggregate, options).untangle
+      Aggregate.from_files(options).compile
     end
 
     def decompile(options)
-      puts options[:file].inspect
-      aggregate = YAML.load(File.read(options[:file]))
-      translations = untangle(aggregate, options)
-
-      translations.each do |language, data|
-        data.each do |path, translation|
-          filename = "#{path}#{language}.yml"
-          write filename, translation
-        end
-      end
-    end
-
-    private
-    def write(filename, content)
-      File.open(filename, 'w:utf-8') do |file|
-        file.write content.to_yaml
-      end
+      Aggregate.from_file(options).decompile
     end
   end
+
 end

data/spec/aggregate_spec.rb

@@ -0,0 +1,141 @@
+require 'langulator/aggregate'
+
+describe Langulator::Aggregate do
+
+  let(:aggregate) do
+    {
+      "spec/fixtures/" => {
+        "words" => {
+          "affirmative" => {
+            :klingon => "HISlaH",
+            :lolcode => "YA RLY"
+          },
+          "negative" => {
+            :klingon => "ghobe'",
+            :lolcode => "NO WAI"
+          },
+          "hello" => {
+            :klingon => "nuqneH",
+            :lolcode => "O HAI"
+          }
+        }
+      }
+    }
+  end
+
+  let(:klingon) { {"spec/fixtures/" => {"words" => {"affirmative" => "HISlaH", "negative" => "ghobe'", "hello" => "nuqneH"}}} }
+  let(:lolcode) { {"spec/fixtures/" => {"words" => {"affirmative" => "YA RLY", "negative" => "NO WAI", "hello" => "O HAI"}}} }
+
+  describe "combining individual translations" do
+    let(:klingon_as_aggregate) do
+      {
+        "spec/fixtures/" => {
+          "words" => {
+            "affirmative" => { :klingon => "HISlaH" },
+            "negative" => { :klingon => "ghobe'" },
+            "hello" => { :klingon => "nuqneH" }
+          }
+        }
+      }
+    end
+
+    let(:outfile) { 'spec/fixtures/output.yml' }
+
+    let(:compile_options) do
+      {
+        :source_language => :klingon,
+        :target_languages => :lolcode,
+        :individual_translations => {:klingon => klingon, :lolcode => lolcode},
+        :to => outfile
+      }
+    end
+
+    subject { Langulator::Aggregate.new(compile_options) }
+
+    its(:source_language) { should eq(:klingon) }
+    its(:target_languages) { should eq([:lolcode]) }
+    its(:languages) { should eq([:klingon, :lolcode]) }
+    its(:individual_translations) { should eq({:klingon => klingon, :lolcode => lolcode}) }
+    its(:aggregate_file_path) { should eq(outfile) }
+    its(:aggregate) { should eq(aggregate) }
+
+    it "remappes the source language to initialize aggregate" do
+      subject.to_aggregate(:klingon, subject.individual_translations[:klingon]).should eq(klingon_as_aggregate)
+    end
+
+    it "inserts a target language into the aggregate" do
+      subject.insert(:lolcode, lolcode, klingon_as_aggregate).should eq(aggregate)
+    end
+
+    it "loads an aggregate" do
+      subject = Langulator::Aggregate.from_file(:from => 'spec/fixtures/translations.yml', :languages => [:klingon, :lolcode])
+      subject.aggregate.should eq(aggregate)
+    end
+
+    context "writing an aggregate" do
+      before(:each) do
+        FileUtils.rm(outfile) if File.exists? outfile
+      end
+
+      after(:each) do
+        FileUtils.rm(outfile) if File.exists? outfile
+      end
+
+      it "compiles" do
+        subject.compile
+        YAML.load(File.read(outfile)).should eq(aggregate)
+      end
+    end
+  end
+
+  describe "de-aggregating translations" do
+    subject { Langulator::Aggregate.new(:languages => [:english]) }
+
+    it 'extracts English' do
+      input = {:rock => {:english => "rock"}, :paper => {:english => "paper"}}
+      expected_output = {:rock => "rock", :paper => "paper"}
+      subject.extract(:english, input).should eq(expected_output)
+    end
+
+    it "extracts complicated English" do
+      input = {:a => {:really => {:deeply => {:nested => {:game => {:rock => {:english => "rock"}, :paper => {:english => "paper"}}}}}}}
+      expected_output = {:a => {:really => {:deeply => {:nested => {:game => {:rock => "rock", :paper => "paper"}}}}}}
+      subject.extract(:english, input).should eq(expected_output)
+    end
+  end
+
+  context "with aggregated data" do
+    subject { Langulator::Aggregate.new(:aggregate_translations => aggregate, :languages => [:klingon, :lolcode]) }
+
+    it "filters out the klingon" do
+      subject.individual_translations[:klingon].should eq(klingon)
+    end
+
+    it "filters out the lolcode" do
+      subject.individual_translations[:lolcode].should eq(lolcode)
+    end
+  end
+
+  context "writing individual translations" do
+    let(:klingon_file) { "spec/fixtures/klingon.yml" }
+    let(:lolcode_file) { "spec/fixtures/lolcode.yml" }
+
+    subject { Langulator::Aggregate.new(:aggregate_translations => aggregate, :languages => [:klingon, :lolcode]) }
+
+    before(:each) do
+      FileUtils.rm(klingon_file) if File.exists? klingon_file
+      FileUtils.rm(lolcode_file) if File.exists? lolcode_file
+    end
+
+    after(:each) do
+      FileUtils.rm(klingon_file) if File.exists? klingon_file
+      FileUtils.rm(lolcode_file) if File.exists? lolcode_file
+    end
+
+    it "decompiles" do
+      subject.decompile
+      YAML.load(File.read(klingon_file)).should eq(klingon["spec/fixtures/"])
+      YAML.load(File.read(lolcode_file)).should eq(lolcode["spec/fixtures/"])
+    end
+  end
+end

data/spec/fixtures/translations.yml

@@ -0,0 +1,12 @@
+---
+spec/fixtures/:
+  words:
+    affirmative:
+      :klingon: HISlaH
+      :lolcode: YA RLY
+    negative:
+      :klingon: ghobe'
+      :lolcode: NO WAI
+    hello:
+      :klingon: nuqneH
+      :lolcode: O HAI

data/spec/loader_spec.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+require 'yaml'
 require 'langulator/loader'
 
 describe Langulator::Loader do
@@ -40,10 +41,6 @@ describe Langulator::Loader do
     }
   end
 
-  subject { Langulator::Loader.new(:base_path => 'spec/fixtures/**/', :origin => 'english', :alternates => ['norsk', 'francais']) }
-
-  its(:paths) { should eq(['spec/fixtures/', 'spec/fixtures/lang/']) }
-
-  its(:source_translations) { should eq(english) }
-  its(:destination_translations) { should eq({'norsk' => norwegian, 'francais' => french}) }
+  subject { Langulator::Loader.new(:base_path => 'spec/fixtures/**/', :source_language => 'english', :target_languages => ['norsk', 'francais']) }
+  its(:translations) { should eq({'english' => english, 'norsk' => norwegian, 'francais' => french}) }
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: langulator
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-03 00:00:00.000000000 Z
+date: 2012-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70303028217820 !ruby/object:Gem::Requirement
+  requirement: &70204764441280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70303028217820
+  version_requirements: *70204764441280
 description: Manage, maintain, and munge your i18n files.
 email:
 - katrina.owen@gmail.com
@@ -38,16 +38,14 @@ files:
 - bin/langulator
 - langulator.gemspec
 - lib/langulator.rb
+- lib/langulator/aggregate.rb
 - lib/langulator/loader.rb
-- lib/langulator/munger.rb
-- lib/langulator/untangler.rb
+- spec/aggregate_spec.rb
 - spec/fixtures/english.yml
 - spec/fixtures/lang/english.yml
 - spec/fixtures/norsk.yml
-- spec/langulator_spec.rb
+- spec/fixtures/translations.yml
 - spec/loader_spec.rb
-- spec/munger_spec.rb
-- spec/untangler_spec.rb
 homepage: http://github.com/kytrinyx/langulator
 licenses: []
 post_install_message: 
@@ -73,10 +71,9 @@ signing_key:
 specification_version: 3
 summary: Tasks to keep your i18n files managable.
 test_files:
+- spec/aggregate_spec.rb
 - spec/fixtures/english.yml
 - spec/fixtures/lang/english.yml
 - spec/fixtures/norsk.yml
-- spec/langulator_spec.rb
+- spec/fixtures/translations.yml
 - spec/loader_spec.rb
-- spec/munger_spec.rb
-- spec/untangler_spec.rb

data/lib/langulator/munger.rb

@@ -1,44 +0,0 @@
-module Langulator
-  class Munger
-
-    attr_reader :source_language, :source_translations, :alternate_translations
-    def initialize(options = {})
-      @source_language = options[:language]
-      @source_translations = options[:translations]
-      @alternate_translations = options[:alternates]
-    end
-
-    def munge
-      dictionary = transform(source_language, source_translations)
-      alternate_translations.each do |language, translations|
-        dictionary = insert(language, translations, dictionary)
-      end
-      dictionary
-    end
-
-    def transform(language, translations)
-      dictionary = {}
-      translations.each do |key, value|
-        dictionary[key] ||= {}
-        if value.is_a?(Hash)
-          dictionary[key] = transform(language, value)
-        else
-          dictionary[key][language] = value
-        end
-      end
-      dictionary
-    end
-
-    def insert(language, translations, dictionary)
-      dictionary.dup.each do |key, value|
-        if value.is_a?(Hash)
-          insert(language, (translations || {})[key], value)
-        else
-          dictionary[language] = translations
-        end
-      end
-      dictionary
-    end
-
-  end
-end

data/lib/langulator/untangler.rb

@@ -1,34 +0,0 @@
-module Langulator
-  class Untangler
-    attr_reader :aggregate, :languages
-    def initialize(aggregate, options = {})
-      @aggregate = aggregate
-      @languages = options[:languages]
-    end
-
-    def untangle
-      untangled = {}
-      languages.each do |language|
-        untangled[language] = extract(language, aggregate)
-      end
-      untangled
-    end
-
-    def extract(language, tangled)
-      untangled = {}
-      tangled.keys.each do |key|
-        values = tangled[key]
-        if translations?(values)
-          untangled[key] = values[language]
-        else
-          untangled[key] = extract(language, values)
-        end
-      end
-      untangled
-    end
-
-    def translations?(values)
-      !values.keys.select {|key| languages.include?(key) }.empty?
-    end
-  end
-end

data/spec/langulator_spec.rb

@@ -1,87 +0,0 @@
-# encoding: utf-8
-require 'langulator'
-
-describe Langulator do
-  let(:options) { {:base_path => 'spec/fixtures/**/', :origin => 'english', :alternates => ['norsk', 'francais']} }
-
-  let(:aggregate_incomplete) do
-    {
-      "spec/fixtures/" => {
-        "food" => {
-          "breakfast" => {"english" => "yoghurt", "norsk" => nil, "francais" => nil},
-          "lunch" => {"english" => "sandwich", "norsk" => "smørbrød", "francais" => nil},
-          "dinner" => {
-            "main_course" => {"english" => "steak", "norsk" => nil, "francais" => nil},
-            "side" => {"english" => "baked potato", "norsk" => nil, "francais" => nil},
-            "desert" => {"english" => "chocolate mousse", "norsk" => nil, "francais" => nil}
-          }
-        }
-      },
-      "spec/fixtures/lang/" => {
-        "volume" => {
-          "sound" => {"english" => "loud", "norsk" => nil, "francais" => nil},
-          "liquid" => {"english" => "sloshing", "norsk" => nil, "francais" => nil},
-          "hair" => {"english" => "because I'm worth it", "norsk" => nil, "francais" => nil}
-        }
-      }
-    }
-  end
-
-  it "loads and munges" do
-    Langulator.compile(options.merge(:to => './tmp/translations.yml')) #.should eq(aggregate_incomplete)
-  end
-
-  let(:aggregate_complete) do
-    {
-      "spec/fixtures/" => {
-        "food" => {
-          "breakfast" => {"english" => "yoghurt", "norsk" => "joggurt", "francais" => "yaourt"},
-          "lunch" => {"english" => "sandwich", "norsk" => "smørbrød", "francais" => "sandwich"},
-          "dinner" => {
-            "main_course" => {"english" => "steak", "norsk" => "steak", "francais" => "biffteak"},
-            "side" => {"english" => "baked potato", "norsk" => "bakt potet", "francais" => "pomme de terre au four"},
-            "desert" => {"english" => "chocolate mousse", "norsk" => "sjokolademousse", "francais" => "mousse au chocolat"}
-          }
-        }
-      },
-      "spec/fixtures/lang/" => {
-        "volume" => {
-          "sound" => {"english" => "loud", "norsk" => "høyt", "francais" => "fort"},
-          "liquid" => {"english" => "sloshing", "norsk" => "skvulper", "francais" => "agité"},
-          "hair" => {"english" => "because I'm worth it", "norsk" => "for det er jeg verdt", "francais" => "parce que je le vaux bien"}
-        }
-      }
-    }
-  end
-
-  it "untangles" do
-    expected = {
-      "english" => {
-        "spec/fixtures/" => {
-          "food" => {"breakfast" => "yoghurt", "lunch" => "sandwich", "dinner" => {"main_course" => "steak", "side" => "baked potato", "desert" => "chocolate mousse"}}
-        },
-        "spec/fixtures/lang/" => {
-          "volume" => {"sound" => "loud", "liquid" => "sloshing", "hair" => "because I'm worth it"}
-        }
-      },
-      "norsk" => {
-        "spec/fixtures/" => {
-          "food" => {"breakfast" => "joggurt", "lunch" => "smørbrød", "dinner" => {"main_course" => "steak", "side" => "bakt potet", "desert" => "sjokolademousse"}}
-        },
-        "spec/fixtures/lang/" => {
-          "volume" => {"sound" => "høyt", "liquid" => "skvulper", "hair" => "for det er jeg verdt"}
-        }
-      },
-      "francais" => {
-        "spec/fixtures/" => {
-          "food" => {"breakfast" => "yaourt", "lunch" => "sandwich", "dinner" => {"main_course" => "biffteak", "side" => "pomme de terre au four", "desert" => "mousse au chocolat"}}
-        },
-        "spec/fixtures/lang/" => {
-          "volume" => {"sound" => "fort", "liquid" => "agité", "hair" => "parce que je le vaux bien"}
-        }
-      }
-    }
-    Langulator.untangle(aggregate_complete, :languages => ["english", "norsk", "francais"]).should eq(expected)
-  end
-
-end

data/spec/munger_spec.rb

@@ -1,102 +0,0 @@
-require 'langulator/munger'
-
-describe Langulator::Munger do
-
-  let(:english) do
-    {
-      :game => {
-        :rock => "rock",
-        :paper => "paper",
-        :scissors => "scissors",
-        :other => {:deeply => "nested"}
-      }
-    }
-  end
-
-  let(:english_remapped) do
-    {
-      :game => {
-        :rock => {:english => "rock"},
-        :paper => {:english => "paper"},
-        :scissors => {:english => "scissors"},
-        :other => {
-          :deeply => {:english => "nested"}
-        }
-      }
-    }
-  end
-
-  let(:french) { {:game => {:paper => 'papier', :other => {:not => 'included'}}} }
-
-  let(:combined) do
-    {
-      :game => {
-        :rock => {
-          :english => "rock",
-          :french => nil
-        },
-        :paper => {
-          :english => "paper",
-          :french => "papier"
-        },
-        :scissors => {
-          :english => "scissors",
-          :french => nil
-        },
-        :other => {
-          :deeply => {
-            :english => "nested",
-            :french => nil
-          }
-        }
-      }
-    }
-  end
-
-  let(:empty_target) do
-    {
-      :game => {
-        :rock => {
-          :english => "rock",
-          :norwegian => nil
-        },
-        :paper => {
-          :english => "paper",
-          :norwegian => nil
-        },
-        :scissors => {
-          :english => "scissors",
-          :norwegian => nil
-        },
-        :other => {
-          :deeply => {
-            :english => "nested",
-            :norwegian => nil
-          }
-        }
-      }
-    }
-  end
-
-  context "partial munges" do
-    subject { Langulator::Munger.new }
-
-    it "remaps a source dictionary" do
-       subject.transform(:english, english).should eq(english_remapped)
-    end
-
-    it "inserts an alternate language" do
-      subject.insert(:french, french, english_remapped).should eq(combined)
-    end
-
-    it "inserts an empty alternate language" do
-      subject.insert(:norwegian, {}, english_remapped).should eq(empty_target)
-    end
-  end
-
-  it "munges" do
-    munger = Langulator::Munger.new(:language => :english, :translations => english, :alternates => {:french => french})
-    munger.munge.should eq(combined)
-  end
-
-end

data/spec/untangler_spec.rb

@@ -1,75 +0,0 @@
-# encoding: utf-8
-require 'langulator/untangler'
-
-describe Langulator::Untangler do
-  let(:aggregate) do
-    {
-      :game => {
-        :rock => {
-          :english => "rock",
-          :french => "pierre",
-        },
-        :paper => {
-          :english => "paper",
-          :french => "papier"
-        },
-        :scissors => {
-          :english => "scissors",
-          :french => "ciseau"
-        },
-        :other => {
-          :deeply => {
-            :english => "nested",
-            :french => "imbriqué"
-          }
-        }
-      }
-    }
-  end
-
-  let(:english) do
-    {
-      :game => {
-        :rock => "rock",
-        :paper => "paper",
-        :scissors => "scissors",
-        :other => {:deeply => "nested"}
-      }
-    }
-  end
-
-  let(:french) do
-    {
-      :game => {
-        :rock => "pierre",
-        :paper => "papier",
-        :scissors => "ciseau",
-        :other => {:deeply => "imbriqué"}
-      }
-    }
-  end
-
-  context "with tangled data" do
-    subject { Langulator::Untangler.new(aggregate, :languages => [:english, :french]) }
-
-    it 'extracts English' do
-      input = {:rock => {:english => "rock"}, :paper => {:english => "paper"}}
-      expected_output = {:rock => "rock", :paper => "paper"}
-      subject.extract(:english, input).should eq(expected_output)
-    end
-
-    it "extracts complicated English" do
-      input = {:a => {:really => {:deeply => {:nested => {:game => {:rock => {:english => "rock"}, :paper => {:english => "paper"}}}}}}}
-      expected_output = {:a => {:really => {:deeply => {:nested => {:game => {:rock => "rock", :paper => "paper"}}}}}}
-      subject.extract(:english, input).should eq(expected_output)
-    end
-
-    it "filters out the english" do
-      subject.untangle[:english].should eq(english)
-    end
-
-    it "filters out the french" do
-      subject.untangle[:french].should eq(french)
-    end
-  end
-end