terrestrial-cli 0.1.0

data/lib/terrestrial/cli/file_finder.rb

@@ -0,0 +1,65 @@
+module Terrestrial
+  module Cli
+    class FileFinder
+      
+      EXCLUDED_FOLDERS = [
+        /Carthage\//,
+        /Pods\//,
+        /Tests\//
+      ]
+
+      EXCLUDED_FILES = [
+        "LaunchScreen.storyboard"
+      ]
+
+      def self.find(directory, extensions)
+        self.new(directory, extensions).find
+      end
+
+      def initialize(directory, extensions)
+        @directory  = directory
+        @extensions = extensions
+      end
+
+      def find
+        Dir[@directory + "/**/*.*"]
+          .map {|f| relative_path(f) }
+          .reject {|f| excluded_folders(f) }
+          .select {|f| @extensions.include?(File.extname(f)) }
+          .reject {|f| excluded_files(f) }
+          .select {|f| valid_paths(f) }
+      end
+
+      private
+
+      def relative_path(file)
+        Pathname.new(file)
+          .relative_path_from(Pathname.new(@directory))
+          .to_s
+      end
+
+      def valid_paths(f)
+        # Some files need to be in specific places to count
+        # as "real files". For example, strings.xml files should
+        # only be read if they are in /res/values/strings.xml
+        #
+        # Add rules here as needed.
+
+        case File.extname(f)
+        when ".xml"
+          f.end_with? "/res/values/strings.xml"
+        else
+          true
+        end
+      end
+      
+      def excluded_folders(path)
+        EXCLUDED_FOLDERS.any? { |folder| path.scan(folder).any? }
+      end
+
+      def excluded_files(path)
+        EXCLUDED_FILES.any? { |name| File.basename(path) == name }
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/file_picker.rb

@@ -0,0 +1,58 @@
+require 'pathname'
+
+module Terrestrial
+  module Cli
+    class FilePicker
+      class << self
+
+        def run(files, platform)
+          if files.count == 1
+            single_file_workflow(files)
+          else
+            multiple_files_workflow(files)
+          end
+        end
+
+        def multiple_files_workflow(files)
+          puts "-- Terrestrial detected #{files.count} localization files:"
+          files.each_with_index do |path, i|
+            puts "(#{i + 1}) #{path}"
+          end
+          puts ""
+          puts "Select the files you want Terrestrial to track as the base localization: e.g. \"1,4,5\""
+          puts "(To not select any files, just hit return. You can edit tracked files in terrestrial.yml)"
+
+          result = STDIN.gets.chomp
+
+          process_result(result, files)
+        end
+
+        def single_file_workflow(files)
+          puts "Terrestrial detected #{files.count} file:"
+          puts "(1) #{files[0].to_s}"
+          puts ""
+          puts "Use this file as your base language file? (you can change this late in terrestrial.yml) y/n?"
+
+          result = STDIN.gets.chomp.strip
+
+          if result == "y"
+            files
+          else
+            []
+          end
+        end
+
+        def process_result(result, files)
+          if result == ""
+            return []
+          else
+            result
+              .split(",")
+              .map {|i| i.to_i}
+              .map {|i| files[i - 1]}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/flight/ios_workflow.rb

@@ -0,0 +1,81 @@
+module Terrestrial
+  module Cli
+    class Flight < Command
+      class IosWorkflow
+        
+        def initialize(bootstrap_results)
+          @results = bootstrap_results
+        end
+
+        def run
+          print_instructions
+          command = STDIN.gets.chomp
+
+          if command == "y"
+            lproj_folder = TerminalUI.show_spinner do
+              Editor.prepare_files(results.all_occurences)
+              initalize_localizable_strings_files
+            end
+            add_file_to_config(lproj_folder)
+            print_done_message(lproj_folder)
+          end
+        end
+
+        private
+
+        def initalize_localizable_strings_files
+          path = create_path_to_localization_files
+
+          File.open(path, "a+") do |f|
+            formatter = DotStringsFormatter.new(results)
+
+            f.write "// Created by Terrestrial (#{Time.now.to_s})"
+            f.write "\n\n"
+            f.write formatter.format
+          end
+          path
+        end
+
+        def create_path_to_localization_files
+          folder_name = Pathname.new(Dir[Config[:directory] + "/*.xcodeproj"].first).basename(".*").to_s
+          base_lproj_path = FileUtils.mkdir_p(Config[:directory] + "/#{folder_name}" + "/Base.lproj").first
+
+          base_lproj_path + "/Localizable.strings"
+        end
+
+        def add_file_to_config(path)
+          path_to_file = Pathname.new(path)
+          current_dir  = Pathname.new(Config[:directory])
+
+          Config.load({ translation_files: [
+            path_to_file.relative_path_from(current_dir).to_s
+          ]})
+          Config.update_project_config
+        end
+
+        def print_done_message(lproj_folder)
+          puts "------------------------------------"
+          puts "-- Done!"
+          puts "- Created Base.lproj in #{lproj_folder}."
+          puts "- Remember to include the new localization files in your project!"
+        end
+
+        def print_instructions
+          puts "- Terrestrial will add #{results.length} strings to your base Localizable.strings."
+          puts ""
+          puts "------------------------------------"
+          puts "-- Source Code" 
+          puts "- Would you like Terrestrial to also modify the selected strings in your"
+          puts "- source code to call .translated?"
+          puts "-   e.g.  \"This is my string\"  =>  \"This is my string\".translated"
+          puts ""
+          puts "y/n?"
+        end
+
+        def results
+          @results
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/flight/table_workflow.rb

@@ -0,0 +1,77 @@
+module Terrestrial
+  module Cli
+    class Flight < Command
+      class TableWorkflow
+
+        LOCAL_CONFIG = {
+          strings_per_page: 10
+        }
+
+        def initialize(bootstrap_results)
+          @results = bootstrap_results
+        end
+
+        def run
+          print_instructions
+
+          exclusions = []
+          i = 0
+
+          results.all_occurences.each_slice(LOCAL_CONFIG[:strings_per_page]).with_index do |five_strings, index|
+            puts "Page #{index + 1} of #{(results.all_occurences.count / LOCAL_CONFIG[:strings_per_page].to_f).ceil}"
+
+            table = create_string_table(five_strings, i)
+            i += LOCAL_CONFIG[:strings_per_page]
+            puts table
+            print_instructions
+            puts ""
+
+            command = STDIN.gets.chomp
+            if command == 'q'
+              abort "Aborting..."
+            else
+              begin
+                exclusions.concat(command.split(",").map(&:to_i))
+              rescue
+                abort "Couldn't process that command :( Aborting..."
+              end
+            end
+          end
+          exclusions
+        end
+
+        private
+
+        def create_string_table(strings, i)
+          Terminal::Table.new(headings: ['Index', 'String', 'File']) do |t|
+            strings.each_with_index do |string, tmp_index|
+              t.add_row([i, string.string, file_name_with_line_number(string)])
+              t.add_separator unless tmp_index == (strings.length - 1) || i == (strings.length - 1)
+              i += 1
+            end
+          end
+        end
+
+        def print_instructions
+          puts "-- Instructions --"
+          puts "- To exclude any strings from translation, type the index of each string."
+          puts "-   e.g. 1,2,4"
+          puts "------------------"
+          puts "Any Exclusions? (press return to continue or 'q' to quit at any time)"
+        end
+
+        def file_name_with_line_number(string)
+          if string.line_number
+            "#{string.file}:#{string.line_number}"
+          else
+            string.file
+          end
+        end
+
+        def results
+          @results
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/flight.rb

@@ -0,0 +1,93 @@
+require 'terrestrial/cli/flight/ios_workflow.rb'
+require 'terrestrial/cli/flight/table_workflow.rb'
+require 'terminal-table'
+require 'pathname'
+
+module Terrestrial
+  module Cli
+    class Flight < Command
+
+      def run
+        Config.load!
+        MixpanelClient.track("cli-flight-command")
+
+        if !Config.project_config_exist?
+          abort_not_initialized
+        end
+        if Config[:translation_files].any?
+          abort_already_run_flight
+        end
+        if Config[:platform] != "ios"
+          puts "'flight' is not supported on Android."
+          puts "  iOS projects often just include strings in their source code instead of extracting them into resource files."
+          puts "  We created 'flight' to get iOS project up and running quicker."
+          puts "  'R.string' makes localization much easier :)"
+          abort 
+        end
+
+        puts "- Finding untranslated human readable strings..."
+        TerminalUI.show_spinner do
+          find_new_strings
+        end
+
+        puts "------------------------------------"
+        puts "- Found #{strings.count} strings"
+        puts ""
+        exclusions = TableWorkflow.new(strings).run
+        puts "------------------------------------"
+        puts "- Done!"
+
+        strings.exclude_occurences(exclusions)
+
+        if Config[:platform] == "ios"
+          IosWorkflow.new(strings).run
+        elsif Config[:platform] == 'android'
+          android_workflow
+        end
+      end
+
+      private
+
+      def android_workflow
+        puts "- Terrestrial will annotate the selected strings in your strings.xml file:"
+        puts "-  e.g.  <string name='my_name'>My string!</string>  =>  <string terrestrial='true' name='my_name'>My string</string>"
+      end
+
+      def find_new_strings
+        @strings = Bootstrapper.find_new_strings(Config[:directory])
+      end
+
+      def strings
+        @strings
+      end
+
+      def abort_not_initialized
+        puts "You should initialize your project before running flight."
+        puts "It's simple! You can do this by running:"
+        puts ""
+        puts "  terrestrial init --api-key <API KEY> --project-id <PROJECT ID>"
+        puts ""
+        puts "You can find your Api Key and Project ID at https://mission.terrestrial.io"
+        abort
+      end
+
+      def abort_already_run_flight
+        if Config[:platform] == "ios"
+          puts "Looks like you already have Localizable.strings files."
+          puts "'flight' scans your source code for human readable strings that have not been translated"
+          puts "and helps you quickstart your internaionalization process."
+          puts ""
+          puts "If you want to new strings into your .strings file, run 'terrestrial gen'. It will:"
+          puts "  1. Scan your source code for .translated and NSLocalizedString calls."
+          puts "  2. Determine if the strings already exist in Localizable.strings."
+          puts "  3. Append any new strings to your base Localizable.strings."
+          puts ""
+          puts "For more information, visit http://docs.terrestrial.io/, or jump on our Slack via https://terrestrial-slack.herokuapp.com/"
+          abort
+        else 
+          # TODO
+        end
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/ignite.rb

@@ -0,0 +1,73 @@
+module Terrestrial
+  module Cli
+    class Ignite < Command
+
+      WORKING_DIR = '/usr/local/var/terrestrial'
+
+      def run
+        Config.load!
+        MixpanelClient.track("cli-ignite-command")
+        lang = opts["language"] 
+
+        if Config[:platform] != "ios"
+          abort "Unfortunately launching your app in a locale via 'ignite' is only supported on iOS at this time."
+        end
+
+        if lang.nil? || lang.empty?
+          abort "Please provide a locale to launch the simulator in.\n  e.g. 'terrestrial ignite es'"
+        end
+
+        puts "Starting simulator in locale \"#{lang}\"..."
+
+        TerminalUI.show_spinner do
+          ensure_var_folder_exists
+
+          workspace = Dir["#{Config[:directory]}/*.xcworkspace"][0]
+          project = Dir["#{Config[:directory]}/*.xcodeproj"][0]
+
+          # Kill simulator and 
+          system("killall \"Simulator\" &> /dev/null")
+          `rm -rf #{WORKING_DIR}`
+
+          if workspace 
+            # If a workspace exists we want to build it instead of the project.
+            # We assume the scheme we want to use is simply the application name
+            app_name = File.basename(workspace).split(".").first
+            `xcodebuild -workspace "#{workspace}" -arch "i386" ONLY_ACTIVE_ARCH=NO VALID_ARCHS="i386 x86_64" -scheme #{app_name} -sdk iphonesimulator clean`
+            `xcodebuild -workspace "#{workspace}" -arch "i386" ONLY_ACTIVE_ARCH=NO VALID_ARCHS="i386 x86_64" -scheme #{app_name} -sdk iphonesimulator CONFIGURATION_BUILD_DIR=#{WORKING_DIR}`
+          else
+            app_name = File.basename(project).split(".").first
+            `xcodebuild -project "#{project}" -arch i386 -sdk iphonesimulator clean`
+            `xcodebuild -project "#{project}" -arch i386 -sdk iphonesimulator CONFIGURATION_BUILD_DIR=#{WORKING_DIR}`
+          end
+          `open /Applications/Xcode.app/Contents/Developer/Applications/Simulator.app`
+
+          # Here we literally sleep until the Simulator has been booted
+          wait_until_booted = %{
+            count=`xcrun simctl list | grep Booted | wc -l | sed -e 's/ //g'`
+            while [ $count -lt 1 ]
+            do
+                sleep 1
+                count=`xcrun simctl list | grep Booted | wc -l | sed -e 's/ //g'`
+            done
+          }
+          `#{wait_until_booted}`
+
+          # Here we magically find the bundle identifier of the app
+          command = "defaults read \"#{Dir[WORKING_DIR + '/*.app/Info.plist'].first}\" CFBundleIdentifier"
+          bundle_name = `#{command}`.chop
+
+          # Reinstall the app,
+          # Run it with the locale we want
+          `xcrun simctl uninstall booted #{bundle_name}`
+          `xcrun simctl install booted "#{Dir[WORKING_DIR + "/" + app_name + ".app"].first}"`
+          `xcrun simctl launch booted #{bundle_name} --args -AppleLanguages \\(#{lang}\\)`
+        end
+      end
+
+      def ensure_var_folder_exists
+        `mkdir -p #{WORKING_DIR}`
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/init.rb

@@ -0,0 +1,133 @@
+module Terrestrial
+  module Cli
+    class Init < Command
+
+      def run
+        # Fail early if project already exists
+        Config.load!({}, project: false)
+        MixpanelClient.track("cli-init-command")
+        
+        if Config.project_config_exist?
+          abort "Looks like there already exists a project in this directory. Are you in the correct folder?"
+        end
+
+        check_arguments
+        detect_platform
+
+        puts "-- Terrestrial Initializing"
+        puts "Adding new app! Searching for localization files..."
+
+        TerminalUI.show_spinner do
+          # Otherwise the whole process is too quick for the eye
+          sleep 2 unless Config.testing?
+        end
+        puts ""
+
+        select_translation_files
+        create_app_in_web
+
+        if @response.success?
+          update_config
+
+          puts "-- Success!"
+          puts "App platform added to project! You can view your app at https://mission.terrestrial.io/projects/#{Config[:project_id]}/apps/#{Config[:app_id]}"
+          puts ""
+          puts "-- What to do next?"
+
+          if @translation_files.any?
+            puts "Run 'terrestrial scan' to see which strings Terrestrial is currently tracking."
+            puts "When you're ready to upload your strings for translation, run 'terrestrial push'!"
+          elsif @translation_files.none? && @platform == "ios"
+            puts "To get started localizing your app, run 'terrestrial flight'."
+            puts "Terrestrial will scan your code for strings, and generate the necessary localization files."
+          elsif @translation_files.none? && @platform == "android"
+            puts "Looks like Terrestrial does not know which strings.xml files to track."
+            puts "To continue, add your base language strings.xml file to terrestrial.yml."
+            puts "When you're ready, run 'terrestrial scan' to see which strings Terrestrial is tracking, and 'terrestrial push' to upload."
+          end
+          puts ""
+          puts "For more information, see http://docs.terrestrial.io or jump on Slack at https://terrestrial-slack.herokuapp.com/ if you have any questions."
+        else
+          puts "Oh snap. There was an error initializing your project."
+          puts response.body.inspect
+          abort
+        end
+      end
+
+      private
+      
+      def select_translation_files
+        @tranlation_files = [] 
+
+        files = find_platform_translation_files
+        if files.any?
+          @tranlation_files = FilePicker.run(files, @platform)
+          
+          if @tranlation_files.count == 1
+            puts "Tracking #{@tranlation_files.count} file!"
+          else
+            puts "Tracking #{@tranlation_files.count} files!"
+          end
+        end
+      end
+
+      def find_platform_translation_files
+        if @platform == "ios"
+          Dir[Config[:directory] + "/**/*.strings"].map {|f| relative_path(f) }
+        elsif @platform == "android"
+          Dir[Config[:directory] + "/**/*/res/values/strings.xml"].map {|f| relative_path(f) }
+        else
+          raise "Unknown platform #{@platform}"
+        end
+      end
+
+      def update_config
+        Terrestrial::Config.load({
+          app_id: @response.body["data"]["id"],
+          project_id: @project_id,
+          platform: @platform,
+          api_key: @api_key,
+          translation_files: @tranlation_files
+        })
+
+        Terrestrial::Config.update_global_config
+        Terrestrial::Config.update_project_config
+      end
+
+      def create_app_in_web
+        @client = Terrestrial::Web.new(@api_key)
+        @response = @client.create_app(@project_id, @platform)
+      end
+
+      def check_arguments
+        @api_key = opts[:api_key] || Config[:api_key] || 
+                 abort("No api key provided. You can find your API key at https://mission.terrestrial.io/.")
+
+        @project_id = opts.fetch(:project_id) { abort(
+          "No project ID provided. Terrestrial needs to know which project this app belongs to.\n" +
+          "Visit https://mission.terrestrial.io to find your project ID."
+        )}
+      end
+
+      def detect_platform
+        @platform = DetectsProjectType.run
+      end
+
+      def project_id
+        @project_id
+      end
+
+      def api_key
+        @api_key
+      end
+
+      def relative_path(file)
+        current_dir = Pathname.new(Config[:directory])
+
+        Pathname.new(file)
+          .relative_path_from(current_dir)
+          .to_s
+      end
+    end
+  end
+end

data/lib/terrestrial/cli/mixpanel_client.rb

@@ -0,0 +1,56 @@
+require 'base64'
+require 'json'
+
+module Terrestrial
+  module Cli
+    module MixpanelClient
+      class << self
+
+        TOKEN = "47d6a27568a3c842ead24b14907eb04e"
+        URL = "https://api.mixpanel.com/track"
+
+        def track(event)
+          # If we're live
+          if Config[:api_url] == "https://mission.terrestrial.io"
+            `curl -silent -X POST #{URL}?data=#{format_event(event)} &`
+          end
+        end
+
+        def user_identifier
+          if Config[:user_id]
+            Config[:user_id]
+          else
+            fetch_and_save_user_id
+          end
+        end
+
+        def format_event(event)
+          Base64.strict_encode64(event_json(event))
+        end
+
+        def event_json(event)
+          {
+            event: event,
+            properties: {
+              distinct_id: user_identifier,
+              token: TOKEN,
+              time: Time.now.to_i
+            }
+          }.to_json
+        end
+
+        def fetch_and_save_user_id
+          response = Web.new.get_profile
+          if response.success?
+            id = response.body["data"]["user"]["id"]
+            Config.load({:user_id => id})
+            Config.update_global_config
+            id
+          else
+            "unknown"
+          end
+        end
+      end
+    end
+  end
+end