rake_options 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d64b8c9debd762394889c921fc5a3c52f23618f3e1d33448c5f6337ab942edc
-  data.tar.gz: d24b0d7525cbb407047c86b61abca35ed3646a4f414272f1521900267a15673d
+  metadata.gz: fb24381876d415a7632d456afd8cace19474689f511ec98df623e65967ab1fe1
+  data.tar.gz: 22e3ef52a8f49fc4287a5f5b89ce302a7df74103aca8debcda6a0175452bc3f0
 SHA512:
-  metadata.gz: b896b635679be32725e5f480441fed874e4a853d3af99ce45b234d4dc5c42ed68ac1bc866879aa434fca4b04fad33b76db825ad9303580d997c8a58c8184fa19
-  data.tar.gz: 2d89ac0871af10c498ebfc23d2bc73c7644923fe14e8e2de2005c3195ff9ad995848e22e496da5f632e165a674b07bcf604b94cec14e5a808923a6c67c23d3d6
+  metadata.gz: 87e1e28bd9dcf2ee316cbc839d00133d12d0098759f0fdb5e19ccf7ebaecf7299b9b4edf5afaa8fc65dc239fa875747f8e0e28904a66548d52d35c08d4948cbe
+  data.tar.gz: e20bfdf5cb10e26ba2cc9eae12184fa23ca9934980b5b31c96efa35a4f4a09d9d99f32437e393789fc315a6d36f9163dae65a970100646f88b00760f061d0483

data/README.md

@@ -31,23 +31,58 @@ 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:
+```bash
+rake build -- --with-mysql-lib="/path/with spaces/lib"
+```
+
+### Type Casting
+
+RakeOptions automatically casts values to the specified type:
+
+```ruby
+config = [
+  ["port", :integer],
+  ["enabled", :boolean],
+  ["ratio", :float],
+  ["name", :string]
+]
+
+options = RakeOptions.command_line_args(config)
+
+# Values are automatically cast:
+options['port']     # => 3000 (Integer)
+options['enabled']  # => true (Boolean)
+options['ratio']    # => 1.5 (Float)
+options['name']     # => "myapp" (String)
+```
+
+Supported types:
+- `:string` - String values (default)
+- `:integer` or `:int` - Integer values
+- `:float` - Float values
+- `:boolean` or `:bool` - Boolean values (true/false)
+
 ### Bracket-Style Arguments
 
 ```ruby
@@ -55,10 +90,10 @@ require 'rake_options'
 
 desc "Deploy with bracket notation"
 task :deploy do
-  config = {
-    "environment" => "[environment=$env]",
-    "region" => "[region=$region]"
-  }
+  config = [
+    ["environment", :string],
+    ["region", :string]
+  ]
   
   options = RakeOptions.command_line_args(config, notation: :bracket)
   
@@ -71,17 +106,6 @@ Run with:
 rake deploy [environment=production] [region=us-west-2]
 ```
 
-### Multiple Variables in One Template
-
-```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
 
 ```ruby
@@ -91,18 +115,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
@@ -128,29 +154,32 @@ 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
@@ -162,8 +191,8 @@ options = RakeOptions.command_line_args(config, notation: :cli)
 ```
 
 Supports:
-- `--flag value`
-- `--flag "value with spaces"`
+- `--flag=value`
+- `--flag="value with spaces"`
 - Multiple flags in one command
 
 ### Bracket Notation
@@ -228,20 +257,20 @@ rake task -- --help
 
 **Solution**: Use quotes around values with spaces:
 ```bash
-rake task -- --path "/path/with spaces"
+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
-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/template_engine.rb

@@ -57,12 +57,15 @@ module RakeOptions
     # @return [Regexp] Regex pattern for matching
     def self.build_pattern(template, variables)
       # Replace $variables with capture groups that match:
-      # - Quoted strings: "value with spaces"
-      # - Unquoted values: value (non-whitespace)
-      pattern_str = template.gsub(/\$\w+/, '(?:"([^"]+)"|(\S+))')
+      # - Values after = sign: --flag=value
+      # Pattern matches: --flag=value or --flag="value with spaces"
       
-      # Escape special regex characters except our capture groups
-      pattern_str = pattern_str.gsub(/\s+/, '\s+')
+      # First, escape the template
+      pattern_str = Regexp.escape(template)
+      
+      # Then replace escaped $variable patterns with our capture group
+      # The pattern after escaping looks like: \$variable
+      pattern_str = pattern_str.gsub(/\\ \\\$\w+/, '=(?:"([^"]+)"|([^\s]+))')
       
       Regexp.new(pattern_str)
     end

data/lib/rake_options/version.rb

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

data/spec/integration/rake_options_integration_spec.rb

@@ -5,25 +5,25 @@ 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"])
+      stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib", "--enable-feature=caching", "--port=3000"])
       
       result = RakeOptions.command_line_args(config, notation: :cli)
       
       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"])
+      stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
       
       result = RakeOptions.command_line_args(config, notation: :cli)
       
@@ -33,7 +33,7 @@ RSpec.describe "RakeOptions Integration Tests" do
     end
 
     it "supports quoted values with spaces" do
-      stub_const("ARGV", ["--with-mysql-lib", '"/path/with spaces/lib"'])
+      stub_const("ARGV", ['--with-mysql-lib="/path/with spaces/lib"'])
       
       result = RakeOptions.command_line_args(config, notation: :cli)
       
@@ -41,7 +41,7 @@ RSpec.describe "RakeOptions Integration Tests" do
     end
 
     it "allows symbol key access" do
-      stub_const("ARGV", ["--with-mysql-lib", "/usr/local/lib"])
+      stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
       
       result = RakeOptions.command_line_args(config, notation: :cli)
       
@@ -134,20 +134,18 @@ 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)
       
-      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
 
@@ -161,7 +159,7 @@ RSpec.describe "RakeOptions Integration Tests" do
     end
 
     it "ignores unrecognized arguments" do
-      stub_const("ARGV", ["--unknown-flag", "value", "--verbose", "info"])
+      stub_const("ARGV", ["--unknown-flag=value", "--verbose=info"])
       
       result = RakeOptions.command_line_args(config, notation: :cli)
       
@@ -172,20 +170,18 @@ RSpec.describe "RakeOptions Integration Tests" do
 
   describe "Error scenarios" do
     let(:config) do
-      {
-        "option" => "--option $value"
-      }
+      [["option", :string]]
     end
 
     it "raises InvalidNotationError for unsupported notation" do
-      stub_const("ARGV", ["--option", "value"])
+      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"])
+      stub_const("ARGV", ["--option=value"])
       
       expect { RakeOptions.command_line_args(config, notation: :xml) }
         .to raise_error(RakeOptions::InvalidNotationError, /:cli, :bracket/)
@@ -195,16 +191,16 @@ RSpec.describe "RakeOptions Integration Tests" do
   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,18 +213,18 @@ 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",
-          "--prefix", "/opt/myapp"
+          "--with-mysql=/usr/local/mysql/lib",
+          "--with-ssl=/usr/local/ssl/lib",
+          "--prefix=/opt/myapp"
         ])
         
         result = RakeOptions.command_line_args(build_config)

data/spec/rake_options/cli_parser_spec.rb

@@ -7,14 +7,12 @@ 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) }
 
       it "parses single flag with value" do
-        argv = ["--with-mysql-lib", "/usr/local/mysql/lib"]
+        argv = ["--with-mysql-lib=/usr/local/mysql/lib"]
         result = parser.parse(argv)
         
         expect(result["with-mysql-lib"]).to eq("/usr/local/mysql/lib")
@@ -30,15 +28,12 @@ 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) }
 
       it "parses multiple flags in one invocation" do
-        argv = ["--with-mysql-lib", "/usr/local/lib", "--enable-feature", "caching"]
+        argv = ["--with-mysql-lib=/usr/local/lib", "--enable-feature=caching"]
         result = parser.parse(argv)
         
         expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
@@ -46,7 +41,7 @@ RSpec.describe RakeOptions::CLIParser do
       end
 
       it "handles partial arguments" do
-        argv = ["--with-mysql-lib", "/usr/local/lib"]
+        argv = ["--with-mysql-lib=/usr/local/lib"]
         result = parser.parse(argv)
         
         expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
@@ -56,14 +51,12 @@ 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) }
 
       it "handles quoted values with spaces" do
-        argv = ["--message", '"Hello World"']
+        argv = ['--message="Hello World"']
         result = parser.parse(argv)
         
         expect(result["message"]).to eq("Hello World")
@@ -72,14 +65,12 @@ 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) }
 
       it "ignores unknown flags without raising errors" do
-        argv = ["--unknown-flag", "value", "--known-flag", "test"]
+        argv = ["--unknown-flag=value", "--known-flag=test"]
         
         expect { parser.parse(argv) }.not_to raise_error
         result = parser.parse(argv)
@@ -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/template_engine_spec.rb

@@ -41,17 +41,17 @@ RSpec.describe RakeOptions::TemplateEngine do
       let(:parsed_template) { described_class.parse_template("--with-mysql-lib $path") }
 
       it "extracts value from matching input" do
-        input = ["--with-mysql-lib", "/usr/local/mysql/lib"]
+        input = ["--with-mysql-lib=/usr/local/mysql/lib"]
         result = described_class.extract_values(input, parsed_template)
         
         expect(result).to eq({ "path" => "/usr/local/mysql/lib" })
       end
 
       it "extracts quoted value with spaces" do
-        input = ["--with-mysql-lib", '"path with spaces"']
+        input = ['--with-mysql-lib="path with spaces"']
         result = described_class.extract_values(input, parsed_template)
         
-        expect(result["path"]).to include("path")
+        expect(result["path"]).to eq("path with spaces")
       end
 
       it "returns nil for non-matching input" do
@@ -66,7 +66,7 @@ RSpec.describe RakeOptions::TemplateEngine do
       let(:parsed_template) { described_class.parse_template("--config $file --env $environment") }
 
       it "extracts multiple values from matching input" do
-        input = ["--config", "database.yml", "--env", "production"]
+        input = ["--config=database.yml", "--env=production"]
         result = described_class.extract_values(input, parsed_template)
         
         expect(result["file"]).to eq("database.yml")
@@ -98,7 +98,7 @@ RSpec.describe RakeOptions::TemplateEngine do
       pattern = described_class.send(:build_pattern, "--with-mysql-lib $path", variables)
       
       expect(pattern).to be_a(Regexp)
-      expect("--with-mysql-lib /usr/local/lib").to match(pattern)
+      expect("--with-mysql-lib=/usr/local/lib").to match(pattern)
     end
 
     it "creates pattern for multiple variables" do
@@ -106,7 +106,7 @@ RSpec.describe RakeOptions::TemplateEngine do
       pattern = described_class.send(:build_pattern, "--config $file --env $env", variables)
       
       expect(pattern).to be_a(Regexp)
-      expect("--config db.yml --env prod").to match(pattern)
+      expect("--config=db.yml --env=prod").to match(pattern)
     end
   end
 end

data/spec/rake_options_spec.rb

@@ -4,23 +4,20 @@ 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
       it "parses CLI-style arguments" do
-        stub_const("ARGV", ["--with-mysql-lib", "/usr/local/lib"])
+        stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
         result = described_class.command_line_args(config, notation: :cli)
         
         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"])
+        stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
         result = described_class.command_line_args(config, notation: :cli)
         
         expect(result[:with_mysql_lib]).to eq("/usr/local/lib")
@@ -38,7 +35,7 @@ RSpec.describe RakeOptions do
 
     context "with default notation" do
       it "defaults to CLI notation" do
-        stub_const("ARGV", ["--with-mysql-lib", "/usr/local/lib"])
+        stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
         result = described_class.command_line_args(config)
         
         expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
@@ -57,7 +54,7 @@ RSpec.describe RakeOptions do
 
     context "return value" do
       it "returns HashWithIndifferentAccess" do
-        stub_const("ARGV", ["--with-mysql-lib", "/usr/local/lib"])
+        stub_const("ARGV", ["--with-mysql-lib=/usr/local/lib"])
         result = described_class.command_line_args(config)
         
         expect(result).to be_a(RakeOptions::HashWithIndifferentAccess)
@@ -66,6 +63,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 +79,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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rake_options
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Randy Villanueva