langulator 0.0.4 → 0.0.5

data/README.md

@@ -4,7 +4,7 @@ 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.
+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 (`<language>.yml`), 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.
 
@@ -20,7 +20,7 @@ If you need something other than US-ASCII, you may want to consider using ruby 1
 
 In 1.9.2 (patch 290):
 
-   S\xC3\xB8knadstekst
+    S\xC3\xB8knadstekst
 
 In 1.9.3:
 
@@ -43,13 +43,17 @@ Or install it yourself as:
 
 ## Usage
 
-### Compile
+### In Ruby
+
+#### Compile
 
 * load individual translations
 * combine into aggregated translations
 * write to an aggregate file
 
-    Langulator.compile(:source_language => :en, :target_languages => [:fr, :no], :base_path => '**/i18n/', :to => '/tmp/translations.yml')
+```
+Langulator.compile(:source_language => :en, :target_languages => [:fr, :no], :base_path => '**/i18n/', :to => '/tmp/translations.yml')
+```
 
 Input:
 
@@ -93,13 +97,16 @@ Outputs:
               fr: 
               no: 
 
-### Decompile
+#### Decompile
 
 * load an aggregate file
 * separate into individual translations
 * write to individual translation files
 
-    Langulator.decompile(:from => './tmp/translations.yml', :languages => [:en, :fr, :no])
+
+```
+Langulator.decompile(:from => './tmp/translations.yml')
+```
 
 Input:
 
@@ -152,6 +159,28 @@ Output:
         main_course: Steak
         desert: Sjokolademousse
 
+### CLI
+
+```
+$~: langulator help
+
+$~: langulator help compile
+
+$~: langulator help decompile
+```
+
+#### Compile
+
+```
+$~: langulator compile -s en -t fr nb-no -p 'config/locales/**/' -f ./tmp/translations.yml
+```
+
+#### Decompile
+
+```
+$~: langulator decompile -f ./tmp/translations.yml
+```
+
 ## TODO
 
 * handle yml files that are namespaced by the language, e.g.

data/bin/langulator

@@ -1,3 +1,6 @@
 #!/usr/bin/env ruby
 
 require 'langulator'
+require 'langulator/cli'
+
+Langulator::CLI.start

data/features/compile_aggregate.feature

@@ -0,0 +1,13 @@
+Feature: Aggregate individual translation files
+
+Combines any number of source translation files into a single file,
+where all the translations for a single key are grouped for easy translation.
+
+  @compile
+  Scenario: Compile aggregate
+    Given a website in English, French, and Norwegian
+    And there is a translation file for English
+    And there is an outdated translation file for French
+    And there is no translation file for Norwegian
+    When the aggregate file is compiled
+    Then the output file collects the translation keys for easy translation

data/features/decompile_aggregate.feature

@@ -0,0 +1,13 @@
+Feature: Separate an aggregate into individual i18n files
+
+Takes an aggregate translation file and writes the translated keys into
+their respective i18n files at their original locations.
+
+  @decompile
+  Scenario: Decompile aggregate
+    Given a website in English, French, and Norwegian
+    And there is an aggregate translation file
+    When the aggregate file is decompiled
+    Then the English translations should be complete
+    And the French translations should be complete
+    And the Norwegian translations should be complete

data/features/fixtures/en.yml

@@ -0,0 +1,8 @@
+---
+food:
+  breakfast: yoghurt
+  lunch: sandwich
+  dinner:
+    main_course: steak
+    side: baked potato
+    desert: chocolate mousse

data/features/fixtures/fr.yml

@@ -0,0 +1,10 @@
+---
+food:
+  breakfast: yaourt
+  lunch: sandwich
+  dinner:
+    main_course: biffteak
+    side: 
+    desert: mousse au chocolat
+  thanks: merci
+

data/features/fixtures/in.yml

@@ -0,0 +1,38 @@
+---
+features/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
+features/fixtures/lang/:
+  volume:
+    sound:
+      :english: loud
+      :norsk: høyt
+      :francais: haut
+    liquid:
+      :english: full
+      :norsk: fullt
+      :francais: plein
+    hair:
+      :english: because I'm worth it
+      :norsk: for det er jeg verdt
+      :francais: parce que je le vaux bien

data/features/fixtures/lang/en.yml

@@ -0,0 +1,5 @@
+---
+volume:
+  sound: loud
+  liquid: full
+  hair: because I'm worth it

data/features/fixtures/lang/fr.yml

@@ -0,0 +1,5 @@
+---
+volume:
+  sound: haut
+  liquid: plein
+  hair: parce que je le vaux bien

data/features/step_definitions/aggregate_steps.rb

@@ -0,0 +1,76 @@
+# encoding: utf-8
+
+Given /a website in English, French, and Norwegian$/ do
+end
+
+Given /^there is a translation file for English$/ do
+end
+
+Given /^there is an outdated translation file for French$/ do
+end
+
+Given /^there is no translation file for Norwegian$/ do
+end
+
+Given /^there is an aggregate translation file$/ do
+end
+
+When /the aggregate file is compiled/ do
+  Langulator.compile(:source_language => :en, :target_languages => [:fr, :no], :base_path => 'features/fixtures/**/', :to => AGGREGATE_FILE)
+end
+
+When /^the aggregate file is decompiled$/ do
+  # Using full language name rather than the iso-code to avoid
+  # overwriting the individual files used for input in the compile feature.
+  # Ideally I should just use different languages, but I don't speak any others.
+  Langulator.decompile(:languages => [:english, :francais, :norsk], :from => INFILE)
+end
+
+Then /^the output file collects the translation keys for easy translation$/ do
+  expected = {
+    "features/fixtures/" => {
+      "food" => {
+        "breakfast" => {:en => "yoghurt", :no => nil, :fr => "yaourt"},
+        "lunch" => {:en => "sandwich", :no => nil, :fr => "sandwich"},
+        "dinner" => {
+          "main_course" => {:en => "steak", :no => nil, :fr => "biffteak"},
+          "side" => {:en => "baked potato", :no => nil, :fr => nil},
+          "desert" => {:en => "chocolate mousse", :no => nil, :fr => "mousse au chocolat"}
+        }
+      }
+    },
+    "features/fixtures/lang/" => {
+      "volume" => {
+        "sound" => {:en => "loud", :no => nil, :fr => "haut"},
+        "liquid" => {:en => "full", :no => nil, :fr => "plein"},
+        "hair" => {:en => "because I'm worth it", :no => nil, :fr => "parce que je le vaux bien"}
+      }
+    }
+  }
+  YAML.load(File.read(AGGREGATE_FILE)).should eq(expected)
+end
+
+Then /^the English translations should be complete$/ do
+  expected = {"food"=>{"breakfast"=>"yoghurt", "lunch"=>"sandwich", "dinner"=>{"main_course"=>"steak", "side"=>"baked potato", "desert"=>"chocolate mousse"}}}
+  english = YAML.load(File.read('features/fixtures/english.yml')).should eq(expected)
+
+  expected = {"volume"=>{"sound"=>"loud", "liquid"=>"full", "hair"=>"because I'm worth it"}}
+  nested_english = YAML.load(File.read('features/fixtures/lang/english.yml')).should eq(expected)
+end
+
+Then /^the French translations should be complete$/ do
+  expected = {"food"=>{"breakfast"=>"yaourt", "lunch"=>"sandwich", "dinner"=>{"main_course"=>"biffteak", "side"=>"pomme de terre au four", "desert"=>"mousse au chocolat"}}}
+  french = YAML.load(File.read('features/fixtures/francais.yml')).should eq(expected)
+
+  expected = {"volume"=>{"sound"=>"haut", "liquid"=>"plein", "hair"=>"parce que je le vaux bien"}}
+  nested_french = YAML.load(File.read('features/fixtures/lang/francais.yml')).should eq(expected)
+end
+
+Then /^the Norwegian translations should be complete$/ do
+  expected = {"food"=>{"breakfast"=>"joggurt", "lunch"=>"smørbrød", "dinner"=>{"main_course"=>"steak", "side"=>"bakt potet", "desert"=>"sjokolademousse"}}}
+  norwegian = YAML.load(File.read('features/fixtures/norsk.yml')).should eq(expected)
+
+  expected = {"volume"=>{"sound"=>"høyt", "liquid"=>"fullt", "hair"=>"for det er jeg verdt"}}
+  nested_norwegian = YAML.load(File.read('features/fixtures/lang/norsk.yml')).should eq(expected)
+end
+

data/features/support/env.rb

@@ -0,0 +1,13 @@
+$:.unshift "#{File.dirname(__FILE__)}/../../lib/"
+
+require 'langulator'
+
+path = 'features/fixtures/'
+
+AGGREGATE_FILE = "#{path}out.yml"
+
+INFILE = "#{path}in.yml"
+
+individual = ['english', 'lang/english', 'francais', 'lang/francais', 'norsk', 'lang/norsk']
+INDIVIDUAL_FILES = individual.map {|f| "#{path}#{f}.yml"}
+

data/features/support/hooks.rb

@@ -0,0 +1,20 @@
+def cleanup(file)
+  FileUtils.rm(file) if File.exists? file
+end
+
+Before('@compile') do
+  cleanup AGGREGATE_FILE
+end
+
+After('@compile') do
+  cleanup AGGREGATE_FILE
+end
+
+Before('@decompile') do
+  INDIVIDUAL_FILES.each {|f| cleanup f}
+
+end
+
+After('@decompile') do
+  INDIVIDUAL_FILES.each {|f| cleanup f}
+end

data/langulator.gemspec

@@ -12,7 +12,9 @@ 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.4"
+  gem.version       = "0.0.5"
 
   gem.add_development_dependency "rspec"
+  gem.add_development_dependency "cucumber"
+  gem.add_runtime_dependency "thor"
 end

data/lib/langulator.rb

@@ -1,16 +1,19 @@
 # encoding: utf-8
 require 'yaml'
-require 'langulator/aggregate'
+require 'langulator/translation'
+require 'langulator/aggregate_translation'
+require 'langulator/individual_translation'
+require 'langulator/individual_translations'
 
 module Langulator
 
   class << self
     def compile(options)
-      Aggregate.from_files(options).compile
+      IndividualTranslations.new(options).compile
     end
 
     def decompile(options)
-      Aggregate.from_file(options).decompile
+      AggregateTranslation.new(:location => options[:from]).decompile
     end
   end
 

data/lib/langulator/aggregate_translation.rb

@@ -0,0 +1,67 @@
+module Langulator
+  class AggregateTranslation < Translation
+
+    attr_writer :individual_translations
+
+    def languages
+      @languages ||= detect_languages
+    end
+
+    def decompile
+      individual_translations.each(&:write)
+    end
+
+    def individual_translations
+      @individual_translations ||= extract_individual_translations
+    end
+
+    private
+
+    def extract_individual_translations
+      i18ns = IndividualTranslations.new
+      languages.each do |language|
+        i18ns << extract_translations(language)
+      end
+      i18ns
+    end
+
+    def extract_translations(language)
+      extract(language, translations).map do |path, values|
+        IndividualTranslation.new(:path => path, :base_filename => language, :translations => values)
+      end
+    end
+
+    def extract(language, aggregate)
+      separated = {}
+      aggregate.keys.each do |key|
+        values = aggregate[key]
+        if translations?(values)
+          separated[key] = values[language]
+        else
+          separated[key] = extract(language, values)
+        end
+      end
+      separated
+    end
+
+    def translations?(values)
+      !values.keys.select {|key| languages.include?(key) }.empty?
+    end
+
+    def detect_languages(dictionary = translations, detected = [])
+      dictionary.each do |key, values|
+        if values.is_a?(Hash)
+          detect_languages(values, detected)
+        else
+          language = key.to_sym
+          # The languages are always listed together.
+          # If we're seeing a duplicate language, then we're done
+          return detected if detected.include?(language)
+
+          detected << language
+        end
+      end
+      return detected
+    end
+  end
+end

data/lib/langulator/cli.rb

@@ -0,0 +1,30 @@
+require 'thor'
+
+module Langulator
+
+  class CLI < Thor
+
+    desc "compile", "Combine individual i18n files into a single aggregate"
+    method_option :source_language, :type => :string, :aliases => "-s", :required => true, :desc => "Which i18n files have the required keys? Expects i18n files to be in format <language>.yml"
+    method_option :target_languages, :type => :array, :aliases => "-t", :required => true, :desc => "The target languages"
+    method_option :base_path, :type => :string, :aliases => "-p", :default => '**/i18n/', :desc => "The path used to glob for .yml files matching the desired languages"
+    method_option :file, :type => :string, :aliases => "-f", :default => './tmp/translations.yml', :desc => "The target path of the aggregate file"
+    def compile
+      compile_options = {
+        :source_language => options[:source_language].to_sym,
+        :target_languages => options[:target_languages].map(&:to_sym),
+        :base_path => options[:base_path],
+        :to => options[:file]
+      }
+      Langulator.compile(compile_options)
+    end
+
+    method_option :file, :type => :string, :aliases => "-f", :default => './tmp/translations.yml', :desc => "The path of the aggregate file"
+    desc "decompile", "Split an aggregate into its respective i18n files"
+    def decompile
+      Langulator.decompile(:from => options[:file])
+    end
+
+  end
+end
+

data/lib/langulator/individual_translation.rb

@@ -0,0 +1,8 @@
+module Langulator
+  class IndividualTranslation < Translation
+
+    def language
+      @language ||= filename.gsub(".yml", '').to_sym
+    end
+  end
+end

data/lib/langulator/individual_translations.rb

@@ -0,0 +1,115 @@
+module Langulator
+  class IndividualTranslations
+    include Enumerable
+
+    attr_reader :translations, :aggregate_location, :base_path, :source_language, :target_languages
+    def initialize(options = {})
+      @aggregate_location = options[:to]
+      @base_path = options[:base_path]
+      @source_language = options[:source_language]
+      @target_languages = options[:target_languages]
+    end
+
+    def each
+      translations.each { |translation| yield translation }
+    end
+
+    def compile
+      aggregate.write
+    end
+
+    def <<(*objects)
+      @translations ||= []
+      objects.flatten.each do |obj|
+        translations << obj
+      end
+    end
+
+    def in(*languages)
+      select {|translation| languages.include?(translation.language)}
+    end
+
+    def source_translations
+      return [] unless source_language
+
+      self.in(source_language)
+    end
+
+    def target_translations
+      return [] unless target_languages
+
+      self.in(*target_languages)
+    end
+
+    def translations
+      @translations ||= load_translations
+    end
+
+    def aggregate
+      @aggregate ||= combine
+    end
+
+    private
+
+    def load_translations
+      i18ns = []
+      [source_language, *target_languages].each do |language|
+        paths.each do |path|
+          i18ns << IndividualTranslation.new(:path => path, :base_filename => language)
+        end
+      end
+      i18ns
+    end
+
+    def paths
+      @paths ||= locations.map {|location| location.gsub("#{source_language}.yml", '')}
+    end
+
+    def locations
+      @locations ||= Dir.glob("#{base_path}#{source_language}.yml")
+    end
+
+    def combine
+      dictionary = initialize_aggregate
+
+      target_translations.each do |i18n|
+        dictionary[i18n.path] = insert(i18n.language, i18n.translations, dictionary[i18n.path])
+      end
+
+      AggregateTranslation.new(:location => aggregate_location, :translations => dictionary)
+    end
+
+    def initialize_aggregate
+      dict = {}
+      source_translations.each do |i18n|
+        dict[i18n.path] = remap(i18n.language, i18n.translations)
+      end
+      dict
+    end
+
+    def remap(language, source)
+      target = {}
+      source.each do |key, value|
+        target[key] ||= {}
+        if value.is_a?(Hash)
+          target[key] = remap(language, value)
+        else
+          target[key][language] = value
+        end
+      end
+      target
+    end
+
+    def insert(language, source, target)
+      target.dup.each do |key, value|
+        if value.is_a?(Hash)
+          insert(language, (source || {})[key], value)
+        else
+          target[language] = source
+        end
+      end
+      target
+    end
+
+  end
+end

data/lib/langulator/translation.rb

@@ -0,0 +1,44 @@
+module Langulator
+  class Translation
+
+    attr_reader :location
+    def initialize(options = {})
+      @path = options[:path]
+      if options[:base_filename]
+        @filename = "#{options[:base_filename]}.yml"
+      end
+      @location = options[:location] || "#{@path}#{@filename}"
+      @translations = options[:translations]
+    end
+
+    def path
+      @path ||= location[/^(.*\/)/, 0] || "./"
+    end
+
+    def filename
+      @filename ||= location.gsub(path, '')
+    end
+
+    def translations
+      unless @translations
+        begin
+          @translations = read
+        rescue Errno::ENOENT => e
+          @translations = {}
+        end
+      end
+      @translations
+    end
+
+    def read
+      YAML.load(File.read(location))
+    end
+
+    def write
+      File.open(location, 'w:utf-8') do |file|
+        file.write translations.to_yaml
+      end
+    end
+
+  end
+end

data/spec/aggregate_translation_spec.rb

@@ -0,0 +1,45 @@
+require 'langulator/translation'
+require 'langulator/aggregate_translation'
+require 'langulator/individual_translation'
+require 'langulator/individual_translations'
+require 'translation_interface'
+
+describe Langulator::AggregateTranslation do
+  subject { Langulator::AggregateTranslation.new(:location => 'spec/fixtures/translations.yml') }
+
+  it_behaves_like "a translation"
+
+  its(:languages) { should eq([:klingon, :lolcode]) }
+
+  let(:combined) 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) do
+    dictionary = {"words" => {"affirmative" => "HISlaH", "negative" => "ghobe'", "hello" => "nuqneH"}}
+    Langulator::IndividualTranslation.new(:location => "spec/fixtures/klingon.yml", :translations => dictionary)
+  end
+
+  let(:lolcode) do
+    dictionary = {"words" => {"affirmative" => "YA RLY", "negative" => "NO WAI", "hello" => "O HAI"}}
+    Langulator::IndividualTranslation.new(:location => "spec/fixtures/lolcode.yml", :translations => dictionary)
+  end
+
+end

data/spec/fixtures/whatever.yml

@@ -0,0 +1,3 @@
+---
+some:
+  stuff: yadda yadda

data/spec/individual_translation_spec.rb

@@ -0,0 +1,13 @@
+require 'langulator/translation'
+require 'langulator/individual_translation'
+require 'translation_interface'
+
+describe Langulator::IndividualTranslation do
+
+  subject { Langulator::IndividualTranslation.new(:location => 'spec/fixtures/english.yml') }
+
+  it_behaves_like "a translation"
+
+  its(:language) { should eq(:english) }
+
+end

data/spec/individual_translations_spec.rb

@@ -0,0 +1,58 @@
+require 'langulator/translation'
+require 'langulator/individual_translation'
+require 'langulator/individual_translations'
+
+describe Langulator::IndividualTranslations do
+
+  describe "collection" do
+    subject { Langulator::IndividualTranslations.new(:source_language => :en, :target_languages => [:fr]) }
+
+    let(:english) { stub(:english, :language => :en, :translations => {"stuff" => "whatever"}) }
+    let(:english2) { stub(:english2, :language => :en, :translations => {"more" => "stuff"}) }
+    let(:french) { stub(:french, :language => :fr, :translations => {"truc" => "machin"}) }
+    let(:french2) { stub(:french2, :language => :fr, :translations => {"autre" => "bidule"}) }
+
+    before(:each) do
+      subject << english
+      subject << english2
+      subject << french
+      subject << french2
+    end
+
+    it "can accumulate many at a time" do
+      subject << [stub(:language => :nl), stub(:language => :cz)]
+      subject.map(&:language).uniq.should eq([:en, :fr, :nl, :cz])
+    end
+
+    it "can iterate through them" do
+      subject.map(&:language).should eq([:en, :en, :fr, :fr])
+    end
+
+    it "selects a language" do
+      subject.in(:en).should eq([english, english2])
+    end
+
+    it "provides the source_translations" do
+      subject.source_translations.should eq([english, english2])
+    end
+
+    it "provides the target translations" do
+      subject.target_translations.should eq([french, french2])
+    end
+  end
+
+  describe "loading from a path" do
+    let(:options) { {:source_language => :english, :target_languages => [:norsk], :base_path => 'spec/**/', :to => 'spec/fixtures/out.yml'} }
+    subject { Langulator::IndividualTranslations.new(options) }
+
+    its(:source_language) { should eq(:english) }
+    its(:target_languages) { should eq([:norsk]) }
+    its(:base_path) { should eq('spec/**/') }
+    its(:aggregate_location) { should eq('spec/fixtures/out.yml') }
+
+    it "loads the actual individual translations" do
+      subject.map(&:language).uniq.should eq([:english, :norsk])
+    end
+
+  end
+end

data/spec/translation_interface.rb

@@ -0,0 +1,7 @@
+shared_examples_for "a translation" do
+  it { subject.should respond_to(:filename) }
+  it { subject.should respond_to(:location) }
+  it { subject.should respond_to(:path) }
+  it { subject.should respond_to(:translations) }
+  it { subject.should respond_to(:write) }
+end

data/spec/translation_spec.rb

@@ -0,0 +1,59 @@
+require 'yaml'
+require 'langulator/translation'
+require 'translation_interface'
+
+describe Langulator::Translation do
+  subject { Langulator::Translation.new(:location => 'spec/fixtures/whatever.yml') }
+
+  it_behaves_like 'a translation'
+
+  its(:path) { should eq('spec/fixtures/') }
+  its(:location) { should eq('spec/fixtures/whatever.yml') }
+  its(:filename) { should eq('whatever.yml') }
+
+  describe "with a hyphen" do
+  subject { Langulator::Translation.new(:location => 'spec/fixtures/nb-no.yml') }
+    its(:filename) { should eq('nb-no.yml') }
+  end
+
+  describe "in the current directory" do
+    subject { Langulator::Translation.new(:location => 'whatever.yml') }
+    its(:path) { should eq('./') }
+    its(:filename) { should eq('whatever.yml') }
+  end
+
+  describe 'with a missing file' do
+    subject { Langulator::Translation.new(:location => 'spec/fixtures/does_not_exist.yml') }
+    its(:path) { should eq('spec/fixtures/') }
+    its(:filename) { should eq('does_not_exist.yml') }
+    its(:translations) { should eq({}) }
+  end
+
+  describe "with a path and base filename" do
+    subject { Langulator::Translation.new(:path => 'spec/fixtures/', :base_filename => 'whatever') }
+    its(:path) { should eq('spec/fixtures/') }
+    its(:location) { should eq('spec/fixtures/whatever.yml') }
+    its(:filename) { should eq('whatever.yml') }
+  end
+
+  its(:translations) { should eq({"some" => {"stuff" => "yadda yadda"}}) }
+
+  describe "with provided translations" do
+    subject { Langulator::Translation.new(:location => './nonexistant.yml', :translations => {"do" => "something"}) }
+    its(:translations) { should eq({"do" => "something"}) }
+  end
+
+  describe "#write" do
+    let(:location) { 'spec/fixtures/xy.yml' }
+    subject { Langulator::Translation.new(:location => location, :translations => {"some" => "stuff"}) }
+
+    before(:each) { FileUtils.rm(location) if File.exists?(location) }
+    after(:each) { FileUtils.rm(location) if File.exists?(location) }
+
+    it "outputs the content to the given location" do
+      subject.write
+
+      Langulator::Translation.new(:location => location).translations.should eq({"some" => "stuff"})
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: langulator
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-05 00:00:00.000000000 Z
+date: 2012-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70204764441280 !ruby/object:Gem::Requirement
+  requirement: &70268228073700 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,29 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70204764441280
+  version_requirements: *70268228073700
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &70268228072740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70268228072740
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70268228071780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70268228071780
 description: Manage, maintain, and munge your i18n files.
 email:
 - katrina.owen@gmail.com
@@ -36,16 +58,33 @@ files:
 - README.md
 - Rakefile
 - bin/langulator
+- features/compile_aggregate.feature
+- features/decompile_aggregate.feature
+- features/fixtures/en.yml
+- features/fixtures/fr.yml
+- features/fixtures/in.yml
+- features/fixtures/lang/en.yml
+- features/fixtures/lang/fr.yml
+- features/step_definitions/aggregate_steps.rb
+- features/support/env.rb
+- features/support/hooks.rb
 - langulator.gemspec
 - lib/langulator.rb
-- lib/langulator/aggregate.rb
-- lib/langulator/loader.rb
-- spec/aggregate_spec.rb
+- lib/langulator/aggregate_translation.rb
+- lib/langulator/cli.rb
+- lib/langulator/individual_translation.rb
+- lib/langulator/individual_translations.rb
+- lib/langulator/translation.rb
+- spec/aggregate_translation_spec.rb
 - spec/fixtures/english.yml
 - spec/fixtures/lang/english.yml
 - spec/fixtures/norsk.yml
 - spec/fixtures/translations.yml
-- spec/loader_spec.rb
+- spec/fixtures/whatever.yml
+- spec/individual_translation_spec.rb
+- spec/individual_translations_spec.rb
+- spec/translation_interface.rb
+- spec/translation_spec.rb
 homepage: http://github.com/kytrinyx/langulator
 licenses: []
 post_install_message: 
@@ -71,9 +110,23 @@ signing_key:
 specification_version: 3
 summary: Tasks to keep your i18n files managable.
 test_files:
-- spec/aggregate_spec.rb
+- features/compile_aggregate.feature
+- features/decompile_aggregate.feature
+- features/fixtures/en.yml
+- features/fixtures/fr.yml
+- features/fixtures/in.yml
+- features/fixtures/lang/en.yml
+- features/fixtures/lang/fr.yml
+- features/step_definitions/aggregate_steps.rb
+- features/support/env.rb
+- features/support/hooks.rb
+- spec/aggregate_translation_spec.rb
 - spec/fixtures/english.yml
 - spec/fixtures/lang/english.yml
 - spec/fixtures/norsk.yml
 - spec/fixtures/translations.yml
-- spec/loader_spec.rb
+- spec/fixtures/whatever.yml
+- spec/individual_translation_spec.rb
+- spec/individual_translations_spec.rb
+- spec/translation_interface.rb
+- spec/translation_spec.rb

data/lib/langulator/aggregate.rb

@@ -1,124 +0,0 @@
-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,44 +0,0 @@
-module Langulator
-  class Loader
-
-    attr_reader :base_path, :languages
-    def initialize(options = {})
-      @base_path = options[:base_path]
-      @languages = [options[:source_language]] + options[:target_languages]
-    end
-
-    def paths
-      unless @paths
-        filename = "#{languages.first}.yml"
-        @paths = Dir.glob("#{base_path}#{filename}").map {|file| file.gsub(filename, '') }.sort
-      end
-      @paths
-    end
-
-    def translations
-      translations = {}
-      languages.each do |language|
-        translations[language] = load_translations(language)
-      end
-      translations
-    end
-
-    def load_translations(language)
-      translations = {}
-      paths.each do |path|
-        translations[path] = read_translations(path, language)
-      end
-      translations
-    end
-
-    def read_translations(path, language)
-      file = "#{path}#{language}.yml"
-      if File.exists?(file)
-        YAML.load(File.read(file))
-      else
-        {}
-      end
-    end
-
-  end
-end

data/spec/aggregate_spec.rb

@@ -1,141 +0,0 @@
-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/loader_spec.rb

@@ -1,46 +0,0 @@
-# encoding: utf-8
-require 'yaml'
-require 'langulator/loader'
-
-describe Langulator::Loader do
-
-  let(:english) do
-    {
-      "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"
-        }
-      }
-    }
-  end
-
-  let(:norwegian) do
-    {
-      "spec/fixtures/" => {
-        "food" => {
-          "lunch" => "smørbrød"
-        }
-      },
-      "spec/fixtures/lang/" => {}
-    }
-  end
-
-  let(:french) do
-    {
-      "spec/fixtures/" => {},
-      "spec/fixtures/lang/" => {}
-    }
-  end
-
-  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