mint 0.7.4 → 0.8.1

data/spec/css_parser_spec.rb

@@ -0,0 +1,149 @@
+require "spec_helper"
+require "mint/css_parser"
+require "tempfile"
+require "pathname"
+
+describe Mint::CssParser do
+  describe ".extract_imports" do
+    it "extracts @import statements with double quotes" do
+      css = '@import "reset.css"; body { margin: 0; }'
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["reset.css"])
+    end
+
+    it "extracts @import statements with single quotes" do
+      css = "@import 'normalize.css'; .class { color: red; }"
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["normalize.css"])
+    end
+
+    it "extracts @import url() statements" do
+      css = '@import url("fonts.css"); @import url(\'colors.css\');'
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["fonts.css", "colors.css"])
+    end
+
+    it "extracts multiple @import statements" do
+      css = <<~CSS
+        @import "reset.css";
+        @import 'normalize.css';
+        @import url("fonts.css");
+        body { margin: 0; }
+      CSS
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["reset.css", "normalize.css", "fonts.css"])
+    end
+
+    it "returns empty array when no imports found" do
+      css = "body { margin: 0; color: blue; }"
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq([])
+    end
+  end
+
+  describe ".resolve_css_files" do
+    let(:temp_dir) { Dir.mktmpdir }
+    
+    after do
+      FileUtils.rm_rf(temp_dir)
+    end
+
+    it "resolves main CSS file path relative to HTML output" do
+      # Create directory structure:
+      # temp_dir/
+      #   css/
+      #     main.css
+      #   output/
+      #     index.html (output file)
+      
+      css_dir = File.join(temp_dir, "css")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([css_dir, output_dir])
+      
+      main_css = File.join(css_dir, "main.css")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(main_css, "body { margin: 0; }")
+      
+      css_files = Mint::CssParser.resolve_css_files(main_css, html_output)
+      expect(css_files).to eq(["../css/main.css"])
+    end
+
+    it "resolves main CSS and imported files" do
+      # Create directory structure:
+      # temp_dir/
+      #   css/
+      #     main.css (imports reset.css)
+      #     reset.css
+      #   output/
+      #     index.html
+      
+      css_dir = File.join(temp_dir, "css")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([css_dir, output_dir])
+      
+      main_css = File.join(css_dir, "main.css")
+      reset_css = File.join(css_dir, "reset.css")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(main_css, '@import "reset.css"; body { margin: 0; }')
+      File.write(reset_css, "* { box-sizing: border-box; }")
+      
+      css_files = Mint::CssParser.resolve_css_files(main_css, html_output)
+      expect(css_files).to eq(["../css/main.css", "../css/reset.css"])
+    end
+
+    it "ignores non-existent imported files" do
+      css_dir = File.join(temp_dir, "css")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([css_dir, output_dir])
+      
+      main_css = File.join(css_dir, "main.css")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(main_css, '@import "nonexistent.css"; body { margin: 0; }')
+      
+      css_files = Mint::CssParser.resolve_css_files(main_css, html_output)
+      expect(css_files).to eq(["../css/main.css"])
+    end
+
+    it "only processes .css files" do
+      scss_dir = File.join(temp_dir, "scss")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([scss_dir, output_dir])
+      
+      main_scss = File.join(scss_dir, "main.scss")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(main_scss, '@import "reset"; body { margin: 0; }')
+      
+      css_files = Mint::CssParser.resolve_css_files(main_scss, html_output)
+      expect(css_files).to eq(["../scss/main.scss"])
+    end
+  end
+
+  describe ".generate_link_tags" do
+    it "generates HTML link tags for CSS files" do
+      css_paths = ["../css/main.css", "../css/reset.css"]
+      
+      html = Mint::CssParser.generate_link_tags(css_paths)
+      
+      expected = <<~HTML.strip
+        <link rel="stylesheet" href="../css/main.css">
+            <link rel="stylesheet" href="../css/reset.css">
+      HTML
+      
+      expect(html).to eq(expected)
+    end
+
+    it "handles empty array" do
+      html = Mint::CssParser.generate_link_tags([])
+      expect(html).to eq("")
+    end
+
+    it "handles single CSS file" do
+      html = Mint::CssParser.generate_link_tags(["styles.css"])
+      expect(html).to eq('<link rel="stylesheet" href="styles.css">')
+    end
+  end
+end

data/spec/css_spec.rb

@@ -39,7 +39,7 @@ module Mint
 
     describe ".parse" do
       it "transforms a map of human-readable styles into a CSS string" do
-        CSS.parse({ "Font" => "Helvetica" }).should == "#container {\n  font-family: Helvetica; }\n" 
+        expect(CSS.parse({ "Font" => "Helvetica" })).to eq("#container {\n  font-family: Helvetica;\n}") 
       end
     end
   end

data/spec/document_spec.rb

@@ -14,20 +14,27 @@ module Mint
       #
       # This test doesn't cover any plugin transformations. Those
       # transformations are covered in the Plugin spec.
-      its(:content) { should =~ /<p>This is just a test.<\/p>/ }
-      its(:metadata) { should == { "metadata" =>  true } }
+      its(:content) { is_expected.to match(/<p>This is just a test.<\/p>/) }
+      its(:metadata) { is_expected.to eq({ "metadata" =>  true }) }
 
       # Render output
 
       # This test doesn't cover any plugin transformations. Those
       # transformations are covered in the Plugin spec.
       it "renders its layout, injecting content inside" do
-        document.render.should =~ 
-          /.*<html>.*#{document.content}.*<\/html>.*/m
+        expect(document.render).to include(document.content)
+        expect(document.render).to include("<html")
+        expect(document.render).to include("</html>")
       end
 
-      it "links to its stylesheet" do 
-        document.render.should =~ /#{document.stylesheet}/
+      it "includes its stylesheet appropriately based on style mode" do
+        if document.style_mode == :external
+          expect(document.render).to include('<link rel="stylesheet"')
+          expect(document.render).not_to include("<style>")
+        else
+          expect(document.render).to include("<style>")
+          expect(document.render).to include("</style>")
+        end
       end
 
       # Mint output
@@ -36,14 +43,19 @@ module Mint
       # transformations are covered in the Plugin spec.
       it "writes its rendered style to #style_destination_file" do
         document.publish!
-        document.style_destination_file_path.should exist
+        if document.style_mode == :external
+          expect(document.style_destination_file_path).to exist
+        else
+          # For inline styles, no external file should be created
+          expect(document.style_destination_file_path).not_to exist
+        end
       end
 
       it "writes its rendered layout and content to #destination_file" do
         document.publish!
-        document.destination_file_path.should exist
+        expect(document.destination_file_path).to exist
         content = File.read document.destination_file
-        content.should == document.render
+        expect(content).to eq(document.render)
       end
     end
 
@@ -51,100 +63,119 @@ module Mint
       let(:document) { Document.new @content_file }
 
       subject { document }
-      its(:root) { should == @tmp_dir }
-      its(:destination) { should be_nil }
-      its(:source) { should == "content.md" }
-      its(:style_destination) { should be_nil }
+      its(:root) { is_expected.to eq(@tmp_dir) }
+      its(:destination) { is_expected.to be_nil }
+      its(:source) { is_expected.to eq("content.md") }
+      its(:style_destination) { is_expected.to be_nil }
 
-      its(:style_destination_file) do
-        should == Mint.root + "/config/templates/default/css/style.css"
+      it "has a style destination file in user tmp directory" do
+        expect(document.style_destination_file).to match(/\.config\/mint\/tmp\/style\.css$/)
       end
 
-      its(:style_destination_directory) do 
-        should == Mint.root + "/config/templates/default/css"
+      it "has a style destination directory in user tmp directory" do
+        expect(document.style_destination_directory).to match(/\.config\/mint\/tmp$/)
       end
 
       its(:style_destination_file_path) do
-        should == Pathname.new(document.style_destination_file)
+        is_expected.to eq(Pathname.new(document.style_destination_file))
       end
 
       its(:style_destination_directory_path) do
-        should == Pathname.new(document.style_destination_directory)
+        is_expected.to eq(Pathname.new(document.style_destination_directory))
       end
 
-      its(:layout) { should be_in_directory("default") }
-      its(:style) { should be_in_directory("default") }
+      its(:layout) { is_expected.to be_in_directory("default") }
+      its(:style) { is_expected.to be_in_directory("default") }
 
-      its(:stylesheet) { should == Mint.root + "/config/templates/default/css/style.css" }
+      it "has a stylesheet path relative to user tmp directory" do
+        expect(document.stylesheet).to match(/\.config\/mint\/tmp\/style\.css$/)
+      end
 
       it_should_behave_like "all documents"
     end
 
     context "when it's created with explicit destination directories" do
       let(:document) { Document.new @content_file,
-                       :destination => "destination",
-                       :style_destination => "styles" }
+                       destination: "destination",
+                       style_destination: "styles" }
 
       subject { document }
-      its(:root) { should == @tmp_dir }
-      its(:destination) { should == "destination" }
-      its(:source) { should == "content.md" }
-      its(:style_destination) { should == "styles" }
+      its(:root) { is_expected.to eq(@tmp_dir) }
+      its(:destination) { is_expected.to eq("destination") }
+      its(:source) { is_expected.to eq("content.md") }
+      its(:style_destination) { is_expected.to eq("styles") }
 
       its(:style_destination_file) do
-        should == "#{@tmp_dir}/destination/styles/style.css"
+        is_expected.to eq("#{@tmp_dir}/destination/styles/style.css")
       end
 
       its(:style_destination_directory) do
-        should == "#{@tmp_dir}/destination/styles"
+        is_expected.to eq("#{@tmp_dir}/destination/styles")
       end
 
       its(:style_destination_file_path) do
-        should == Pathname.new(document.style_destination_file)
+        is_expected.to eq(Pathname.new(document.style_destination_file))
       end
 
       its(:style_destination_directory_path) do
-        should == Pathname.new(document.style_destination_directory)
+        is_expected.to eq(Pathname.new(document.style_destination_directory))
       end
 
-      its(:layout) { should be_in_directory("default") }
-      its(:style) { should be_in_directory("default") }
+      its(:layout) { is_expected.to be_in_directory("default") }
+      its(:style) { is_expected.to be_in_directory("default") }
 
-      its(:stylesheet) { should == "styles/style.css" }
+      it "has a stylesheet path relative to user tmp directory" do
+        expect(document.stylesheet).to match(/\.config\/mint\/tmp\/style\.css$/)
+      end
 
       it_should_behave_like "all documents"
     end
 
     context "when it's created with an explicit root" do 
       let(:document) { Document.new @content_file,
-                       :root => "#{@tmp_dir}/alternative-root" }
+                       root: "#{@tmp_dir}/alternative-root" }
 
       subject { document }
-      its(:root) { should == "#{@tmp_dir}/alternative-root" }
-      its(:destination) { should be_nil }
-      its(:source) { should == "content.md" }
-      its(:style_destination) { should be_nil }
-
-      its(:style_destination_file) do
-        should == Mint.root + "/config/templates/default/css/style.css"
+      its(:root) { is_expected.to eq("#{@tmp_dir}/alternative-root") }
+      it "preserves folder structure" do
+        expect(document.destination).to be_present
+      end
+      its(:source) { is_expected.to eq("content.md") }
+      its(:style_destination) { is_expected.to be_nil }
+
+      it "has appropriate style behavior based on style mode" do
+        if document.style_mode == :external
+          expect(document.style_destination_file).to match(/\.config\/mint\/tmp\/style\.css$/)
+        else
+          # For inline styles, the style_destination_file should still exist as a path
+          # but no actual file should be created during publish
+          expect(document.style_destination_file).to be_present
+        end
       end
 
-      its(:style_destination_directory) do
-        should == Mint.root + "/config/templates/default/css"
+      it "has appropriate style destination directory based on style mode" do
+        if document.style_mode == :external
+          expect(document.style_destination_directory).to match(/\.config\/mint\/tmp$/)
+        else
+          # For inline styles, still has a directory path but it's not used for external files
+          expect(document.style_destination_directory).to be_present
+        end
       end
 
       its(:style_destination_file_path) do
-        should == Pathname.new(document.style_destination_file)
+        is_expected.to eq(Pathname.new(document.style_destination_file))
       end
 
       its(:style_destination_directory_path) do
-        should == Pathname.new(document.style_destination_directory)
+        is_expected.to eq(Pathname.new(document.style_destination_directory))
       end
 
-      its(:layout) { should be_in_directory("default") }
-      its(:style) { should be_in_directory("default") }
+      its(:layout) { is_expected.to be_in_directory("default") }
+      its(:style) { is_expected.to be_in_directory("default") }
 
-      its(:stylesheet) { should == Mint.root + "/config/templates/default/css/style.css" }
+      it "has a stylesheet path relative to user tmp directory" do
+        expect(document.stylesheet).to match(/\.config\/mint\/tmp\/style\.css$/)
+      end
 
       it_should_behave_like "all documents"
     end
@@ -161,31 +192,33 @@ module Mint
       end
 
       subject { document }
-      its(:root) { should == "#{@tmp_dir}/alternative-root" }
-      its(:destination) { should == "destination" }
-      its(:source) { should == "content.md" }
-      its(:style_destination) { should == "styles" }
+      its(:root) { is_expected.to eq("#{@tmp_dir}/alternative-root") }
+      its(:destination) { is_expected.to eq("destination") }
+      its(:source) { is_expected.to eq("content.md") }
+      its(:style_destination) { is_expected.to eq("styles") }
 
       its(:style_destination_file) do
-        should == "#{@tmp_dir}/alternative-root/destination/styles/style.css"
+        is_expected.to eq("#{@tmp_dir}/alternative-root/destination/styles/style.css")
       end
 
       its(:style_destination_directory) do
-        should == "#{@tmp_dir}/alternative-root/destination/styles"
+        is_expected.to eq("#{@tmp_dir}/alternative-root/destination/styles")
       end
 
       its(:style_destination_file_path) do
-        should == Pathname.new(document.style_destination_file)
+        is_expected.to eq(Pathname.new(document.style_destination_file))
       end
 
       its(:style_destination_directory_path) do
-        should == Pathname.new(document.style_destination_directory)
+        is_expected.to eq(Pathname.new(document.style_destination_directory))
       end
 
-      its(:layout) { should be_in_directory("zen") }
-      its(:style) { should be_in_directory("zen") }
+      its(:layout) { is_expected.to be_in_directory("zen") }
+      its(:style) { is_expected.to be_in_directory("zen") }
 
-      its(:stylesheet) { should == "styles/style.css" }
+      it "has a stylesheet path relative to user tmp directory" do
+        expect(document.stylesheet).to match(/\.config\/mint\/tmp\/style\.css$/)
+      end
 
       it_should_behave_like "all documents"
     end
@@ -194,33 +227,33 @@ module Mint
       let(:text) { "metadata: true\n\nReal text" }
       describe ".metadata_chunk" do
         it "extracts, but does not parse, metadata from text" do
-          Document.metadata_chunk(text).should == "metadata: true"
+          expect(Document.metadata_chunk(text)).to eq("metadata: true")
         end
       end
 
       describe ".metadata_from" do
         it "parses a documents metadata if present" do
-          Document.metadata_from(text).should == { "metadata" => true }
+          expect(Document.metadata_from(text)).to eq({ "metadata" => true })
         end
 
         it "returns the empty string if a document has bad/no metadata" do
-          Document.metadata_from("No metadata here").should == {}
+          expect(Document.metadata_from("No metadata here")).to eq({})
         end
 
         it "handles a non-simple string that is also not YAML" do
-          Document.metadata_from("# Non-simple string").should == {}
+          expect(Document.metadata_from("# Non-simple string")).to eq({})
         end
       end
 
       describe ".parse_metadata_from" do
         it "separates text from its metadata if present" do
-          Document.parse_metadata_from(text).should ==
-            [{ "metadata" => true }, "Real text"]
+          expect(Document.parse_metadata_from(text)).to eq(
+            [{ "metadata" => true }, "Real text"])
         end
 
         it "returns the entire text if no metadata is found" do
-          Document.parse_metadata_from("No metadata here").should ==
-            [{}, "No metadata here"]
+          expect(Document.parse_metadata_from("No metadata here")).to eq(
+            [{}, "No metadata here"])
         end
       end
     end