rubocounsel 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df8f7f81d3443e7d62fbf3dc59fb31d2f0e491c93fec1b7c9e6d8150266d7517
-  data.tar.gz: ea8ffb9483013e9194dd188bc6300ffe5f0009f1cced90330f8099987925a9df
+  metadata.gz: ae3bff325e5426cf4c5fc317a6115e4564fcfa6b2c9623bb6049dbc097036a48
+  data.tar.gz: d07dd7dd339759d409bfa47410e2adb432f0ccece654177181891af77714d6c8
 SHA512:
-  metadata.gz: cb5255b7e2f10bb3ed885a1db2e21abff41ef12b90dd553b79a9f153b67abab42de64e3dc20d629c9a64fcc95b493e67d6d9e7e584ccf60f981ec1fdf49b1e51
-  data.tar.gz: c11acd191699d9d282e13120277fa125b9b5d02e714b97f54ff7d02495c913faef843d208ff700e2dab9fa3190b52e77821c526247372b41d2e4404e4ac5f7f4
+  metadata.gz: 0d0e95026cdd70567ea9ee806eaa6d50be180313846c35afe7ffd5d95be2fc9df03ce70f187a4c6359ed000945703a59e2984c850298b27bde8b5c7738d084e7
+  data.tar.gz: cae2f648bd814c0e86432f703e5fa44b67c71c860e279d6e94bd8501fb61e74e15aaeb4f4a5fe3b156849b645d0c2b320632dbf3e5a279249edb203efc886f8b

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.1.2] - 2026-03-22
+
+- Show "Show examples" option for cops with no configurable attributes
+- Refactor to polymorphic ConfigurableAttribute hierarchy with .for() factory
+- Extract composable CopActions and CopPrompt classes
+
 ## [0.1.1] - 2026-03-21
 
 - Show "Enable" action instead of "Configure" for cops with no configurable attributes

data/lib/rubocounsel/configurable_attribute.rb

@@ -1,44 +1,116 @@
 # frozen_string_literal: true
 
+require "cli/ui"
+
 module RuboCounsel
   # Represents one configurable aspect of a cop (e.g., EnforcedStyle, Max).
   #
-  # Determines the attribute type based on its value:
-  #   - :choice   - has a list of valid options (EnforcedStyle with SupportedStyles)
-  #   - :boolean  - true/false value
-  #   - :integer  - numeric value
-  #   - :array    - list of values (AllowedMethods, etc.)
-  #   - :string   - any other string value
+  # Use the .for factory to get the right subclass based on the value type:
+  #
+  #   ConfigurableAttribute.for("EnforcedStyle", "single_quotes", options: [...])
+  #   # => ChoiceAttribute
+  #
+  # Each subclass knows how to prompt for its own value via #prompt.
   class ConfigurableAttribute
-    attr_reader :name, :default_value, :options
+    attr_reader :name, :default_value, :options, :examples
+
+    def self.for(name, value, options: nil, examples: [])
+      if options
+        ChoiceAttribute.new(name, value, options: options, examples: examples)
+      elsif value.is_a?(Array)
+        ArrayAttribute.new(name, value, examples: examples)
+      elsif value.in?([true, false])
+        BooleanAttribute.new(name, value, examples: examples)
+      else
+        ScalarAttribute.new(name, value, examples: examples)
+      end
+    end
 
-    def initialize(name, default_value, options: nil)
+    def initialize(name, default_value, options: nil, examples: [])
       @name = name
       @default_value = default_value
       @options = options
+      @examples = examples
     end
 
-    def type
-      return :choice if @options
+    def promptable? = true
+    def choice? = false
+    def boolean? = false
 
-      case @default_value
-      when true, false
-        :boolean
-      when Integer
-        :integer
-      when Array
-        :array
-      else
-        :string
+    def has_examples?
+      @examples.any?
+    end
+
+    # Template method: prompt with "Show examples" re-prompt loop.
+    # Subclasses provide #base_options and #parse_answer.
+    def prompt(output: $stdout)
+      output.puts ::CLI::UI.fmt("{{italic:No examples available for #{@name}.}}") unless has_examples?
+
+      loop do
+        options = has_examples? ? base_options + ["Show examples"] : base_options
+        answer = ::CLI::UI::Prompt.ask("#{@name}?", options: options)
+
+        if answer == "Show examples"
+          display_examples(output)
+        else
+          return parse_answer(answer)
+        end
       end
     end
 
-    def choice?
-      type == :choice
+    private
+
+    def display_examples(output)
+      @examples.each do |example|
+        label = example.default? ? "#{example.value} (default)" : example.value
+        output.puts <<~OUTPUT
+          #{::CLI::UI.fmt("{{yellow:#{label}:}}")}
+          #{example.text}
+        OUTPUT
+      end
     end
+  end
+
+  class ChoiceAttribute < ConfigurableAttribute
+    def choice? = true
 
-    def boolean?
-      type == :boolean
+    private
+
+    def base_options
+      default_val = @default_value.to_s
+      sorted = @options.sort_by { |opt| opt == default_val ? 0 : 1 }
+      sorted.map { |opt| opt == default_val ? "#{opt} (default)" : opt }
+    end
+
+    def parse_answer(answer)
+      answer.sub(/ \(default\)$/, "")
+    end
+  end
+
+  class BooleanAttribute < ConfigurableAttribute
+    def boolean? = true
+
+    private
+
+    def base_options
+      @default_value ? ["yes (default)", "no"] : ["no (default)", "yes"]
     end
+
+    def parse_answer(answer)
+      answer.sub(/ \(default\)$/, "") == "yes"
+    end
+  end
+
+  class ScalarAttribute < ConfigurableAttribute
+    def prompt(output: $stdout)
+      ::CLI::UI::Prompt.ask(
+        "#{@name}? (default: #{@default_value})",
+        default: @default_value.to_s
+      )
+    end
+  end
+
+  class ArrayAttribute < ConfigurableAttribute
+    def promptable? = false
   end
 end

data/lib/rubocounsel/cop_actions.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCounsel
+  module CopActions
+    class Enable
+      def label = "Enable"
+      def reprompt? = false
+      def call = { "Enabled" => true }
+    end
+
+    class Disable
+      def label = "Disable"
+      def reprompt? = false
+      def call = { "Enabled" => false }
+    end
+
+    class Skip
+      def label = "Skip"
+      def reprompt? = false
+      def call = nil
+    end
+
+    # Displays all examples for a cop, then signals re-prompt.
+    class ShowExamples
+      def initialize(examples, output: $stdout)
+        @examples = examples
+        @output = output
+      end
+
+      def label = "Show examples"
+      def reprompt? = true
+
+      def call
+        @examples.each do |example|
+          example_label = example.default? ? "#{example.value} (default)" : example.value
+          @output.puts <<~OUTPUT
+            #{::CLI::UI.fmt("{{yellow:#{example_label}:}}")}
+            #{example.text}
+          OUTPUT
+        end
+      end
+    end
+
+    # Walks through each promptable attribute and collects configuration.
+    class Configure
+      FILE_TARGETING_ATTRIBUTES = ["Include", "Exclude"].freeze
+
+      def initialize(entry, output: $stdout)
+        @entry = entry
+        @output = output
+      end
+
+      def label = "Configure"
+      def reprompt? = false
+
+      def call
+        display_array_attributes_message
+
+        config = {}
+        @entry.configurable_attributes.select(&:promptable?).each do |attr|
+          value = attr.prompt(output: @output)
+          config[attr.name] = value unless value.nil?
+        end
+        config
+      end
+
+      private
+
+      def display_array_attributes_message
+        array_names = @entry.configurable_attributes
+          .reject(&:promptable?)
+          .reject { |attr| FILE_TARGETING_ATTRIBUTES.include?(attr.name) }
+          .map(&:name)
+
+        return if array_names.empty?
+
+        @output.puts ::CLI::UI.fmt(
+          "{{green:These attributes accept lists and can be configured directly in .rubocop.yml: #{array_names.join(", ")}}}"
+        )
+      end
+    end
+  end
+end

data/lib/rubocounsel/cop_entry.rb

@@ -43,20 +43,21 @@ module RuboCounsel
       @configurable_attributes ||= build_configurable_attributes
     end
 
+    def configurable?
+      configurable_attributes.any?(&:promptable?)
+    end
+
     private
 
     def build_configurable_attributes
-      attributes = []
-
-      configuration.each do |key, value|
+      configuration.each_with_object([]) do |(key, value), attributes|
         next if metadata_key?(key)
         next if supported_key?(key)
 
         options = find_options_for(key)
-        attributes << ConfigurableAttribute.new(key, value, options: options)
+        attr_examples = @examples.select { |ex| ex.attribute == key }
+        attributes << ConfigurableAttribute.for(key, value, options: options, examples: attr_examples)
       end
-
-      attributes
     end
 
     def metadata_key?(key)

data/lib/rubocounsel/cop_prompt.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "cli/ui"
+
+module RuboCounsel
+  # Presents a list of actions for a cop and collects the user's choice.
+  #
+  # Actions are composable objects with #label, #call, and #reprompt?.
+  # The prompt loops until an action returns a result (reprompt? is false).
+  class CopPrompt
+    def self.for(entry, output: $stdout)
+      if entry.configurable?
+        actions = [
+          CopActions::Configure.new(entry, output: output),
+          CopActions::Disable.new,
+          CopActions::Skip.new
+        ]
+      else
+        actions = []
+        actions << CopActions::ShowExamples.new(entry.examples, output: output) if entry.examples.any?
+        actions.push(CopActions::Enable.new, CopActions::Disable.new, CopActions::Skip.new)
+      end
+
+      new(actions: actions)
+    end
+
+    def initialize(actions:)
+      @actions = actions
+    end
+
+    def prompt
+      loop do
+        labels = @actions.map(&:label)
+        chosen = ::CLI::UI::Prompt.ask("What would you like to do?", options: labels)
+        action = @actions.find { |a| a.label == chosen }
+        result = action.call
+        return result unless action.reprompt?
+      end
+    end
+  end
+end

data/lib/rubocounsel/counselor.rb

@@ -8,16 +8,12 @@ module RuboCounsel
   #
   # Responsibilities:
   #   - Walk through each offending cop
-  #   - Display cop information and examples
-  #   - Collect user choices via cli-ui prompts
+  #   - Display cop information
+  #   - Delegate action prompting to CopPrompt
   #   - Return choices hash for ConfigWriter
   #
   # Cops that are already configured in .rubocop.yml are skipped by default.
   class Counselor
-    CONFIGURABLE_ACTIONS = ["Configure", "Disable", "Skip"].freeze
-    SIMPLE_ACTIONS = ["Enable", "Disable", "Skip"].freeze
-    FILE_TARGETING_ATTRIBUTES = ["Include", "Exclude"].freeze
-
     def initialize(cop_names, catalog: CopCatalog.new, user_config: nil, output: $stdout)
       @cop_names = cop_names
       @catalog = catalog
@@ -51,19 +47,7 @@ module RuboCounsel
 
       ::CLI::UI::Frame.open(entry.cop_name, color: :blue) do
         display_cop_info(entry, docstring)
-        actions = entry.configurable_attributes.empty? ? SIMPLE_ACTIONS : CONFIGURABLE_ACTIONS
-        action = ::CLI::UI::Prompt.ask("What would you like to do?", options: actions)
-
-        case action
-        when "Enable"
-          { "Enabled" => true }
-        when "Disable"
-          { "Enabled" => false }
-        when "Skip"
-          nil
-        when "Configure"
-          configure_cop(entry)
-        end
+        CopPrompt.for(entry, output: @output).prompt
       end
     end
 
@@ -90,129 +74,11 @@ module RuboCounsel
     end
 
     def display_cop_info(entry, docstring)
-      # Prefer full YARD docstring over short config description
       description = docstring || entry.configuration["Description"]
       @output.puts ::CLI::UI.fmt("{{cyan:#{description}}}\n") if description
 
-      # Show documentation URL
       doc_url = entry.cop_class.documentation_url
       @output.puts ::CLI::UI.fmt("{{underline:#{doc_url}}}\n") if doc_url
     end
-
-    def configure_cop(entry)
-      config = {}
-
-      display_array_attributes_message(entry.configurable_attributes)
-
-      entry.configurable_attributes.each do |attr|
-        value = prompt_for_attribute(attr, entry.examples)
-        config[attr.name] = value unless value.nil?
-      end
-
-      config
-    end
-
-    def display_array_attributes_message(attributes)
-      array_attrs = attributes
-        .select { |attr| attr.type == :array }
-        .reject { |attr| FILE_TARGETING_ATTRIBUTES.include?(attr.name) }
-
-      return if array_attrs.empty?
-
-      names = array_attrs.map(&:name).join(", ")
-      @output.puts ::CLI::UI.fmt(
-        "{{green:These attributes accept lists and can be configured directly in .rubocop.yml: #{names}}}"
-      )
-    end
-
-    def prompt_for_attribute(attr, examples)
-      if attr.type.in?([:choice, :boolean]) && !has_examples_for?(attr.name, examples)
-        display_no_examples_message(attr.name)
-      end
-
-      case attr.type
-      when :choice
-        prompt_for_choice(attr, examples)
-      when :boolean
-        prompt_for_boolean(attr, examples)
-      when :array
-        # Skip array attributes (Include, Exclude, AllowedMethods, etc.)
-        # These aren't style choices and prompting for them causes type corruption
-        nil
-      else
-        prompt_for_value(attr)
-      end
-    end
-
-    def prompt_for_choice(attr, examples)
-      # Put default first, then the rest
-      default_val = attr.default_value.to_s
-      sorted_options = attr.options.sort_by { |opt| opt == default_val ? 0 : 1 }
-      options_with_default = sorted_options.map do |opt|
-        opt == default_val ? "#{opt} (default)" : opt
-      end
-
-      loop do
-        options = has_examples_for?(attr.name, examples) ? options_with_default + ["Show examples"] : options_with_default
-
-        answer = ::CLI::UI::Prompt.ask("#{attr.name}?", options: options)
-
-        if answer == "Show examples"
-          display_examples_for_attribute(attr.name, examples)
-        else
-          # Strip "(default)" suffix if present
-          return answer.sub(/ \(default\)$/, "")
-        end
-      end
-    end
-
-    def has_examples_for?(attr_name, examples)
-      examples.any? { |ex| ex.attribute == attr_name }
-    end
-
-    def prompt_for_boolean(attr, examples)
-      # Always show default first
-      base_options = if attr.default_value
-                       ["yes (default)", "no"]
-                     else
-                       ["no (default)", "yes"]
-                     end
-
-      loop do
-        options = has_examples_for?(attr.name, examples) ? base_options + ["Show examples"] : base_options
-
-        answer = ::CLI::UI::Prompt.ask("#{attr.name}?", options: options)
-
-        if answer == "Show examples"
-          display_examples_for_attribute(attr.name, examples)
-        else
-          return answer.sub(/ \(default\)$/, "") == "yes"
-        end
-      end
-    end
-
-    def prompt_for_value(attr)
-      ::CLI::UI::Prompt.ask(
-        "#{attr.name}? (default: #{attr.default_value})",
-        default: attr.default_value.to_s
-      )
-    end
-
-    def display_no_examples_message(attr_name)
-      @output.puts ::CLI::UI.fmt("{{italic:No examples available for #{attr_name}.}}")
-    end
-
-    def display_examples_for_attribute(attr_name, examples)
-      relevant = examples.select { |ex| ex.attribute == attr_name }
-      return if relevant.empty?
-
-      relevant.each do |example|
-        label = example.default? ? "#{example.value} (default)" : example.value
-        @output.puts <<~OUTPUT
-          #{::CLI::UI.fmt("{{yellow:#{label}:}}")}
-          #{example.text}
-        OUTPUT
-      end
-    end
   end
 end

data/lib/rubocounsel/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RuboCounsel
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/rubocounsel.rb

@@ -6,6 +6,8 @@ require_relative "rubocounsel/example_loader"
 require_relative "rubocounsel/configurable_attribute"
 require_relative "rubocounsel/cop_entry"
 require_relative "rubocounsel/cop_catalog"
+require_relative "rubocounsel/cop_actions"
+require_relative "rubocounsel/cop_prompt"
 require_relative "rubocounsel/config_writer"
 require_relative "rubocounsel/counselor"
 require_relative "rubocounsel/runner"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocounsel
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - John DeWyze
@@ -90,8 +90,10 @@ files:
 - lib/rubocounsel/cli.rb
 - lib/rubocounsel/config_writer.rb
 - lib/rubocounsel/configurable_attribute.rb
+- lib/rubocounsel/cop_actions.rb
 - lib/rubocounsel/cop_catalog.rb
 - lib/rubocounsel/cop_entry.rb
+- lib/rubocounsel/cop_prompt.rb
 - lib/rubocounsel/counselor.rb
 - lib/rubocounsel/example.rb
 - lib/rubocounsel/example_loader.rb