rake_options 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f139479b6f1399fc8d375f81f8b0d55c0ee617f38a029754e9ae1a70099015bb
-  data.tar.gz: 744d888d606e102fd3b2e442c89596ac347c8397c30004808ee4d7d6b8416464
+  metadata.gz: c23f2f501224d1849ee5255aafb6f023e12f6bacdeacdcd2a4909eb711e73adb
+  data.tar.gz: eaaa2f161b92704669317004e64dfee3267f4473095a561be9b8c71354d6362e
 SHA512:
-  metadata.gz: 27a9ba60af3907fb6b346fe00f386e02ed976ec3055b330a68848e42a911183b493fdd51f4a1584df90545bdb569339b5899a2da4ffe0be94beaaba96b0a2713
-  data.tar.gz: 9c3f3056b9abfc8ed41e40991751c95a04c6e56d6d3cb3f4f4c76071930d4d87d5535ad4d1f9c31921acac6d12d14ed1d9ccef6d161b8a94c97f7d78b0475c1d
+  metadata.gz: b507cb81d6ae6518115b35ce028779d7dbccbdebac5d328970ff2935269cf4d46041bc45927333d39efe897ede7646087873401095295635853e0d6e1a542560
+  data.tar.gz: 54a8901e28628730a2a15c8a2b53a06a89bdc0e1c621aa437dcef36890f4ee6f8c7cff07c32b3d299a6ce42360137661266426d1323995caa001fdd17052a67a

data/README.md

@@ -31,21 +31,24 @@ require 'rake_options'
 
 desc "Build with custom options"
 task :build do
-  config = {
-    "with-mysql-lib" => "--with-mysql-lib $path",
-    "enable-feature" => "--enable-feature $name"
-  }
+  # Simple array configuration: [flag_name, type]
+  config = [
+    ["with-mysql-lib", :string],
+    ["enable-feature", :string],
+    ["port", :integer]
+  ]
   
   options = RakeOptions.command_line_args(config)
   
   puts "MySQL lib path: #{options['with-mysql-lib']}"
   puts "Feature: #{options['enable-feature']}"
+  puts "Port: #{options['port']}"  # Automatically cast to integer
 end
 ```
 
 Run with:
 ```bash
-rake build -- --with-mysql-lib=/usr/local/mysql/lib --enable-feature=caching
+rake build -- --with-mysql-lib=/usr/local/mysql/lib --enable-feature=caching --port=3000
 ```
 
 For values with spaces, use quotes:
@@ -53,39 +56,34 @@ For values with spaces, use quotes:
 rake build -- --with-mysql-lib="/path/with spaces/lib"
 ```
 
-### Bracket-Style Arguments
+### Type Casting
+
+RakeOptions automatically casts values to the specified type:
 
 ```ruby
-require 'rake_options'
+config = [
+  ["port", :integer],
+  ["enabled", :boolean],
+  ["ratio", :float],
+  ["name", :string]
+]
 
-desc "Deploy with bracket notation"
-task :deploy do
-  config = {
-    "environment" => "[environment=$env]",
-    "region" => "[region=$region]"
-  }
-  
-  options = RakeOptions.command_line_args(config, notation: :bracket)
-  
-  puts "Deploying to #{options['environment']} in #{options['region']}"
-end
-```
+options = RakeOptions.command_line_args(config)
 
-Run with:
-```bash
-rake deploy [environment=production] [region=us-west-2]
+# Values are automatically cast:
+options['port']     # => 3000 (Integer)
+options['enabled']  # => true (Boolean)
+options['ratio']    # => 1.5 (Float)
+options['name']     # => "myapp" (String)
 ```
 
-### Multiple Variables in One Template
+Supported types:
+- `:string` - String values (default)
+- `:integer` or `:int` - Integer values
+- `:float` - Float values
+- `:boolean` or `:bool` - Boolean values (true/false)
 
-```ruby
-config = {
-  "database" => "--config $file --env $environment"
-}
 
-options = RakeOptions.command_line_args(config)
-# Extracts both file and environment from: --config=database.yml --env=production
-```
 
 ### Automatic Help Documentation
 
@@ -96,18 +94,20 @@ readme_content = <<~HELP
   Build Task Help
   
   Available options:
-    --with-mysql-lib PATH    Specify MySQL library path
-    --enable-feature NAME    Enable a specific feature
+    --with-mysql-lib=PATH    Specify MySQL library path (string)
+    --enable-feature=NAME    Enable a specific feature (string)
+    --port=NUMBER            Port number (integer)
 HELP
 
 RakeOptions.initialize_readme(readme_content)
 
 desc "Build with help support"
 task :build do
-  config = {
-    "with-mysql-lib" => "--with-mysql-lib $path",
-    "enable-feature" => "--enable-feature $name"
-  }
+  config = [
+    ["with-mysql-lib", :string],
+    ["enable-feature", :string],
+    ["port", :integer]
+  ]
   
   options = RakeOptions.command_line_args(config)
   # Your build logic here
@@ -133,37 +133,40 @@ options[:with_mysql_lib]
 
 ## Configuration Format
 
-The configuration hash maps symbolic names to template patterns:
+The configuration is a simple array of tuples:
 
 ```ruby
-{
-  "key-name" => "template pattern with $variables"
-}
+[
+  ["flag-name", :type],
+  ["another-flag", :type]
+]
 ```
 
-- **Key**: The name you'll use to access the parsed value
-- **Value**: A template string that defines how to extract the argument
-- **Variables**: Prefixed with `$` to indicate where values should be extracted
+- **flag-name**: The CLI flag name (will become `--flag-name`)
+- **type**: The data type (`:string`, `:integer`, `:float`, `:boolean`)
 
-### Template Examples
+### Examples
 
 ```ruby
-# Single variable
-"mysql-path" => "--with-mysql-lib $path"
+# String values
+["mysql-path", :string]
+
+# Integer values
+["port", :integer]
 
-# Multiple variables
-"database" => "--config $file --env $environment"
+# Boolean flags
+["enabled", :boolean]
 
-# Bracket notation
-"region" => "[region=$value]"
+# Float values
+["ratio", :float]
 ```
 
-## Notation Styles
+## Usage Format
 
-### CLI Notation (default)
+RakeOptions uses standard CLI flag format:
 
 ```ruby
-options = RakeOptions.command_line_args(config, notation: :cli)
+options = RakeOptions.command_line_args(config)
 ```
 
 Supports:
@@ -171,17 +174,6 @@ Supports:
 - `--flag="value with spaces"`
 - Multiple flags in one command
 
-### Bracket Notation
-
-```ruby
-options = RakeOptions.command_line_args(config, notation: :bracket)
-```
-
-Supports:
-- `[key=value]`
-- `[key="value with spaces"]`
-- Multiple bracket arguments
-
 ## Error Handling
 
 RakeOptions provides clear error messages:
@@ -236,17 +228,17 @@ rake task -- --help
 rake task -- --path="/path/with spaces"
 ```
 
-### Template not matching
+### Flag name mismatch
 
-**Problem**: Template variables aren't extracting values.
+**Problem**: Arguments aren't being recognized.
 
-**Solution**: Ensure your template matches the command line format exactly:
+**Solution**: Ensure the flag name in ARGV matches the config:
 ```ruby
-# Template
-"option" => "--option $value"
+# Config
+["my-option", :string]
 
-# Command line must match (note the = sign)
-rake task -- --option=myvalue
+# Command line must match exactly
+rake task -- --my-option=myvalue
 ```
 
 ## Requirements

data/lib/rake_options/cli_parser.rb

@@ -5,12 +5,14 @@ require_relative "template_engine"
 module RakeOptions
   class CLIParser
     def initialize(config)
-      @config = config
+      @config = normalize_config(config)
       @parsed_templates = {}
       
       # Pre-parse all templates
-      @config.each do |key, template_str|
-        @parsed_templates[key] = TemplateEngine.parse_template(template_str)
+      @config.each do |key, type|
+        # Auto-construct the full template from the key
+        full_template = "--#{key} $value"
+        @parsed_templates[key] = TemplateEngine.parse_template(full_template)
       end
     end
 
@@ -20,18 +22,13 @@ module RakeOptions
     def parse(argv = ARGV)
       result = {}
       
-      @config.each do |key, _template_str|
+      @config.each do |key, type|
         parsed_template = @parsed_templates[key]
         extracted = TemplateEngine.extract_values(argv, parsed_template)
         
         if extracted && !extracted.empty?
-          # For single variable templates, store the value directly
-          if extracted.size == 1
-            result[key] = extracted.values.first
-          else
-            # For multiple variables, store the hash
-            result[key] = extracted
-          end
+          raw_value = extracted.values.first
+          result[key] = cast_value(raw_value, type)
         else
           result[key] = nil
         end
@@ -39,5 +36,40 @@ module RakeOptions
       
       result
     end
+
+    private
+
+    # Normalize config to hash format
+    # @param config [Array, Hash] Configuration
+    # @return [Hash] Normalized configuration
+    def normalize_config(config)
+      if config.is_a?(Array)
+        # Convert array of tuples to hash
+        config.to_h
+      else
+        config
+      end
+    end
+
+    # Cast value to specified type
+    # @param value [String] Raw string value
+    # @param type [Symbol] Target type
+    # @return [Object] Casted value
+    def cast_value(value, type)
+      return nil if value.nil?
+
+      case type
+      when :string
+        value.to_s
+      when :integer, :int
+        value.to_i
+      when :float
+        value.to_f
+      when :boolean, :bool
+        value.downcase == 'true' || value == '1'
+      else
+        value
+      end
+    end
   end
 end

data/lib/rake_options/help_generator.rb

@@ -3,7 +3,7 @@
 module RakeOptions
   class HelpGenerator
     def initialize(config, readme_content = nil)
-      @config = config
+      @config = normalize_config(config)
       @readme_content = readme_content
     end
 
@@ -26,13 +26,24 @@ module RakeOptions
       end
     end
 
+    # Normalize config to hash format
+    # @param config [Array, Hash] Configuration
+    # @return [Hash] Normalized configuration
+    def normalize_config(config)
+      if config.is_a?(Array)
+        config.to_h
+      else
+        config
+      end
+    end
+
     # Auto-generate help from config
     # @return [String] Auto-generated help text
     def auto_generate_help
       help_text = "Available Options:\n\n"
       
-      @config.each do |key, template|
-        help_text += format_option(key, template)
+      @config.each do |key, type|
+        help_text += format_option(key, type)
       end
       
       help_text
@@ -40,10 +51,10 @@ module RakeOptions
 
     # Format individual option for display
     # @param key [String] Option key
-    # @param template [String] Template string
+    # @param type [Symbol] Value type
     # @return [String] Formatted option line
-    def format_option(key, template)
-      "  #{template.ljust(40)} (#{key})\n"
+    def format_option(key, type)
+      "  --#{key}=VALUE".ljust(42) + "(#{type})\n"
     end
   end
 end

data/lib/rake_options/version.rb

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

data/lib/rake_options.rb

@@ -2,7 +2,7 @@
 
 require_relative "rake_options/version"
 require_relative "rake_options/errors"
-require_relative "rake_options/argument_parser"
+require_relative "rake_options/cli_parser"
 require_relative "rake_options/help_generator"
 require_relative "rake_options/hash_with_indifferent_access"
 
@@ -11,18 +11,17 @@ module RakeOptions
     attr_accessor :readme_content
 
     # Parse command line arguments based on configuration
-    # @param config [Hash] Argument configuration mapping
-    # @param notation [Symbol] Notation style (:cli or :bracket)
+    # @param config [Array] Argument configuration as array of [name, type] tuples
     # @return [HashWithIndifferentAccess] Parsed arguments with indifferent access
-    def command_line_args(config, notation: :cli)
+    def command_line_args(config)
       # Check for --help flag
       if ARGV.include?("--help")
         help_generator = HelpGenerator.new(config, readme_content)
         help_generator.display_and_exit
       end
 
-      # Parse arguments
-      parser = ArgumentParser.new(config, notation)
+      # Parse arguments using CLI parser
+      parser = CLIParser.new(config)
       result = parser.parse
 
       # Wrap in HashWithIndifferentAccess

data/spec/integration/rake_options_integration_spec.rb

@@ -5,27 +5,27 @@ require "spec_helper"
 RSpec.describe "RakeOptions Integration Tests" do
   describe "Full CLI parsing workflow" do
     let(:config) do
-      {
-        "with-mysql-lib" => "--with-mysql-lib $path",
-        "enable-feature" => "--enable-feature $name",
-        "port" => "--port $number"
-      }
+      [
+        ["with-mysql-lib", :string],
+        ["enable-feature", :string],
+        ["port", :integer]
+      ]
     end
 
     it "parses multiple CLI arguments in one invocation" do
       stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib", "--enable-feature=caching", "--port=3000"])
       
-      result = RakeOptions.command_line_args(config, notation: :cli)
+      result = RakeOptions.command_line_args(config)
       
       expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
       expect(result["enable-feature"]).to eq("caching")
-      expect(result["port"]).to eq("3000")
+      expect(result["port"]).to eq(3000)
     end
 
     it "handles partial arguments gracefully" do
       stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
       
-      result = RakeOptions.command_line_args(config, notation: :cli)
+      result = RakeOptions.command_line_args(config)
       
       expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
       expect(result["enable-feature"]).to be_nil
@@ -35,7 +35,7 @@ RSpec.describe "RakeOptions Integration Tests" do
     it "supports quoted values with spaces" do
       stub_const("ARGV", ['--with-mysql-lib="/path/with spaces/lib"'])
       
-      result = RakeOptions.command_line_args(config, notation: :cli)
+      result = RakeOptions.command_line_args(config)
       
       expect(result["with-mysql-lib"]).to eq("/path/with spaces/lib")
     end
@@ -43,50 +43,13 @@ RSpec.describe "RakeOptions Integration Tests" do
     it "allows symbol key access" do
       stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
       
-      result = RakeOptions.command_line_args(config, notation: :cli)
+      result = RakeOptions.command_line_args(config)
       
       expect(result[:with_mysql_lib]).to eq("/usr/local/lib")
       expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
     end
   end
 
-  describe "Full bracket parsing workflow" do
-    let(:config) do
-      {
-        "environment" => "[environment=$env]",
-        "region" => "[region=$reg]",
-        "instance-type" => "[instance-type=$type]"
-      }
-    end
-
-    it "parses multiple bracket arguments" do
-      stub_const("ARGV", ["[environment=production]", "[region=us-west-2]", "[instance-type=t2.micro]"])
-      
-      result = RakeOptions.command_line_args(config, notation: :bracket)
-      
-      expect(result["environment"]).to eq("production")
-      expect(result["region"]).to eq("us-west-2")
-      expect(result["instance-type"]).to eq("t2.micro")
-    end
-
-    it "handles quoted bracket values" do
-      stub_const("ARGV", ['[environment="staging environment"]'])
-      
-      result = RakeOptions.command_line_args(config, notation: :bracket)
-      
-      expect(result["environment"]).to eq("staging environment")
-    end
-
-    it "supports symbol key access with dashes/underscores" do
-      stub_const("ARGV", ["[instance-type=t2.micro]"])
-      
-      result = RakeOptions.command_line_args(config, notation: :bracket)
-      
-      expect(result[:instance_type]).to eq("t2.micro")
-      expect(result["instance-type"]).to eq("t2.micro")
-    end
-  end
-
   describe "Help display integration" do
     let(:config) do
       {
@@ -134,27 +97,25 @@ RSpec.describe "RakeOptions Integration Tests" do
 
   describe "Mixed scenarios" do
     let(:config) do
-      {
-        "database" => "--config $file --env $environment",
-        "verbose" => "--verbose $level"
-      }
+      [
+        ["database", :string],
+        ["verbose", :string]
+      ]
     end
 
-    it "handles templates with multiple variables" do
-      stub_const("ARGV", ["--config=database.yml", "--env=production", "--verbose=debug"])
+    it "handles multiple arguments" do
+      stub_const("ARGV", ["--database=mydb", "--verbose=debug"])
       
-      result = RakeOptions.command_line_args(config, notation: :cli)
+      result = RakeOptions.command_line_args(config)
       
-      expect(result["database"]).to be_a(Hash)
-      expect(result["database"]["file"]).to eq("database.yml")
-      expect(result["database"]["environment"]).to eq("production")
+      expect(result["database"]).to eq("mydb")
       expect(result["verbose"]).to eq("debug")
     end
 
     it "handles empty ARGV" do
       stub_const("ARGV", [])
       
-      result = RakeOptions.command_line_args(config, notation: :cli)
+      result = RakeOptions.command_line_args(config)
       
       expect(result["database"]).to be_nil
       expect(result["verbose"]).to be_nil
@@ -163,48 +124,28 @@ RSpec.describe "RakeOptions Integration Tests" do
     it "ignores unrecognized arguments" do
       stub_const("ARGV", ["--unknown-flag=value", "--verbose=info"])
       
-      result = RakeOptions.command_line_args(config, notation: :cli)
+      result = RakeOptions.command_line_args(config)
       
       expect(result["verbose"]).to eq("info")
       expect(result["database"]).to be_nil
     end
   end
 
-  describe "Error scenarios" do
-    let(:config) do
-      {
-        "option" => "--option $value"
-      }
-    end
-
-    it "raises InvalidNotationError for unsupported notation" do
-      stub_const("ARGV", ["--option=value"])
-      
-      expect { RakeOptions.command_line_args(config, notation: :invalid) }
-        .to raise_error(RakeOptions::InvalidNotationError, /Invalid notation/)
-    end
 
-    it "provides clear error message with supported notations" do
-      stub_const("ARGV", ["--option=value"])
-      
-      expect { RakeOptions.command_line_args(config, notation: :xml) }
-        .to raise_error(RakeOptions::InvalidNotationError, /:cli, :bracket/)
-    end
-  end
 
   describe "Real-world usage scenarios" do
     context "deployment task" do
       let(:deploy_config) do
-        {
-          "environment" => "--env $environment",
-          "region" => "--region $region",
-          "version" => "--version $ver",
-          "dry-run" => "--dry-run $flag"
-        }
+        [
+          ["environment", :string],
+          ["region", :string],
+          ["version", :string],
+          ["dry-run", :boolean]
+        ]
       end
 
       it "handles typical deployment command" do
-        stub_const("ARGV", ["--env=production", "--region=us-east-1", "--version=v1.2.3"])
+        stub_const("ARGV", ["--environment=production", "--region=us-east-1", "--version=v1.2.3"])
         
         result = RakeOptions.command_line_args(deploy_config)
         
@@ -217,17 +158,17 @@ RSpec.describe "RakeOptions Integration Tests" do
 
     context "build task" do
       let(:build_config) do
-        {
-          "with-mysql" => "--with-mysql-lib $path",
-          "with-ssl" => "--with-ssl-lib $path",
-          "prefix" => "--prefix $path"
-        }
+        [
+          ["with-mysql", :string],
+          ["with-ssl", :string],
+          ["prefix", :string]
+        ]
       end
 
       it "handles build configuration" do
         stub_const("ARGV", [
-          "--with-mysql-lib=/usr/local/mysql/lib",
-          "--with-ssl-lib=/usr/local/ssl/lib",
+          "--with-mysql=/usr/local/mysql/lib",
+          "--with-ssl=/usr/local/ssl/lib",
           "--prefix=/opt/myapp"
         ])
         

data/spec/rake_options/cli_parser_spec.rb

@@ -7,9 +7,7 @@ RSpec.describe RakeOptions::CLIParser do
   describe "#parse" do
     context "with single flag" do
       let(:config) do
-        {
-          "with-mysql-lib" => "--with-mysql-lib $path"
-        }
+        [["with-mysql-lib", :string]]
       end
       let(:parser) { described_class.new(config) }
 
@@ -30,10 +28,7 @@ RSpec.describe RakeOptions::CLIParser do
 
     context "with multiple flags" do
       let(:config) do
-        {
-          "with-mysql-lib" => "--with-mysql-lib $path",
-          "enable-feature" => "--enable-feature $name"
-        }
+        [["with-mysql-lib", :string], ["enable-feature", :string]]
       end
       let(:parser) { described_class.new(config) }
 
@@ -56,9 +51,7 @@ RSpec.describe RakeOptions::CLIParser do
 
     context "with quoted values" do
       let(:config) do
-        {
-          "message" => "--message $text"
-        }
+        [["message", :string]]
       end
       let(:parser) { described_class.new(config) }
 
@@ -72,9 +65,7 @@ RSpec.describe RakeOptions::CLIParser do
 
     context "with unknown flags" do
       let(:config) do
-        {
-          "known-flag" => "--known-flag $value"
-        }
+        [["known-flag", :string]]
       end
       let(:parser) { described_class.new(config) }
 
@@ -87,21 +78,34 @@ RSpec.describe RakeOptions::CLIParser do
       end
     end
 
-    context "with multiple variables in template" do
+    context "with type casting" do
       let(:config) do
-        {
-          "database" => "--config $file --env $environment"
-        }
+        [["port", :integer], ["enabled", :boolean], ["ratio", :float]]
       end
       let(:parser) { described_class.new(config) }
 
-      it "extracts multiple variables" do
-        argv = ["--config=database.yml", "--env=production"]
+      it "casts integer values" do
+        argv = ["--port=3000"]
         result = parser.parse(argv)
         
-        expect(result["database"]).to be_a(Hash)
-        expect(result["database"]["file"]).to eq("database.yml")
-        expect(result["database"]["environment"]).to eq("production")
+        expect(result["port"]).to eq(3000)
+        expect(result["port"]).to be_a(Integer)
+      end
+
+      it "casts boolean values" do
+        argv = ["--enabled=true"]
+        result = parser.parse(argv)
+        
+        expect(result["enabled"]).to eq(true)
+        expect(result["enabled"]).to be_a(TrueClass)
+      end
+
+      it "casts float values" do
+        argv = ["--ratio=1.5"]
+        result = parser.parse(argv)
+        
+        expect(result["ratio"]).to eq(1.5)
+        expect(result["ratio"]).to be_a(Float)
       end
     end
   end

data/spec/rake_options/help_generator_spec.rb

@@ -6,10 +6,7 @@ require "rake_options/help_generator"
 RSpec.describe RakeOptions::HelpGenerator do
   describe "#display_and_exit" do
     let(:config) do
-      {
-        "with-mysql-lib" => "--with-mysql-lib $path",
-        "enable-feature" => "--enable-feature $name"
-      }
+      [["with-mysql-lib", :string], ["enable-feature", :string]]
     end
 
     context "with custom README" do
@@ -46,10 +43,7 @@ RSpec.describe RakeOptions::HelpGenerator do
 
   describe "#generate_help_text" do
     let(:config) do
-      {
-        "option1" => "--option1 $value",
-        "option2" => "--option2 $value"
-      }
+      [["option1", :string], ["option2", :string]]
     end
 
     context "with custom README" do
@@ -75,12 +69,12 @@ RSpec.describe RakeOptions::HelpGenerator do
   end
 
   describe "#format_option" do
-    let(:generator) { described_class.new({}) }
+    let(:generator) { described_class.new([]) }
 
-    it "formats option with key and template" do
-      formatted = generator.send(:format_option, "my-option", "--my-option $value")
-      expect(formatted).to include("--my-option $value")
-      expect(formatted).to include("my-option")
+    it "formats option with key and type" do
+      formatted = generator.send(:format_option, "my-option", :string)
+      expect(formatted).to include("--my-option")
+      expect(formatted).to include("string")
     end
   end
 end

data/spec/rake_options_spec.rb

@@ -4,44 +4,31 @@ require "spec_helper"
 
 RSpec.describe RakeOptions do
   let(:config) do
-    {
-      "with-mysql-lib" => "--with-mysql-lib $path",
-      "enable-feature" => "--enable-feature $name"
-    }
+    [["with-mysql-lib", :string], ["enable-feature", :string]]
   end
 
   describe ".command_line_args" do
-    context "with CLI notation" do
+    context "parsing arguments" do
       it "parses CLI-style arguments" do
         stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
-        result = described_class.command_line_args(config, notation: :cli)
+        result = described_class.command_line_args(config)
         
         expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
       end
 
       it "supports symbol key access" do
         stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
-        result = described_class.command_line_args(config, notation: :cli)
+        result = described_class.command_line_args(config)
         
         expect(result[:with_mysql_lib]).to eq("/usr/local/lib")
       end
-    end
 
-    context "with bracket notation" do
-      it "parses bracket-style arguments" do
-        stub_const("ARGV", ["[with-mysql-lib=/usr/local/lib]"])
-        result = described_class.command_line_args(config, notation: :bracket)
-        
-        expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
-      end
-    end
-
-    context "with default notation" do
-      it "defaults to CLI notation" do
-        stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
+      it "parses multiple arguments" do
+        stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib", "--enable-feature=caching"])
         result = described_class.command_line_args(config)
         
         expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
+        expect(result["enable-feature"]).to eq("caching")
       end
     end
 
@@ -66,6 +53,10 @@ RSpec.describe RakeOptions do
   end
 
   describe ".initialize_readme" do
+    let(:simple_config) do
+      [["option", :string]]
+    end
+
     it "stores readme content" do
       readme = "Custom help text"
       described_class.initialize_readme(readme)
@@ -78,7 +69,7 @@ RSpec.describe RakeOptions do
       described_class.initialize_readme(readme)
       stub_const("ARGV", ["--help"])
       
-      expect { described_class.command_line_args(config) }
+      expect { described_class.command_line_args(simple_config) }
         .to output(/My Custom Help/).to_stdout
         .and raise_error(SystemExit)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rake_options
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Randy Villanueva
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-15 00:00:00.000000000 Z
+date: 2025-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -51,8 +51,6 @@ files:
 - README.md
 - Rakefile
 - lib/rake_options.rb
-- lib/rake_options/argument_parser.rb
-- lib/rake_options/bracket_parser.rb
 - lib/rake_options/cli_parser.rb
 - lib/rake_options/errors.rb
 - lib/rake_options/hash_with_indifferent_access.rb
@@ -60,8 +58,6 @@ files:
 - lib/rake_options/template_engine.rb
 - lib/rake_options/version.rb
 - spec/integration/rake_options_integration_spec.rb
-- spec/rake_options/argument_parser_spec.rb
-- spec/rake_options/bracket_parser_spec.rb
 - spec/rake_options/cli_parser_spec.rb
 - spec/rake_options/help_generator_spec.rb
 - spec/rake_options/template_engine_spec.rb

data/lib/rake_options/argument_parser.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "cli_parser"
-require_relative "bracket_parser"
-require_relative "errors"
-
-module RakeOptions
-  class ArgumentParser
-    VALID_NOTATIONS = [:cli, :bracket].freeze
-
-    def initialize(config, notation)
-      @config = config
-      @notation = notation
-      validate_notation
-    end
-
-    # Parse ARGV and return structured options
-    # @return [Hash] Parsed options
-    def parse
-      parser = select_parser
-      parser.parse
-    end
-
-    private
-
-    # Select appropriate parser based on notation
-    # @return [CLIParser, BracketParser] Parser instance
-    def select_parser
-      case @notation
-      when :cli
-        CLIParser.new(@config)
-      when :bracket
-        BracketParser.new(@config)
-      end
-    end
-
-    # Validate notation parameter
-    # @raise [InvalidNotationError] if notation is invalid
-    def validate_notation
-      return if VALID_NOTATIONS.include?(@notation)
-
-      raise InvalidNotationError,
-            "Invalid notation ':#{@notation}'. Supported notations: #{VALID_NOTATIONS.map { |n| ":#{n}" }.join(', ')}"
-    end
-  end
-end

data/lib/rake_options/bracket_parser.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module RakeOptions
-  class BracketParser
-    def initialize(config)
-      @config = config
-    end
-
-    # Parse bracket-style arguments from ARGV
-    # @param argv [Array] Command line arguments (defaults to ARGV)
-    # @return [Hash] Parsed values
-    def parse(argv = ARGV)
-      result = {}
-      
-      # Extract all bracket arguments from argv
-      bracket_args = extract_bracket_args(argv)
-      
-      # Match bracket args to config keys
-      @config.each do |key, _template|
-        # Look for matching bracket key
-        if bracket_args.key?(key)
-          result[key] = bracket_args[key]
-        else
-          result[key] = nil
-        end
-      end
-      
-      result
-    end
-
-    private
-
-    # Find all [key=value] patterns in argv
-    # @param argv [Array] Command line arguments
-    # @return [Hash] Extracted key-value pairs
-    def extract_bracket_args(argv)
-      result = {}
-      
-      argv.each do |arg|
-        # Match [key=value] or [key="value"]
-        match = arg.match(/^\[([^=]+)=(.+)\]$/)
-        next unless match
-        
-        key = match[1]
-        value = parse_bracket_value(match[2])
-        result[key] = value
-      end
-      
-      result
-    end
-
-    # Handle quoted and unquoted values in brackets
-    # @param value [String] Value from bracket
-    # @return [String] Parsed value
-    def parse_bracket_value(value)
-      # Remove surrounding quotes if present
-      if value.start_with?('"') && value.end_with?('"')
-        value[1..-2]
-      else
-        value
-      end
-    end
-  end
-end

data/spec/rake_options/argument_parser_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "rake_options/argument_parser"
-
-RSpec.describe RakeOptions::ArgumentParser do
-  let(:config) do
-    {
-      "option1" => "--option1 $value"
-    }
-  end
-
-  describe "#initialize" do
-    context "with valid notation" do
-      it "accepts :cli notation" do
-        expect { described_class.new(config, :cli) }.not_to raise_error
-      end
-
-      it "accepts :bracket notation" do
-        expect { described_class.new(config, :bracket) }.not_to raise_error
-      end
-    end
-
-    context "with invalid notation" do
-      it "raises InvalidNotationError" do
-        expect { described_class.new(config, :invalid) }.to raise_error(RakeOptions::InvalidNotationError)
-      end
-
-      it "provides helpful error message" do
-        expect { described_class.new(config, :invalid) }.to raise_error(
-          RakeOptions::InvalidNotationError,
-          /Invalid notation ':invalid'. Supported notations: :cli, :bracket/
-        )
-      end
-    end
-  end
-
-  describe "#parse" do
-    context "with CLI notation" do
-      let(:parser) { described_class.new(config, :cli) }
-
-      it "uses CLIParser" do
-        expect(RakeOptions::CLIParser).to receive(:new).with(config).and_call_original
-        parser.parse
-      end
-    end
-
-    context "with bracket notation" do
-      let(:parser) { described_class.new(config, :bracket) }
-
-      it "uses BracketParser" do
-        expect(RakeOptions::BracketParser).to receive(:new).with(config).and_call_original
-        parser.parse
-      end
-    end
-  end
-
-  describe "#select_parser" do
-    it "returns CLIParser for :cli notation" do
-      parser = described_class.new(config, :cli)
-      selected = parser.send(:select_parser)
-      expect(selected).to be_a(RakeOptions::CLIParser)
-    end
-
-    it "returns BracketParser for :bracket notation" do
-      parser = described_class.new(config, :bracket)
-      selected = parser.send(:select_parser)
-      expect(selected).to be_a(RakeOptions::BracketParser)
-    end
-  end
-end

data/spec/rake_options/bracket_parser_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "rake_options/bracket_parser"
-
-RSpec.describe RakeOptions::BracketParser do
-  describe "#parse" do
-    context "with simple key=value" do
-      let(:config) do
-        {
-          "environment" => "[environment=$env]",
-          "region" => "[region=$region]"
-        }
-      end
-      let(:parser) { described_class.new(config) }
-
-      it "parses [key=value] format" do
-        argv = ["[environment=production]", "[region=us-west-2]"]
-        result = parser.parse(argv)
-        
-        expect(result["environment"]).to eq("production")
-        expect(result["region"]).to eq("us-west-2")
-      end
-
-      it "returns nil for missing arguments" do
-        argv = ["[environment=production]"]
-        result = parser.parse(argv)
-        
-        expect(result["environment"]).to eq("production")
-        expect(result["region"]).to be_nil
-      end
-    end
-
-    context "with quoted values" do
-      let(:config) do
-        {
-          "message" => "[message=$text]"
-        }
-      end
-      let(:parser) { described_class.new(config) }
-
-      it "parses [key=\"value with spaces\"] format" do
-        argv = ['[message="Hello World"]']
-        result = parser.parse(argv)
-        
-        expect(result["message"]).to eq("Hello World")
-      end
-    end
-
-    context "with multiple bracket arguments" do
-      let(:config) do
-        {
-          "env" => "[env=$environment]",
-          "region" => "[region=$reg]",
-          "instance" => "[instance=$type]"
-        }
-      end
-      let(:parser) { described_class.new(config) }
-
-      it "parses multiple bracket arguments" do
-        argv = ["[env=prod]", "[region=us-east-1]", "[instance=t2.micro]"]
-        result = parser.parse(argv)
-        
-        expect(result["env"]).to eq("prod")
-        expect(result["region"]).to eq("us-east-1")
-        expect(result["instance"]).to eq("t2.micro")
-      end
-    end
-
-    context "with malformed brackets" do
-      let(:config) do
-        {
-          "valid" => "[valid=$val]"
-        }
-      end
-      let(:parser) { described_class.new(config) }
-
-      it "ignores malformed bracket arguments" do
-        argv = ["[valid=test]", "invalid=value", "[missing-bracket"]
-        result = parser.parse(argv)
-        
-        expect(result["valid"]).to eq("test")
-      end
-    end
-  end
-end