analytics_ops 0.1.0 → 0.2.0

data/lib/analytics_ops/cli.rb

@@ -20,43 +20,100 @@ module AnalyticsOps
     UNSUPPORTED = 78
     STALE_PLAN = 79
     PARTIAL_APPLY = 80
+    INTERRUPTED = 130
 
-    COMMANDS = %w[doctor discover snapshot audit plan apply verify report realtime schema].freeze
+    COMMANDS = %w[
+      setup properties doctor discover snapshot audit plan apply verify overview report realtime schema
+    ].freeze
     FORMATS = %w[human json csv].freeze
     LOG_LEVELS = %w[debug info warn error].freeze
-    NO_ARGUMENT_COMMANDS = %w[doctor discover snapshot audit plan verify schema].freeze
-
-    def self.start(arguments, out: $stdout, err: $stderr, input: $stdin, workspace_loader: nil)
-      new(arguments, out:, err:, input:, workspace_loader:).call
-    end
-
-    def initialize(arguments, out:, err:, input:, workspace_loader:)
+    NO_ARGUMENT_COMMANDS = %w[setup properties doctor discover snapshot audit plan verify overview schema].freeze
+    CONNECTION_COMMANDS = %w[setup properties discover].freeze
+
+    def self.start(arguments, out: $stdout, err: $stderr, input: $stdin, workspace_loader: nil,
+                   connection_loader: nil, service_account_loader: nil, service_account_store: nil)
+      new(
+        arguments,
+        out:,
+        err:,
+        input:,
+        workspace_loader:,
+        connection_loader:,
+        service_account_loader:,
+        service_account_store:
+      ).call
+    end
+
+    def initialize(arguments, out:, err:, input:, workspace_loader:, connection_loader:,
+                   service_account_loader:, service_account_store:)
       @arguments = arguments.dup
+      @json_requested = json_option_present?(@arguments)
       @out = out
       @err = err
       @input = input
       @workspace_loader = workspace_loader || method(:load_workspace)
-      @options = default_options
+      @connection_loader = connection_loader || method(:load_connection)
+      @service_account_loader = service_account_loader || ServiceAccount.method(:load)
+      @service_account_store = service_account_store
     end
 
     def call
+      with_error_handling { execute_command }
+    end
+
+    private
+
+    def execute_command
       command = @arguments.shift
-      return write(@out, help) if [nil, "help", "--help", "-h"].include?(command)
-      return write(@out, AnalyticsOps::VERSION) if ["version", "--version", "-v"].include?(command)
+      if [nil, "help", "--help", "-h"].include?(command)
+        raise OptionParser::InvalidArgument, "help does not accept arguments" if @arguments.any?
+
+        return write(@out, help)
+      end
+      if ["version", "--version", "-v"].include?(command)
+        raise OptionParser::InvalidArgument, "version does not accept arguments" if @arguments.any?
+
+        return write(@out, AnalyticsOps::VERSION)
+      end
+
+      options = Options.new(@arguments)
+      @options = options.values
+      options.parse!(command)
       return unknown_command(command) unless COMMANDS.include?(command)
 
-      parse_options!
-      validate_command!(command)
+      execute(command)
+    end
+
+    def execute(command)
       return render(Configuration::SCHEMA, status: SUCCESS) if command == "schema"
 
+      if CONNECTION_COMMANDS.include?(command)
+        service_account = load_service_account
+        connection = @connection_loader.call(
+          service_account:,
+          transport: @options.fetch(:transport),
+          timeout: @options[:timeout],
+          logger: operation_logger
+        )
+        return dispatch_connection(command, connection, service_account)
+      end
+
+      service_account = load_service_account
       workspace = @workspace_loader.call(
         config: @options.fetch(:config),
         profile: @options.fetch(:profile),
+        service_account:,
         transport: @options.fetch(:transport),
         timeout: @options[:timeout],
         logger: operation_logger
       )
       dispatch(command, workspace)
+    end
+
+    def with_error_handling
+      yield
+    rescue Interrupt
+      error_response(Interrupt.new("Interrupted by user"), INTERRUPTED)
     rescue OptionParser::ParseError, ConfirmationRequiredError => error
       error_response(error, USAGE_ERROR)
     rescue ConfigurationError, InvalidPlanError, ConflictError => error
@@ -79,61 +136,11 @@ module AnalyticsOps
       error_response(error, REMOTE_ERROR)
     end
 
-    private
-
-    def default_options
-      {
-        config: "config/analytics_ops.yml",
-        profile: "production",
-        format: "human",
-        log_level: "warn",
-        transport: :grpc,
-        yes: false,
-        noninteractive: false
-      }
-    end
-
-    def parse_options!
-      parser = OptionParser.new do |value|
-        value.on("-c", "--config PATH", "Configuration path") { |path| @options[:config] = path }
-        value.on("-p", "--profile NAME", "Configuration profile") { |name| @options[:profile] = name }
-        value.on("-f", "--format FORMAT", FORMATS, FORMATS.join(", ")) { |format| @options[:format] = format }
-        value.on("-o", "--output PATH", "Write a generated plan to PATH") { |path| @options[:output] = path }
-        value.on("--log-level LEVEL", LOG_LEVELS, LOG_LEVELS.join(", ")) { |level| @options[:log_level] = level }
-        value.on("--transport TRANSPORT", %w[grpc rest], "grpc or rest") do |transport|
-          @options[:transport] = transport.to_sym
-        end
-        value.on("--timeout SECONDS", Float, "Google API timeout") do |seconds|
-          raise OptionParser::InvalidArgument, "timeout must be positive" unless seconds.positive?
-
-          @options[:timeout] = seconds
-        end
-        value.on("--yes", "Approve every operation in a saved plan") { @options[:yes] = true }
-        value.on("--non-interactive", "Never prompt") { @options[:noninteractive] = true }
-      end
-      parser.parse!(@arguments)
-    end
-
-    def validate_command!(command)
-      if NO_ARGUMENT_COMMANDS.include?(command) && @arguments.any?
-        raise OptionParser::InvalidArgument, "#{command} does not accept positional arguments"
-      end
-      raise OptionParser::InvalidArgument, "--output is only valid with plan" if @options[:output] && command != "plan"
-      if (@options[:yes] || @options[:noninteractive]) && command != "apply"
-        raise OptionParser::InvalidArgument, "--yes and --non-interactive are only valid with apply"
-      end
-      return unless @options.fetch(:format) == "csv" && !%w[report realtime].include?(command)
-
-      raise OptionParser::InvalidArgument, "CSV output is only valid for report results"
-    end
-
     def dispatch(command, workspace)
       case command
       when "doctor"
         result = workspace.doctor
         render(result, status: result.success? ? SUCCESS : REMOTE_ERROR)
-      when "discover"
-        render(workspace.discover)
       when "snapshot"
         render(workspace.snapshot)
       when "audit"
@@ -146,6 +153,8 @@ module AnalyticsOps
       when "verify"
         verification = workspace.verify
         render(verification, status: verification.converged ? SUCCESS : DRIFT)
+      when "overview"
+        render(workspace.overview)
       when "report"
         render(workspace.report(required_report_name!("report")))
       when "realtime"
@@ -153,6 +162,42 @@ module AnalyticsOps
       end
     end
 
+    def dispatch_connection(command, connection, service_account)
+      case command
+      when "discover"
+        render(connection.discover)
+      when "properties"
+        render_properties(connection.properties)
+      when "setup"
+        setup(connection, service_account)
+      end
+    end
+
+    def setup(connection, service_account)
+      result = Setup.new(
+        connection:,
+        config: @options.fetch(:config),
+        profile: @options.fetch(:profile),
+        property_id: @options[:property],
+        noninteractive: @options[:noninteractive],
+        input: @input,
+        out: @out
+      ).call
+      service_account_store.write(service_account.path)
+
+      if human?
+        action = result.created? ? "Created" : "Using"
+        @out.puts "#{action} #{Redaction.message(result.config_path)}"
+        @out.puts "Connected #{Redaction.message(result.profile)} to " \
+                  "#{Redaction.message(result.property.display_name)} " \
+                  "(property #{Redaction.message(result.property.id)})."
+        @out.puts "Next: analytics-ops overview"
+        SUCCESS
+      else
+        render(result)
+      end
+    end
+
     def render_plan(plan)
       plan.write(@options.fetch(:output)) if @options[:output]
       render(plan)
@@ -195,154 +240,51 @@ module AnalyticsOps
       true
     end
 
-    def load_workspace(config:, profile:, transport:, timeout:, logger:)
-      Workspace.load(config, profile:, transport:, timeout:, logger:)
+    def load_workspace(config:, profile:, service_account:, transport:, timeout:, logger:)
+      Workspace.load(config, profile:, service_account:, transport:, timeout:, logger:)
     end
 
-    def operation_logger
-      @operation_logger ||= Logger.new(@err).tap do |logger|
-        logger.level = Logger.const_get(@options.fetch(:log_level).upcase)
-        logger.formatter = ->(_severity, _time, _program, message) { "#{message}\n" }
-      end
+    def load_connection(service_account:, transport:, timeout:, logger:)
+      Connection.new(service_account:, transport:, timeout:, logger:)
     end
 
-    def render(value, status: SUCCESS)
-      case @options.fetch(:format)
-      when "json"
-        @out.write(json(value))
-      when "csv"
-        @out.write(csv(value))
-      else
-        @out.puts(human(value))
-      end
-      status
-    end
-
-    def json(value)
-      payload = serializable(value)
-      "#{JSON.pretty_generate(Canonical.normalize(payload))}\n"
-    end
-
-    def csv(value)
-      unless value.is_a?(Reports::Result)
-        raise OptionParser::InvalidArgument, "CSV output is only valid for report results"
-      end
-
-      lines = [value.headers]
-      value.rows.each { |row| lines << value.headers.map { |header| csv_cell(row.fetch(header)) } }
-      "#{lines.map { |line| line.map { |cell| csv_field(cell) }.join(",") }.join("\n")}\n"
-    end
-
-    def csv_cell(value)
-      string = value.to_s
-      string.match?(/\A[=+\-@]/) ? "'#{string}" : string
+    def load_service_account
+      @service_account_loader.call(
+        path: @options[:service_account],
+        store: service_account_store
+      )
     end
 
-    def csv_field(value)
-      string = value.to_s
-      return string unless string.match?(/[",\r\n]/)
-
-      "\"#{string.gsub("\"", "\"\"")}\""
+    def service_account_store
+      @service_account_store ||= ServiceAccount::Store.new
     end
 
-    def serializable(value)
-      case value
-      when Array
-        value.map { |item| serializable(item) }
-      when Hash
-        value.to_h { |key, item| [key.to_s, serializable(item)] }
-      else
-        value.respond_to?(:to_h) ? serializable(value.to_h) : value
+    def operation_logger
+      @operation_logger ||= Logger.new(@err).tap do |logger|
+        logger.level = Logger.const_get(@options.fetch(:log_level).upcase)
+        logger.formatter = ->(_severity, _time, _program, message) { "#{message}\n" }
       end
     end
 
-    def human(value)
-      case value
-      when Plan
-        human_plan(value)
-      when Snapshot
-        "Snapshot #{value.fingerprint}\n#{JSON.pretty_generate(Canonical.normalize(value.to_h))}"
-      when Workspace::DoctorResult
-        human_doctor(value)
-      when Workspace::Verification
-        "#{value.converged ? "Converged" : "Drift found"}: #{value.plan.changes.length} planned changes"
-      when Applier::Result
-        "Apply #{value.status}: #{value.applied.length} changes completed"
-      when Reports::Result
-        human_report(value)
-      when Array
-        human_discovery(value)
-      else
-        JSON.pretty_generate(Canonical.normalize(serializable(value)))
-      end
+    def render(value, status: SUCCESS)
+      presenter.render(value, status:)
     end
 
-    def human_doctor(value)
-      value.checks.map do |check|
-        "#{check.fetch("status").upcase.ljust(11)} #{check.fetch("name")}: #{check.fetch("detail")}"
-      end.join("\n")
+    def json(value)
+      presenter.json(value)
     end
 
     def human_plan(plan, detailed: false)
-      lines = [
-        "Plan for profile #{plan.profile} / property #{plan.property_id}",
-        "Snapshot: #{plan.snapshot_fingerprint}",
-        "Changes: #{plan.changes.length}; findings: #{plan.findings.length}"
-      ]
-      plan.changes.each do |change|
-        lines << "  #{change.operation.upcase.ljust(6)} #{change.resource_type} #{change.resource_identity}"
-        next unless detailed
-
-        lines << "    before: #{JSON.generate(Canonical.normalize(change.before))}"
-        lines << "    after:  #{JSON.generate(Canonical.normalize(change.after))}"
-        lines << "    rollback: #{change.rollback}"
-      end
-      plan.findings.each do |finding|
-        lines << "  #{finding.severity.upcase.ljust(12)} #{finding.resource_identity}: #{finding.message}"
-      end
-      lines.join("\n")
-    end
-
-    def human_report(result)
-      lines = ["Report #{result.name} (#{result.kind}) — #{result.row_count} rows"]
-      return (lines << "No rows returned").join("\n") if result.rows.empty?
-
-      widths = result.headers.to_h do |header|
-        values = result.rows.map { |row| row.fetch(header).to_s }
-        [header, ([header.length] + values.map(&:length)).max.clamp(1, 60)]
-      end
-      lines << table_row(result.headers, widths)
-      lines << result.headers.map { |header| "-" * widths.fetch(header) }.join("-+-")
-      result.rows.each do |row|
-        lines << table_row(result.headers.map { |header| row.fetch(header) }, widths, headers: result.headers)
-      end
-      lines.join("\n")
-    end
-
-    def table_row(values, widths, headers: values)
-      values.zip(headers).map do |value, header|
-        value.to_s.slice(0, widths.fetch(header)).ljust(widths.fetch(header))
-      end.join(" | ")
+      presenter.human_plan(plan, detailed:)
     end
 
-    def human_discovery(accounts)
-      return "No accessible Google Analytics accounts found" if accounts.empty?
-
-      accounts.flat_map do |account|
-        lines = ["Account #{account.id}: #{account.display_name}"]
-        account.properties.each do |property|
-          lines << "  Property #{property.fetch("id")}: #{property.fetch("display_name")}"
-          property.fetch("streams").each do |stream|
-            lines << "    Stream #{stream.fetch("id")}: #{stream.fetch("display_name")} (#{stream.fetch("type")})"
-          end
-        end
-        lines
-      end.join("\n")
+    def render_properties(accounts)
+      presenter.render_properties(accounts)
     end
 
     def render_error_result(error, status)
       if json?
-        @err.write(json("error" => error_payload(error), "result" => serializable(error.result)))
+        @err.write(json("error" => error_payload(error), "result" => error.result))
       else
         @err.puts "#{error_name(error)}: #{Redaction.message(error.message)}"
         @err.write(json(error.result))
@@ -368,11 +310,16 @@ module AnalyticsOps
     end
 
     def human?
-      @options.fetch(:format) == "human"
+      @options&.fetch(:format, "human") == "human"
     end
 
     def json?
-      @options.fetch(:format) == "json"
+      @json_requested || @options&.fetch(:format, "human") == "json"
+    end
+
+    def presenter
+      format = json? ? "json" : @options&.fetch(:format, "human") || "human"
+      @presenter ||= Presenter.new(out: @out, format:)
     end
 
     def write(stream, message, status = SUCCESS)
@@ -381,10 +328,22 @@ module AnalyticsOps
     end
 
     def unknown_command(command)
+      if json?
+        error = OptionParser::InvalidArgument.new("Unknown command: #{Redaction.message(command)}")
+        return error_response(error, USAGE_ERROR)
+      end
+
       @err.puts "Unknown command: #{Redaction.message(command)}"
       write(@err, "Run `analytics-ops help` for available commands.", USAGE_ERROR)
     end
 
+    def json_option_present?(arguments)
+      arguments.each_with_index.any? do |argument, index|
+        argument == "--json" || argument == "--format=json" || argument == "-fjson" ||
+          (%w[--format -f].include?(argument) && arguments[index + 1] == "json")
+      end
+    end
+
     def help
       <<~HELP
         Analytics Ops #{AnalyticsOps::VERSION}
@@ -393,9 +352,14 @@ module AnalyticsOps
         Usage:
           analytics-ops COMMAND [options]
 
+        Start here:
+          setup        Connect Google, choose a property, and create configuration
+          overview     Show a useful five-section summary for the selected property
+          properties   List accessible accounts and properties without configuration
+
         Read-only commands:
           doctor       Validate local setup and Google API/property access
-          discover     List accessible accounts, properties, and data streams
+          discover     List accessible accounts, properties, and streams without configuration
           snapshot     Print normalized remote configuration
           audit        Compare desired and remote state (exit 2 for drift)
           plan         Generate a deterministic plan; use --output to save it
@@ -412,16 +376,23 @@ module AnalyticsOps
           version      Print the installed version
 
         Common options:
-          -c, --config PATH       Default: config/analytics_ops.yml
-          -p, --profile NAME     Default: production
-          -f, --format FORMAT    human, json, or report-only csv
-          -o, --output PATH      Save a generated plan (plan only)
-              --transport NAME   grpc or rest
-              --timeout SECONDS
-              --log-level LEVEL  debug, info, warn, or error
-              --yes              Required for non-interactive apply
-              --non-interactive  Never prompt
+          -c, --config PATH          Default: config/analytics_ops.yml
+          -p, --profile NAME        Default: production
+          -f, --format FORMAT       human, json, or report-only csv
+              --json                Shortcut for --format json
+              --csv                 Shortcut for --format csv
+          -o, --output PATH         Save a generated plan (plan only)
+              --property ID         Select a property without prompting (setup only)
+              --service-account PATH Google service-account JSON key (setup only)
+              --transport NAME      grpc or rest
+              --timeout SECONDS     Positive Google API timeout
+              --log-level LEVEL     debug, info, warn, or error
+              --yes                 Required for non-interactive apply
+              --non-interactive     Never prompt
       HELP
     end
   end
 end
+
+require_relative "cli/presenter"
+require_relative "cli/options"