lokale 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28a49cbbd5450645fa6067b0fd096191bb7a1760
-  data.tar.gz: 578fbe40eee917b39badc508ad62a5b63d748b9d
+  metadata.gz: 1605552979ae04cc32ed6b6eae40be4491cb6d43
+  data.tar.gz: 240de056b27a37bd6b7fc2cf7b07a147ccc0c9b0
 SHA512:
-  metadata.gz: d8bcfbc01c0144b33d804a0b0d60b1b9224ffcb1b87af2730f4cf27f86ddb2e5eca0f032dcd6486279c2bfbdeb3506cea4661bdd5445fdc74372723357594c73
-  data.tar.gz: 063b8a079d93f1189f9d261896d818472d0b6d193c80a044f2d70810e8426f758b4e0676678b8703433a2506b0c6edc343804e927fd2917021d4718e4712b4c7
+  metadata.gz: 272fa81006f2b4f4cf0a0f4066e34d4926433c4998e364604dcc7701f1a0c562e93895acc3050d5d40dfd4af588e900dcebfce5fc5f939ce53b4ce709111e29f
+  data.tar.gz: c9d92c14f1cbef0bf2faa8884d10c3e63a058c9af00664c8be534137171c0375b81adf163579969db4ae866962242de00590f242c43bccf4c33ced8fcf91322a

data/a.sh

@@ -0,0 +1,4 @@
+rake install
+cd ~/Documents/hand2hand-ios
+lokale -e
+cd ~/Documents/lokale

data/bin/lokale

@@ -1,64 +1,6 @@
 #!/usr/bin/env ruby
 
 require 'lokale'
-require 'lokale/find_dir'
-require 'lokale/colorize'
-require 'lokale/options'
 
-Settings.init
-
-git_path = find_git_repo
-if git_path.nil? 
-	puts "Could not find any git repository."
-	exit
-end
-
-project_name = xcode_project_name(git_path)
-if project_name.nil?
-	puts "Found git repository (#{git_path}) does not contain an Xcode project."
-	exit
-end
-
-puts "Target Xcode project: '#{project_name}'".green
-
-########################################################################################
-
-class Action
-	def perform(agent, reporter)
-		send(("perform_" + @type.to_s).to_sym, agent, reporter)
-	end
-
-	def perform_summary(agent, reporter)
-		puts "Printing summary".blue
-		reporter.print_summary
-	end
-
-	def perform_copy_base(agent, reporter)
-		puts "Copying `en` strings files to `Base`".blue
-		agent.copy_base
-		puts
-	end
-
-	def perform_append(agent, reporter)
-
-	end
-end
-
-
-
-settings = Settings.get
-
-macros = [
-    Lokale::Macro.new("NSLocalizedString", /NSLocalizedString\("(.+?)",\s*comment:\s*"(.*?)"\)/, "Localizable.strings"), 
-    Lokale::Macro.new("PluralString", /String.localizedPlural\("(.+?)"/, nil),
-    #LocalizationMacro.new("ObjC String", /NSLocalizedString\("(.*)",\s*(.*)\)/),
-    #LocalizationMacro.new("ObjC Table String", /NSLocalizedStringFromTableInBundle\((.*?),/)
-]
-
-agent = Lokale::Agent.new(git_path, macros)
-reporter = Lokale::Reporter.new(agent)
-
-
-settings.actions.each do |action|
-	action.perform(agent, reporter)
-end
+main = Lokale::Main.new
+main.run

data/lib/lokale/.lokale

@@ -0,0 +1,16 @@
+
+add_macro "NSLocalizedString" do |m|
+  m.localization_file = "Localizable.strings"
+
+  m.regex = /NSLocalizedString\("(.+?)",\s*comment:\s*"(.*?)"\)/
+  m.key_index = 0
+  m.note_index = 1
+end
+
+add_macro "PluralString" do |m|
+  m.regex = /String.localizedPlural\("(.+?)"/
+  m.key_index = 0
+end
+
+main_language "en"
+base_language "Base"

data/lib/lokale/agent.rb

@@ -0,0 +1,231 @@
+require "lokale/version"
+require "lokale/colorize"
+require "lokale/util"
+require "lokale/model"
+require "xliffle"
+require "set"
+
+
+module Lokale
+  class LFile
+    def repeats
+      return [] if @parsed.nil?
+      uniq_keys = keys.to_set
+
+      keys.delete_if do |k|
+        if uniq_keys.include? k
+          uniq_keys.delete k
+          true
+        end
+      end
+    end
+
+    def keys 
+      return nil if parsed.nil?
+      parsed.map(&:key)
+    end
+  end
+
+  class LString
+    def write_format
+      "/* #{note} */\n\"#{key}\" = \"#{str}\";\n"
+    end
+
+    def pretty
+      "\"#{key}\" = \"#{str}\";"
+    end
+
+    attr_accessor :source
+
+    def for_export(lang)
+      str = LString.new(@key, nil, @note, lang)
+      str.source = @str
+      str
+    end
+  end
+end
+
+
+
+module Lokale 
+  class Agent
+    attr_reader :proj_path, :macros, :lfiles, :sfiles_proceeded
+
+    def initialize(proj_path, macros)
+      @proj_path = proj_path
+      @macros = macros
+
+      @writer = Writer.new
+      @exporter = Exporter.new
+      @importer = Importer.new
+
+      get_localization_files
+      find_all_localization_calls
+    end
+
+    ###
+
+    def proj_files 
+      if block_given?
+        Dir.glob("#{@proj_path}/**/**") { |f| yield f }
+      else
+        Dir.glob("#{@proj_path}/**/**")
+      end
+    end
+
+    def get_localization_files
+      return @lfiles unless @lfiles.nil?
+      @lfiles = proj_files.map { |file| LFile.try_to_read(file) }.compact
+    end
+
+    def find_all_localization_calls
+      @macros.each { |m| m.clear_calls }
+
+      @sfiles_proceeded = 0
+      proj_files do |file| 
+        next unless file.source_file?        
+
+        file_content = File.read(file)
+        @macros.each { |macro| macro.read_from file_content }
+        @sfiles_proceeded += 1
+      end
+    end
+
+    ###
+
+    def copy_base
+      main_lfiles = @lfiles.group_by { |f| f.lang }[Config.get.main_lang].select { |f| f.strings_file? }
+      base_lfiles = @lfiles.group_by { |f| f.lang }[Config.get.base_lang].select { |f| f.strings_file? }
+
+      main_lfiles.each do |en|
+        base = base_lfiles.select { |f| f.full_name == en.full_name }.sample
+        next if base.nil?
+        IO.copy_stream(en.path, base.path)
+      end
+    end
+
+    def append_new_macro_calls
+      @macros.each do |macro|
+        next if macro.localization_file.nil?
+        file = @lfiles.select { |lf| lf.full_name == macro.localization_file && lf.lang == Config.get.main_lang }.sample
+        next if file.nil?
+
+        found_strings = macro.found_strings.keys
+        proj_keys = found_strings.map { |ls| ls.key }.to_set
+        current_keys = file.keys.to_set
+        new_keys = proj_keys - current_keys
+
+        next if new_keys.empty?
+
+        new_lstrings = found_strings.select { |ls| new_keys.include? ls.key }
+        @writer.append_new_strings(new_lstrings, file)
+      end
+    end
+
+    def export_xliffs
+      files = Config.get.base_lang.nil? ? @lfiles : @lfiles.select { |lf| lf.lang != Config.get.base_lang }
+      main_lang = Config.get.main_lang
+      diffs = Exporter::Diff.find(files, main_lang)
+      @exporter.export(diffs) unless diffs.empty?
+    end
+
+    def try_to_import
+    end
+  end
+
+  class Writer 
+    def find_append_point(content)
+      ignore_after = content =~ /^\s*?\/\/\s*?\n\s*?\/\/\s*?MARK/
+      string_regexp = /".*?"\s*=\s*".*?"\s*;\s*\n/
+
+      append_at = content.match(string_regexp).end(0) - 1
+      return if append_at.nil?
+      next_try = append_at
+      while next_try < ignore_after
+        append_at = next_try
+        next_try = content.match(string_regexp, next_try).end(0) - 1
+      end
+
+      append_at - 1
+    end
+
+    def append_new_strings(lstrings, file)
+      content = file.content
+
+      puts "Appending #{lstrings.size} new strings to file #{file.lang}/#{file.full_name}".blue
+      lstrings.each { |ls| puts ls.pretty }
+      puts
+
+      append_at = find_append_point(content)
+      data_to_append = "\n" + lstrings.map { |ls| ls.write_format }.join("\n")
+
+      content.insert(append_at, data_to_append)
+      File.write(file.path, content)
+    end
+  end
+
+
+  class Exporter
+    class Diff
+      attr_reader :lang, :missing_strings
+
+      def self.find(files, main_lang)
+        groups = files.group_by { |lf| lf.lang }
+        main_files = groups[main_lang]
+        diffs = []
+        groups.each do |lang, files|
+          next if lang == main_lang
+          diffs << Diff.new(main_files, files, lang)
+        end
+        diffs.delete_if { |d| d.empty? }
+      end
+
+      def initialize(main_files, lfiles, lang)
+        @lang = lang
+        @missing_strings = Hash.new { |h, k| h[k] = [] }
+        lfiles.each do |lf|
+          next unless lf.strings_file?
+          counterpart = main_files.select { |m| m.full_name == lf.full_name }.sample
+          next if counterpart.nil?
+
+          missing_keys = counterpart.keys - lf.keys
+          next if missing_keys.empty?
+
+          counterpart.parsed.each do |lstr|
+            next unless missing_keys.include? lstr.key 
+            @missing_strings[lf.full_name] << lstr.for_export(lang)
+          end
+        end
+      end
+
+      def empty?
+        @missing_strings.empty? || @missing_strings.all? { |file_name, strings| strings.empty? }
+      end
+    end
+
+
+    def export(diffs)
+      # puts "Exporting stuff"
+      diffs.each do |d|
+        puts "Writing xliff for `#{d.lang}` language. Missing strings count: #{d.missing_strings.values.map { |e| e.size }.reduce(:+)}"
+
+        xliffle = Xliffle.new
+        d.missing_strings.each do |lfile, strings|
+          xfile = xliffle.file(lfile, Config.get.main_lang, d.lang)
+          strings.each do |lstr|
+            xfile.string(lstr.key, lstr.source, nil).note(lstr.note, 0)
+          end
+        end
+
+        file_name = "#{d.lang}.xliff"
+        File.write(file_name, xliffle.to_xliff)
+      end
+    end
+  end
+
+  class Importer
+    def look_for_strings(root_path)
+    end
+  end
+end
+

data/lib/lokale/config.rb

@@ -0,0 +1,68 @@
+
+require "optparse"
+require "lokale/util"
+
+class Action
+  attr_accessor :type, :arg
+
+  def initialize(type)
+    @type = type
+  end
+
+  def self.summary;     Action.new(:summary)        end
+  def self.copy_base;   Action.new(:copy_base)      end
+  def self.append;      Action.new(:append)         end  
+  def self.export;      Action.new(:export)         end  
+  def self.import;      Action.new(:import)         end  
+end
+
+class Config
+  attr_accessor :actions
+
+  def self.init 
+    return unless @config.nil?
+
+    actions = []
+
+    OptionParser.new do |opts|
+      opts.banner = "Usage: lokale [-bsh]"
+
+      opts.on("-b", "--copy-base", "Copies 'en' localization files to 'Base'") do |n|
+        actions << Action.copy_base
+      end
+
+      opts.on("-s", "--summary", "Prints project summary") do |n|
+        actions << Action.summary
+      end
+
+      opts.on("-a", "--append", "Appends new strings to english localization file") do |n|
+        actions << Action.append
+      end
+
+      opts.on("-e", "--export", "Creates xliff files with missing localization") do |n|
+        actions << Action.export
+      end
+
+      opts.on("-i", "--import", "Looks for xliffs in project dir and imports whatever possible") do |n|
+        actions << Action.import
+      end
+
+      opts.on("-h", "--help", "Prints this help") do
+        puts opts
+        exit
+      end
+    end.parse!
+
+    actions << Action.summary if actions.empty? 
+
+    @config = Config.new
+    @config.actions = actions
+  end
+
+  def self.get
+    init if @config.nil?
+    @config
+  end
+end
+
+

data/lib/lokale/find_dir.rb

@@ -2,38 +2,59 @@
 # Based on https://github.com/mojombo/grit/pull/178 by https://github.com/derricks
 
 
-# Returns true if the given path represents a root directory (/ or C:/)
-def root_directory?(file_path)
-  # Implementation inspired by http://stackoverflow.com/a/4969416:
-  # Does file + ".." resolve to the same directory as file_path?
-  File.directory?(file_path) && 
-    File.expand_path(file_path) == File.expand_path(File.join(file_path, '..'))
-end
+module ProjectFinder
+
+  # Returns true if the given path represents a root directory (/ or C:/)
+  def self.root_directory?(file_path)
+    # Implementation inspired by http://stackoverflow.com/a/4969416:
+    # Does file + ".." resolve to the same directory as file_path?
+    File.directory?(file_path) && 
+      File.expand_path(file_path) == File.expand_path(File.join(file_path, '..'))
+  end
+
+  # Returns the git root directory given a path inside the repo. Returns nil if
+  # the path is not in a git repo.
+  def self.find_git_repo(start_path = '.')
+    raise NoSuchPathError unless File.exists?(start_path)
 
-# Returns the git root directory given a path inside the repo. Returns nil if
-# the path is not in a git repo.
-def find_git_repo(start_path = '.')
-  raise NoSuchPathError unless File.exists?(start_path)
-
-  current_path = File.expand_path(start_path)
-
-  # for clarity: set to an explicit nil and then just return whatever
-  # the current value of this variable is (nil or otherwise)
-  return_path = nil
-
-  until root_directory?(current_path)
-    if File.exists?(File.join(current_path, '.git'))   
-      # done
-      return_path = current_path
-      break
-    else
-      # go up a directory and try again
-      current_path = File.dirname(current_path)
+    current_path = File.expand_path(start_path)
+
+    # for clarity: set to an explicit nil and then just return whatever
+    # the current value of this variable is (nil or otherwise)
+    return_path = nil
+
+    until root_directory?(current_path)
+      if File.exists?(File.join(current_path, '.git'))   
+        # done
+        return_path = current_path
+        break
+      else
+        # go up a directory and try again
+        current_path = File.dirname(current_path)
+      end
     end
+    return_path
   end
-  return_path
-end
 
-def xcode_project_name(path)
-  Dir.glob("#{path}/**/**") { |file| return $1 if file =~ /\/(.+?)\.(?:xcodeproj|xcworkspace)$/ }
+  ##
+
+  def self.xcode_project_name(path)
+    Dir.glob("#{path}/**/**") { |file| return $1 if file =~ /\/(.+?)\.(?:xcodeproj|xcworkspace)$/ }
+  end
+
+  ##
+
+  def self.find_proj
+    project_path = find_git_repo
+    if project_path.nil? 
+      raise "Could not find any git repository."
+    end
+
+    project_name = xcode_project_name(project_path)
+    if project_name.nil?
+      raise "Found git repository (#{project_path}) does not contain an Xcode project."
+    end
+
+    return project_path, project_name
+  end
 end

data/lib/lokale/lokalefile.rb

@@ -0,0 +1,98 @@
+
+require "lokale/config"
+require "lokale/model"
+
+DEFAULT_LOKALEFILE = <<FILE
+
+add_macro "NSLocalizedString" do |m|
+  m.localization_file = "Localizable.strings"
+
+  m.regex = /NSLocalizedString\\("(.+?)",\\s*comment:\\s*"(.*?)"\\)/
+  m.key_index = 0
+  m.note_index = 1
+end
+
+add_macro "PluralString" do |m|
+  m.regex = /String.localizedPlural\\("(.+?)"/
+  m.key_index = 0
+end
+
+main_language "en"
+base_language "Base"
+
+FILE
+
+
+class Config 
+  def read_lokalefile(project_path)
+    lokalefile_path = File.join(project_path, ".lokale")
+
+    if File.file? lokalefile_path 
+      read_config_from_file(lokalefile_path)
+    else
+      read_default_config
+    end
+  end
+
+  def read_default_config
+    reset_config
+    instance_eval(DEFAULT_LOKALEFILE)
+  end
+
+  def read_config_from_file(file_path)
+    content = File.read(file_path)
+    reset_config
+    instance_eval(content)
+    fill_defaults
+  end
+end
+
+
+class Config 
+
+  attr_reader :macros
+  attr_reader :main_lang, :base_lang
+
+  def reset_config 
+    @macros = nil
+    @main_lang = nil
+    @base_lang = nil  
+  end
+
+  def fill_defaults
+    default = Config.new
+    default.read_default_config
+
+    @macros ||= default.macros
+    @main_lang ||= default.main_lang
+    @base_lang ||= default.base_lang
+  end
+
+  private
+
+  def add_macro(name)
+    macro = Lokale::Macro.new(name)
+    yield macro
+    @macros ||= []
+    @macros << macro
+  end
+  
+  def main_language(l)
+    @main_lang = l
+  end
+
+  def base_language(l)
+    @base_lang = l
+  end
+end
+
+
+def test 
+  Config.get.read_lokalefile File.dirname(__FILE__)
+  p Config.get.macros
+  p Config.get.main_lang
+  p Config.get.base_lang
+end
+
+# test
+

data/lib/lokale/model.rb

@@ -0,0 +1,137 @@
+
+class String
+  def localization_file?
+    File.directory?(self) == false &&
+        (self =~ /\/Pods\//) == nil &&
+        (self =~ /\.bundle\//) == nil &&
+        (self =~ /\/(.{1,8})\.lproj\//)
+  end
+
+  def source_file?
+    (File.directory?(self) == false) && (self =~ /\/Pods\//).nil? && ((self =~ /\.(swift|h|m)$/) != nil)
+  end
+end
+
+
+module Lokale
+  class LString
+    attr_accessor :key, :str, :note, :target
+
+    def initialize(key, str, note, target)
+      @key = key; @str = str; @note = note; @target = target
+    end
+
+    def self.strings_from_file(file_path, lang)
+      regex = /(?:\/\* (.+) \*\/.*\n)?"(.+)" *= *"(.+)";/
+      File.read(file_path).scan(regex).map { |m| LString.new(m[1], m[2], m[0], lang) }
+    end
+
+    def inspect
+    	"<\#LS:#{@key}; s:#{@str}; n:#{@note}; t:#{@target}>"
+    end
+  end
+
+  #
+
+  class LFile
+    attr_reader :path, :lang, :name, :type
+    def initialize(file_path)
+      @path = file_path
+
+      File.basename(file_path) =~ /^(.+)\.([^\.]*?)$/
+      @name = $1
+      @type = $2
+
+      file_path =~ /\/(.{1,8})\.lproj\//
+      @lang = $1
+    end
+
+    def self.try_to_read(file_path)
+      return nil unless file_path.localization_file?
+      LFile.new(file_path)
+    end
+
+    def inspect 
+      "<LF:#{@lang}/#{full_name}>"
+    end
+
+    def full_name
+      "#{@name}.#{@type}"
+    end
+
+    def strings_file?
+      @type == "strings" || @type == "stringsdict"
+    end
+
+    def content
+    	File.read(@path)
+    end
+
+    def parsed
+      return @parsed unless @parsed.nil?
+      @parsed = case type
+        when "strings"      then LString.strings_from_file(@path, @lang)
+        when "stringsdict"  then []
+        else nil
+      end      
+    end
+  end
+
+  #
+
+  class Macro
+    attr_accessor :regex, :name, :localization_file, :key_index, :note_index
+    attr_reader :found_strings
+
+    def initialize(name)
+      @name = name
+      clear_calls
+    end 
+
+    def clear_calls
+      @found_strings = Hash.new { |h, k| h[k] = 0 }
+    end
+
+    def read_from(file)
+      file.scan(@regex) do |m| 
+      	lang = Config.get.main_lang
+      	key = m[key_index] unless key_index.nil?
+      	val = m[note_index] unless note_index.nil?
+      	lstr = LString.new(key, val, val, lang)
+      	@found_strings[lstr] += 1 
+      end
+    end
+
+    def uniq_count
+      @found_strings.size
+    end
+
+    def total_count
+      @found_strings.values.reduce(:+) || 0
+    end
+
+  end
+end
+
+
+
+
+module Lokale
+
+	# Hashable
+	class LString 
+		def fields
+    	[@key, @str, @note, @target]
+    end
+
+		def ==(other)
+			self.class === other && other.fields == fields
+		end
+
+		alias eql? ==
+
+		def hash
+			fields.hash
+		end
+	end
+end

data/lib/lokale/reporter.rb

@@ -0,0 +1,102 @@
+module Lokale
+  class Reporter
+    def initialize(agent)
+      @agent = agent
+    end
+
+    def print_summary
+      print_macro_calls_summary
+      print_macro_table
+      print_files_table
+      print_repeats_report
+      print_diferences_report
+    end 
+
+    def print_macro_calls_summary
+      total_macro_calls = @agent.macros.map(&:total_count).reduce(:+)
+      uniq_macro_calls = @agent.macros.map(&:uniq_count).reduce(:+)
+      puts "Found #{total_macro_calls} localization macro calls in #{@agent.sfiles_proceeded} files."
+      puts "Uniq macro calls: #{uniq_macro_calls}"
+      puts
+    end
+
+    def print_files_table
+      languages = @agent.lfiles.map { |e| e.lang }.to_set.to_a
+      files = @agent.lfiles.map { |e| e.full_name }.to_set.to_a
+
+      puts "Found #{@agent.lfiles.size} localized files for #{languages.size} languages."
+
+      description_header = "[*]".rpadded(36)
+      languages.each { |l| description_header << l.rpadded(8) }
+      puts description_header
+
+      files.each do |f|
+        description_string = f.rpadded(36)
+        languages.each do |l|
+          lfile = @agent.lfiles.select { |lf| lf.full_name == f && lf.lang == l }
+          description_string << (lfile.empty? ? "-" : lfile[0].parsed.nil? ? "*" : "#{lfile[0].parsed.size}").rpadded(8)
+        end
+        puts description_string
+      end
+      puts
+    end
+
+    def print_macro_table
+      @agent.macros.each do |macro|
+        puts "#{macro.name}:".rpadded(24) + "total: #{macro.total_count}".rpadded(16) + "uniq: #{macro.uniq_count}"
+      end
+      puts
+    end
+
+    def print_repeats_report
+      repeats_repot = ""
+      @agent.lfiles.each do |lf| 
+        repeats = lf.repeats
+        next if repeats.count.zero?
+        repeats_repot << "#{lf.lang}/#{lf.full_name} repeats:\n"
+        repeats_repot << repeats.join("\n")
+        repeats_repot << "\n"
+      end
+
+      if repeats_repot.empty? 
+        puts "Repeats not found.".green
+        puts
+      else
+        puts "Found repeats in strings files.".red
+        puts repeats_repot
+        puts
+      end
+    end
+
+    def print_diferences_report
+      diferences_repot = ""
+
+      @agent.lfiles.group_by { |f| f.full_name }.each do |file_name, files|
+        base_lang = files.any? { |f| f.lang == "Base" } ? "Base" : "en"
+        files = files.select { |f| f.lang != base_lang }
+        all_keys = files.map(&:keys).compact.map(&:to_set)
+        next if all_keys.empty?
+        united_keys = all_keys.reduce(:|)
+        all_keys.map! { |ks| united_keys - ks }
+        next if all_keys.map(&:length).reduce(:+).zero?
+
+        diferences_repot << "Missing keys in file \"#{file_name}\":\n"
+        all_keys.zip(files) do |missing_keys, lfile|
+          next if missing_keys.size.zero?
+          diferences_repot << "*".red + " #{lfile.lang} - #{missing_keys.size} key(s):\n"
+          missing_keys.each { |k| diferences_repot << "#{k}\n" }
+        end
+        diferences_repot << "\n"
+      end
+
+      if diferences_repot.empty? 
+        puts "Localization files are full.".green
+        puts
+      else
+        puts "Localization files are not full.".red
+        puts diferences_repot
+        puts
+      end
+    end 
+  end
+end

data/lib/lokale/util.rb

@@ -0,0 +1,16 @@
+class String
+  def rpadded(count=20)
+    "%-#{count}.#{count}s" % self
+  end
+
+  def lpadded(count=20)
+    "%#{count}.#{count}s" % self
+  end
+end
+
+module Then
+	def then		
+		yield self
+		return self
+	end
+end

data/lib/lokale/version.rb

@@ -1,3 +1,3 @@
 module Lokale
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/lokale.rb

@@ -1,305 +1,84 @@
-require "lokale/version"
-require "lokale/colorize"
-require "set"
 
-class String
-  def rpadded(count=20)
-    "%-#{count}.#{count}s" % self
-  end
+require 'lokale/find_dir'
+require 'lokale/colorize'
+require 'lokale/config'
+require 'lokale/reporter'
+require 'lokale/lokalefile'
+require 'lokale/agent'
 
-  def lpadded(count=20)
-    "%#{count}.#{count}s" % self
+class Action
+  def print(str)
+    puts str.blue
   end
 
-  def localization_file?
-    File.directory?(self) == false &&
-        (self =~ /\/Pods\//) == nil &&
-        (self =~ /\.bundle\//) == nil &&
-        (self =~ /\/(.{1,8})\.lproj\//)
+  def perform(agent, reporter)
+    send(("perform_" + @type.to_s).to_sym, agent, reporter)
   end
 
-  def source_file?
-    (File.directory?(self) == false) && (self =~ /\/Pods\//).nil? && ((self =~ /\.(swift|h|m)$/) != nil)
+  def perform_summary(agent, reporter)
+    print "Printing summary...".blue
+    reporter.print_summary
   end
-end
-
-
-module Lokale 
-  class LString
-    attr_accessor :key, :str, :note, :target
-
-    def initialize(key, str, note, target)
-      @key = key; @str = str; @note = note; @target = target
-    end
 
-    def self.strings_from_file(file_path, lang)
-      regex = /(?:\/* (.+) *\/.*\n)?"(.+)" *= *"(.+)";/
-      File.read(file_path).scan(regex).map { |m| LString.new(m[1], m[2], m[0], lang) }
-    end
+  def perform_copy_base(agent, reporter)
+    print "Copying `en` strings files to `Base`...".blue
+    agent.copy_base
   end
 
-  #
-
-  class LFile
-    attr_reader :path, :lang, :name, :type
-    def initialize(file_path)
-      @path = file_path
-
-      File.basename(file_path) =~ /^(.+)\.([^\.]*?)$/
-      @name = $1
-      @type = $2
-
-      file_path =~ /\/(.{1,8})\.lproj\//
-      @lang = $1
-    end
-
-    def self.try_to_read(file_path)
-      return nil unless file_path.localization_file?
-      LFile.new(file_path)
-    end
-
-    def inspect 
-      "<#{@lang}/#{full_name}>"
-    end
-
-    def full_name
-      "#{@name}.#{@type}"
-    end
-
-    def parsed
-      return @parsed unless @parsed.nil?
-      @parsed = case type
-        when "strings"      then LString.strings_from_file(@path, @lang)
-        when "stringsdict"  then []
-        else nil
-      end      
-    end
-
-    def repeats
-      return [] if @parsed.nil?
-      keys = @parsed.map(&:key)
-      uniq_keys = keys.to_set
-
-      keys.delete_if do |k|
-        if uniq_keys.include? k
-          uniq_keys.delete k
-          true
-        end
-      end
-    end
-
-    def keys 
-      return nil if parsed.nil?
-      parsed.map(&:key)
-    end
-
-     
-    def strings_file?
-      @type == "strings" || @type == "stringsdict"
-    end
+  def perform_append(agent, reporter)
+    print "Appending new macro calls to localization files...".blue
+    agent.append_new_macro_calls
   end
 
-  #
-
-  class Macro
-    attr_reader :regex, :found_strings, :name, :file_name
-
-    def initialize(name, regex, file_name)
-      @name = name
-      @regex = regex
-      @file_name = file_name
-      clear_calls
-    end 
-
-    def clear_calls
-      @found_strings = Hash.new { |h, k| h[k] = 0 }
-    end
-
-    def read_from(file)
-      file.scan(@regex) { |m| @found_strings[m] += 1 }
-    end
-
-    def uniq_count
-      @found_strings.size
-    end
-
-    def total_count
-      @found_strings.values.reduce(:+) || 0
-    end
+  def perform_export(agent, reporter)
+    print "Preparing xliff files with new localized strings...".blue
+    agent.export_xliffs
   end
 
+  def perform_import(agent, reporter)
+    print "Attempting to import new strings...".blue
+    agent.try_to_import
+  end
+end
 
-  #
-  #
-  #
-  #
-
-  class Agent
-    attr_reader :proj_path, :macros, :lfiles, :sfiles_proceeded
-
-    def initialize(proj_path, macros)
-      @proj_path = proj_path
-      @macros = macros
-
-      get_localization_files
-      find_all_localization_calls
-    end
-
-    def proj_files 
-      if block_given?
-        Dir.glob("#{@proj_path}/**/**") { |f| yield f }
-      else
-        Dir.glob("#{@proj_path}/**/**")
-      end
-    end
-
-    def get_localization_files
-      return @lfiles unless @lfiles.nil?
-      @lfiles = proj_files.map { |file| LFile.try_to_read(file) }.compact
-    end
-
-    def find_all_localization_calls
-      @macros.each { |m| m.clear_calls }
 
-      @sfiles_proceeded = 0
-      proj_files do |file| 
-        next unless file.source_file?        
+module Lokale
+  class Main
 
-        file_content = File.read(file)
-        @macros.each { |macro| macro.read_from file_content }
-        @sfiles_proceeded += 1
-      end
+    def run
+      find_dir
+      read_config
+      init_workers
+      run_actions
     end
 
-    def copy_base
-      en_files = @lfiles.group_by { |f| f.lang }["en"].select { |f| f.strings_file? }
-      base_files = @lfiles.group_by { |f| f.lang }["Base"].select { |f| f.strings_file? }
+    #
 
-      en_files.each do |en|
-        base = base_files.select { |f| f.full_name == en.full_name }.sample
-        next if base.nil?
-        IO.copy_stream(en.path, base.path)
+    def find_dir 
+      begin
+        @project_path, @project_name = ProjectFinder::find_proj   
+      rescue Exception => e
+        puts e
+        exit
       end
-    end
-
-    def append_new_macro_calls
-
-    end
-  end
-
-  #
-
-  class Reporter
-    def initialize(agent)
-      @agent = agent
-    end
-
-    def print_summary
-      print_macro_calls_summary
-      print_macro_table
-      print_files_table
-      print_repeats_report
-      print_diferences_report
-    end 
 
-    def print_macro_calls_summary
-      total_macro_calls = @agent.macros.map(&:total_count).reduce(:+)
-      uniq_macro_calls = @agent.macros.map(&:uniq_count).reduce(:+)
-      puts "Found #{total_macro_calls} localization macro calls in #{@agent.sfiles_proceeded} files."
-      puts "Uniq macro calls: #{uniq_macro_calls}"
-      puts
+      puts "Target Xcode project: '#{@project_name}'".green
     end
 
-    def print_files_table
-      languages = @agent.lfiles.map { |e| e.lang }.to_set.to_a
-      files = @agent.lfiles.map { |e| e.full_name }.to_set.to_a
-
-      puts "Found #{@agent.lfiles.size} localized files for #{languages.size} languages."
-
-      description_header = "[*]".rpadded(36)
-      languages.each { |l| description_header << l.rpadded(8) }
-      puts description_header
-
-      files.each do |f|
-        description_string = f.rpadded(36)
-        languages.each do |l|
-          lfile = @agent.lfiles.select { |lf| lf.full_name == f && lf.lang == l }
-          description_string << (lfile.empty? ? "-" : lfile[0].parsed.nil? ? "*" : "#{lfile[0].parsed.size}").rpadded(8)
-        end
-        puts description_string
-      end
-      puts
+    def read_config
+      Config.init
+      Config.get.read_lokalefile(@project_path)
     end
 
-    def print_macro_table
-      @agent.macros.each do |macro|
-        puts "#{macro.name}:".rpadded(24) + "total: #{macro.total_count}".rpadded(16) + "uniq: #{macro.uniq_count}"
-      end
-      puts
+    def init_workers
+      @agent = Lokale::Agent.new(@project_path, Config.get.macros)
+      @reporter = Lokale::Reporter.new(@agent)
     end
-
-    def print_repeats_report
-      repeats_repot = ""
-      @agent.lfiles.each do |lf| 
-        repeats = lf.repeats
-        next if repeats.count.zero?
-        repeats_repot << "#{lf.lang}/#{lf.full_name} repeats:\n"
-        repeats_repot << repeats.join("\n")
-        repeats_repot << "\n"
-      end
-
-      if repeats_repot.empty? 
-        puts "Repeats not found.".green
-        puts
-      else
-        puts "Found repeats in strings files.".red
-        puts repeats_repot
-        puts
-      end
+    
+    def run_actions
+      Config.get.actions.each { |action| action.perform(@agent, @reporter) }
     end
-
-    def print_diferences_report
-      diferences_repot = ""
-
-      @agent.lfiles.group_by { |f| f.full_name }.each do |file_name, files|
-        base_lang = files.any? { |f| f.lang == "Base" } ? "Base" : "en"
-        files = files.select { |f| f.lang != base_lang }
-        all_keys = files.map(&:keys).compact.map(&:to_set)
-        next if all_keys.empty?
-        united_keys = all_keys.reduce(:|)
-        all_keys.map! { |ks| united_keys - ks }
-        next if all_keys.map(&:length).reduce(:+).zero?
-
-        diferences_repot << "Missing keys in file \"#{file_name}\":\n"
-        all_keys.zip(files) do |missing_keys, lfile|
-          next if missing_keys.size.zero?
-          diferences_repot << "*".red + " #{lfile.lang} - #{missing_keys.size} key(s):\n"
-          missing_keys.each { |k| diferences_repot << "#{k}\n" }
-        end
-        diferences_repot << "\n"
-      end
-
-      if diferences_repot.empty? 
-        puts "Localization files are full.".green
-        puts
-      else
-        puts "Localization files are not full.".red
-        puts diferences_repot
-        puts
-      end
-    end 
   end
 end
 
 
-
-# macros = [
-#     Lokale::Macro.new("NSLocalizedString", /NSLocalizedString\("(.+?)",\s*comment:\s*"(.*?)"\)/), 
-#     Lokale::Macro.new("PluralString", /String.localizedPlural\("(.+?)"/),
-#     #LocalizationMacro.new("ObjC String", /NSLocalizedString\("(.*)",\s*(.*)\)/),
-#     #LocalizationMacro.new("ObjC Table String", /NSLocalizedStringFromTableInBundle\((.*?),/)
-# ]
-
-# agent = Lokale::Agent.new("/Users/crysberry/Documents/hand2hand", macros)
-# reporter = Lokale::Reporter.new(agent)
-# reporter.print_summary

data/lokale.gemspec

@@ -31,4 +31,6 @@ Gem::Specification.new do |spec|
   spec.executables   = ["lokale"]
   spec.require_paths = ["lib"]
 
+  spec.add_runtime_dependency 'xliffle', '0.2.2'
+
 end

data/test.sh

@@ -0,0 +1 @@
+rake install; cd ~/Documents/hand2hand-ios; lokale; cd ~/Documents/lokale

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: lokale
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Anton Onizhuk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-25 00:00:00.000000000 Z
-dependencies: []
+date: 2017-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xliffle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
 description: Write a longer description or delete this line.
 email:
 - anton.onizhuk@gmail.com
@@ -23,15 +37,23 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- a.sh
 - bin/console
 - bin/lokale
 - bin/setup
 - lib/lokale.rb
+- lib/lokale/.lokale
+- lib/lokale/agent.rb
 - lib/lokale/colorize.rb
+- lib/lokale/config.rb
 - lib/lokale/find_dir.rb
-- lib/lokale/options.rb
+- lib/lokale/lokalefile.rb
+- lib/lokale/model.rb
+- lib/lokale/reporter.rb
+- lib/lokale/util.rb
 - lib/lokale/version.rb
 - lokale.gemspec
+- test.sh
 homepage: 
 licenses:
 - MIT

data/lib/lokale/options.rb

@@ -1,70 +0,0 @@
-
-require "optparse"
-
-class Action
-  attr_reader :type, :arg, :precedence
-  def initialize(type, arg, precedence)
-    @type = type; @arg = arg; @precedence = precedence
-  end
-
-  def self.summary
-    Action.new(:summary, nil, 10)
-  end
-  def self.copy_base
-    Action.new(:copy_base, nil, 50)
-  end
-  def self.append
-    Action.new(:append, nil, 60)
-  end
-end
-
-class Settings
-  attr_reader :actions
-
-  def self.init 
-    actions = []
-
-    OptionParser.new do |opts|
-      opts.banner = "Usage: lokale [-bsh]"
-
-      opts.on("-b", "--copy-base", "Copies 'en' localization files to 'Base'") do |n|
-        actions << Action.copy_base
-      end
-
-      opts.on("-s", "--summary", "Prints project summary") do |n|
-        actions << Action.summary
-      end
-
-      opts.on("-a", "--append", "Appends new strings to english localization file") do |n|
-        actions << Action.append
-      end
-
-      opts.on("-h", "--help", "Prints this help") do
-        puts opts
-        exit
-      end
-    end.parse!
-
-
-
-    if actions.empty? 
-      actions << Action.summary
-    else 
-      actions.sort_by! { |e| -e.precedence }
-    end
-
-    @shared_settings = Settings.new(actions)
-  end
-
-  def self.get
-    init if @shared_settings.nil?
-    @shared_settings
-  end
-
-  def initialize(actions)
-    @actions = actions
-  end
-end
-
-
-