i18n-tools 0.0.4 → 0.0.5

data/lib/i18n/keys/formatter.rb

@@ -1,39 +0,0 @@
-module I18n
-  module Keys
-    class Index
-      module Formatter
-        module Setup
-          def setup(target)
-            (class << target; self; end).send(:include, self)
-          end
-        end
-
-        module Stdin
-          extend Setup
-
-          def build(*args)
-            puts "building index \"#{name}\"" if I18n::Keys.verbose?
-            super
-            puts "\nfound #{occurences.size} occurences of #{keys.size} keys in #{files.size} files" if I18n::Keys.verbose?
-          end
-
-          def save
-            puts "saving index \"#{name}\"" if I18n::Keys.verbose?
-            super
-          end
-
-          def parse(file)
-            # puts "  parsing #{file}" if I18n::Keys.verbose?
-            putc '.' if I18n::Keys.verbose?
-            super
-          end
-
-          # def each(*keys)
-          #   puts "iterating occurences of: #{keys.map { |key| key.to_sym.inspect }.join(', ')}" if I18n::Keys.verbose?
-          #   super
-          # end
-        end
-      end
-    end
-  end
-end

data/lib/i18n/keys/index.rb

@@ -1,209 +0,0 @@
-require 'yaml'
-require File.dirname(__FILE__) + '/formatter'
-require File.dirname(__FILE__) + '/occurence'
-
-# Keys.index(:default, :pattern => '/**/*.{rb,erb}').each(:foo, :bar) { |occurence| ... }
-#
-# when the :index name is not given it creates the index on the fly but won't save it
-# when the :index name is true it uses :default as an index name
-#
-# when an index with the given name does not exist it builds and saves an index
-# when an index with the given name exists and the given pattern does not match
-#   the index's pattern it issues a warning and rebuilds the index
-#
-# when no keys are given, occurences of all keys will be iterated
-# when keys are given, only occurences of the given keys will be iterated
-
-module I18n
-  module Keys
-    class Index
-      include Enumerable
-
-      @@formatter = Formatter::Stdin
-      @@default_pattern = '/**/*.{rb,erb}'
-
-      class << self
-        def load_or_create_or_init(*args)
-          options = args.last.is_a?(Hash) ? args.pop : {}
-          name = TrueClass === args.first ? :default : args.first
-          index = name ? load_or_create(name, options) : new(name, options)
-          index
-        end
-
-        def load_or_create(*args)
-          options = args.last.is_a?(Hash) ? args.pop : {}
-          name = args.first || :default
-          exists?(name) ? load(name) : create(name, options)
-        end
-
-        def create(*args)
-          index = new(*args)
-          index.update
-          index
-        end
-
-        def load(name)
-          File.open(filename(name), 'r') { |f| Marshal.load(f) } if exists?
-        end
-
-        def mk_dir
-          FileUtils.mkdir_p(store_dir) unless exists?
-        end
-
-        def exists?(name = nil)
-          name ? File.exists?(filename(name)) : File.exists?(store_dir)
-        end
-
-        def delete(name)
-          new(name).delete
-        end
-
-        def delete_all
-          FileUtils.rm_r(store_dir) if exists? rescue Errno::ENOENT
-        end
-
-        def filename(name)
-          store_dir + "/#{name.to_s}.marshal"
-        end
-
-        def store_dir
-          File.expand_path(Keys.meta_dir + '/indizes')
-        end
-      end
-
-      attr_reader :name
-
-      [:keys, :occurences, :by_key].each do |name|
-        class_eval <<-code
-          def #{name}             # def key
-            build unless built?   #   build unless built?
-            @#{name}              #   @key
-          end                     # end
-        code
-      end
-
-      def initialize(*args)
-        options = args.last.is_a?(Hash) ? args.pop : {}
-        @name = args.first || :default
-        @pattern = options[:pattern] || @@default_pattern
-        reset!
-        @@formatter.setup(self) if @@formatter
-      end
-
-      def reset!
-        @built = false
-        @keys = []
-        @occurences = []
-        @by_key = {}
-      end
-
-      def built?
-        @built
-      end
-
-      def build(options = {})
-        @occurences = find_occurences(options)
-        @occurences.each do |occurence|
-          @keys << occurence.key
-          (@by_key[occurence.key] ||= []) << occurence
-        end
-        @built = true
-      end
-
-      def exists?
-        File.exists?(filename)
-      end
-
-      def save
-        self.class.mk_dir
-        File.open(filename, 'w+') { |f| Marshal.dump(self, f) }
-      end
-
-      def update(options = {})
-        reset!
-        build(options)
-        save
-      end
-
-      def delete
-        FileUtils.rm(filename) if exists? rescue Errno::ENOENT
-      end
-
-      def filename
-        self.class.filename(name)
-      end
-
-      def files
-        Dir[Keys.root + pattern]
-      end
-
-      def pattern
-        @pattern ||= config['pattern'] || @@default_pattern
-      end
-
-      def config
-        @config ||= Keys.config['indices'][name] || { }
-      end
-      
-      def each(*keys)
-        patterns = key_patterns(keys)
-        occurences.each { |occurence| yield(occurence) if key_matches?(occurence.key, patterns) }
-      end
-      
-      def inject(memo, *keys)
-        each(*keys) { |occurence| yield(memo, occurence) }
-        memo
-      end
-      
-      def replace!(occurence, replacement)
-        occurence.replace!(replacement)
-        save if exists?
-      end
-
-      def marshal_dump
-        keys = :name, :pattern, :keys, :occurences, :by_key
-        keys.inject({ :built => built? }) { |result, key| result[key] = send(key); result }
-      end
-
-      def marshal_load(data)
-        keys = :name, :pattern, :keys, :occurences, :by_key, :built
-        keys.each { |key| instance_variable_set(:"@#{key}", data[key]) }
-      end
-
-      protected
-      
-        def find_occurences(options)
-          files.inject([]) do |result, file|
-            code = parse(file) || Sexp.new
-            code.find_by_type(:call).select { |call| call[2] == :t }.inject(result) do |result, node|
-              node.each_key_node { |key| result << Occurence.from_sexp(key, file) }
-              result
-            end
-          end
-        end
-        
-        def key_matches?(subject, key_patterns)
-          key_patterns.empty? || key_patterns.any? do |key, pattern| 
-            subject.to_sym == key || subject.to_s =~ pattern
-          end
-        end
-        
-        def key_patterns(keys)
-          keys.inject({}) { |result, key| result[key] = key_pattern(key); result }
-        end
-        
-        def key_pattern(key)
-          key = key.to_s.dup
-          match_end = key.gsub!(/\*$/, '') ? '' : '$'
-          pattern = Regexp.escape("#{key}")
-          /^#{pattern}#{match_end}/
-        end
-
-        def parse(file)
-          source = File.read(file)
-          source = ErbParser.new.to_ruby(source) if File.extname(file) == '.erb'
-          RubyParser.new.parse(source)
-        end
-    end
-  end
-end

data/lib/i18n/keys/occurence.rb

@@ -1,120 +0,0 @@
-require File.dirname(__FILE__) + '/../../ansi'
-
-module I18n
-  module Keys
-    class Occurence
-      include Ansi
-
-      @@context_lines = 2
-
-      class << self
-        def context_lines
-          @@context_lines
-        end
-
-        def context_lines=(num)
-          @@context_lines = num
-        end
-
-        def from_sexp(sexp, file = nil)
-          new(sexp[1], file || sexp.file, sexp.source_start_pos, sexp.source_end_pos)
-        end
-      end
-
-      attr_reader :key, :file, :start_pos, :end_pos
-
-      def initialize(key, file, start_pos, end_pos)
-        @key = key.to_sym
-        @file = file
-        @start_pos = start_pos
-        @end_pos = end_pos
-      end
-      
-      def replace!(replacement)
-        replacement = replacement.to_sym.inspect
-        content = content_head + replacement + content_tail
-        @key = replacement.to_sym
-        self.length = replacement.to_s.length
-        File.open(file, 'w+') { |f| f.write(content) }
-        @position, @lines, @context = nil, nil, nil
-      end
-      
-      def content
-        lines.join
-      end
-
-      def lines
-        @lines ||= File.open(file, 'r') { |f| f.readlines }
-      end
-
-      def line(highlight = false)
-        line = lines[line_num - 1].dup
-        highlight ? line_head + ansi_format(original_key, [:red, :bold]) + line_tail : line
-      end
-
-      def line_num
-        position[0]
-      end
-
-      def column
-        position[1]
-      end
-
-      def length
-        end_pos - start_pos + 1
-      end
-      
-      def length=(length)
-        @length = length
-        @end_pos = start_pos + length - 1
-      end
-      
-      def original_key
-        line[column - 1, length]
-      end
-      
-      def content_head
-        content[0..(start_pos - 1)].to_s
-      end
-      
-      def content_tail
-        content[(end_pos + 1)..-1].to_s
-      end
-      
-      def line_head
-        line[0..(column - 2)].to_s
-      end
-      
-      def line_tail
-        line[(column + length - 1)..-1].to_s
-      end
-
-      def context
-        @context ||=
-          lines[line_num - self.class.context_lines - 1, self.class.context_lines].join +
-          line(true) + lines[line_num, self.class.context_lines].join
-      end
-
-      def to_s
-        "#{key}: #{file} [#{line_num}/#{column}]"
-      end
-      
-      def ==(other)
-        key == other.key and start_pos == other.start_pos and end_pos == other.end_pos
-      end
-
-      def position
-        @position ||= begin
-          line_num, col = 1, 1
-          lines.inject(0) do |sum, line|
-            break if sum + line.length > start_pos
-            line_num += 1
-            col = start_pos - sum - line.length + 1
-            sum += line.length
-          end
-          [line_num, col]
-        end
-      end
-    end
-  end
-end

data/lib/i18n/parser/erb_parser.rb

@@ -1,54 +0,0 @@
-# replaces html and erb tags with whitespace so that we can parse the result
-# as pure ruby preserving the exact positions of tokens in the original erb
-# source code
-
-require 'erb'
-$KCODE = 'u'
-
-class String
-  def to_whitespace
-    gsub(/[^\s;]/, ' ')
-  end
-end
-
-module I18n
-  class ErbParser
-    class Scanner < ERB::Compiler::Scanner
-      def scan
-        stag_reg = /(.*?)(^[ \t]*<%%|<%=|<%#|<%-|<%|\z)/m
-        etag_reg = /(.*?)(%%>|\-%>|%>|\z)/m
-        scanner = StringScanner.new(@src)
-        while !scanner.eos?
-          scanner.scan(@stag ? etag_reg : stag_reg)
-          yield(scanner[1]) unless scanner[1].nil?
-          yield(scanner[2]) unless scanner[2].nil?
-        end
-      end
-    end
-    ERB::Compiler::Scanner.regist_scanner(Scanner, nil, false)
-
-    def to_ruby(source)
-      result = ''
-      comment = false
-      scanner = ERB::Compiler.new(nil).make_scanner(source)
-      scanner.scan do |token|
-        comment = true if token == '<%#'
-        if scanner.stag.nil?
-          result << token.to_whitespace
-          scanner.stag = token if ['<%', '<%-', '<%=', '<%#'].include?(token)
-        elsif ['%>', '-%>'].include?(token)
-          result << token.gsub(/>/, ';').to_whitespace
-          scanner.stag = nil
-        else
-          result << (comment ? token.to_whitespace : token) # so, this is the ruby code, then
-          comment = false
-        end
-      end
-      result
-    end
-    
-    def content_dump(string)
-      string.split("\n").map { |s| s.to_whitespace }.join("\n")
-    end
-  end
-end

data/lib/i18n/parser/ruby_parser.rb

@@ -1,93 +0,0 @@
-require 'rubygems'
-require 'sexp_processor'
-require 'ruby_parser'
-
-# monkey patch galore, adds the ability to inspect the original source code
-# that a :lit or :str sexp was parsed from
-
-Sexp.class_eval do
-  attr_accessor :full_source, :source_start_pos, :source_end_pos
-  
-  def value
-    self[1]
-  end
-
-  def source_range
-    source_start_pos..source_end_pos if source_start_pos && source_end_pos
-  end
-
-  def source
-    full_source[source_range] if full_source && source_range
-  end
-  
-  def find_by_type(type)
-    nodes = []
-    nodes << self if self.first == type
-    each_of_type(type) { |node| nodes << node }
-    nodes
-  end
-  
-  def each_key_node(&block)
-    each do |element|
-      next unless Sexp === element
-      element.each_key_node(&block)
-      block.call(element) if element.is_key_node?
-    end
-  end
-  
-  def is_key_node?
-    first == :str || first == :lit && self[1].is_a?(Symbol)
-  end
-end
-
-RubyLexer.class_eval do
-  attr_accessor :source_start_pos, :source_end_pos
-
-  def reset_source_positions!
-    self.source_start_pos, self.source_end_pos = nil, nil, nil
-  end
-end
-
-module I18n
-  class RubyParser < RubyParser
-    def s(*args)
-      result = super
-
-      result.full_source = lexer.src.string.dup
-      result.source_start_pos = lexer.source_start_pos
-      result.source_end_pos = lexer.source_end_pos || lexer.src.pos
-      lexer.reset_source_positions!
-
-      result
-    end
-
-    # :tSYMBOL
-    def _reduce_380(val, _values, result)
-      lexer.source_start_pos = lexer.src.pos - lexer.yacc_value.size - 1
-      lexer.source_end_pos = lexer.src.pos - 1
-      super
-    end
-
-    # :tSTRING
-    def _reduce_386(val, _values, result)
-      lexer.source_start_pos = lexer.src.pos - lexer.yacc_value.size - 2
-      lexer.source_end_pos = lexer.src.pos - 1
-      super
-    end
-  
-    # :tSYMBEG
-    def _reduce_403(val, _values, result)
-      lexer.source_start_pos = lexer.src.pos - lexer.yacc_value.size - 2
-      super
-    end
-  
-    def _reduce_418(val, _values, result)
-      result = super
-      result.source_start_pos = val[1].source_start_pos
-      result.source_end_pos = val[1].source_end_pos
-      result.full_source = val[1].full_source
-      result
-    end
-  end
-end
-