terrestrial-cli 0.1.0

data/lib/terrestrial/cli/dot_strings_parser.rb

@@ -0,0 +1,139 @@
+module Terrestrial
+  module Cli
+    module DotStringsParser
+      class << self
+
+        def parse_file(path)
+          entries = do_parse_file read_file_with_correct_encoding(path)
+          entries.each do |entry|
+            entry["type"] = "localizable.strings"
+            entry["file"] = path
+          end
+        end
+
+        private
+
+        def do_parse_file(contents)
+          results = []
+          
+          multiline_comment = false
+          expecting_string  = false
+          multiline_string  = false
+          current = {}
+
+          contents.split("\n").each do |line|
+            line = line.rstrip
+            line = remove_comments(line) unless multiline_string
+
+            if !multiline_string && !multiline_comment && line == ""
+              # Just empty line between entries
+              next 
+            elsif line.start_with?("\"") && !line.end_with?(";")
+              # Start multiline string"
+              current_id = line.split("=").map(&:strip)[0][1..-1][0..-2]
+              current_string = line.split("=").map(&:strip)[1][1..-1]
+
+              current["identifier"] = current_id
+              current["string"] = current_string unless current_string.empty?
+              multiline_string = true
+            elsif multiline_string && !line.end_with?(";")
+              # Continuing multiline string
+              if current["string"].nil?
+                current["string"] = line.lstrip
+              else
+                current["string"] << "\n" + line
+              end
+            elsif multiline_string && line.end_with?(";")
+              # Ending multiline string
+              current["string"] << "\n#{line[0..-3]}"
+              multiline_string = false
+              results << current
+              current = {}
+            elsif !expecting_string && line.lstrip.start_with?("/*") && !line.end_with?("*/")
+              # Start multline comment
+              tmp_content = line[2..-1].strip
+              current["context"] = "\n" + tmp_content unless tmp_content.empty?
+              multiline_comment = true
+            elsif multiline_comment && !line.end_with?("*/")
+              # Continuing multline comment
+              if current["context"].nil?
+                current["context"] = line.lstrip
+              else
+                current["context"] << "\n" + line
+              end
+            elsif multiline_comment && line.end_with?("*/")
+              # Ending multline comment
+              tmp_content = line[0..-3].strip
+              current["context"] << (tmp_content.empty? ? "" : "\n#{tmp_content}")
+              multiline_comment = false
+              expecting_string  = true
+            elsif !expecting_string && line.start_with?("/*") && line.end_with?("*/")
+              # Single line comment
+              current["context"] = line[2..-1][0..-3].strip
+              expecting_string = true
+            elsif expecting_string && line.end_with?(";")
+              # Single line id/string pair after a comment
+              current_id, current_string = get_string_and_id(line)
+              current["identifier"] = current_id
+              current["string"] = current_string
+
+              expecting_string = false
+              results << current
+              current = {}
+            elsif !expecting_string && line.end_with?(";")
+              # id/string without comment first
+              current_id, current_string = get_string_and_id(line)
+              current["identifier"] = current_id
+              current["string"] = current_string
+
+              results << current
+              current = {}
+            else
+              raise "Don't know what to do with '#{line.inspect}'"
+            end
+          end
+          results
+        end
+
+        def get_string_and_id(line)
+          id = line.split("=").map(&:strip)[0].gsub("\"", "")
+          string = line.split("=").map(&:strip)[1].gsub("\"", "")[0..-2]
+          [id, string]
+        end
+
+        def read_file_with_correct_encoding(path)
+          # Genstrings creates files with BOM UTF-16LE encoding.
+          # If we realise that we cannot operate on the content
+          # of the file assumin UTF-8, we try UTF-16!
+
+          content = File.read path
+          begin 
+            # Try performing an operation on the content
+            content.split("\n") 
+          rescue ArgumentError
+            # Failure! We think this is a UTF-16 file 
+
+            # Remove the byte order marker from the beginning
+            # of the file. We tried doing this with a simple
+            # sub! of \xFF\xFE, but we kept running into 
+            # more issues. We instead do it manually.
+            content = content.bytes[2..-1].pack('c*')
+
+            # Force UTF-16LE encoding as a setting (not actually
+            # changing any representations yet!), then encode from 
+            # that to UTF-8 again
+            content = content
+                        .force_encoding(Encoding::UTF_16LE)
+                        .encode!(Encoding::UTF_8)
+          end
+          content
+        end
+
+        def remove_comments(line)
+          line = line.split("//")[0] || ""
+          line.rstrip
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/editor/android_xml.rb

@@ -0,0 +1,64 @@
+module Terrestrial
+  module Cli
+    module Editor
+      class AndroidXML < BaseEditor
+
+        def self.find_and_edit_line(string_entry)
+          self.new(string_entry).add_attributes
+        end
+
+        def self.add_import(file)
+          # Not needed
+        end
+
+        def initialize(entry)
+          @path = entry.file
+          @type = entry.type
+          @string = entry.string
+          @identifier = entry.identifier
+
+          @document = REXML::Document.new(File.new(@path))
+          @document.context[:attribute_quote] = :quote 
+        end
+
+        def add_attributes
+          node = find_node(@identifier)
+          node.add_attribute("terrestrial", true) 
+          refresh_document(node)
+          save_document
+        end
+
+        def find_node(name)
+          REXML::XPath.first(@document, "//resources/string[@name=\"#{name}\"]")
+        end
+
+        def refresh_document(node)
+          # This is a bit ridiculous, but necessary because
+          # &*£(*$)£@*$!£ REXML
+          
+          @document = REXML::Document.new(node.document.to_s)
+        end
+
+        def save_document
+          # AAAAAAAARARARARARARRARAAAGH REXML STAAAAHP
+          # You can't make REXML print attributes inside double
+          # quotes without monkey patching >.<
+          #
+          # ...seriously?
+
+          REXML::Attribute.class_eval( %q^
+                                            def to_string
+                                              %Q[#@expanded_name="#{to_s().gsub(/"/, '&quot;')}"]
+                                            end
+                                        ^)
+          File.open(@path, "w") do |f|
+            printer = Printer.new(2)
+            printer.compact = true
+            printer.width = 1000000
+            printer.write(@document, f)
+          end 
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/editor/base_editor.rb

@@ -0,0 +1,36 @@
+require 'tempfile'
+
+module Terrestrial
+  module Cli
+    module Editor
+      class BaseEditor
+
+        def self.find_and_edit_line(string_entry)
+          raise "Not implemented"
+        end
+
+        def self.add_import(file)
+          raise "Not implemented"
+        end
+
+        def self.edit_file(path)
+          temp_file = Tempfile.new(File.basename(path))
+          begin
+            line_number = 1
+            File.open(path, 'r') do |file|
+              file.each_line do |line|
+                yield line, line_number, temp_file
+                line_number += 1
+              end
+            end
+            temp_file.close
+            FileUtils.mv(temp_file.path, path)
+          ensure
+            temp_file.close
+            temp_file.unlink
+          end
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/editor/objc.rb

@@ -0,0 +1,66 @@
+module Terrestrial
+  module Cli
+    module Editor
+      class ObjC < BaseEditor
+
+        def self.find_and_edit_line(new_string)
+          edit_file(new_string.file) do |line, line_number, file|
+            if line_number == new_string.line_number
+              file.puts do_edit_string(line, new_string)
+            else
+              file.puts line
+            end
+          end
+        end
+
+        def self.do_edit_string(line, entry)
+          line.gsub(a_string_not_followed_by_translated(entry.string), "@\"#{entry.identifier}\".translated")
+        end
+
+        def self.add_import(file)
+          # Adds #import "Terrestrial.h" as the last import
+          # statement at the top of the file.
+          #
+          # It goes through the file from top to bottom looking for the first import
+          # statement. After it finds it, it will look for the first line without
+          # an import statement. When it finds it, it will write the import line,
+          # and all following lines are just copied over.
+
+          found_first_import = false
+          imported = false
+
+          edit_file(file) do |line, line_number, file|
+            if !found_first_import && line.start_with?("#import ")
+              found_first_import = true
+              file.puts line
+            elsif line.start_with?("#import <Terrestrial/Terrestrial.h>")
+              imported = true
+              file.puts line
+            elsif !imported && found_first_import && !line.start_with?("#import ")
+              file.puts "#import <Terrestrial/Terrestrial.h>"
+              file.puts ""
+              imported = true
+            else
+              file.puts line
+            end
+          end
+        end
+
+        def self.a_string_not_followed_by_translated(string)
+          # Does not match:
+          #
+          #   @"foo".translated
+          #   or
+          #   @"foo" translatedWithContext
+          #
+          #   (?!(\.|\s)translated) means don't match either
+          #   period or single whitepspace character,
+          #   followed by translated
+
+
+          /@"#{string}"(?!(\.|\s)translated)/
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/editor/printer.rb

@@ -0,0 +1,47 @@
+# Common fixes for editors that use 
+# REXML
+class Printer < REXML::Formatters::Pretty
+  # The point of this little thing is to keep
+  # the order of attributes when we flush the 
+  # storyboard back to disk.
+  # We do this to avoid massive git diffs.
+  # Turns out that xcode is quite good at updating
+  # and reverting our formating changes though.
+  #
+  # Source: 
+  #   http://stackoverflow.com/questions/574724/rexml-preserve-attributes-order
+  #
+  #   fmt = OrderedAttributes.new
+  #   fmt.write(xmldoc, $stdout)
+  #
+  def write_element(elm, out)
+    att = elm.attributes
+    class <<att
+      alias _each_attribute each_attribute
+
+      def each_attribute(&b)
+        to_enum(:_each_attribute).sort_by {|x| x.name}.each(&b)
+      end
+    end
+    super(elm, out)
+  end
+
+  # This genious is here to stop the damn thing from wrapping
+  # lines over 80 chars long >.<
+  #
+  # Source:
+  #   http://stackoverflow.com/questions/4203180/rexml-is-wrapping-long-lines-how-do-i-switch-that-off
+  #
+  def write_text( node, output )
+    s = node.to_s()
+    s.gsub!(/\s/,' ')
+    s.squeeze!(" ")
+
+    #The Pretty formatter code mistakenly used 80 instead of the @width variable
+    #s = wrap(s, 80-@level)
+    s = wrap(s, @width-@level)
+
+    s = indent_text(s, @level, " ", true)
+    output << (' '*@level + s)
+  end
+end

data/lib/terrestrial/cli/editor/storyboard.rb

@@ -0,0 +1,98 @@
+module Terrestrial
+  module Cli
+    module Editor
+      class Storyboard < BaseEditor
+
+        QUERIES = {
+          "storyboard-label" => "//label",
+          "storyboard-text-field" => "//textField",
+          "storyboard-button" => "//button",
+          "storyboard-bar-button-item" => "//barButtonItem",
+          "storyboard-navbar-item" => "//navigationItem",
+          "storyboard-text-view" => "//textView"
+        }
+
+        def self.find_and_edit_line(approved_string)
+          insert_runtime_attribute(approved_string)
+        end
+
+
+        def self.add_import(file)
+          # Not needed
+          # Override parent class implementation
+        end
+
+        def initialize(entry)
+          @path          = entry.file
+          @type          = entry.type
+          @string        = entry.string
+          @storyboard_id = entry.metadata["storyboard_element_id"]
+          @identifier    = entry.identifier
+
+          @document = REXML::Document.new(File.new(@path))
+        end
+
+        def self.insert_runtime_attribute(entry)
+          self.new(entry).insert_attribute
+        end
+
+        def insert_attribute
+          node = find_node
+
+          # TODO, There was a case when "node" was nil in this point, after
+          # trying to find it by type + ID.
+          #
+          # Keep an eye out for it to see if reproducible
+
+          node.add(create_element)
+          refresh_document(node)
+          save_document
+        end
+
+        private
+
+        def find_node
+          REXML::XPath.first(@document, query_for(@type, storyboard_id: @storyboard_id))
+        end
+
+        def refresh_document(node)
+          # This is a bit ridiculous, but necessary because
+          # &*£(*$)£@*$!£ REXML
+          
+          @document = REXML::Document.new(node.document.to_s)
+        end
+
+        def save_document
+          File.open(@path, "w") do |f|
+            printer = Printer.new(2)
+            printer.width = 1000
+            printer.write(@document, f)
+          end 
+        end
+
+        def query_for(type, storyboard_id: "")
+          # Find element of said type, with the ID, that does not
+          # have a userDefinedRuntimeAttribute as a child
+
+          QUERIES[type] + "[@id=\"#{storyboard_id}\" and not(userDefinedRuntimeAttributes)]]"
+        end
+
+        def text_attribute(type)
+          Parser::Storyboard::Engine::TEXT_ATTRIBUTE[type]
+        end
+
+        def create_element
+          REXML::Element.new("userDefinedRuntimeAttributes")
+                .add_element("userDefinedRuntimeAttribute", 
+                     {"type" => "boolean", 
+                      "keyPath" => "Terrestrial", 
+                      "value" => "YES" }).parent
+                .add_element("userDefinedRuntimeAttribute", 
+                     {"type" => "string", 
+                      "keyPath" => "Identifier", 
+                      "value" => @identifier }).parent
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/editor/swift.rb

@@ -0,0 +1,92 @@
+module Terrestrial
+  module Cli
+    module Editor
+      class Swift < BaseEditor
+
+        def self.find_and_edit_line(new_string)
+          edit_file(new_string.file) do |line, line_number, file|
+            if line_number == new_string.line_number
+              file.puts do_edit_string(line, new_string)
+            else
+              file.puts line
+            end
+            line_number += 1
+          end
+        end
+
+        def self.do_edit_string(line, entry)
+          if has_swift_variables? entry.string
+            edit_with_variables(line, entry)
+          else
+            line.gsub(a_string_not_followed_by_translated(entry.string), "\"#{entry.identifier}\".translated")
+          end
+        end
+
+        def self.edit_with_variables(line, entry)
+          line.gsub(a_string_not_followed_by_translated(entry.string), build_string_with_variables(entry))
+        end
+
+        def self.build_string_with_variables(entry)
+          "NSString(format: \"#{entry.identifier}\".translated, #{swift_variables(entry.string).join(", ")})"
+        end
+
+        def self.add_import(file)
+          # Adds import Terrestrial as the last import
+          # statement at the top of the file.
+          #
+          # It goes through the file from top to bottom looking for the first import
+          # statement. After it finds it, it will look for the first line without
+          # an import statement. When it finds it, it will write the import line,
+          # and all following lines are just copied over.
+
+          found_first_import = false
+          imported = false
+
+          edit_file(file) do |line, line_number, file|
+            # Detect first import statement
+            if !found_first_import && line.start_with?("import ")
+              found_first_import = true
+              file.puts line
+            # Terrestrial had already been imported
+            elsif line.start_with?("import Terrestrial")
+              imported = true
+              file.puts line
+            # Not imported, had found first import, and doesn't start with "import"
+            #   -> import
+            elsif !imported && found_first_import && !line.start_with?("import ")
+              file.puts "import Terrestrial"
+              file.puts ""
+              imported = true
+            # Copy over as normal
+            else
+              file.puts line
+            end
+          end
+        end
+
+        def self.has_swift_variables?(string)
+          swift_variables(string).any?
+        end
+
+        def self.swift_variables(string)
+          string.scan(Parser::Swift::VARIABLE_REGEX).map(&:first)
+        end
+
+        def self.a_string_not_followed_by_translated(string)
+          # Does not match:
+          #
+          #   @"foo".translated
+          #   or
+          #   @"foo" translatedWithContext
+          #
+          #   (?!(\.|\s)translated) means don't match either
+          #   period or single whitepspace character,
+          #   followed by translated
+
+
+          /"#{Regexp.quote(string)}"(?!\.translated)/
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/editor.rb

@@ -0,0 +1,42 @@
+require 'terrestrial/cli/editor/printer'
+require 'terrestrial/cli/editor/base_editor'
+require 'terrestrial/cli/editor/objc'
+require 'terrestrial/cli/editor/swift'
+require 'terrestrial/cli/editor/storyboard'
+require 'terrestrial/cli/editor/android_xml'
+
+module Terrestrial
+  module Cli
+    module Editor
+      class << self
+        def prepare_files(new_strings)
+          @new_strings = new_strings
+          run
+        end
+
+        private
+
+        def run
+          wrap_string_with_sdk_functions
+          add_imports
+        end
+
+        def add_imports
+          @new_strings
+            .uniq {|string| string.file}
+            .each {|string| editor_for_type(string.file).add_import(string.file)}
+        end
+
+        def wrap_string_with_sdk_functions
+          @new_strings.each do |string|
+            editor_for_type(string.file).find_and_edit_line(string)
+          end
+        end
+
+        def editor_for_type(file)
+          EngineMapper.editor_for(File.extname(file))
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/engine_mapper.rb

@@ -0,0 +1,30 @@
+module Terrestrial
+  module Cli
+    class EngineMapper
+
+      PARSERS = {
+        ".m" => Terrestrial::Cli::Parser::ObjC,
+        ".h" => Terrestrial::Cli::Parser::ObjC,
+        ".swift" => Terrestrial::Cli::Parser::Swift,
+        ".storyboard" => Terrestrial::Cli::Parser::Storyboard,
+        ".xml" => Terrestrial::Cli::Parser::AndroidXML
+      }
+
+      EDITORS = {
+        ".m" => Terrestrial::Cli::Editor::ObjC,
+        ".h" => Terrestrial::Cli::Editor::ObjC,
+        ".swift" => Terrestrial::Cli::Editor::Swift,
+        ".storyboard" => Terrestrial::Cli::Editor::Storyboard,
+        ".xml" => Terrestrial::Cli::Editor::AndroidXML
+      }
+
+      def self.parser_for(extension)
+        PARSERS[extension]
+      end
+
+      def self.editor_for(extension)
+        EDITORS[extension]
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/entry_collection_differ.rb

@@ -0,0 +1,22 @@
+module Terrestrial
+  module Cli
+    class EntryCollectionDiffer
+
+      def self.omissions(first, second)
+        first.select do |a|
+          !second.any? {|b| match?(a, b)}
+        end
+      end
+
+      def self.additions(first, second)
+        second.reject do |b| 
+          first.any? {|a| match?(a, b) }
+        end
+      end
+      
+      def self.match?(a, b)
+        a.fetch("identifier") == b.fetch("identifier")
+      end
+    end
+  end
+end