pantograph 0.1.0

data/pantograph_core/lib/pantograph_core/analytics/analytics_event_builder.rb

@@ -0,0 +1,23 @@
+module PantographCore
+  class AnalyticsEventBuilder
+    attr_accessor :action_name
+
+    # pantograph_client_language valid options are :ruby
+    def initialize(p_hash: nil, session_id: nil, action_name: nil, pantograph_client_language: :ruby)
+      @p_hash = p_hash
+      @session_id = session_id
+      @action_name = action_name
+      @pantograph_client_language = pantograph_client_language
+    end
+
+    def new_event(action_stage)
+      {
+        client_id: @p_hash,
+        category: "pantograph Client Language - #{@pantograph_client_language}",
+        action: action_stage,
+        label: action_name,
+        value: nil
+      }
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/analytics/analytics_ingester_client.rb

@@ -0,0 +1,54 @@
+require 'faraday'
+require 'openssl'
+require 'json'
+
+require_relative '../helper'
+
+module PantographCore
+  class AnalyticsIngesterClient
+    GA_URL = "https://www.google-analytics.com"
+
+    private_constant :GA_URL
+
+    def initialize(ga_tracking)
+      @ga_tracking = ga_tracking
+    end
+
+    def post_event(event)
+      # If our users want to opt out of usage metrics, don't post the events.
+      # Learn more at https://docs.pantograph.tools/#metrics
+      if Helper.test? || PantographCore::Env.truthy?("PANTOGRAPH_OPT_OUT_USAGE")
+        return nil
+      end
+      return Thread.new do
+        send_request(event)
+      end
+    end
+
+    def send_request(event, retries: 2)
+      post_request(event)
+    rescue
+      retries -= 1
+      retry if retries >= 0
+    end
+
+    def post_request(event)
+      connection = Faraday.new(GA_URL) do |conn|
+        conn.request(:url_encoded)
+        conn.adapter(Faraday.default_adapter)
+      end
+      connection.headers[:user_agent] = 'pantograph/' + Pantograph::VERSION
+      connection.post("/collect", {
+        v: "1",                                            # API Version
+        tid: @ga_tracking,                                 # Tracking ID / Property ID
+        cid: event[:client_id],                            # Client ID
+        t: "event",                                        # Event hit type
+        ec: event[:category],                              # Event category
+        ea: event[:action],                                # Event action
+        el: event[:label] || "na",                         # Event label
+        ev: event[:value] || "0",                          # Event value
+        aip: "1"                                           # IP anonymization
+      })
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/analytics/analytics_session.rb

@@ -0,0 +1,71 @@
+require_relative 'analytics_ingester_client'
+require_relative 'action_launch_context'
+require_relative 'analytics_event_builder'
+
+module PantographCore
+  class AnalyticsSession
+    GA_TRACKING = "UA-121171860-1"
+
+    private_constant :GA_TRACKING
+    attr_accessor :session_id
+    attr_accessor :client
+
+    def initialize(analytics_ingester_client: AnalyticsIngesterClient.new(GA_TRACKING))
+      require 'securerandom'
+      @session_id = SecureRandom.uuid
+      @client = analytics_ingester_client
+      @threads = []
+      @launch_event_sent = false
+    end
+
+    def action_launched(launch_context: nil)
+      unless did_show_message?
+        show_message
+      end
+
+      if @launch_event_sent || launch_context.p_hash.nil?
+        return
+      end
+
+      @launch_event_sent = true
+      builder = AnalyticsEventBuilder.new(
+        p_hash: launch_context.p_hash,
+        session_id: session_id,
+        action_name: nil,
+        pantograph_client_language: launch_context.pantograph_client_language
+      )
+
+      launch_event = builder.new_event(:launch)
+      post_thread = client.post_event(launch_event)
+      unless post_thread.nil?
+        @threads << post_thread
+      end
+    end
+
+    def action_completed(completion_context: nil)
+    end
+
+    def show_message
+      UI.message("Sending anonymous analytics information")
+      UI.message("Learn more at https://docs.pantograph.tools/#metrics")
+      UI.message("No personal or sensitive data is sent.")
+      UI.message("You can disable this by adding `opt_out_usage` at the top of your Pantfile")
+    end
+
+    def did_show_message?
+      file_name = ".did_show_opt_info"
+
+      new_path = File.join(PantographCore.pantograph_user_dir, file_name)
+      did_show = File.exist?(new_path)
+
+      return did_show if did_show
+
+      File.write(new_path, '1')
+      false
+    end
+
+    def finalize_session
+      @threads.map(&:join)
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/cert_checker.rb

@@ -0,0 +1,116 @@
+require 'tempfile'
+require 'openssl'
+
+require_relative 'helper'
+
+module PantographCore
+  # This class checks if a specific certificate is installed on the current mac
+  class CertChecker
+    def self.installed?(path, in_keychain: nil)
+      UI.user_error!("Could not find file '#{path}'") unless File.exist?(path)
+
+      ids = installed_identies(in_keychain: in_keychain)
+      finger_print = sha1_fingerprint(path)
+
+      return ids.include?(finger_print)
+    end
+
+    # Legacy Method, use `installed?` instead
+    def self.is_installed?(path)
+      installed?(path)
+    end
+
+    def self.installed_identies(in_keychain: nil)
+      install_wwdr_certificate unless wwdr_certificate_installed?
+
+      available = list_available_identities(in_keychain: in_keychain)
+      # Match for this text against word boundaries to avoid edge cases around multiples of 10 identities!
+      if /\b0 valid identities found\b/ =~ available
+        UI.error([
+          "There are no local code signing identities found.",
+          "You can run" << " `security find-identity -v -p codesigning #{in_keychain}".rstrip << "` to get this output.",
+          "This Stack Overflow thread has more information: https://stackoverflow.com/q/35390072/774.",
+          "(Check in Keychain Access for an expired WWDR certificate: https://stackoverflow.com/a/35409835/774 has more info.)"
+        ].join("\n"))
+      end
+
+      ids = []
+      available.split("\n").each do |current|
+        next if current.include?("REVOKED")
+        begin
+          (ids << current.match(/.*\) ([[:xdigit:]]*) \".*/)[1])
+        rescue
+          # the last line does not match
+        end
+      end
+
+      return ids
+    end
+
+    def self.list_available_identities(in_keychain: nil)
+      commands = ['security find-identity -v -p codesigning']
+      commands << in_keychain if in_keychain
+      `#{commands.join(' ')}`
+    end
+
+    def self.wwdr_certificate_installed?
+      certificate_name = "Apple Worldwide Developer Relations Certification Authority"
+      keychain = wwdr_keychain
+      response = Helper.backticks("security find-certificate -c '#{certificate_name}' #{keychain.shellescape}", print: PantographCore::Globals.verbose?)
+      return response.include?("attributes:")
+    end
+
+    def self.install_wwdr_certificate
+      url = 'https://developer.apple.com/certificationauthority/AppleWWDRCA.cer'
+      file = Tempfile.new('AppleWWDRCA')
+      filename = file.path
+      keychain = wwdr_keychain
+      keychain = "-k #{keychain.shellescape}" unless keychain.empty?
+
+      require 'open3'
+
+      import_command = "curl -f -o #{filename} #{url} && security import #{filename} #{keychain}"
+      UI.verbose("Installing WWDR Cert: #{import_command}")
+
+      stdout, stderr, _status = Open3.capture3(import_command)
+      if PantographCore::Globals.verbose?
+        UI.command_output(stdout)
+        UI.command_output(stderr)
+      end
+
+      unless $?.success?
+        UI.verbose("Failed to install WWDR Certificate, checking output to see why")
+        # Check the command output, WWDR might already exist
+        unless /The specified item already exists in the keychain./ =~ stderr
+          UI.user_error!("Could not install WWDR certificate")
+        end
+        UI.verbose("WWDR Certificate was already installed")
+      end
+      return true
+    end
+
+    def self.wwdr_keychain
+      priority = [
+        "security list-keychains -d user",
+        "security default-keychain -d user"
+      ]
+      priority.each do |command|
+        keychains = Helper.backticks(command, print: PantographCore::Globals.verbose?).split("\n")
+        unless keychains.empty?
+          # Select first keychain name from returned keychains list
+          return keychains[0].strip.tr('"', '')
+        end
+      end
+      return ""
+    end
+
+    def self.sha1_fingerprint(path)
+      file_data = File.read(path.to_s)
+      cert = OpenSSL::X509::Certificate.new(file_data)
+      return OpenSSL::Digest::SHA1.new(cert.to_der).to_s.upcase
+    rescue => error
+      UI.error(error)
+      UI.user_error!("Error parsing certificate '#{path}'")
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/command_executor.rb

@@ -0,0 +1,99 @@
+require_relative 'ui/ui'
+require_relative 'globals'
+require_relative 'pantograph_pty'
+
+module PantographCore
+  # Executes commands and takes care of error handling and more
+  class CommandExecutor
+    class << self
+      # Cross-platform way of finding an executable in the $PATH. Respects the $PATHEXT, which lists
+      # valid file extensions for executables on Windows.
+      #
+      #    which('ruby') #=> /usr/bin/ruby
+      #
+      # Derived from https://stackoverflow.com/a/5471032/3005
+      def which(cmd)
+        # PATHEXT contains the list of file extensions that Windows considers executable, semicolon separated.
+        # e.g. ".COM;.EXE;.BAT;.CMD"
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : []
+        exts << '' # Always have an empty string (= no file extension)
+
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            cmd_path = File.join(path, "#{cmd}#{ext}")
+            return cmd_path if Helper.executable?(cmd_path)
+          end
+        end
+
+        return nil
+      end
+
+      # @param command [String] The command to be executed
+      # @param print_all [Boolean] Do we want to print out the command output while running?
+      # @param print_command [Boolean] Should we print the command that's being executed
+      # @param error [Block] A block that's called if an error occurs
+      # @param prefix [Array] An array containing a prefix + block which might get applied to the output
+      # @param loading [String] A loading string that is shown before the first output
+      # @param suppress_output [Boolean] Should we print the command's output?
+      # @return [String] All the output as string
+      def execute(command: nil, print_all: false, print_command: true, error: nil, prefix: nil, loading: nil, suppress_output: false)
+        print_all = true if PantographCore::Globals.verbose?
+        prefix ||= {}
+
+        output = []
+        command = command.join(" ") if command.kind_of?(Array)
+        UI.command(command) if print_command
+
+        if print_all && loading # this is only used to show the "Loading text"...
+          UI.command_output(loading)
+        end
+
+        begin
+          status = PantographCore::PantographPty.spawn(command) do |command_stdout, command_stdin, pid|
+            command_stdout.each do |l|
+              line = l.chomp
+              output << line
+
+              next unless print_all
+
+              # Prefix the current line with a string
+              prefix.each do |element|
+                line = element[:prefix] + line if element[:block] && element[:block].call(line)
+              end
+
+              UI.command_output(line) unless suppress_output
+            end
+          end
+        rescue => ex
+          # PantographPty adds exit_status on to StandardError so every error will have a status code
+          status = ex.exit_status
+
+          # This could happen when the environment is wrong:
+          # > invalid byte sequence in US-ASCII (ArgumentError)
+          output << ex.to_s
+          o = output.join("\n")
+          puts(o)
+          if error
+            error.call(o, nil)
+          else
+            raise ex
+          end
+        end
+
+        # Exit status for build command, should be 0 if build succeeded
+        if status != 0
+          o = output.join("\n")
+          puts(o) unless suppress_output # the user has the right to see the raw output
+          UI.error("Exit status: #{status}")
+          if error
+            error.call(o, status)
+          else
+            UI.user_error!("Exit status: #{status}")
+          end
+        end
+
+        return output.join("\n")
+      end
+    end
+  end
+end

data/pantograph_core/lib/pantograph_core/configuration/commander_generator.rb

@@ -0,0 +1,103 @@
+require 'commander'
+
+require_relative '../module'
+require_relative '../ui/ui'
+
+module PantographCore
+  class CommanderGenerator
+    include Commander::Methods
+
+    # Calls the appropriate methods for commander to show the available parameters
+    def generate(options, command: nil)
+      # First, enable `always_trace`, to show the stack trace
+      always_trace!
+
+      used_switches = []
+      options.each do |option|
+        next if option.description.to_s.empty? # "private" options
+        next unless option.display_in_shell
+
+        short_switch = option.short_option
+        key = option.key
+        validate_short_switch(used_switches, short_switch, key)
+
+        type = option.data_type
+
+        # We added type: Hash to code generation, but Ruby's OptionParser doesn't like that
+        # so we need to switch that to something that is supported, luckily, we have an `is_string`
+        # property and if that is false, we'll default to nil
+        if type == Hash
+          type = option.is_string ? String : nil
+        end
+
+        # Boolean is a pantograph thing, it's either TrueClass, or FalseClass, but we won't know
+        # that until runtime, so nil is the best we get
+        if type == Pantograph::Boolean
+          type = nil
+        end
+
+        # This is an important bit of trickery to solve the boolean option situation.
+        #
+        # Typically, boolean command line flags do not accept trailing values. If the flag
+        # is present, the value is true, if it is missing, the value is false. pantograph
+        # supports this style of flag. For example, you can specify a flag like `--clean`,
+        # and the :clean option will be true.
+        #
+        # However, pantograph also supports another boolean flag style that accepts trailing
+        # values much like options for Strings and other value types. That looks like
+        # `--include_bitcode false` The problem is that this does not work out of the box
+        # for Commander and OptionsParser. So, we need to get tricky.
+        #
+        # The value_appendix below acts as a placeholder in the switch definition that
+        # states that we expect to have a trailing value for our options. When an option
+        # declares a data type, we use the name of that data type in all caps like:
+        # "--devices ARRAY". When the data type is nil, this implies that we're going
+        # to be doing some special handling on that value. One special thing we do
+        # automatically in Configuration is to coerce special Strings into boolean values.
+        #
+        # If the data type is nil, the trick we do is to specify a value placeholder, but
+        # we wrap it in [] brackets to mark it as optional. That means that the trailing
+        # value may or may not be present for this flag. If the flag is present, but the
+        # value is not, we get a value of `true`. Perfect for the boolean flag base-case!
+        # If the value is there, we'll actually get it back as a String, which we can
+        # later coerce into a boolean.
+        #
+        # In this way we support handling boolean flags with or without trailing values.
+        value_appendix = (type || '[VALUE]').to_s.upcase
+        long_switch = "--#{option.key} #{value_appendix}"
+
+        description = option.description
+        description += " (#{option.env_name})" unless option.env_name.to_s.empty?
+
+        # We compact this array here to remove the short_switch variable if it is nil.
+        # Passing a nil value to global_option has been shown to create problems with
+        # option parsing!
+        #
+        # See: https://github.com/pantograph/pantograph_core/pull/89
+        #
+        # If we don't have a data type for this option, we tell it to act like a String.
+        # This allows us to get a reasonable value for boolean options that can be
+        # automatically coerced or otherwise handled by the ConfigItem for others.
+        args = [short_switch, long_switch, (type || String), description].compact
+
+        if command
+          command.option(*args)
+        else
+          # This is the call to Commander to set up the option we've been building.
+          global_option(*args)
+        end
+      end
+    end
+
+    def validate_short_switch(used_switches, short_switch, key)
+      return if short_switch.nil?
+
+      UI.user_error!("Short option #{short_switch} already taken for key #{key}") if used_switches.include?(short_switch)
+      UI.user_error!("-v is already used for the version (key #{key})") if short_switch == "-v"
+      UI.user_error!("-h is already used for the help screen (key #{key})") if short_switch == "-h"
+      UI.user_error!("-t is already used for the trace screen (key #{key})") if short_switch == "-t"
+
+      used_switches << short_switch
+    end
+  end
+end