i18n-tools 0.0.4 → 0.0.5

data/lib/i18n/index/file.rb

@@ -0,0 +1,55 @@
+module I18n
+  module Index
+    class Files < Hash
+      def [](filename)
+        fetch(filename) 
+      rescue
+        store(filename, File.new(filename))
+      end
+    end
+    
+  	class File
+  	  attr_accessor :filename
+
+  	  def initialize(filename)
+  	    self.filename = filename
+	    end
+
+	    def source
+	      @source ||= begin
+	        source = ::File.read(filename) # TODO srsly ... how am i supposed to open a file in ruby 1.9?
+	        source = ::File.open(filename, 'r:iso-8859-1:utf-8') { |f| f.read } unless source.valid_encoding?
+	        source
+        end
+      end
+	    
+	    def ruby
+	      @ruby ||= begin
+	        parser.parse
+	      rescue Ripper::RubyBuilder::ParseError => e
+	        puts "\nWARNING Ruby 1.9 incompatible syntax in: " + e.message.gsub(Dir.pwd, '') + ". Can not index file."
+	        Ruby::Program.new(source, filename)
+        end
+      end
+      
+      def calls
+        @calls ||= ruby.select_translate_calls
+      end
+      
+      def update(source)
+        @source = source
+        save
+      end
+
+	    def save
+        ::File.open(filename, 'w+') { |f| f.write(source) } # TODO need to modify/write unfiltered source for ERB
+      end
+      
+      protected
+
+        def parser
+          @parser ||= Index.parser.new(source, filename)
+        end
+	  end
+  end
+end

data/lib/i18n/index/format.rb

@@ -0,0 +1,49 @@
+# wicked. but i can't see a better pattern right now. i want a module to include
+# into the meta_class. and i don't want to set the io object globally (or on
+# any class or module var) so i need to instantiate something, too.
+
+module I18n
+  module Index
+    module Format
+      class Base
+        attr_accessor :io
+
+        def initialize(io = nil)
+          self.io = io || $stdout
+        end
+        
+        def out(str)
+          io.print(str)
+        end
+
+        def setup(target)
+          $stdout.sync = true
+          (class << target; self; end).send(:include, self.class::Hooks)
+          target.format = self
+        end
+      end
+
+      class Stdout < Base
+        module Hooks
+          attr_accessor :format
+          
+          def build(*args)
+            format.out "indexing files ... "
+            super
+            format.out "found #{occurences.size} occurences of #{keys.size} keys in #{filenames.size} files in total\n"
+          end
+
+          def save
+            format.out "saving index\n"
+            super
+          end
+
+          def parse(file)
+            format.out '.'
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n/index/key.rb

@@ -0,0 +1,45 @@
+module I18n
+  module Index
+    class Key
+      class << self
+        def patterns(*keys)
+          keys.inject({}) { |result, key| result[key] = pattern(key); result }
+        end
+
+        def pattern(key)
+          key = key.to_s.dup
+          match_start = key.gsub!(/^\*/, '') ? '' : '^'
+          match_end = key.gsub!(/\*$/, '') ? '' : '$'
+          pattern = Regexp.escape("#{key}")
+          /#{match_start}#{pattern}#{match_end}/
+        end
+      end
+      
+      attr_accessor :key
+      
+      def initialize(key)
+        self.key = key
+      end
+      
+      def matches?(*keys)
+        patterns = Key.patterns(*keys)
+        patterns.empty? || patterns.any? do |key, pattern|
+          self.key == key.to_sym || self.key.to_s =~ pattern
+        end
+      end
+      
+      def <=>(other)
+        key <=> other.key
+      end
+      
+      def ==(other)
+        key == (other.respond_to?(:key) ? other.key : other)
+      end
+      alias eql? ==
+      
+      def hash
+        key.hash
+      end
+    end
+  end
+end

data/lib/i18n/index/occurence.rb

@@ -0,0 +1,18 @@
+module I18n
+  module Index
+  	class Occurence
+  		attr_reader :key, :filename, :position
+		
+  		def initialize(key, filename, position)
+  		  @key = key
+  		  @filename = filename
+  		  @position = position
+  	  end
+      
+      def ==(other)
+        key == other.key && filename == other.filename && position == other.position
+      end
+      alias eql? ==
+  	end
+	end
+end

data/lib/i18n/index/simple.rb

@@ -0,0 +1,69 @@
+require 'i18n/index/base'
+require 'i18n/index/key'
+require 'i18n/index/occurence'
+require 'i18n/index/format'
+require 'i18n/index/simple/storage'
+require 'i18n/index/simple/data'
+require 'erb/stripper'
+
+module I18n
+  module Index
+    class Simple < Base
+      include Storage
+
+    	def find_call(*keys)
+    		return unless key = data.keys.detect { |key, data| key.matches?(*keys) }
+    		occurence = data.occurences(key).first
+    		files[occurence.filename].ruby.select_translate_calls(:position => occurence.position).first
+    	end
+
+    	def find_calls(*keys)
+    		keys = data.keys.select { |key, data| key.matches?(*keys) }
+    		occurences = keys.map { |key| data.occurences(key) }.flatten
+    		occurences.map do |occurence|
+    		  files[occurence.filename].ruby.select_translate_calls(:position => occurence.position)
+  		  end.flatten
+    	end
+
+      def replace_key(call, search, replacement)
+        data.remove(call)
+        call.replace_key(search.to_s.gsub(/[^\w\.]/, ''), replacement.to_sym)
+        files[call.filename].update(call.root.src)
+        data.add(call)
+        save if built?
+      end
+
+      def data
+        @data ||= Data.new
+        build unless built?
+        @data
+      end
+
+      def keys
+        data.keys
+      end
+
+      def occurences
+        data.values.map { |value| value[:occurences] }.flatten
+      end
+
+      protected
+
+        def reset!
+          @built = false
+          @data = nil
+        end
+
+        def built?
+          @built
+        end
+
+        def build
+          reset!
+          @built = true
+          calls = filenames.map { |filename| files[filename].calls }.flatten
+          calls.each { |call| data.add(call) }
+        end
+  	end
+  end
+end

data/lib/i18n/index/simple/data.rb

@@ -0,0 +1,34 @@
+module I18n
+  module Index
+    class Simple < Base
+      class Data < Hash
+        def add(call)
+    	    key = Key.new(call.full_key(true))
+    	    occurences(key) << Occurence.new(key, call.filename, call.position)
+  	    end
+  	    
+        def remove(call)
+    	    key = Key.new(call.full_key(true))
+    	    occurences = occurences(key)
+    	    occurences.delete(Occurence.new(key, call.filename, call.position))
+    	    self.delete(key) if occurences.empty?
+  	    end
+	    
+  	    def occurences(key)
+  	      self[key] ||= { :occurences => [] }
+  	      self[key][:occurences]
+        end
+        
+        def [](key)
+          key = Key.new(key) unless key.is_a?(Key)
+          super
+        end
+
+        def []=(key, value)
+          key = Key.new(key) unless key.is_a?(Key)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/i18n/index/simple/storage.rb

@@ -0,0 +1,79 @@
+module I18n
+  module Index
+    class Simple < Base
+      module Storage
+        class << self
+          def included(target)
+            target.send(:extend, ClassMethods)
+          end
+        end
+        
+        module ClassMethods
+          def load_or_create(options = {})
+            exists?(options) ? load(options) : create(options)
+          end
+
+          protected
+
+            def create(options = {})
+              index = Simple.new(options)
+              index.update
+              index
+            end
+
+            def load(options)
+              ::File.open(filename(options), 'r') { |f| ::Marshal.load(f) }
+            end
+
+            def exists?(options)
+              ::File.exists?(filename(options))
+            end
+
+            def filename(options)
+              store_dir(options) + "/index.marshal"
+            end
+
+            def store_dir(options)
+              root_dir = options[:root_dir] || Dir.pwd
+              ::File.expand_path(root_dir + '/.i18n')
+            end
+        end
+      end
+
+      def exists?
+        ::File.exists?(filename)
+      end
+
+      def update
+        reset!
+        build
+        save
+      end
+
+      def save
+        mkdir
+        ::File.open(filename, 'w+') { |f| ::Marshal.dump(self, f) }
+      end
+
+      def delete
+        FileUtils.rm(filename) if exists? rescue Errno::ENOENT
+      end
+
+      def filename
+        self.class.send(:filename, :root_dir => root_dir)
+      end
+      
+      def store_dir
+        self.class.send(:store_dir, :root_dir => root_dir)
+      end
+      
+      def mkdir
+        FileUtils.mkdir_p(store_dir) unless ::File.exists?(store_dir)
+      end
+      
+      def marshalled_vars
+        super + [:built, :data]
+      end
+    end
+  end
+end

data/lib/i18n/ripper2ruby.rb

@@ -0,0 +1,7 @@
+require 'core_ext/object/meta_class'
+
+require 'ripper/ruby_builder'
+require 'ruby/call'
+
+require 'i18n/ripper2ruby/translate_call'
+require 'i18n/ripper2ruby/translate_args_list'

data/lib/i18n/ripper2ruby/translate_args_list.rb

@@ -0,0 +1,89 @@
+module Ruby
+  class ArgsList
+    def to_translate_args_list
+      meta_class.send(:include, TranslateArgsList)
+      self
+    end
+  end
+
+  module TranslateArgsList
+    def full_key(joined = false)
+      full_key = normalize_keys(scope, key)
+      joined ? join_key(full_key) : full_key
+    end
+
+    def key
+      first.arg.value if first
+    end
+
+    def scope
+      last.arg.is_a?(Ruby::Hash) ? last.arg.value[:scope] : nil
+    end
+
+    def key_matches?(keys)
+      keys = normalize_keys(keys)
+      keys == full_key[0, keys.length]
+    end
+
+    def replace_key(search, replace)
+      original_length = length
+      self.key, self.scope = compute_replace_keys(search, replace)
+      root.replace_src(row, column, original_length, to_ruby)
+    end
+
+    protected
+
+      def key=(key)
+        self[0] = key
+      end
+
+      def scope=(scope)
+        if scope
+          set_option(:scope, scope)
+        elsif options
+          options.delete(:scope)
+          pop if options.arg.empty?
+        end
+      end
+
+      def compute_replace_keys(search, replace)
+        search  = normalize_keys(search)
+        replace = normalize_keys(replace)
+        key     = normalize_keys(self.key)
+        scope   = normalize_keys(self.scope)
+        all     = scope + key
+
+        all[key_index(search), search.length] = replace
+
+        if scope.empty?
+          key = all
+        else
+          key = all.slice!(-[key.length, all.size].min..-1) # i.e. we preserve the key length, this is debatable
+          scope = all.empty? ? nil : all
+          # scope = all.slice!(0, scope.length)     # this would preserve the scope length
+          # key = all                               # comment this in, previous lines out and observe the tests
+        end
+
+        key = [scope.pop] if key.empty?
+        scope = scope.first if scope && scope.size == 1
+        scope = nil if scope && scope.empty?
+
+        [join_key(key), scope]
+      end
+
+      def key_index(search)
+        (all = full_key).each_index { |ix| return ix if all[ix, search.length] == search } and nil
+      end
+
+      def join_key(key)
+        key.map { |k| k.to_s }.join('.').to_sym
+      end
+
+      def normalize_keys(*args)
+        args.flatten.
+            map { |k| k.to_s.split(/\./) }.flatten.
+            reject { |k| k.empty? }.
+            map { |k| k.to_sym }
+      end
+  end
+end