strata-cli 0.1.3.beta → 0.1.5.beta

data/lib/strata/cli/sub_commands/create.rb

@@ -126,9 +126,15 @@ module Strata
         end
 
         def handle_table_creation_interactive
-          return if all_tables.empty?
+          fetch_result = table_fetch_result
+          tables = fetch_result[:tables]
+          if tables.empty?
+            return handle_table_creation_without_connection if fetch_result[:failed]
 
-          selected_table = resolve_table_selection(nil)
+            return
+          end
+
+          selected_table = resolve_table_selection(tables, nil)
           return unless selected_table
 
           # For interactive, derive path from table name
@@ -191,21 +197,26 @@ module Strata
           schema_info = parsed[:schema] ? " in schema '#{parsed[:schema]}'" : ""
           say "\nCould not find table '#{table_name}'#{schema_info} in datasource '#{datasource_key}'.", :red
 
-          if prompt.yes?("Proceed anyway or cancel?")
-            proceed_with_table_creation(nil, parsed)
+          if prompt.yes?("Proceed with template-only file (no generated fields)?", default: true)
+            proceed_with_table_creation(nil, parsed, skip_field_editor: true)
           else
             say "Cancelled.", :yellow
           end
         end
 
-        def proceed_with_table_creation(selected_table, parsed)
+        def proceed_with_table_creation(selected_table, parsed, skip_field_editor: false)
           # If table not found, use parsed physical_name
           physical_table_name = selected_table || (parsed[:schema] ? "#{parsed[:schema]}.#{parsed[:physical_name]}" : parsed[:physical_name])
 
           model_config = prompt_model_config(parsed)
           return unless model_config[:name]
 
-          # Only fetch columns if we have a valid table
+          if skip_field_editor || selected_table.nil?
+            say "Skipping field generation. Template file will be created without fields.", :yellow
+            save_model_file(parsed, physical_table_name, [], model_config)
+            return
+          end
+
           columns = []
           if selected_table
             columns = fetch_columns(selected_table)
@@ -218,7 +229,6 @@ module Strata
             []
           end
 
-          # Interactive field editor
           result = run_field_editor(fields, physical_table_name, columns, model_config)
           return if result.nil?
 
@@ -235,16 +245,27 @@ module Strata
           save_model_file(parsed, physical_table_name, confirmed_fields, final_model_context)
         end
 
-        def resolve_table_selection(initial_filter)
+        def resolve_table_selection(tables, initial_filter)
           autocomplete = Autocomplete.new(prompt: prompt)
           autocomplete.select(
             MSG_SEARCH_TABLE,
-            all_tables,
+            tables,
             display_transform: ->(table) { TableFilter.display_name(table) },
             default_filter: initial_filter
           )
         end
 
+        def handle_table_creation_without_connection
+          say "\nConnection failed. You can still create a template-only table model.", :yellow
+          return unless prompt.yes?("Continue without fetching table metadata?", default: true)
+
+          table_path = prompt.ask("  Table path (e.g., games/event_details):")
+          return unless table_path
+
+          parsed = parse_table_path(table_path)
+          proceed_with_table_creation(nil, parsed, skip_field_editor: true)
+        end
+
         def prompt_model_config(parsed)
           # Default name should be the table name (without schema), not a display name
           # This matches the requirement: "The name and physical name will be event_details"
@@ -367,14 +388,15 @@ module Strata
             []
           end
 
-          unless valid_entities.include?(entity&.downcase)
-            valid_list = valid_entities.join(", ")
-            if operation == "swap" && entity&.downcase == "datasource"
-              raise Strata::CommandError, "Swap operation does not support 'datasource' entity type. Valid types: #{valid_list}"
-            else
-              raise Strata::CommandError, "Invalid entity type: #{entity}. Valid types for #{operation}: #{valid_list}"
-            end
+          return if valid_entities.include?(entity&.downcase)
+
+          valid_list = valid_entities.join(", ")
+          unless operation == "swap" && entity&.downcase == "datasource"
+            raise Strata::CommandError, "Invalid entity type: #{entity}. Valid types for #{operation}: #{valid_list}"
           end
+
+          raise Strata::CommandError,
+            "Swap operation does not support 'datasource' entity type. Valid types: #{valid_list}"
         end
 
         def validate_required_params(entity, from, to)
@@ -382,9 +404,9 @@ module Strata
           raise Strata::CommandError, "Missing required option: --from" if from.nil? || from.strip.empty?
           raise Strata::CommandError, "Missing required option: --to" if to.nil? || to.strip.empty?
 
-          if from.strip == to.strip
-            say "Warning: --from and --to have the same value. Migration will have no effect.", ColorHelper.warning
-          end
+          return unless from.strip == to.strip
+
+          say "Warning: --from and --to have the same value. Migration will have no effect.", ColorHelper.warning
         end
 
         def prompt_migration_hook(operation)

data/lib/strata/cli/sub_commands/datasource.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require_relative "../guard"
 require_relative "../credentials"
 require_relative "../terminal"
+require_relative "../utils/git"
 require "tty-prompt"
 require_relative "../helpers/datasource_helper"
 require_relative "../helpers/description_helper"
@@ -18,7 +21,7 @@ module Strata
         desc "adapters", "Lists supported data warehouse adapters"
         def adapters
           say "\n\tSupported Adapters\n\n", :yellow
-          DWH.adapters.keys.each do
+          DWH.adapters.each_key do
             say "\t\t● #{it}", :magenta
           end
         end
@@ -196,7 +199,7 @@ module Strata
         def meta(ds_key, table_name)
           say "\n● Schema for table: #{table_name} (#{ds_key}):\n", :yellow
           adapter = create_adapter(ds_key)
-          md = adapter.metadata(table_name, **options.transform_keys { it.to_sym })
+          md = adapter.metadata(table_name, **options.transform_keys(&:to_sym))
 
           headings = md.columns.first.to_h.keys
           rows = md.columns.map(&:to_h).map(&:values)
@@ -254,6 +257,7 @@ module Strata
           unless expanded.start_with?(project_root)
             raise Strata::CommandError, "File path must be within project directory"
           end
+
           expanded
         end
 
@@ -369,6 +373,11 @@ module Strata
           strata_file = Configuration::STRATA_CONFIG_FILE
           File.chmod(0o600, strata_file) if File.exist?(strata_file)
 
+          if Utils::Git.git_repo?
+            Utils::Git.commit_file(Configuration::STRATA_CONFIG_FILE, "[Strata-CLI] Add AI config to .strata",
+              Dir.pwd)
+          end
+
           say "\n✔ AI configured with #{provider}", :green
           say "  Note: API key is stored securely in .strata (not committed to repo)", :cyan
         end

data/lib/strata/cli/sub_commands/deploy.rb

@@ -58,7 +58,9 @@ module Strata
             import_commit_hash = Utils::ImportManager.generate_import_commit_hash(project_path)
             say "\nExternal imports change found. Proceeding with deployment", ColorHelper.info
             metadata[:commit] = "imports-#{import_commit_hash}"
-            metadata[:commit_message] = "External imports updated: #{refreshed_imports.map { |c| File.basename(c[:source]) }.join(", ")}"
+            metadata[:commit_message] = "External imports updated: #{refreshed_imports.map do |c|
+              File.basename(c[:source])
+            end.join(", ")}"
           end
 
           archive_path = create_and_upload_archive(last_deployment_commit, refreshed_imports: refreshed_imports)
@@ -90,13 +92,14 @@ module Strata
 
           deployment_id = deployment["id"]
           has_tests = test_files_exist?
-          monitor = Utils::DeploymentMonitor.new(client, config["project_id"], branch_id, deployment_id, has_tests: has_tests)
+          monitor = Utils::DeploymentMonitor.new(client, config["project_id"], branch_id, deployment_id,
+            has_tests: has_tests)
 
           # Show current status
           result = monitor.display_status
 
           # Continue monitoring if deployment is in progress, or if tests are expected but not yet available
-          should_continue_monitoring = if result && !["succeeded", "failed"].include?(result["status"])
+          should_continue_monitoring = if result && !%w[succeeded failed].include?(result["status"])
             true
           elsif result && result["status"] == "succeeded" && result["stage"] == "finished"
             # Check if tests are expected but not yet available
@@ -122,25 +125,52 @@ module Strata
 
         def validate_deployment_configuration(config)
           ensure_api_key(config)
-          validate_server_url(config)
+          ensure_server(config)
           ensure_git_url_populated
           ensure_project_id(config)
         end
 
         def ensure_api_key(config)
-          return if config["api_key"] && !config["api_key"].to_s.strip.empty? && config["api_key"] != "YOUR_STRATA_API_KEY"
+          if config["api_key"] && !config["api_key"].to_s.strip.empty? && config["api_key"] != "YOUR_STRATA_API_KEY"
+            return
+          end
 
           config["api_key"] = collect_api_key_interactively
         end
 
-        def validate_server_url(config)
-          server_url = config["server"]
-          return if server_url && !server_url.to_s.strip.empty?
+        def ensure_server(config)
+          return if config["server"] && !config["server"].to_s.strip.empty?
+
+          config["server"] = collect_server_interactively
+        end
+
+        def collect_server_interactively
+          prompt = TTY::Prompt.new
+
+          say "\nServer URL not found (not in project.yml)", :yellow
+          say "You can add it to project.yml or enter it now here\n", :cyan
+
+          server = prompt.ask("Enter Strata server URL:") do |q|
+            q.required true
+            q.validate(/\S+/, "Server URL cannot be empty")
+          end
+
+          server = server.strip.sub(%r{/\z}, "") # normalize: remove trailing slash
+
+          with_spinner("Saving server URL to project.yml") do
+            save_server_to_project_yml(server)
+          end
 
-          env_msg = options[:environment] ? " (or in '#{options[:environment]}' environment section)" : ""
-          say "\nServer URL not configured in project.yml#{env_msg}", :yellow
-          say "Please add or update the 'server' field in project.yml and try again.\n", :white
-          exit(1)
+          server
+        end
+
+        def save_server_to_project_yml(server)
+          Helpers::ProjectHelper.persist_server_to_project_yml(server, project_yml_path: File.join(project_path, Configuration::PROJECT_CONFIG_FILE))
+          CLI.config.reload!
+          return unless Utils::Git.git_repo?
+
+          Utils::Git.commit_file(Configuration::PROJECT_CONFIG_FILE, "[Strata-CLI] Add server URL to project.yml",
+            project_path)
         end
 
         def ensure_git_url_populated
@@ -148,13 +178,13 @@ module Strata
 
           CLI.config.reload!
 
-          if Utils::Git.git_repo?
-            Utils::Git.commit_file(
-              Configuration::PROJECT_CONFIG_FILE,
-              "[Strata-CLI] Auto-populate git URL from remote",
-              project_path
-            )
-          end
+          return unless Utils::Git.git_repo?
+
+          Utils::Git.commit_file(
+            Configuration::PROJECT_CONFIG_FILE,
+            "[Strata-CLI] Auto-populate git URL from remote",
+            project_path
+          )
         end
 
         def ensure_project_id(config)
@@ -182,41 +212,50 @@ module Strata
             save_api_key_to_strata(api_key)
           end
 
+          if Utils::Git.git_repo?
+            Utils::Git.commit_file(Configuration::STRATA_CONFIG_FILE, "[Strata-CLI] Save API key to .strata",
+              project_path)
+          end
+
           api_key
         end
 
         def save_api_key_to_strata(api_key)
+          save_key_to_strata("api_key", api_key)
+        end
+
+        def save_key_to_strata(key, value)
           strata_file = Configuration::STRATA_CONFIG_FILE
 
           # Read existing content if file exists
           existing_content = File.exist?(strata_file) ? File.read(strata_file) : ""
 
           begin
-            if /^api_key:\s*.+$/m.match?(existing_content)
-              updated_content = existing_content.gsub(/^(\s*)api_key:\s*.+$/, "\\1api_key: #{api_key}")
+            if /^#{Regexp.escape(key)}:\s*.+$/m.match?(existing_content)
+              updated_content = existing_content.gsub(/^(\s*)#{Regexp.escape(key)}:\s*.+$/, "\\1#{key}: #{value}")
               File.write(strata_file, updated_content)
             else
               File.open(strata_file, "a") do |f|
                 f.puts "\n" unless existing_content.empty? || existing_content.end_with?("\n")
-                f.puts "api_key: #{api_key}"
+                f.puts "#{key}: #{value}"
               end
             end
 
             # Set restrictive permissions (read/write for owner only)
             File.chmod(0o600, strata_file) if File.exist?(strata_file)
 
-            # Reload config to pick up the new API key
+            # Reload config to pick up the new value
             CLI.config.reload!
           rescue Errno::EACCES => e
             raise Strata::CommandError, "Permission denied writing to #{strata_file}: #{e.message}"
           rescue Errno::ENOSPC => e
             raise Strata::CommandError, "Disk full: #{e.message}"
           rescue => e
-            raise Strata::CommandError, "Failed to write API key to #{strata_file}: #{e.message}"
+            raise Strata::CommandError, "Failed to write #{key} to #{strata_file}: #{e.message}"
           end
         end
 
-        def handle_missing_deployment_config(config, key)
+        def handle_missing_deployment_config(_config, key)
           raise Strata::CommandError, "Missing required configuration: #{key}. Check your project.yml file."
         end
 
@@ -248,9 +287,11 @@ module Strata
           commit_status = Utils::Git.check_commit_status(branch_name)
           case commit_status[:status]
           when :behind
-            raise Strata::CommandError, "Your local branch is behind remote. Please pull latest changes before deploying."
+            raise Strata::CommandError,
+              "Your local branch is behind remote. Please pull latest changes before deploying."
           when :diverged
-            raise Strata::CommandError, "Your local branch has diverged from remote. Please sync your branch before deploying."
+            raise Strata::CommandError,
+              "Your local branch has diverged from remote. Please sync your branch before deploying."
           when :ahead, :same
             # Status is already shown via spinner, no need for additional message
           end
@@ -299,9 +340,7 @@ module Strata
               end.select { |path| File.exist?(path) }
 
               change_count = files_to_include.length
-              if refreshed_imports.any?
-                change_count += refreshed_imports.length
-              end
+              change_count += refreshed_imports.length if refreshed_imports.any?
 
               say "Including #{change_count} changed file(s) in archive...\n", ColorHelper.info
               Utils::Archive.create(project_path, files_to_include: files_to_include)
@@ -327,7 +366,8 @@ module Strata
           client = API::Client.new(config["server"], config["api_key"])
 
           has_tests = test_files_exist?
-          Utils::DeploymentMonitor.new(client, config["project_id"], branch_id, deployment_id, has_tests: has_tests).start
+          Utils::DeploymentMonitor.new(client, config["project_id"], branch_id, deployment_id,
+            has_tests: has_tests).start
         end
 
         def test_files_exist?
@@ -353,7 +393,7 @@ module Strata
           exit(0)
         end
 
-        def get_production_branch(config)
+        def get_production_branch(_config)
           return nil unless File.exist?("project.yml")
 
           project_config = YAML.safe_load_file("project.yml", permitted_classes: [Date, Time], aliases: true) || {}
@@ -390,13 +430,12 @@ module Strata
           git = project_config["git"]
           production_branch = project_config["production_branch"]
 
-          unless name
-            raise Strata::CommandError, "Cannot create project: name is required in project.yml"
-          end
+          raise Strata::CommandError, "Cannot create project: name is required in project.yml" unless name
 
           with_spinner("Creating project '#{name}' on server") do
             client = API::Client.new(config["server"], config["api_key"])
-            project = client.create_project(name, uid, description: description, git: git, production_branch: production_branch)
+            project = client.create_project(name, uid, description: description, git: git,
+              production_branch: production_branch)
             project["id"]
           end
         end
@@ -405,6 +444,10 @@ module Strata
           with_spinner("Persisting project ID to project.yml") do
             Helpers::ProjectHelper.persist_project_id_to_yml(project_id)
           end
+          return unless Utils::Git.git_repo?
+
+          Utils::Git.commit_file(Configuration::PROJECT_CONFIG_FILE, "[Strata-CLI] Persist project ID to project.yml",
+            project_path)
         end
 
         def refresh_external_imports

data/lib/strata/cli/sub_commands/project.rb

@@ -16,9 +16,7 @@ module Strata
 
         desc "link PROJECT_ID", "Link local project to an existing project on the server"
         def link(project_id)
-          unless project_id && !project_id.to_s.strip.empty?
-            raise Strata::CommandError, "Project ID is required."
-          end
+          raise Strata::CommandError, "Project ID is required." unless project_id && !project_id.to_s.strip.empty?
 
           project_yml_path = "project.yml"
           project_config = YAML.safe_load_file(project_yml_path, permitted_classes: [Date, Time], aliases: true) || {}
@@ -28,9 +26,9 @@ module Strata
             return
           end
 
-          if Helpers::ProjectHelper.persist_project_id_to_yml(project_id, project_yml_path: project_yml_path)
-            say "✓ Project linked successfully. project_id: #{project_id}", ColorHelper.info
-          end
+          return unless Helpers::ProjectHelper.persist_project_id_to_yml(project_id, project_yml_path: project_yml_path)
+
+          say "✓ Project linked successfully. project_id: #{project_id}", ColorHelper.info
         end
       end
     end

data/lib/strata/cli/sub_commands/table.rb

@@ -44,7 +44,7 @@ module Strata
           name = File.basename(file, ".yml")
           content = File.read(file)
           desc = content.match(/^# Description: (.+)$/)&.[](1) || ""
-          desc = desc[0..50] + "..." if desc.length > 50
+          desc = "#{desc[0..50]}..." if desc.length > 50
 
           if desc.empty?
             say "    #{name}", :white

data/lib/strata/cli/terminal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "tty-spinner"
 require "pastel"
 require "tty-table"

data/lib/strata/cli/ui/autocomplete.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "tty-prompt"
 require_relative "../helpers/table_filter"
 

data/lib/strata/cli/ui/field_editor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "tty-prompt"
 require "tty-table"
 require "pastel"
@@ -143,6 +145,10 @@ module Strata
           return if field[:expression] == "back"
 
           field[:schema_type] = prompt.select("  Type:", %w[dimension measure], default: field[:schema_type])
+
+          current_synonyms = (field[:synonyms] || []).join(", ")
+          synonyms_input = prompt.ask("  Synonyms (comma-separated):", default: current_synonyms)
+          field[:synonyms] = synonyms_input.to_s.split(",").map(&:strip).reject(&:empty?)
         rescue TTY::Reader::InputInterrupt
           # User pressed Ctrl+C, go back without saving
           nil

data/lib/strata/cli/utils/archive.rb

@@ -46,9 +46,7 @@ module Strata
           ]
 
           required_files.each do |required_file|
-            if File.exist?(required_file) && !files.include?(required_file)
-              files << required_file
-            end
+            files << required_file if File.exist?(required_file) && !files.include?(required_file)
           end
 
           # Always include all test files

data/lib/strata/cli/utils/deployment_monitor.rb

@@ -15,26 +15,26 @@ module Strata
         include Terminal
 
         # Terminal statuses that indicate deployment is complete
-        TERMINAL_STATUSES = ["succeeded", "failed"].freeze
+        TERMINAL_STATUSES = %w[succeeded failed].freeze
         NOT_STARTED_STAGE = "not_started"
         DEFAULT_POLL_INTERVAL = 0.5 # seconds
         DEFAULT_TIMEOUT = 600 # seconds (10 minutes)
         TEST_WAIT_TIMEOUT = 5 # seconds
-        STAGES = [
-          :not_started,
-          :preparing,
-          :pre_migrations,
-          :project_configuration,
-          :processing_datasources,
-          :processing_models,
-          :removing_deleted_models,
-          :processing_relationships,
-          :forming_universes,
-          :creating_blend_paths,
-          :validating_references,
-          :post_migrations,
-          :cleaning_up,
-          :finished
+        STAGES = %i[
+          not_started
+          preparing
+          pre_migrations
+          project_configuration
+          processing_datasources
+          processing_models
+          removing_deleted_models
+          processing_relationships
+          forming_universes
+          creating_blend_paths
+          validating_references
+          post_migrations
+          cleaning_up
+          finished
         ].freeze
         TESTING_STAGE = :running_tests
 
@@ -127,7 +127,7 @@ module Strata
         rescue Interrupt
           stop_all_spinners
           say "\n\n  Monitoring interrupted. Deployment continues in background.", ColorHelper.warning
-          say "   Check server for deployment status.\n", ColorHelper.info
+          say "  Check server for deployment status with command `strata deploy status`.\n", ColorHelper.info
           nil
         rescue => e
           stop_all_spinners
@@ -145,9 +145,7 @@ module Strata
 
           process_deployment_state(deployment)
 
-          if terminal_status?(deployment_value(deployment, "status"))
-            display_final_status(deployment)
-          end
+          display_final_status(deployment) if terminal_status?(deployment_value(deployment, "status"))
 
           deployment
         rescue Interrupt
@@ -324,6 +322,7 @@ module Strata
           final_stage_string = final_stage&.to_s
           @spinners.each_key do |stage_string|
             next if stage_string == TESTING_STAGE # Handle test spinner separately
+
             complete_stage(stage_string) if stage_string != final_stage_string
           end
         end
@@ -385,9 +384,7 @@ module Strata
         end
 
         def stop_all_spinners
-          @spinners.each do |_stage_string, spinner|
-            spinner.stop
-          end
+          @spinners.each_value(&:stop)
           @spinners.clear
           @tests_running = false
         end
@@ -396,11 +393,16 @@ module Strata
           raise ArgumentError, "client cannot be nil" if client.nil?
           raise ArgumentError, "project_id cannot be nil or empty" if project_id.nil? || project_id.to_s.strip.empty?
           raise ArgumentError, "branch_id cannot be nil or empty" if branch_id.nil? || branch_id.to_s.strip.empty?
-          raise ArgumentError, "deployment_id cannot be nil or empty" if deployment_id.nil? || deployment_id.to_s.strip.empty?
+
+          return unless deployment_id.nil? || deployment_id.to_s.strip.empty?
+
+          raise ArgumentError,
+            "deployment_id cannot be nil or empty"
         end
 
         def deployment_value(deployment, key)
           return nil unless deployment.is_a?(Hash)
+
           deployment[key] || deployment[key.to_sym]
         end
 
@@ -430,7 +432,7 @@ module Strata
 
           test_results = deployment_value(latest_test_run, "test_results")
           if test_results
-            say "\n" + "=" * 60, :border
+            say "\n#{"=" * 60}", :border
             complete_stage(TESTING_STAGE)
             display_test_results(test_results, skip_opening_divider: true)
           else

data/lib/strata/cli/utils/git.rb

@@ -11,6 +11,7 @@ module Strata
         def validate_commit_hash(commit_hash)
           return false unless commit_hash.is_a?(String)
           return false unless commit_hash.match?(/\A[a-f0-9]{7,40}\z/i)
+
           true
         end
 
@@ -127,7 +128,8 @@ module Strata
 
           return if git_available?
 
-          Thor::Shell::Color.new.say_error "ERROR: Git is required but not found. Please install Git to use strata-cli.", :red
+          Thor::Shell::Color.new.say_error "ERROR: Git is required but not found. Please install Git to use strata-cli.",
+            :red
           exit 1
         end
 
@@ -143,7 +145,7 @@ module Strata
         end
 
         def run_git_command(*args)
-          stdout, _, _ = Open3.capture3("git", *args)
+          stdout, = Open3.capture3("git", *args)
           stdout&.strip
         end
 
@@ -190,7 +192,7 @@ module Strata
         def uncommitted_changes?
           return false unless git_repo?
 
-          stdout, _, _ = Open3.capture3("git", "status", "--porcelain")
+          stdout, = Open3.capture3("git", "status", "--porcelain")
           !stdout.strip.empty?
         end
 
@@ -219,17 +221,18 @@ module Strata
 
           # Check if local is ahead, behind, or diverged
           # rev-list --left-right shows: > = commits in local not in remote (ahead), < = commits in remote not in local (behind)
-          diff_output, _, _ = Open3.capture3("git", "rev-list", "--left-right", "#{remote_sha}...#{local_sha}")
+          diff_output, = Open3.capture3("git", "rev-list", "--left-right", "#{remote_sha}...#{local_sha}")
 
           ahead_count = diff_output.lines.count { |line| line.start_with?(">") }
           behind_count = diff_output.lines.count { |line| line.start_with?("<") }
 
-          if ahead_count > 0 && behind_count == 0
+          if ahead_count.positive? && behind_count.zero?
             {status: :ahead, message: "Local branch is #{ahead_count} commit(s) ahead of remote"}
-          elsif ahead_count == 0 && behind_count > 0
+          elsif ahead_count.zero? && behind_count.positive?
             {status: :behind, message: "Local branch is #{behind_count} commit(s) behind remote"}
           else
-            {status: :diverged, message: "Local branch has diverged from remote (#{ahead_count} ahead, #{behind_count} behind)"}
+            {status: :diverged,
+             message: "Local branch has diverged from remote (#{ahead_count} ahead, #{behind_count} behind)"}
           end
         end