rake_options 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb24381876d415a7632d456afd8cace19474689f511ec98df623e65967ab1fe1
-  data.tar.gz: 22e3ef52a8f49fc4287a5f5b89ce302a7df74103aca8debcda6a0175452bc3f0
+  metadata.gz: c23f2f501224d1849ee5255aafb6f023e12f6bacdeacdcd2a4909eb711e73adb
+  data.tar.gz: eaaa2f161b92704669317004e64dfee3267f4473095a561be9b8c71354d6362e
 SHA512:
-  metadata.gz: 87e1e28bd9dcf2ee316cbc839d00133d12d0098759f0fdb5e19ccf7ebaecf7299b9b4edf5afaa8fc65dc239fa875747f8e0e28904a66548d52d35c08d4948cbe
-  data.tar.gz: e20bfdf5cb10e26ba2cc9eae12184fa23ca9934980b5b31c96efa35a4f4a09d9d99f32437e393789fc315a6d36f9163dae65a970100646f88b00760f061d0483
+  metadata.gz: b507cb81d6ae6518115b35ce028779d7dbccbdebac5d328970ff2935269cf4d46041bc45927333d39efe897ede7646087873401095295635853e0d6e1a542560
+  data.tar.gz: 54a8901e28628730a2a15c8a2b53a06a89bdc0e1c621aa437dcef36890f4ee6f8c7cff07c32b3d299a6ce42360137661266426d1323995caa001fdd17052a67a

data/README.md

@@ -83,28 +83,7 @@ Supported types:
 - `:float` - Float values
 - `:boolean` or `:bool` - Boolean values (true/false)
 
-### Bracket-Style Arguments
 
-```ruby
-require 'rake_options'
-
-desc "Deploy with bracket notation"
-task :deploy do
-  config = [
-    ["environment", :string],
-    ["region", :string]
-  ]
-  
-  options = RakeOptions.command_line_args(config, notation: :bracket)
-  
-  puts "Deploying to #{options['environment']} in #{options['region']}"
-end
-```
-
-Run with:
-```bash
-rake deploy [environment=production] [region=us-west-2]
-```
 
 ### Automatic Help Documentation
 
@@ -182,12 +161,12 @@ The configuration is a simple array of tuples:
 ["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:
@@ -195,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:

data/lib/rake_options/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RakeOptions
-  VERSION = "0.1.2"
+  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

@@ -15,7 +15,7 @@ RSpec.describe "RakeOptions Integration Tests" do
     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")
@@ -25,7 +25,7 @@ RSpec.describe "RakeOptions Integration Tests" do
     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
       {
@@ -143,7 +106,7 @@ RSpec.describe "RakeOptions Integration Tests" do
     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 eq("mydb")
       expect(result["verbose"]).to eq("debug")
@@ -152,7 +115,7 @@ RSpec.describe "RakeOptions Integration Tests" do
     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
@@ -161,32 +124,14 @@ 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", :string]]
-    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

data/spec/rake_options_spec.rb

@@ -8,37 +8,27 @@ RSpec.describe RakeOptions do
   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
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rake_options
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  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