i18nliner 0.0.1

data/lib/i18nliner/extractors/translate_call.rb

@@ -0,0 +1,111 @@
+require 'i18nliner/call_helpers'
+require 'i18nliner/errors'
+
+module I18nliner
+  module Extractors
+    class TranslateCall
+      include CallHelpers
+
+      def initialize(scope, line, receiver, method, args)
+        @scope = scope
+        @line = line
+        @receiver = receiver
+        @method = method
+
+        normalize_arguments(args)
+
+        validate
+        normalize
+      end
+
+      def validate
+        validate_key
+        validate_default
+        validate_options
+      end
+
+      def normalize
+        @key = normalize_key(@key, @scope, @receiver)
+        @default = normalize_default(@default, @options || {})
+      end
+
+      def translations
+        return [] unless @default
+        return [[@key, @default]] if @default.is_a?(String)
+        @default.map { |key, value|
+          ["#{@key}.#{key}", value]
+        }
+      end
+
+      def validate_key
+      end
+
+      def validate_default
+        return unless @default.is_a?(Hash)
+        if (keys = @default.keys - ALLOWED_PLURALIZATION_KEYS).size > 0
+          raise InvalidPluralizationKeyError.new(@line, keys)
+        elsif REQUIRED_PLURALIZATION_KEYS & (keys = @default.keys) != REQUIRED_PLURALIZATION_KEYS
+          raise MissingPluralizationKeyError.new(@line, keys)
+        else
+          @default.values.each do |value|
+            raise InvalidPluralizationDefaultError.new(@line, value) unless value.is_a?(String)
+          end
+        end
+
+        unless I18nliner.infer_interpolation_values
+          if @default.is_a?(String)
+            validate_interpolation_values(@key, @default)
+          else
+            @default.each_pair do |sub_key, default|
+              validate_interpolation_values("#{@key}.#{sub_key}", default)
+            end
+          end
+        end
+      end
+
+     private
+
+      # Possible translate signatures:
+      #
+      # key [, options]
+      # key, default_string [, options]
+      # key, default_hash, options
+      # default_string [, options]
+      # default_hash, options
+      def normalize_arguments(args)
+        raise InvalidSignatureError.new(@line, args) if args.empty?
+
+        has_key = key_provided?(@scope, @receiver, *args)
+        args.unshift infer_key(args[0]) if !has_key && args[0].is_a?(String) || args[0].is_a?(Hash)
+
+        # [key, options] -> [key, nil, options]
+        args.insert(1, nil) if has_key && args[1].is_a?(Hash) && args[2].nil?
+
+        @key, @default, @options, *others = args
+
+        raise InvalidSignatureError.new(@line, args) if !others.empty?
+        raise InvalidSignatureError.new(@line, args) unless @key.is_a?(Symbol) || @key.is_a?(String)
+        raise InvalidSignatureError.new(@line, args) unless @default.nil? || @default.is_a?(String) || @default.is_a?(Hash)
+        raise InvalidSignatureError.new(@line, args) unless @options.nil? || @options.is_a?(Hash)
+      end
+
+      def validate_interpolation_values(key, default)
+        default.scan(/%\{([^\}]+)\}/) do |match|
+          placeholder = match[0].to_sym
+          next if @options.include?(placeholder)
+          raise MissingInterpolationValueError.new(@line, placeholder)
+        end
+      end
+
+      def validate_options
+        if @default.is_a?(Hash)
+          raise MissingCountValueError.new(@line) unless @options && @options.key?(:count)
+        end
+        return if @options.nil?
+        @options.keys.each do |key|
+          raise InvalidOptionKeyError.new(@line) unless key.is_a?(String) || key.is_a?(Symbol)
+        end
+      end
+    end
+  end
+end

data/lib/i18nliner/extractors/translation_hash.rb

@@ -0,0 +1,45 @@
+module I18nLine
+  module Extractors
+    class TranslationHash < Hash
+      attr_accessor :line
+
+      def self.new(hash)
+        hash.is_a?(self) ? hash : super
+      end
+  
+      def initialize(*args)
+        super
+        @total_size = 0
+      end
+  
+      def []=(key, value)
+        parts = key.split('.')
+        leaf = parts.pop
+        hash = self
+        while part = parts.shift
+          if hash[part]
+            unless hash[part].is_a?(Hash)
+              intermediate_key = key.sub((parts + [leaf]).join('.'), '')
+              raise KeyAsScopeError, intermediate_key
+            end
+          else
+            hash[part] = {}
+          end
+          hash = hash[part]
+        end
+        if hash[leaf]
+          if hash[leaf] != default
+            if hash[leaf].is_a?(Hash)
+              raise KeyAsScopeError.new(@line, key)
+            else
+              raise KeyInUseError.new(@line, key)
+            end
+          end
+        else
+          @total_size += 1
+          hash[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/i18nliner/processors/abstract_processor.rb

@@ -0,0 +1,33 @@
+module I18nliner
+  module Processors
+    class AbstractProcessor
+      def initialize(translations, options = {})
+        @translations = translations
+        @only = options[:only]
+        @checker = options[:checker] || methods(:noop_checker)
+      end
+
+      def noop_checker(file)
+        yield file
+      end
+
+      def files
+        @files ||= begin
+          files = Globby.select(@pattern)
+          files = files.select(@only) if @only
+          files.reject(I18nliner.ignore)
+        end
+      end
+
+      def check_files
+        files.each do |file|
+          @checker.call file, &methods(:check_file)
+        end
+      end
+
+      def self.inherited(klass)
+        Processors.register klass
+      end
+    end
+  end
+end

data/lib/i18nliner/processors/erb_processor.rb

@@ -0,0 +1,16 @@
+module I18nliner
+  module Processors
+    class ErbProcessor < RubyProcessor
+      def source_for(file)
+        # TODO: pre-process for block fu
+        Erubis::Eruby.new(super).src
+      end
+
+      def scope_for(path)
+        scope = path.gsub(/(\A|.*\/)app\/views\/|\.html\z|(\.html)?\.erb\z/, '')
+        scope = scope.gsub(/\/_?/, '.')
+        Scope.new(scope, :allow_relative => true)
+      end
+    end
+  end
+end

data/lib/i18nliner/processors/ruby_processor.rb

@@ -0,0 +1,22 @@
+module I18nliner
+  module Processors
+    class RubyProcessor < AbstractProcessor
+      def check_file(file)
+        sexps = RubyParser.new.parse(source_for(file))
+        extractor = Extractors::RubyExtractor.new(sexps, scope_for(file))
+        extractor.each_translation do |key, value|
+          @translations.line = extractor.line
+          @translations[key] = value
+        end
+      end
+
+      def source_for(file)
+        File.read(file)
+      end
+
+      def scope_for(path)
+        Scope.new
+      end
+    end
+  end
+end

data/lib/i18nliner/processors.rb

@@ -0,0 +1,11 @@
+module I18nliner
+  module Processors
+    def self.register(klass)
+      (@processors ||= []) << klass
+    end
+
+    def self.all
+      @processors.dup
+    end
+  end
+end

data/lib/i18nliner/scope.rb

@@ -0,0 +1,24 @@
+module I18nliner
+  class Scope
+    attr_reader :scope
+
+    def initialize(scope = nil, options = {})
+      @scope = scope ? "#{scope}." : scope
+      @options = {
+        :allow_relative => false
+      }.merge(options)
+    end
+
+    def allow_relative?
+      @options[:allow_relative]
+    end
+
+    def normalize_key(key)
+      if allow_relative? && (key = key.dup) && key.sub!(/\A\./, '')
+        scope + key
+      else
+        key
+      end
+    end
+  end
+end

data/lib/i18nliner.rb

@@ -0,0 +1,31 @@
+require 'active_support/core_ext/string/inflections'
+
+module I18nliner
+  def self.translations
+  end
+
+  def self.look_up(*args)
+  end
+
+  def self.setting(key, value)
+    instance_eval <<-CODE
+      def #{key}(value = nil)
+        if value && block_given?
+          begin
+            value_was = @#{key}
+            @#{key} = value
+            yield
+          ensure
+            @#{key} = value_was
+          end
+        else
+          @#{key} = #{value.inspect} if @#{key}.nil?
+          @#{key}
+        end
+      end
+    CODE
+  end
+
+  setting :inferred_key_format,        :underscored_crc32
+  setting :infer_interpolation_values, true
+end

data/lib/tasks/i18nliner.rake

@@ -0,0 +1,14 @@
+namespace :i18nliner do
+  desc "Verifies all translation calls"
+  task :check => :environment do
+    options = {:only => ENV['ONLY'])}
+    @command = I18nliner::Commands::Check.run(options) or exit 1
+  end
+
+  desc "Generates a new [default_locale].yml file for all translations"
+  task :dump => :check do
+    options = {:translations => @command.translations}
+    @command = I18nliner::Commands::Dump.run(options) or exit 1
+  end
+end
+

data/spec/extractors/ruby_extractor_spec.rb

@@ -0,0 +1,61 @@
+require 'sexp_processor'
+require 'ruby_parser'
+require 'i18nliner'
+require 'i18nliner/errors'
+require 'i18nliner/scope'
+require 'i18nliner/extractors/ruby_extractor'
+require 'i18nliner/extractors/translate_call'
+
+describe I18nliner::Extractors::RubyExtractor do
+  def extract(source, scope = I18nliner::Scope.new(nil))
+    sexps = RubyParser.new.parse(source)
+    extractor = I18nliner::Extractors::RubyExtractor.new(sexps, scope)
+    translations = []
+    extractor.each_translation { |translation| translations << translation }
+    Hash[translations]
+  end
+
+  def assert_error(*args)
+    error = args.pop
+    expect {
+      extract(*args)
+    }.to raise_error(error)
+  end
+
+  describe "#each_translation" do
+    it "should ignore non-t calls" do
+      extract("foo 'Foo'").should == {}
+    end
+
+    it "should not extract t calls with no default" do
+      extract("t :foo").should == {}
+    end
+
+    it "should extract valid t calls" do
+      if false
+      extract("t 'Foo'").should ==
+        {"foo_f44ad75d" => "Foo"}
+      extract("t :bar, 'Baz'").should ==
+        {"bar" => "Baz"}
+      extract("t 'lol', 'wut'").should ==
+        {"lol" => "wut"}
+      extract("translate 'one', {:one => '1', :other => '2'}, :count => 1").should == 
+        {"one.one" => "1", "one.other" => "2"}
+      extract("t({:one => 'just one', :other => 'zomg lots'}, :count => 1)").should ==
+        {"zomg_lots_a54248c9.one" => "just one", "zomg_lots_a54248c9.other" => "zomg lots"}
+      extract("t 'foo2', <<-STR\nFoo\nSTR").should ==
+        {'foo2' => "Foo"}
+      end
+      extract("t 'foo', 'F' + 'o' + 'o'").should ==
+        {'foo' => "Foo"}
+    end
+
+    it "should bail on invalid t calls" do
+      assert_error "t foo", I18nliner::InvalidSignatureError
+      assert_error "t :foo, foo", I18nliner::InvalidSignatureError
+      assert_error "t :foo, \"hello \#{man}\"", I18nliner::InvalidSignatureError
+      assert_error "t :a, \"a\", {}, {}", I18nliner::InvalidSignatureError
+      assert_error "t({:one => '1', :other => '2'})", I18nliner::MissingCountValueError
+    end
+  end
+end

data/spec/extractors/translate_call_spec.rb

@@ -0,0 +1,154 @@
+require 'i18nliner'
+require 'i18nliner/scope'
+require 'i18nliner/extractors/translate_call'
+
+describe I18nliner::Extractors::TranslateCall do
+  def call(scope, *args)
+    I18nliner::Extractors::TranslateCall.new(scope, nil, nil, :t, args)
+  end
+
+  let(:no_scope) { I18nliner::Scope.new(nil) }
+  let(:scope) { I18nliner::Scope.new("foo", :auto => true, :allow_relative => true) }
+
+  describe "signature" do
+    it "should reject extra arguments" do
+      expect {
+        call(no_scope, :key, "value", {}, :wat)
+      }.to raise_error(I18nliner::InvalidSignatureError)
+    end
+
+    it "should accept a valid key or default" do
+      expect {
+        call(no_scope, "key", "value", {})
+      }.to_not raise_error
+
+      expect {
+        call(no_scope, "key_or_value", {})
+      }.to_not raise_error
+
+      expect {
+        call(no_scope, :key, {})
+      }.to_not raise_error
+    end
+
+    it "should require at least a key or default" do
+      expect {
+        call(no_scope)
+      }.to raise_error(I18nliner::InvalidSignatureError)
+    end
+
+    it "should require a literal default" do
+      expect {
+        call(no_scope, :key, Object.new)
+      }.to raise_error(I18nliner::InvalidSignatureError)
+    end
+
+    it "should ensure options is a hash, if provided" do
+      expect {
+        call(no_scope, :key, "value", Object.new)
+      }.to raise_error(I18nliner::InvalidSignatureError)
+    end
+  end
+
+  describe "key inference" do
+    it "should generate literal keys" do
+      I18nliner.inferred_key_format :literal do
+        call(no_scope, "zomg key").translations.should ==
+          [["zomg key", "zomg key"]]
+      end
+    end
+
+    it "should generate underscored keys" do
+      I18nliner.inferred_key_format :underscored do
+        call(no_scope, "zOmg key!!").translations.should ==
+          [["zomg_key", "zOmg key!!"]]
+      end
+    end
+
+    it "should generate underscored + crc32 keys" do
+      I18nliner.inferred_key_format :underscored_crc32 do
+        call(no_scope, "zOmg key!!").translations.should ==
+          [["zomg_key_90a85b0b", "zOmg key!!"]]
+      end
+    end
+  end
+
+  describe "normalization" do
+    it "should make keys absolute if scoped" do
+      call(scope, '.key', "value").translations[0][0].should =~ /\Afoo\.key/
+    end
+
+    it "should strip whitespace from defaults" do
+      call(no_scope, "\t whitespace \n\t ").translations[0][1].should == "whitespace"
+    end
+  end
+
+  describe "pluralization" do
+    describe "defaults" do
+      it "should be inferred" do
+        translations = call(no_scope, "person", {:count => Object.new}).translations
+        translations.map(&:last).sort.should == ["%{count} people", "1 person"]
+      end
+
+      it "should not be inferred if given multiple words" do
+        translations = call(no_scope, "happy person", {:count => Object.new}).translations
+        translations.map(&:last).should == ["happy person"]
+      end
+    end
+
+    it "should accept valid hashes" do
+      call(no_scope, {:one => "asdf", :other => "qwerty"}, :count => 1).translations.sort.should ==
+        [["qwerty_98185351.one", "asdf"], ["qwerty_98185351.other", "qwerty"]]
+      call(no_scope, :some_stuff, {:one => "asdf", :other => "qwerty"}, :count => 1).translations.sort.should ==
+        [["some_stuff.one", "asdf"], ["some_stuff.other", "qwerty"]]
+    end
+
+    it "should reject invalid keys" do
+      expect {
+        call(no_scope, {:one => "asdf", :twenty => "qwerty"}, :count => 1)
+      }.to raise_error(I18nliner::InvalidPluralizationKeyError)
+    end
+
+    it "should require essential keys" do
+      expect {
+        call(no_scope, {:one => "asdf"}, :count => 1)
+      }.to raise_error(I18nliner::MissingPluralizationKeyError)
+    end
+
+    it "should reject invalid count defaults" do
+      expect {
+        call(no_scope, {:one => "asdf", :other => Object.new}, :count => 1)
+      }.to raise_error(I18nliner::InvalidPluralizationDefaultError)
+    end
+
+    it "should complain if no :count is provided" do
+      expect {
+        call(no_scope, {:one => "asdf", :other => "qwerty"})
+      }.to raise_error(I18nliner::MissingCountValueError)
+    end
+  end
+
+  describe "validation" do
+    it "should require all interpolation values" do
+      I18nliner.infer_interpolation_values false do
+        expect {
+          call(no_scope, "asdf %{bob}")
+        }.to raise_error(I18nliner::MissingInterpolationValueError)
+      end
+    end
+
+    it "should require all interpolation values in count defaults" do
+      I18nliner.infer_interpolation_values false do
+        expect {
+          call(no_scope, {:one => "asdf %{bob}", :other => "querty"})
+        }.to raise_error(I18nliner::MissingInterpolationValueError)
+      end
+    end
+
+    it "should ensure option keys are symbols or strings" do
+      expect {
+        call(no_scope, "hello", {Object.new => "okay"})
+      }.to raise_error(I18nliner::InvalidOptionKeyError)
+    end
+  end
+end