rake_options 0.1.0

data/spec/integration/rake_options_integration_spec.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+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"
+      }
+    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)
+      
+      expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
+      expect(result["enable-feature"]).to eq("caching")
+      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)
+      
+      expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
+      expect(result["enable-feature"]).to be_nil
+      expect(result["port"]).to be_nil
+    end
+
+    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)
+      
+      expect(result["with-mysql-lib"]).to eq("/path/with spaces/lib")
+    end
+
+    it "allows symbol key access" do
+      stub_const("ARGV", ["--with-mysql-lib", "/usr/local/lib"])
+      
+      result = RakeOptions.command_line_args(config, notation: :cli)
+      
+      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
+      {
+        "option1" => "--option1 $value",
+        "option2" => "--option2 $value"
+      }
+    end
+
+    context "with custom README" do
+      before do
+        RakeOptions.initialize_readme("Custom Help Documentation\n\nUsage: rake task [options]")
+      end
+
+      it "displays custom README and exits" do
+        stub_const("ARGV", ["--help"])
+        
+        expect { RakeOptions.command_line_args(config) }
+          .to output(/Custom Help Documentation/).to_stdout
+          .and raise_error(SystemExit) { |error| expect(error.status).to eq(0) }
+      end
+    end
+
+    context "with auto-generated help" do
+      before do
+        RakeOptions.readme_content = nil
+      end
+
+      it "displays auto-generated help and exits" do
+        stub_const("ARGV", ["--help"])
+        
+        expect { RakeOptions.command_line_args(config) }
+          .to output(/Available Options/).to_stdout
+          .and raise_error(SystemExit) { |error| expect(error.status).to eq(0) }
+      end
+
+      it "includes all configured options in help" do
+        stub_const("ARGV", ["--help"])
+        
+        expect { RakeOptions.command_line_args(config) }
+          .to output(/--option1/).to_stdout
+          .and raise_error(SystemExit)
+      end
+    end
+  end
+
+  describe "Mixed scenarios" do
+    let(:config) do
+      {
+        "database" => "--config $file --env $environment",
+        "verbose" => "--verbose $level"
+      }
+    end
+
+    it "handles templates with multiple variables" do
+      stub_const("ARGV", ["--config", "database.yml", "--env", "production", "--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["verbose"]).to eq("debug")
+    end
+
+    it "handles empty ARGV" do
+      stub_const("ARGV", [])
+      
+      result = RakeOptions.command_line_args(config, notation: :cli)
+      
+      expect(result["database"]).to be_nil
+      expect(result["verbose"]).to be_nil
+    end
+
+    it "ignores unrecognized arguments" do
+      stub_const("ARGV", ["--unknown-flag", "value", "--verbose", "info"])
+      
+      result = RakeOptions.command_line_args(config, notation: :cli)
+      
+      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"
+        }
+      end
+
+      it "handles typical deployment command" do
+        stub_const("ARGV", ["--env", "production", "--region", "us-east-1", "--version", "v1.2.3"])
+        
+        result = RakeOptions.command_line_args(deploy_config)
+        
+        expect(result[:environment]).to eq("production")
+        expect(result[:region]).to eq("us-east-1")
+        expect(result[:version]).to eq("v1.2.3")
+        expect(result[:dry_run]).to be_nil
+      end
+    end
+
+    context "build task" do
+      let(:build_config) do
+        {
+          "with-mysql" => "--with-mysql-lib $path",
+          "with-ssl" => "--with-ssl-lib $path",
+          "prefix" => "--prefix $path"
+        }
+      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"
+        ])
+        
+        result = RakeOptions.command_line_args(build_config)
+        
+        expect(result["with-mysql"]).to eq("/usr/local/mysql/lib")
+        expect(result["with-ssl"]).to eq("/usr/local/ssl/lib")
+        expect(result["prefix"]).to eq("/opt/myapp")
+      end
+    end
+  end
+end

data/spec/rake_options/argument_parser_spec.rb

@@ -0,0 +1,71 @@
+# 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

@@ -0,0 +1,86 @@
+# 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

data/spec/rake_options/cli_parser_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "rake_options/cli_parser"
+
+RSpec.describe RakeOptions::CLIParser do
+  describe "#parse" do
+    context "with single flag" do
+      let(:config) do
+        {
+          "with-mysql-lib" => "--with-mysql-lib $path"
+        }
+      end
+      let(:parser) { described_class.new(config) }
+
+      it "parses single flag with value" do
+        argv = ["--with-mysql-lib", "/usr/local/mysql/lib"]
+        result = parser.parse(argv)
+        
+        expect(result["with-mysql-lib"]).to eq("/usr/local/mysql/lib")
+      end
+
+      it "returns nil for missing argument" do
+        argv = []
+        result = parser.parse(argv)
+        
+        expect(result["with-mysql-lib"]).to be_nil
+      end
+    end
+
+    context "with multiple flags" do
+      let(:config) do
+        {
+          "with-mysql-lib" => "--with-mysql-lib $path",
+          "enable-feature" => "--enable-feature $name"
+        }
+      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"]
+        result = parser.parse(argv)
+        
+        expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
+        expect(result["enable-feature"]).to eq("caching")
+      end
+
+      it "handles partial arguments" do
+        argv = ["--with-mysql-lib", "/usr/local/lib"]
+        result = parser.parse(argv)
+        
+        expect(result["with-mysql-lib"]).to eq("/usr/local/lib")
+        expect(result["enable-feature"]).to be_nil
+      end
+    end
+
+    context "with quoted values" do
+      let(:config) do
+        {
+          "message" => "--message $text"
+        }
+      end
+      let(:parser) { described_class.new(config) }
+
+      it "handles quoted values with spaces" do
+        argv = ["--message", '"Hello World"']
+        result = parser.parse(argv)
+        
+        expect(result["message"]).to eq("Hello World")
+      end
+    end
+
+    context "with unknown flags" do
+      let(:config) do
+        {
+          "known-flag" => "--known-flag $value"
+        }
+      end
+      let(:parser) { described_class.new(config) }
+
+      it "ignores unknown flags without raising errors" do
+        argv = ["--unknown-flag", "value", "--known-flag", "test"]
+        
+        expect { parser.parse(argv) }.not_to raise_error
+        result = parser.parse(argv)
+        expect(result["known-flag"]).to eq("test")
+      end
+    end
+
+    context "with multiple variables in template" do
+      let(:config) do
+        {
+          "database" => "--config $file --env $environment"
+        }
+      end
+      let(:parser) { described_class.new(config) }
+
+      it "extracts multiple variables" do
+        argv = ["--config", "database.yml", "--env", "production"]
+        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")
+      end
+    end
+  end
+end

data/spec/rake_options/help_generator_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+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"
+      }
+    end
+
+    context "with custom README" do
+      let(:readme) { "Custom Help Text\n\nUsage instructions here" }
+      let(:generator) { described_class.new(config, readme) }
+
+      it "displays custom README content" do
+        expect { generator.display_and_exit }.to output(/Custom Help Text/).to_stdout.and raise_error(SystemExit)
+      end
+    end
+
+    context "without custom README" do
+      let(:generator) { described_class.new(config) }
+
+      it "auto-generates help from config" do
+        expect { generator.display_and_exit }.to output(/Available Options/).to_stdout.and raise_error(SystemExit)
+      end
+
+      it "includes all configured options" do
+        expect { generator.display_and_exit }.to output(/--with-mysql-lib/).to_stdout.and raise_error(SystemExit)
+      end
+    end
+
+    context "exit behavior" do
+      let(:generator) { described_class.new(config) }
+
+      it "exits with status 0" do
+        expect { generator.display_and_exit }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(0)
+        end
+      end
+    end
+  end
+
+  describe "#generate_help_text" do
+    let(:config) do
+      {
+        "option1" => "--option1 $value",
+        "option2" => "--option2 $value"
+      }
+    end
+
+    context "with custom README" do
+      let(:readme) { "My Custom Help" }
+      let(:generator) { described_class.new(config, readme) }
+
+      it "returns custom README" do
+        help_text = generator.send(:generate_help_text)
+        expect(help_text).to eq("My Custom Help")
+      end
+    end
+
+    context "without custom README" do
+      let(:generator) { described_class.new(config) }
+
+      it "generates help from config" do
+        help_text = generator.send(:generate_help_text)
+        expect(help_text).to include("Available Options")
+        expect(help_text).to include("--option1")
+        expect(help_text).to include("--option2")
+      end
+    end
+  end
+
+  describe "#format_option" do
+    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")
+    end
+  end
+end