thor_enhance 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29e06b1db0b1f965fc4896f15781ab95d11999a03b3c8d87d3bde9a7ce7505b4
-  data.tar.gz: 503883577bd91606b5007adecc6592077b571978abd02c017b7222144fb45c62
+  metadata.gz: 921021cfeb7e6d2528aa29efeeeb0b282208b08cecef9dff992dd421696f13d6
+  data.tar.gz: e43f824f5d32922d71c385722b50f31f34a7c7912eb2e6b93e1cb507e7e9f8e3
 SHA512:
-  metadata.gz: 9640892f989be7e49445b89c5345b4993b29203bd0d58cf638244bb92f861154e11afa19408a4b69f6e09b828369c9d7fee55f81725639bf6cf8ef34c58ca1a0
-  data.tar.gz: a1dbc442d2a09e0aed8a50f08eee393e9b2a67624dea27629d4951d88472c060cbff102364a7953310d74af531fe75eb11bb680f1488a0faa62b023ab3717c0b
+  metadata.gz: 74090f01c075d963fbffd046cb4f3968901cb5683d8bf1f1f91a181de618e75f1ec20368fd0d04815ed76962f00c12a409c24639e03e7c80b647e6ad980ddafd
+  data.tar.gz: 2d815c6bc7957019524de7785b4678d8b10ccaa38f9d172ea383f21241cfaf80cf9601573d859140c7e4b29b9d14cdc3ce5f492c3a2bd282f8b5be33100e81eb

data/.gitignore

@@ -13,3 +13,5 @@
 
 # generated gems
 *.gem
+
+spec/examples.txt

data/CHANGELOG.md

@@ -5,22 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
 
-## [0.2.0] - 2022-06-18
+## [0.3.0]
+- remove `warn` hook in favor of enriched `deprecate` hook
+- method name validation on entry
+- Add examples and better documentation
 
-### Added
-- New feature 1
-- New feature 2
-
-### Changed
-- Changed feature 1
-- Changed feature 2
-
-### Removed
-- Removed feature 1
-- Removed feature 2
-
-### Fixed
-- Bug fix 1
-- Bug fix 2
+## [0.2.0]
+- Stable Release

data/Gemfile.lock

@@ -1,27 +1,19 @@
 PATH
   remote: .
   specs:
-    thor_enhance (0.1.0)
-      class_composer
-      faraday
+    thor_enhance (0.3.0)
+      thor (~> 1.3)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    base64 (0.2.0)
     byebug (11.1.3)
-    class_composer (1.0.2)
     coderay (1.1.3)
     concurrent-ruby (1.2.2)
     diff-lcs (1.5.0)
     docile (1.4.0)
     faker (3.2.2)
       i18n (>= 1.8.11, < 2)
-    faraday (2.7.11)
-      base64
-      faraday-net_http (>= 2.0, < 3.1)
-      ruby2_keywords (>= 0.0.4)
-    faraday-net_http (3.0.2)
     i18n (1.14.1)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
@@ -47,13 +39,13 @@ GEM
     rspec-support (3.12.1)
     rspec_junit_formatter (0.6.0)
       rspec-core (>= 2, < 4, != 2.12.0)
-    ruby2_keywords (0.0.5)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
+    thor (1.3.0)
 
 PLATFORMS
   aarch64-linux

data/docs/command.md

@@ -0,0 +1,54 @@
+# Command Method Injection
+
+Command Method injection allows you to easily enrich Thor Commands with additional data.
+
+## When to use:
+This should be used when you want to enrich your command data. This data can then be retrieved by using the [ThorEnhance::Tree](tree.md) class.
+
+## How to use
+
+Additional configuration is needed prior to loading the your Thor instance
+
+```ruby
+# thor_enhance_config.rb
+ThorEnhance.configure do |c|
+  # Adds `example` method to the command
+  # Value can be anything and is a repeatable command
+  c.add_command_method_enhance "example", repeatable: true
+
+  # Adds `validate` method to the command
+  # Value must be one of :some or :thing
+  c.add_command_method_enhance "validate", enum: [:some, :thing]
+
+  # Adds `enhace` method to the command
+  # Value must be of type CustomClass
+  # It is repeatble and required
+  c.add_command_method_enhance "enhance", allowed_klasses: [CustomClass], repeatable: true, required: true
+end
+```
+The `add_option_enhance` takes the name as argument 1 followed by options.
+
+The available options are:
+
+**enums**:
+- When provided, the value of the `name` must be a value in the `enums` array
+EX: `publish: true` succeeds. `publish: :fail` fails.
+- Default: `nil`
+
+**allowed_klasses**
+- When provided, this is expected to be an array of class types the value can be.
+- Default: `nil`
+
+**required**
+- When flag is set to true, this option will be required on all `method_option` immediately. An error is raised if validation fails
+- Default: `false`
+
+**repeatable**
+- When flag is set to true, this option will allow the same command to reference the method multiple times. The value will be retreable as an Array from [ThorEnhance::Tree](tree.md) class.
+- Default: `false`
+
+# Examples:
+
+[Basic Example](../examples/basic_example.md)
+[Basic Example with Subcommand](../examples/basic_example_with_subcommand.md)
+

data/docs/hooks.md

@@ -0,0 +1,59 @@
+# Hooks:
+
+Hooks allow you to slowly deprecate options over time. There are three basic Hooks available on every method_option
+
+## Arguments:
+Both `deprecate` and `hook` are expected to be a `proc`. The input arguments will be `input, options`
+
+### Argument: Input
+The `input` argument is the first argument. It is the value that the user inputted. When there is no user input, the hook will not run.
+
+### Argument: Option
+The `option` argument is the second argument. It is the `Thor::Option` struct for that existing method. The instance will have all ThorEnhance methods available.
+
+## Deprecate:
+The `deprecate` hook is available on every `method_option`. It expects a `Proc` class. The returned value from the proc is expected as either an Hash or a String.
+
+This hook should be used when you want to either immediately depreacte a method or over time deprecate a command while migrating to a new command. The decision to raise or warn is dynamic in real time.
+
+### When returned an String
+If the method option is provided, it will raise `ThorEnhance::OptionDeprecated` every time
+
+### When returned a Hash
+**hash[:raise]**: Expected a boolean value on weather to raise or warn. When true, it will raise `ThorEnhance::OptionDeprecated`. When false it will send WARNING to console
+**hash[:warn]**: Console message used when `:raise` is false. Does not output when `:raise` is true
+**hash[:msg]**: Message for both raise and warn. This should a short message on how to migrate to new command or syntax
+
+```ruby
+# When provided `--value1 "string"`:
+# This will raise `ThorEnhance::OptionDeprecated` with a message that looks like:
+# Passing value for option --value1 is deprecated. Provided `string`. Please migrate to `--value4`
+method_option :value1, type: :string, deprecate: ->(input, option) { "Please migrate to `--value4`" }
+
+# When provided `--value2 "string"` and deprecated criteria is not met:
+# This will send a WARNING message to the console. It will resemble:
+# Passing value for option --value1 is deprecated. Provided `string`. Please migrate to `--value4`
+method_option :value2, type: :string, deprecate: ->(input, option) { { raise: Date.today > Date.today, warn: "This option will deprecate after #{Date.today}", msg: "Please migrate to --value4"} }
+
+# When provided `--value3 "string"` and deprecated criteria is:
+# This will raise `ThorEnhance::OptionDeprecated` with a message that looks like:
+# Passing value for option --value3 is deprecated. Provided `string`. Please migrate to `--value4`
+method_option :value3, type: :string, deprecate: ->(input, option) { { raise: true, warn: "This option will deprecate after #{Date.today}", msg: "Please migrate to --value4"} }
+```
+
+## Hook
+The `hook` hook is available on every `method_option`. It expects a `Proc` class. No return value is expected. When the input is provided, custom code can get executed
+
+```ruby
+# When provided `--value1 "string"`:
+# This will raise `ThorEnhance::OptionDeprecated` with a message that looks like:
+# Passing value for option --value1 is deprecated. Provided `string`. Please migrate to `--value4`
+method_option :value1, type: :string, hook: ->(input, option) { Kernel.puts "#{input} is a good choice for #{option.name}" }
+```
+
+---
+
+# Examples
+
+For examples, [please navigate here](../examples/hooks.md)
+

data/docs/method_option.md

@@ -0,0 +1,52 @@
+# Method Option Injection
+
+Method option injection allows you to easily add additional flags to the `method_option` for commands. You can set them as required for every option. You can even set allowable values or allowable classes
+
+## When to use:
+This should be used when you want to enrich your command data. This data can then be retrieved by using the [ThorEnhance::Tree](tree.md) class.
+
+## How to use
+
+Additional configuration is needed prior to loading the your Thor instance
+
+```ruby
+# thor_enhance_config.rb
+ThorEnhance.configure do |c|
+  # Adds `classify` method to the option class
+  # Value of classify must be one of the enums
+  # It is not a required field on every method
+  c.add_option_enhance "classify", allowed_klasses: [String, Symbol, NilClass], required: false
+
+  # Adds `publish` method to the option
+  # Value of classify must be one of the enums
+  # It is a required field on every option
+  c.add_option_enhance :publish, enums: [true, false], required: true
+
+  # Adds `avoid method to the option
+  # Value is not restricted to any type or enum
+  # Not a required field
+  c.add_option_enhance :avoid
+end
+```
+The `add_option_enhance` takes the name as argument 1 followed by options.
+
+The available options are:
+
+**enums**:
+- When provided, the value of the `name` must be a value in the `enums` array
+EX: `publish: true` succeeds. `publish: :fail` fails.
+- Default: `nil`
+
+**allowed_klasses**
+- When provided, this is expected to be an array of class types the value can be.
+- Default: `nil`
+
+**required**
+- When flag is set to true, this option will be required on all `method_option` immediately. An error is raised if validation fails
+- Default: `false`
+
+# Examples:
+
+[Basic Example](../examples/basic_example.md)
+[Basic Example with Subcommand](../examples/basic_example_with_subcommand.md)
+

data/docs/tree.md

@@ -0,0 +1,42 @@
+# ThorEnhance::Tree
+
+The thor tree is a powerful tool to do introspection on all Thor commands within a repo.
+
+## How to use:
+
+MyTestClass definitiona can be found in [spec_helper.rb](../spec/spec_helper.rb)
+
+```ruby
+require "thor_enhance"
+
+tree = ThorEnhance::Tree.tree(base: MyTestClass)
+
+# View all commands on parent tree:
+tree.children.map(&:command)
+
+# View all commands including subcommands
+
+def iterate_base(base:)
+  tree.map do |name, object|
+    if object.children?
+      iterate_base(base: object)
+    else
+      object.command
+    end
+  end.flatten
+end
+
+iterate_base(base: tree)
+
+# View specific command
+command = tree["test_meth"].command
+
+# View specific sub command
+sub_command_innard = tree["sub"].children["innard"].command
+
+# View Options on specific command
+command.options
+
+# View specific Option on specific command
+sub_command_innard.options[:t]
+```

data/examples/basic_example.md

@@ -0,0 +1,47 @@
+```ruby
+# thor_enhance_config.rb
+
+require "thor_enhance"
+
+ThorEnhance.configure do |c|
+  # Adds `classify` method to the option class
+  # Value of classify must be one of the enums
+  # It is not a required field on every method
+  c.add_option_enhance "classify", enums: [:allowed, :future, :existing], required: false
+
+  # Adds `publish` method to the option
+  # Value of classify must be one of the enums
+  # It is a required field on every option
+  c.add_option_enhance :publish, enums: [true, false], required: true
+
+  # Adds `example` method to the command
+  # Value can be anything and is a repeatable command
+  c.add_command_method_enhance "example", repeatable: true
+end
+```
+
+```ruby
+# thor_cli.rb
+
+require "rubygems"
+require "bundler/setup"
+require "thor_enhance_config"
+
+class ThorEnhancement < Thor
+
+  dec "test", "Testing method"
+  example "thor_cli.rb test --value 'This is rad'"
+  example "thor_cli.rb test"
+  method_option :value, type: :string, publish: true
+  def test
+    command = ThorEnhance::Tree.tree(base: self.class)["test"].command
+    # example was set as `repeatable` so it gets returned as an array
+    command.example.each { puts _1 }
+
+    command.options[:value].publish == true
+    command.options[:value].classify == nil
+  end
+end
+
+ThorEnhancement.start
+```

data/examples/example_with_subcommand.md

@@ -0,0 +1,73 @@
+```ruby
+# thor_enhance_config.rb
+
+require "thor_enhance"
+
+ThorEnhance.configure do |c|
+  # Adds `classify` method to the option class
+  # Value of classify must be one of the enums
+  # It is not a required field on every method
+  c.add_option_enhance :classify, allowed_klasses: [Symbol], required: false
+
+  # Adds `publish` method to the option
+  # Value of classify must be one of the enums
+  # It is a required field on every option
+  c.add_option_enhance "publish", allowed_klasses: [TrueClass, FalseClass], required: true
+
+  # Adds `example` method to the command
+  # Value can be anything and is a repeatable command
+  c.add_command_method_enhance :example, repeatable: true
+end
+```
+
+```ruby
+# thor_cli.rb
+
+require "rubygems"
+require "bundler/setup"
+require "thor_enhance_config"
+
+class ThorEnhancement < Thor
+
+  dec "test", "Testing method"
+  example "thor_cli.rb test --value 'This is rad'"
+  example "thor_cli.rb test"
+  method_option :value, type: :string, publish: true
+  def test
+    command = ThorEnhance::Tree.tree(base: self.class)["test"].command
+    # example was set as `repeatable` so it gets returned as an array
+    command.example.each { puts _1 }
+
+    command.options[:value].publish == true
+    command.options[:value].classify == nil
+  end
+
+  class SubCommand < Thor
+    desc "sub_command", "Command for SubCommand"
+    example "bin/thor sub_command innard -t something -s better"
+    example "bin/thor sub_command innard -s better"
+    example "bin/thor sub_command innard"
+
+    method_option :t, type: :string, classify: :allowed, publish: true
+    method_option :s, type: :string, classify: :erase, publish: false
+    def sub_command
+      parent = ThorEnhance::Tree.tree(base: self.class)["sub"]
+      parent.example.each { puts _1 } # 1 example
+
+      command = parent.children["sub_command"].command
+      command.children? == false
+
+      command.example.each { puts _1 } # 3 examples
+
+      command.options[:t].publish == true
+      command.options[:t].classify == :allowed
+    end
+  end
+
+  desc "sub", "Submodule command line"
+  example "bin/thor sub ***"
+  subcommand "sub", SubCommand
+end
+
+ThorEnhancement.start
+```

data/examples/hooks.md

@@ -0,0 +1,57 @@
+# Hook Examples
+
+For more information on how to use hooks, [view documentation here](../docs/hooks.md)
+
+```ruby
+# thor_enhance_config.rb
+
+require "thor_enhance"
+
+ThorEnhance.configure do |c|
+  # Adds `classify` method to the option class
+  # Value of classify must be one of the enums
+  # It is not a required field on every method
+  c.add_option_enhance "classify", enums: [:allowed, :future, :existing], required: false
+
+  # Adds `publish` method to the option
+  # Value of classify must be one of the enums
+  # It is a required field on every option
+  c.add_option_enhance :publish, enums: [true, false], required: true
+
+  # Adds `example` method to the command
+  # Value can be anything and is a repeatable command
+  c.add_command_method_enhance "example", repeatable: true
+end
+```
+
+```ruby
+# thor_cli.rb
+
+require "rubygems"
+require "bundler/setup"
+require "thor_enhance_config"
+
+VERSION = Gem::Version.new("1.2.3")
+MAX_VERSION = Gem::Version.new("2.0.0")
+class ThorEnhancement < Thor
+
+  dec "test", "Testing method"
+  example "thor_cli.rb test --value 'This is rad'"
+  example "thor_cli.rb test"
+  method_option :value, type: :string, publish: true, deprecate: ->(input, option) { { raise: VERSION > MAX_VERSION, warn: "This option will deprecate with version #{MAX_VERSION}", msg: "Please migrate to --value4"} }
+
+  # Deprecate hook
+  method_option :option, type: :string, publish: false,
+  method_option :test, type: :string, publish: false,
+  def test
+    command = ThorEnhance::Tree.tree(base: self.class)["test"].command
+    # example was set as `repeatable` so it gets returned as an array
+    command.example.each { puts _1 }
+
+    command.options[:value].publish == true
+    command.options[:value].classify == nil
+  end
+end
+
+ThorEnhancement.start
+```

data/lib/thor_enhance/command.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module ThorEnhance
+  module Command
+    def self.thor_enhance_injection!
+      return false unless ThorEnhance::Configuration.allow_changes?
+
+      # Create Thor::Command getter and setter methods -- Validation gets done on setting
+      ThorEnhance.configuration.command_method_enhance.each do |name, object|
+        define_method(name) { instance_variable_get("@#{name}") }
+        define_method("#{name}=") { instance_variable_set("@#{name}", _1) }
+      end
+
+      # Prepend it so we can call this run method first
+      ::Thor::Command.prepend ThorEnhance::CommandHook
+
+      ::Thor::Command.include ThorEnhance::Command
+    end
+  end
+end

data/lib/thor_enhance/command_hook.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module ThorEnhance
+  module CommandHook
+    def run(instance, args = [])
+      raw_args = instance.instance_variable_get(:@_initializer)[1]
+      ThorEnhance::Configuration::HOOKERS.each do |hook|
+        object = ThorEnhance.configuration.option_enhance[hook]
+        # Iterate the options list based on each hook type
+        instance.options.each do |name, given_value|
+          option = options[name.to_s] || options[name.to_sym]
+          next if option.nil?
+
+          # If the hook exists on the method option, retreive it
+          # if not, move on
+          proclamation = option.send(hook)
+          next if proclamation.nil?
+
+          # if input tags is included in raw args, the user inputted the value
+          # hooks should only get called if the value was inputted
+          input_tags = [option.switch_name] + option.aliases
+          next unless input_tags.any? { raw_args.include?(_1) }
+
+          proc_value = proclamation.(given_value, option)
+
+          if object[:behavior] == :request
+            if Hash === proc_value && proc_value.keys.sort == [:raise, :warn, :msg].sort
+              warn_msg = proc_value[:warn].to_s
+              msg = proc_value[:msg].to_s
+              if proc_value[:raise]
+                raise ThorEnhance::OptionDeprecated, "Passing value for option #{option.switch_name} is deprecated. " \
+                  "Provided `#{given_value}`. #{proc_value[:msg]}"
+              else
+                Kernel.warn("WARNING: Provided `#{given_value}` for option #{option.switch_name}. " \
+                  "#{proc_value[:warn]}. #{proc_value[:msg]}")
+              end
+            else
+              raise ThorEnhance::OptionDeprecated, "Passing value for option #{option.switch_name} is deprecated. " \
+                "Provided `#{given_value}`. #{proc_value}"
+            end
+          end
+        end
+      end
+
+      super
+    end
+  end
+end

data/lib/thor_enhance/command_method.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module ThorEnhance
+  module CommandMethod
+
+    def self.thor_enhance_injection!
+      return false unless ThorEnhance::Configuration.allow_changes?
+
+      # This will dynamically define a class on the Thor module
+      # This allows us to add convenience helpers per method
+      ThorEnhance.configuration.command_method_enhance.each do |name, object|
+        # This is how thor works -- at the class level using memoization
+        # Interesting approach and it works because thor should boot before everything else -- and only boots once
+        ClassMethods.define_method("#{name}") do |input|
+          value = instance_variable_get("@#{name}")
+          value ||= {}
+          if @usage.nil?
+            raise ArgumentError, "Usage is not set. Please ensure `#{name}` is defined after usage is set"
+          end
+          if object[:repeatable]
+            value[@usage] ||= []
+            value[@usage] << input
+          else
+            value[@usage] = input
+          end
+
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      ::Thor.include ThorEnhance::CommandMethod
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # Call all things super for it (super in thor also calls super as well)
+      # If the command exists, then add the initi
+      def method_added(meth)
+        super(meth)
+
+        # Skip if the we should not be creating the command
+        if command = all_commands[meth.to_s]
+          ThorEnhance.configuration.command_method_enhance.each do |name, object|
+            # When value is not required and not present, it will not exist. Rescue and return nil
+            value = instance_variable_get("@#{name}")[meth.to_s] rescue nil
+            command.send("#{name}=", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thor_enhance/configuration.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module ThorEnhance
+  class Configuration
+
+    # Order is important -- Ensure deoreacte is first
+    HOOKERS = [DEPRECATE = :deprecate, HOOK = :hook]
+
+    class << self
+      attr_accessor :allow_changes
+
+      def allow_changes?(raise_error: true)
+        return true if allow_changes.nil?
+
+        if raise_error
+          raise BaseError, "Configuration changes are halted. Unable to change ThorEnhancements"
+        else
+          false
+        end
+      end
+
+      def disallow_changes!
+        allow_changes = true
+      end
+    end
+
+    def inject_thor!
+      self.class.allow_changes?
+
+      ThorEnhance::Option.thor_enhance_injection!
+      ThorEnhance::Command.thor_enhance_injection!
+      ThorEnhance::CommandMethod.thor_enhance_injection!
+      self.class.disallow_changes!
+    end
+
+    def command_method_enhance
+      @command_method_enhance ||= {}
+    end
+
+    def option_enhance
+      @option_enhance ||= {
+        DEPRECATE => { allowed_klasses: [Proc], behavior: :request, required: false },
+        HOOK => { allowed_klasses: [Proc], behavior: nil, required: false },
+      }
+    end
+
+    # Adding a new method to enhance the overall command
+    def add_command_method_enhance(name, allowed_klasses: nil, enums: nil, required: false, repeatable: false)
+      self.class.allow_changes?
+
+      add_to_variable(command_method_enhance, ::Thor::Command.instance_methods, name, allowed_klasses, enums, required, repeatable)
+    end
+
+    # add a new flag on the command option
+    def add_option_enhance(name, allowed_klasses: nil, enums: nil, required: false)
+      self.class.allow_changes?
+
+      add_to_variable(option_enhance, ::Thor::Option.instance_methods, name, allowed_klasses, enums, required)
+    end
+
+    private
+
+    def add_to_variable(storage, methods, name, allowed_klasses, enums, required, repeatable = false)
+      # Reject if the name is not a Symbol or a string
+      if [String, Symbol].none? { _1 === name }
+        raise ArgumentError, "Invalid name type received. Received [#{name}] of type [#{name.class}]. Expected to be of type String or Symbol"
+      end
+
+      # If name contains characters other than upper or lower case letters and _ FAIL
+      unless name =~ /^[A-Za-z_]+$/
+        raise ArgumentError, "Invalid name received. Received [#{name}] does not match /^[A-Za-z_]+$/."
+      end
+
+      if methods.include?(name.to_sym)
+        raise OptionNotAllowed, "[#{name}] is not allowed as an enhancement"
+      end
+
+      if storage.key?(name.to_sym)
+        raise OptionNotAllowed, "Duplicate detected. [#{name}] was already added."
+      end
+
+      # if enums is present and not an array
+      if !enums.nil? && !enums.is_a?(Array)
+        raise ArgumentError, "Recieved enum of #{enums}. When present, it is expected to be an Array"
+      end
+
+      storage[name.to_sym] = { allowed_klasses: allowed_klasses, enums: enums, required: required, repeatable: repeatable }
+    end
+  end
+end

data/lib/thor_enhance/option.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module ThorEnhance
+  module Option
+    def self.thor_enhance_injection!
+      return false unless ThorEnhance::Configuration.allow_changes?
+
+      # Create getter method for the enhance instance variable
+      ThorEnhance.configuration.option_enhance.each do |name, object|
+        define_method(name) { instance_variable_get("@#{name}") }
+      end
+
+      ::Thor::Option.include ThorEnhance::Option
+    end
+
+    def initialize(name, options = {})
+      super
+
+      thor_enhance_definitions(options)
+    end
+
+    def thor_enhance_definitions(options)
+      ThorEnhance.configuration.option_enhance.each do |name, object|
+        if options[name.to_sym].nil? && object[:required]
+          raise RequiredOption, "#{@name} does not have required option #{name}. Please add it to the option"
+        end
+
+        value = options[name.to_sym]
+        if value.nil? && object[:required] == false
+          # no op when it is nil and not required
+        elsif !object[:enums].nil?
+          unless object[:enums].include?(value)
+            raise ValidationFailed, "#{@name} recieved option #{name} with incorrect enum. Received: [#{value}]. Expected: [#{object[:enums]}]"
+          end
+        elsif !object[:allowed_klasses].nil?
+          unless object[:allowed_klasses].include?(value.class)
+            raise ValidationFailed, "#{@name} recieved option #{name} with incorrect class type. Received: [#{value.class}]. Expected: [#{object[:allowed_klasses]}]"
+          end
+        end
+
+        instance_variable_set("@#{name}", value)
+      end
+    end
+  end
+end

data/lib/thor_enhance/tree.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ThorEnhance
+  class Tree
+    DEFAULT_IGNORE_COMMANDS = ["help"]
+
+    def self.add_ignore_commands(command)
+      return false if ignore_commands.include?(command)
+
+      ignore_commands << command
+      true
+    end
+
+    def self.ignore_commands
+      @ignore_commands ||= DEFAULT_IGNORE_COMMANDS.dup
+    end
+
+    def self.reset_ignore_commands!
+      @ignore_commands = DEFAULT_IGNORE_COMMANDS.dup
+    end
+
+    def self.tree(base:, parent: nil)
+      base.all_commands.map do |k, command|
+        next if ignore_commands.include?(k)
+
+        [k, new(command: command, base: base, parent: parent)]
+      end.compact.to_h
+    end
+
+    attr_reader :command, :base, :parent, :children
+
+    # command: Thor::Command struct
+    # base: Root level class where the command is from
+    # parent: 1 level up if nested subcommand
+    def initialize(command:, base:, parent: nil)
+      @parent = parent
+      @base = base
+      @command = command
+      @children = []
+
+      if !base.subcommand_classes.nil? && base.subcommand_classes[command.name]
+        @children = self.class.tree(parent: self, base: base.subcommand_classes[command.name])
+      end
+    end
+
+    def children?
+      children.count > 0
+    end
+  end
+end

data/lib/thor_enhance/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ThorEnhance
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/thor_enhance.rb

@@ -1,24 +1,26 @@
 # frozen_string_literal: true
 
-require "faraday"
+require "thor_enhance/command"
+require "thor_enhance/command_hook"
+require "thor_enhance/command_method"
+require "thor_enhance/configuration"
+require "thor_enhance/option"
+require "thor_enhance/tree"
 
 module ThorEnhance
+  class BaseError < StandardError; end
+  class OptionNotAllowed < StandardError; end
+  class ValidationFailed < StandardError; end
+  class RequiredOption < StandardError; end
+  class OptionDeprecated < StandardError; end
 
   def self.configure
     yield configuration if block_given?
+
+    configuration.inject_thor!
   end
 
   def self.configuration
     @configuration ||= ThorEnhance::Configuration.new
   end
-
-  def self.configuration=(object)
-    raise ConfigError, "Expected configuration to be a ThorEnhance::Configuration" unless object.is_a?(ThorEnhance::Configuration)
-
-    @configuration = object
-  end
-
-  def self.reset_configuration!
-    @configuration = ThorEnhance::Configuration.new
-  end
 end

data/thor_enhance.gemspec

@@ -8,12 +8,12 @@ Gem::Specification.new do |spec|
   spec.authors = ["Matt Taylor"]
   spec.email   = ["mattius.taylor@gmail.com"]
 
-  spec.summary     = ""
-  spec.description = ""
+  spec.summary     = "Add hooks and human readable components to Thor Options and Thor Commands"
+  spec.description = "Have you ever wanted your thor commands to tell a story of what they are? Or have you ever wanted to deprecate an option over time easily? ThorEnhance allows to to annote methods and commands in a human readable way"
   spec.homepage    = "https://github.com/matt-taylor/thor_enhance"
   spec.license     = "MIT"
 
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.7")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3")
 
   spec.metadata = {
     "homepage_uri" => spec.homepage,
@@ -29,8 +29,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "class_composer"
-  spec.add_dependency "faraday"
+  spec.add_dependency "thor", "~> 1.3"
 
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "rake", "~> 12.0"

metadata

@@ -1,43 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: thor_enhance
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Matt Taylor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-19 00:00:00.000000000 Z
+date: 2023-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: class_composer
+  name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: faraday
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -94,7 +80,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.17.0
-description: ''
+description: Have you ever wanted your thor commands to tell a story of what they
+  are? Or have you ever wanted to deprecate an option over time easily? ThorEnhance
+  allows to to annote methods and commands in a human readable way
 email:
 - mattius.taylor@gmail.com
 executables: []
@@ -114,7 +102,20 @@ files:
 - bin/console
 - bin/setup
 - docker-compose.yml
+- docs/command.md
+- docs/hooks.md
+- docs/method_option.md
+- docs/tree.md
+- examples/basic_example.md
+- examples/example_with_subcommand.md
+- examples/hooks.md
 - lib/thor_enhance.rb
+- lib/thor_enhance/command.rb
+- lib/thor_enhance/command_hook.rb
+- lib/thor_enhance/command_method.rb
+- lib/thor_enhance/configuration.rb
+- lib/thor_enhance/option.rb
+- lib/thor_enhance/tree.rb
 - lib/thor_enhance/version.rb
 - thor_enhance.gemspec
 homepage: https://github.com/matt-taylor/thor_enhance
@@ -131,7 +132,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -141,5 +142,5 @@ requirements: []
 rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
-summary: ''
+summary: Add hooks and human readable components to Thor Options and Thor Commands
 test_files: []