mint 0.8.0 → 0.10.0

data/spec/cli/configuration_management_spec.rb

@@ -1,363 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "CLI Configuration Management" do
-  describe "configuration operations" do
-    context "in isolated environment" do
-      around(:each) do |example|
-        in_temp_dir do |dir|
-          @test_dir = dir
-          example.run
-        end
-      end
-
-      describe "Mint::CommandLine.set" do
-        it "sets configuration values at local scope" do
-          expect {
-            Mint::CommandLine.set("layout", "custom", :local)
-          }.not_to raise_error
-          
-          expect(File.exist?(".mint/config.yaml")).to be true
-          config = YAML.load_file(".mint/config.yaml")
-          expect(config["layout"]).to eq("custom")
-        end
-
-        it "sets configuration values at different scopes" do
-          # Test local scope (should work)
-          Mint::CommandLine.set("layout", "local-template", :local)
-          expect(File.exist?(".mint/config.yaml")).to be true
-          
-          local_config = YAML.load_file(".mint/config.yaml")
-          expect(local_config["layout"]).to eq("local-template")
-          
-          # For user/global scopes, we'd test the path construction 
-          # but can't actually write to those locations in tests
-        end
-
-        it "creates config directory if it doesn't exist" do
-          expect(File.exist?(".mint")).to be false
-          
-          Mint::CommandLine.set("style", "minimal", :local)
-          
-          expect(File.exist?(".mint")).to be true
-          expect(File.directory?(".mint")).to be true
-          expect(File.exist?(".mint/config.yaml")).to be true
-        end
-
-        it "updates existing configuration values" do
-          # Set initial value
-          Mint::CommandLine.set("layout", "initial", :local)
-          initial_config = YAML.load_file(".mint/config.yaml")
-          expect(initial_config["layout"]).to eq("initial")
-          
-          # Update value
-          Mint::CommandLine.set("layout", "updated", :local)
-          updated_config = YAML.load_file(".mint/config.yaml")
-          expect(updated_config["layout"]).to eq("updated")
-        end
-
-        it "preserves other configuration values" do
-          # Set multiple values
-          Mint::CommandLine.set("layout", "my-layout", :local)
-          Mint::CommandLine.set("style", "my-style", :local)
-          Mint::CommandLine.set("destination", "output", :local)
-          
-          config = YAML.load_file(".mint/config.yaml")
-          expect(config["layout"]).to eq("my-layout")
-          expect(config["style"]).to eq("my-style")
-          expect(config["destination"]).to eq("output")
-          
-          # Update one value
-          Mint::CommandLine.set("layout", "new-layout", :local)
-          
-          updated_config = YAML.load_file(".mint/config.yaml")
-          expect(updated_config["layout"]).to eq("new-layout")
-          expect(updated_config["style"]).to eq("my-style") # preserved
-          expect(updated_config["destination"]).to eq("output") # preserved
-        end
-
-        it "handles various data types" do
-          Mint::CommandLine.set("string_value", "text", :local)
-          Mint::CommandLine.set("boolean_value", true, :local)
-          Mint::CommandLine.set("number_value", 42, :local)
-          Mint::CommandLine.set("nil_value", nil, :local)
-          
-          config = YAML.load_file(".mint/config.yaml")
-          expect(config["string_value"]).to eq("text")
-          expect(config["boolean_value"]).to be true
-          expect(config["number_value"]).to eq(42)
-          expect(config["nil_value"]).to be_nil
-        end
-
-        it "defaults to local scope" do
-          Mint::CommandLine.set("test_key", "test_value") # no scope specified
-          
-          expect(File.exist?(".mint/config.yaml")).to be true
-          config = YAML.load_file(".mint/config.yaml")
-          expect(config["test_key"]).to eq("test_value")
-        end
-      end
-
-      describe "Mint::CommandLine.configure" do
-        it "sets multiple configuration options at once" do
-          options = {
-            "layout" => "custom",
-            "style" => "minimal", 
-            "destination" => "build",
-            "verbose" => true
-          }
-          
-          expect {
-            Mint::CommandLine.configure(options, :local)
-          }.not_to raise_error
-          
-          config = YAML.load_file(".mint/config.yaml")
-          expect(config["layout"]).to eq("custom")
-          expect(config["style"]).to eq("minimal")
-          expect(config["destination"]).to eq("build")
-          expect(config["verbose"]).to be true
-        end
-
-        it "merges with existing configuration" do
-          # Set initial config
-          initial_options = {
-            "layout" => "default",
-            "style" => "default",
-            "author" => "Test Author"
-          }
-          Mint::CommandLine.configure(initial_options, :local)
-          
-          # Add more options
-          additional_options = {
-            "layout" => "updated", # should override
-            "destination" => "output", # should add
-            "verbose" => true # should add
-          }
-          Mint::CommandLine.configure(additional_options, :local)
-          
-          config = YAML.load_file(".mint/config.yaml")
-          expect(config["layout"]).to eq("updated") # overridden
-          expect(config["style"]).to eq("default") # preserved
-          expect(config["author"]).to eq("Test Author") # preserved
-          expect(config["destination"]).to eq("output") # added
-          expect(config["verbose"]).to be true # added
-        end
-
-        it "handles empty options" do
-          expect {
-            Mint::CommandLine.configure({}, :local)
-          }.not_to raise_error
-          
-          # Should create an empty config file
-          expect(File.exist?(".mint/config.yaml")).to be true
-        end
-
-        it "handles symbol keys" do
-          options = {
-            layout: "symbol-layout",
-            style: "symbol-style"
-          }
-          
-          Mint::CommandLine.configure(options, :local)
-          
-          config = YAML.load_file(".mint/config.yaml")
-          # Symbol keys remain as symbols in YAML
-          expect(config[:layout]).to eq("symbol-layout")
-          expect(config[:style]).to eq("symbol-style")
-        end
-      end
-
-      describe "Mint::CommandLine.config" do
-        it "displays current configuration" do
-          # Set up some configuration
-          Mint::CommandLine.set("layout", "test-layout", :local)
-          Mint::CommandLine.set("style", "test-style", :local)
-          
-          stdout, stderr = capture_output do
-            Mint::CommandLine.config
-          end
-          
-          expect(stdout).to include("layout")
-          expect(stdout).to include("test-layout")
-          expect(stdout).to include("style") 
-          expect(stdout).to include("test-style")
-        end
-
-        it "shows empty configuration when none exists" do
-          stdout, stderr = capture_output do
-            Mint::CommandLine.config
-          end
-          
-          # Should show default configuration or empty YAML
-          expect(stdout).to include("---") # YAML document start
-        end
-
-        it "merges configuration from multiple scopes" do
-          # This is more complex to test since we can't easily create
-          # user/global configs, but we can test the concept
-          setup_basic_config(:local)
-          
-          stdout, stderr = capture_output do
-            Mint::CommandLine.config
-          end
-          
-          expect(stdout).to include("layout")
-          expect(stdout).to include("default")
-        end
-      end
-
-      describe "configuration precedence and merging" do
-        describe "Mint.configuration" do
-          it "provides default configuration when no files exist" do
-            config = Mint.configuration
-            
-            expect(config).to be_a(Hash)
-            expect(config[:layout_or_style_or_template]).to eq([:template, "default"])
-          end
-
-          it "merges local configuration with defaults" do
-            Mint::CommandLine.set("layout", "custom", :local)
-            Mint::CommandLine.set("author", "Test Author", :local)
-            
-            config = Mint.configuration
-            
-            expect(config[:layout]).to eq("custom") # from local config
-            expect(config[:layout_or_style_or_template]).to eq([:template, "default"]) # from defaults
-            expect(config[:author]).to eq("Test Author") # from local config
-          end
-        end
-
-        describe "Mint.configuration_with" do
-          it "merges additional options with configuration" do
-            Mint::CommandLine.set("layout", "from-config", :local)
-            
-            config = Mint.configuration_with({
-              style: "from-options",
-              destination: "custom-dest"
-            })
-            
-            expect(config[:layout]).to eq("from-config") # from config file
-            expect(config[:style]).to eq("from-options") # from options
-            expect(config[:destination]).to eq("custom-dest") # from options
-          end
-
-          it "allows options to override configuration" do
-            Mint::CommandLine.set("layout", "config-layout", :local)
-            Mint::CommandLine.set("style", "config-style", :local)
-            
-            config = Mint.configuration_with({
-              layout: "override-layout" # should override config
-            })
-            
-            expect(config[:layout]).to eq("override-layout") # overridden
-            expect(config[:style]).to eq("config-style") # preserved
-          end
-
-          it "handles scope-specific configuration" do
-            # Test that scope flags affect which configs are loaded
-            # This is more complex but important for the new scope system
-            setup_basic_config(:local)
-            
-            # Test with different scope selections
-            config_local = Mint.configuration_with({ scope: :local })
-            config_with_defaults = Mint.configuration_with({})
-            
-            expect(config_local).to include(:layout)
-            expect(config_with_defaults).to include(:layout)
-          end
-        end
-      end
-
-      describe "configuration file handling" do
-        it "creates valid YAML files" do
-          Mint::CommandLine.set("test", "value", :local)
-          
-          expect(File.exist?(".mint/config.yaml")).to be true
-          
-          # Should be parseable YAML
-          expect {
-            YAML.load_file(".mint/config.yaml")
-          }.not_to raise_error
-        end
-
-        it "handles special characters in values" do
-          special_values = {
-            "quotes" => 'Value with "quotes"',
-            "newlines" => "Line 1\nLine 2",
-            "unicode" => "Unicode: 中文 🚀",
-            "symbols" => "Symbols: @#$%^&*()"
-          }
-          
-          special_values.each do |key, value|
-            Mint::CommandLine.set(key, value, :local)
-          end
-          
-          config = YAML.load_file(".mint/config.yaml")
-          special_values.each do |key, expected_value|
-            expect(config[key]).to eq(expected_value)
-          end
-        end
-
-        it "handles concurrent access gracefully" do
-          # This is difficult to test properly, but we can at least
-          # verify that multiple rapid operations don't corrupt the file
-          10.times do |i|
-            Mint::CommandLine.set("key#{i}", "value#{i}", :local)
-          end
-          
-          config = YAML.load_file(".mint/config.yaml")
-          10.times do |i|
-            expect(config["key#{i}"]).to eq("value#{i}")
-          end
-        end
-
-        it "preserves file permissions" do
-          Mint::CommandLine.set("test", "value", :local)
-          
-          file_stat = File.stat(".mint/config.yaml")
-          original_mode = file_stat.mode
-          
-          Mint::CommandLine.set("test2", "value2", :local)
-          
-          new_file_stat = File.stat(".mint/config.yaml")
-          expect(new_file_stat.mode).to eq(original_mode)
-        end
-      end
-
-      describe "error handling" do
-        it "handles invalid YAML gracefully" do
-          # Create an invalid YAML file
-          FileUtils.mkdir_p(".mint")
-          File.write(".mint/config.yaml", "invalid: yaml: content: [unclosed")
-          
-          expect {
-            Mint.configuration
-          }.not_to raise_error # Should handle gracefully
-        end
-
-        it "handles permission errors" do
-          # Create config directory but make it read-only
-          FileUtils.mkdir_p(".mint")
-          File.chmod(0444, ".mint")
-          
-          begin
-            expect {
-              Mint::CommandLine.set("test", "value", :local)
-            }.to raise_error(Errno::EACCES) # Should fail due to permissions
-          ensure
-            # Restore permissions for cleanup
-            File.chmod(0755, ".mint")
-          end
-        end
-
-        it "handles missing parent directories" do
-          # This should work - the set method should create directories
-          expect {
-            Mint::CommandLine.set("test", "value", :local)
-          }.not_to raise_error
-          
-          expect(File.exist?(".mint/config.yaml")).to be true
-        end
-      end
-    end
-  end
-end

data/spec/cli/template_management_spec.rb

@@ -1,300 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "CLI Template Management" do
-  describe "template operations" do
-    context "in isolated environment" do
-      around(:each) do |example|
-        in_temp_dir do |dir|
-          @test_dir = dir
-          example.run
-        end
-      end
-
-      describe "Mint::CommandLine.templates" do
-        it "lists templates from specified scope" do
-          create_template_directory("custom")
-          create_template_directory("minimal")
-          
-          stdout, stderr = capture_output do
-            Mint::CommandLine.templates("", :local)
-          end
-          
-          expect(stdout).to include("custom")
-          expect(stdout).to include("minimal")
-        end
-
-        it "filters templates by pattern" do
-          create_template_directory("custom-dark")
-          create_template_directory("custom-light") 
-          create_template_directory("minimal")
-          
-          stdout, stderr = capture_output do
-            Mint::CommandLine.templates("custom", :local)
-          end
-          
-          expect(stdout).to include("custom-dark")
-          expect(stdout).to include("custom-light")
-          expect(stdout).not_to include("minimal")
-        end
-
-        it "shows template paths in output" do
-          create_template_directory("test-template")
-          
-          stdout, stderr = capture_output do
-            Mint::CommandLine.templates("", :local)
-          end
-          
-          expect(stdout).to include("test-template")
-          expect(stdout).to include(".mint/templates/test-template")
-        end
-
-        it "handles empty template directory" do
-          stdout, stderr = capture_output do
-            Mint::CommandLine.templates("", :local)
-          end
-          
-          expect(stdout.strip).to eq("")
-        end
-      end
-
-      describe "Mint::CommandLine.install" do
-        it "installs a layout template file" do
-          layout_content = "<html><body><%= yield %></body></html>"
-          create_template_file("custom.erb", :layout, layout_content)
-          
-          expect {
-            Mint::CommandLine.install("custom.erb", "mytemplate", :local)
-          }.not_to raise_error
-          
-          installed_file = ".mint/templates/mytemplate/layout.erb"
-          expect(File.exist?(installed_file)).to be true
-          expect(File.read(installed_file)).to eq(layout_content)
-        end
-
-        it "installs a style template file" do
-          style_content = "body { background: #f0f0f0; }"
-          create_template_file("custom.css", :style, style_content)
-          
-          expect {
-            Mint::CommandLine.install("custom.css", "mystyle", :local)  
-          }.not_to raise_error
-          
-          installed_file = ".mint/templates/mystyle/style.css"
-          expect(File.exist?(installed_file)).to be true
-          expect(File.read(installed_file)).to eq(style_content)
-        end
-
-        it "creates template directory if it doesn't exist" do
-          create_template_file("layout.erb", :layout)
-          
-          expect(File.exist?(".mint/templates/newtemplate")).to be false
-          
-          Mint::CommandLine.install("layout.erb", "newtemplate", :local)
-          
-          expect(File.exist?(".mint/templates/newtemplate")).to be true
-          expect(File.exist?(".mint/templates/newtemplate/layout.erb")).to be true
-        end
-
-        it "determines template type by file extension" do
-          # Create different file types
-          File.write("layout.haml", "%html\n  %body= yield")
-          File.write("style.scss", "$primary: #333;\nbody { color: $primary; }")
-          
-          Mint::CommandLine.install("layout.haml", "haml-template", :local)
-          Mint::CommandLine.install("style.scss", "scss-template", :local)
-          
-          expect(File.exist?(".mint/templates/haml-template/layout.haml")).to be true
-          expect(File.exist?(".mint/templates/scss-template/style.scss")).to be true
-        end
-
-        it "raises error for non-existent source file" do
-          expect {
-            Mint::CommandLine.install("nonexistent.erb", "test", :local)
-          }.to raise_error(RuntimeError, /No such file/)
-        end
-
-      end
-
-      describe "Mint::CommandLine.uninstall" do
-        it "removes an entire template directory" do
-          create_template_directory("removeme", with_layout: true, with_style: true)
-          
-          expect(File.exist?(".mint/templates/removeme")).to be true
-          
-          Mint::CommandLine.uninstall("removeme", :local)
-          
-          expect(File.exist?(".mint/templates/removeme")).to be false
-        end
-
-        it "handles non-existent templates gracefully" do
-          expect {
-            Mint::CommandLine.uninstall("nonexistent", :local)
-          }.to raise_error(Errno::ENOENT)
-        end
-      end
-
-      describe "Mint::CommandLine.edit" do
-        it "opens layout template in editor" do
-          create_template_directory("editable", with_layout: true)
-          template_file = ".mint/templates/editable/layout.erb"
-          
-          silence_output do
-            mock_editor do
-              expect {
-                Mint::CommandLine.edit("editable", :layout, :local)
-              }.not_to raise_error
-            end
-          end
-        end
-
-        it "opens style template in editor" do
-          create_template_directory("editable", with_style: true)
-          
-          silence_output do
-            mock_editor do
-              expect {
-                Mint::CommandLine.edit("editable", :style, :local)
-              }.not_to raise_error
-            end
-          end
-        end
-
-        it "prompts to create template if it doesn't exist" do
-          # Mock STDIN to simulate user input
-          allow(STDIN).to receive(:gets).and_return("y\n")
-          
-          silence_output do
-            mock_editor do
-              expect {
-                Mint::CommandLine.edit("newtemplate", :layout, :local)
-              }.not_to raise_error
-            end
-          end
-          
-          expect(File.exist?(".mint/templates/newtemplate/layout.erb")).to be true
-        end
-
-        it "cancels creation when user says no" do
-          allow(STDIN).to receive(:gets).and_return("n\n")
-          
-          silence_output do
-            expect {
-              Mint::CommandLine.edit("newtemplate", :layout, :local)
-            }.to raise_error(SystemExit)
-          end
-        end
-
-        it "rejects invalid template types" do
-          silence_output do
-            expect {
-              Mint::CommandLine.edit("template", :invalid, :local)
-            }.to raise_error(SystemExit, /Invalid template type/)
-          end
-        end
-
-        it "requires template name" do
-          silence_output do
-            expect {
-              Mint::CommandLine.edit("", :layout, :local)
-            }.to raise_error(SystemExit, /No template specified/)
-            
-            expect {
-              Mint::CommandLine.edit(nil, :layout, :local)
-            }.to raise_error(SystemExit, /No template specified/)
-          end
-        end
-      end
-
-      describe "template creation helpers" do
-        describe "Mint::CommandLine.create_template" do
-          it "creates a layout template with default content" do
-            template_file = Mint::CommandLine.create_template("newlayout", :layout, :local)
-            
-            expect(File.exist?(template_file)).to be true
-            content = File.read(template_file)
-            expect(content).to include("<!DOCTYPE html>")
-            expect(content).to include("<%= content %>")
-            expect(template_file).to end_with("/layout.erb")
-          end
-
-          it "creates a style template with default content" do
-            template_file = Mint::CommandLine.create_template("newstyle", :style, :local)
-            
-            expect(File.exist?(template_file)).to be true
-            content = File.read(template_file)
-            expect(content).to include("body {")
-            expect(content).to include("font-family:")
-            expect(template_file).to end_with("/style.css")
-          end
-
-          it "creates template directory structure" do
-            Mint::CommandLine.create_template("organized", :layout, :local)
-            
-            expect(File.exist?(".mint/templates/organized")).to be true
-            expect(File.directory?(".mint/templates/organized")).to be true
-          end
-
-          it "rejects invalid template types" do
-            silence_output do
-              expect {
-                Mint::CommandLine.create_template("test", :invalid, :local)
-              }.to raise_error(SystemExit, /Invalid template type/)
-            end
-          end
-        end
-
-        describe "default template content" do
-          it "provides valid HTML5 layout template" do
-            content = Mint::CommandLine.default_layout_content
-            
-            expect(content).to include("<!DOCTYPE html>")
-            expect(content).to include("<html>")
-            expect(content).to include("<title>Document</title>")
-            expect(content).to include("<%= content %>")
-            expect(content).to include("<%= style %>")
-          end
-
-          it "provides basic CSS style template" do
-            content = Mint::CommandLine.default_style_content
-            
-            expect(content).to include("body {")
-            expect(content).to include("font-family:")
-            expect(content).to include("max-width:")
-            expect(content).to include("code {")
-          end
-        end
-      end
-
-      describe "template lookup integration" do
-        it "finds installed templates via lookup methods" do
-          create_template_directory("findme", with_layout: true, with_style: true)
-          
-          layout_file = Mint.lookup_layout("findme")
-          style_file = Mint.lookup_style("findme")
-          template_dir = Mint.lookup_template("findme")
-          
-          expect(layout_file).to include("findme/layout.erb")
-          expect(style_file).to include("findme/style.css")
-          expect(template_dir.to_s).to include("findme")
-          expect(File.exist?(layout_file)).to be true
-          expect(File.exist?(style_file)).to be true
-          expect(File.directory?(template_dir)).to be true
-        end
-
-        it "raises TemplateNotFoundException for missing templates" do
-          expect {
-            Mint.lookup_layout("missing")
-          }.to raise_error(Mint::TemplateNotFoundException)
-          
-          expect {
-            Mint.lookup_style("missing") 
-          }.to raise_error(Mint::TemplateNotFoundException)
-          
-          expect {
-            Mint.lookup_template("missing")
-          }.to raise_error(Mint::TemplateNotFoundException)
-        end
-      end
-    end
-  end
-end