scriptorium 0.6.1 → 0.7.2

data/test/unit/edit_post_test.rb

@@ -0,0 +1,168 @@
+require 'minitest/autorun'
+require_relative '../../lib/scriptorium'
+require_relative '../test_helpers'
+
+class TestEditPost < Minitest::Test
+  include TestHelpers
+  
+  def setup
+    @test_dir = "test/scriptorium-TEST"
+    FileUtils.rm_rf(@test_dir) if Dir.exist?(@test_dir)
+    
+    @api = Scriptorium::API.new(testmode: true)
+    @api.create_repo(@test_dir)
+    @api.open_repo(@test_dir)
+  end
+  
+  def teardown
+    FileUtils.rm_rf(@test_dir) if Dir.exist?(@test_dir)
+  end
+  
+  def test_001_edit_post_no_changes
+    @api.create_view("test_view", "Test View")
+    post = @api.create_post("Test Post", "Test body")
+    
+    # Initially unpublished and undeployed
+    refute @api.post_published?(post.id)
+    refute @api.post_deployed?(post.id)
+    
+    # Mock the editor by not changing the file content
+    # (file content remains the same, so checksum will be identical)
+    
+    # Call edit_post with mock (should detect no changes)
+    @api.edit_post(post.id, mock: true)
+    
+    # State should remain unchanged
+    refute @api.post_published?(post.id)
+    refute @api.post_deployed?(post.id)
+  end
+  
+  def test_002_edit_post_with_changes
+    @api.create_view("test_view", "Test View")
+    post = @api.create_post("Test Post", "Test body")
+    
+    # Initially unpublished and undeployed
+    refute @api.post_published?(post.id)
+    refute @api.post_deployed?(post.id)
+    
+    # Mock the editor by simulating a different checksum
+    @api.edit_post(post.id, mock: [:checksum, "different_checksum_for_testing"])
+    
+    # State should remain unchanged since it was already unpublished/undeployed
+    refute @api.post_published?(post.id)
+    refute @api.post_deployed?(post.id)
+  end
+  
+  def test_003_edit_post_published_post
+    @api.create_view("test_view", "Test View")
+    @api.repo.instance_variable_set(:@current_view, @api.repo.lookup_view("test_view"))
+    
+    post = @api.create_post("Test Post", "Test body")
+    
+    # Publish the post
+    @api.publish_post(post.id)
+    assert @api.post_published?(post.id)
+    
+    # Mock the editor by simulating a different checksum
+    @api.edit_post(post.id, mock: [:checksum, "different_checksum_for_testing"])
+    
+    # Post should now be unpublished
+    refute @api.post_published?(post.id)
+  end
+  
+  def test_004_edit_post_deployed_post
+    @api.create_view("test_view", "Test View")
+    @api.repo.instance_variable_set(:@current_view, @api.repo.lookup_view("test_view"))
+    
+    post = @api.create_post("Test Post", "Test body")
+    
+    # Publish and deploy the post
+    @api.publish_post(post.id)
+    @api.mark_post_deployed(post.id)
+    assert @api.post_published?(post.id)
+    assert @api.post_deployed?(post.id)
+    
+    # Mock the editor by simulating a different checksum
+    @api.edit_post(post.id, mock: [:checksum, "different_checksum_for_testing"])
+    
+    # Post should now be unpublished and undeployed
+    refute @api.post_published?(post.id)
+    refute @api.post_deployed?(post.id)
+  end
+  
+  def test_005_edit_post_multiple_views
+    @api.create_view("test_view", "Test View")
+    @api.create_view("other_view", "Other View")
+    
+    post = @api.create_post("Test Post", "Test body", views: "test_view other_view")
+    
+    # Publish in both views
+    @api.publish_post(post.id, "test_view")
+    @api.publish_post(post.id, "other_view")
+    @api.mark_post_deployed(post.id, "test_view")
+    @api.mark_post_deployed(post.id, "other_view")
+    
+    assert @api.post_published?(post.id, "test_view")
+    assert @api.post_published?(post.id, "other_view")
+    assert @api.post_deployed?(post.id, "test_view")
+    assert @api.post_deployed?(post.id, "other_view")
+    
+    # Mock the editor by simulating a different checksum
+    @api.edit_post(post.id, mock: [:checksum, "different_checksum_for_testing"])
+    
+    # Post should now be unpublished and undeployed in both views
+    
+    refute @api.post_published?(post.id, "test_view")
+    refute @api.post_published?(post.id, "other_view")
+    refute @api.post_deployed?(post.id, "test_view")
+    refute @api.post_deployed?(post.id, "other_view")
+  end
+  
+  def test_006_edit_post_timestamp_change_only
+    @api.create_view("test_view", "Test View")
+    post = @api.create_post("Test Post", "Test body")
+    
+    # Initially unpublished and undeployed
+    refute @api.post_published?(post.id)
+    refute @api.post_deployed?(post.id)
+    
+    # Mock the editor by simulating no content changes (same checksum)
+    @api.edit_post(post.id, mock: [:checksum, Digest::MD5.file("#{@test_dir}/posts/#{post.num}/source.lt3").hexdigest])
+    
+    # State should remain unchanged since content didn't change
+    refute @api.post_published?(post.id)
+    refute @api.post_deployed?(post.id)
+  end
+  
+  def test_007_edit_post_missing_source
+    @api.create_view("test_view", "Test View")
+    post = @api.create_post("Test Post", "Test body")
+    
+    # Remove source.lt3 to test error handling
+    source_path = "#{@test_dir}/posts/#{post.num}/source.lt3"
+    File.delete(source_path) if File.exist?(source_path)
+    
+    # Ensure body.html exists
+    body_path = "#{@test_dir}/posts/#{post.num}/body.html"
+    assert File.exist?(body_path)
+    
+    # Call edit_post should raise error since source.lt3 is missing
+    assert_raises(RuntimeError) do
+      @api.edit_post(post.id, mock: true)
+    end
+  end
+  
+  def test_008_edit_post_deleted_post
+    @api.create_view("test_view", "Test View")
+    post = @api.create_post("Test Post", "Test body")
+    
+    # Delete the post
+    @api.delete_post(post.id)
+    assert @api.post_deleted?(post.id)
+    
+    # Try to edit deleted post
+    assert_raises(PostDeleted) do
+      @api.edit_post(post.id, mock: true)
+    end
+  end
+end

data/test/unit/gem_asset_management.rb

@@ -46,6 +46,8 @@ class TestGemAssetManagement < Minitest::Test
       live = Livetext.customize(mix: "lt3scriptor", call: ".nopara", vars: @vars)
       body, vars = live.process(file: temp_file)
       vars = vars.to_h
+      # Strip paragraph tags for asset function tests
+      body = body.gsub(/^<p>\n?(.*?)\n?<\/p>$/m, '\1')
       return { vars: vars, body: body }
     rescue => e
       puts "Livetext error: #{e.message}"
@@ -59,11 +61,11 @@ class TestGemAssetManagement < Minitest::Test
 
   def test_001_gem_asset_discovery_in_development
     # Test that gem assets are found in development environment
-    content = "$$asset[icons/ui/back-arrow.svg]"
+    content = "$$asset[icons/ui/back.png]"
     result = process_livetext(content)
     
     # Should find gem asset and return correct path
-    assert_equal "assets/icons/ui/back-arrow.svg", result[:body].strip
+    assert_equal "assets/icons/ui/back.png", result[:body].strip
   end
 
   def test_002_gem_asset_discovery_in_production
@@ -82,7 +84,7 @@ class TestGemAssetManagement < Minitest::Test
     # Check for specific theme assets
     expected_theme_assets = [
       "standard/favicon.svg",
-      "icons/ui/back-arrow.svg"
+      "icons/ui/back.png"
     ]
     
     expected_theme_assets.each do |asset|
@@ -111,57 +113,55 @@ class TestGemAssetManagement < Minitest::Test
 
   def test_005_gem_assets_in_search_hierarchy
     # Test that gem assets are found in the correct priority order
-    content = "$$asset[icons/ui/back-arrow.svg]"
+    content = "$$asset[icons/ui/back.png]"
     result = process_livetext(content)
     
     # Should find gem asset and return correct path
-    assert_equal "assets/icons/ui/back-arrow.svg", result[:body].strip
+    assert_equal "assets/icons/ui/back.png", result[:body].strip
   end
 
   def test_006_gem_assets_override_by_user_assets
     # Test that user assets override gem assets
     # Create a user asset with the same name as a gem asset
-    user_asset_path = @repo.root/"assets"/"icons"/"ui"/"back-arrow.svg"
+    user_asset_path = @repo.root/"assets"/"icons"/"ui"/"back.png"
     FileUtils.mkdir_p(File.dirname(user_asset_path))
-    File.write(user_asset_path, "User asset content")
+    write_file(user_asset_path, "User asset content")
     
-    content = "$$asset[icons/ui/back-arrow.svg]"
+    content = "$$asset[icons/ui/back.png]"
     result = process_livetext(content)
     
     # Should find user asset first (higher priority)
-    assert_equal "assets/icons/ui/back-arrow.svg", result[:body].strip
+    assert_equal "assets/icons/ui/back.png", result[:body].strip
   end
 
   def test_007_gem_asset_path_resolution
     # Test that gem asset paths are resolved correctly
-    begin
-      gem_spec = Gem.loaded_specs['scriptorium']
-      if gem_spec
-        # Production environment - gem is installed
-        gem_assets_dir = "#{gem_spec.full_gem_path}/assets"
-        assert Dir.exist?(gem_assets_dir), "Gem assets directory should exist"
-        
-        # Check for specific gem assets
-        expected_gem_assets = [
-          "icons/ui/back-arrow.svg",
-          "samples/placeholder.svg",
-          "themes/standard/favicon.svg"
-        ]
-        
-        expected_gem_assets.each do |asset|
-          asset_path = "#{gem_assets_dir}/#{asset}"
-          assert File.exist?(asset_path), "Gem asset #{asset} should exist"
-        end
-      else
-        # Development environment - use working path
-        dev_assets_dir = File.expand_path("assets")
-        assert Dir.exist?(dev_assets_dir), "Development assets directory should exist"
+    gem_spec = Gem.loaded_specs['scriptorium']
+    if gem_spec
+      # Production environment - gem is installed
+      gem_assets_dir = "#{gem_spec.full_gem_path}/assets"
+      assert Dir.exist?(gem_assets_dir), "Gem assets directory should exist"
+      
+      # Check for specific gem assets
+      expected_gem_assets = [
+        "icons/ui/back.png",
+        "samples/placeholder.svg",
+        "themes/standard/favicon.svg"
+      ]
+      
+      expected_gem_assets.each do |asset|
+        asset_path = "#{gem_assets_dir}/#{asset}"
+        assert File.exist?(asset_path), "Gem asset #{asset} should exist"
       end
-    rescue => e
-      # If gem lookup fails, that's expected in development
-              dev_assets_dir = File.expand_path("assets")
+    else
+      # Development environment - use working path
+      dev_assets_dir = File.expand_path("assets")
       assert Dir.exist?(dev_assets_dir), "Development assets directory should exist"
     end
+  rescue => e
+    # If gem lookup fails, that's expected in development
+    dev_assets_dir = File.expand_path("assets")
+    assert Dir.exist?(dev_assets_dir), "Development assets directory should exist"
   end
 
   def test_008_gem_assets_not_copied_to_output
@@ -170,20 +170,14 @@ class TestGemAssetManagement < Minitest::Test
     output_assets_dir = @repo.root/"views"/"gem_asset_test_view"/"output"/"assets"
     
     # Generate a post that references gem assets
-    draft_body = "$$asset[icons/ui/back-arrow.svg]"
+    draft_body = "$$asset[icons/ui/back.png]"
     name = @repo.create_draft(title: "Gem Asset Test", views: ["gem_asset_test_view"], body: draft_body)
     num = @repo.finish_draft(name)
     @repo.generate_post(num)
     
     # Check that gem assets are not copied to output
-    gem_asset_in_output = output_assets_dir/"icons"/"ui"/"back-arrow.svg"
+    gem_asset_in_output = output_assets_dir/"icons"/"ui"/"back.png"
     refute File.exist?(gem_asset_in_output), "Gem assets should not be copied to output"
   end
 
-  private
-
-  def write_file(path, content)
-    FileUtils.mkdir_p(File.dirname(path)) unless Dir.exist?(File.dirname(path))
-    File.write(path, content)
-  end
 end

data/test/unit/livetext_basic.rb

@@ -9,15 +9,12 @@ class TestLivetextBasic < Minitest::Test
     # Test basic Livetext without any plugins
     content = "Simple text content"
     
-    begin
-      live = Livetext.customize(call: ".nopara")
-      body, vars = live.process(text: content)
-      assert_equal "Simple text content", body.strip
-      assert vars.is_a?(Hash)
-      puts "✓ Basic Livetext processing works"
-    rescue => e
-      flunk "Basic Livetext processing failed: #{e.message}"
-    end
+    live = Livetext.customize(call: ".nopara")
+    body, vars = live.process(text: content)
+    assert_equal "<p>\nSimple text content\n</p>", body.strip
+    assert vars.is_a?(Hash)
+  rescue => e
+    flunk "Basic Livetext processing failed: #{e.message}"
   end
 
   def test_002_livetext_with_simple_dot_commands
@@ -29,41 +26,32 @@ class TestLivetextBasic < Minitest::Test
       This is the body.
     CONTENT
     
-    begin
-      live = Livetext.customize(mix: "lt3scriptor", call: ".nopara")
-      body, vars = live.process(text: content)
-      assert_includes body, "This is the body"
-      assert vars.is_a?(Hash)
-      puts "✓ Livetext with dot commands works"
-    rescue => e
-      flunk "Livetext with dot commands failed: #{e.message}"
-    end
+    live = Livetext.customize(mix: "lt3scriptor", call: ".nopara")
+    body, vars = live.process(text: content)
+    assert_includes body, "This is the body"
+    assert vars.is_a?(Hash)
+  rescue => e
+    flunk "Livetext with dot commands failed: #{e.message}"
   end
 
   def test_003_livetext_plugin_loading
     # Test if the plugin can be loaded without processing
-    begin
-      live = Livetext.customize(mix: "lt3scriptor")
-      assert live
-      puts "✓ Plugin loads successfully"
-    rescue => e
-      flunk "Plugin loading failed: #{e.message}"
-    end
+    live = Livetext.customize(mix: "lt3scriptor")
+    assert live
+  rescue => e
+    flunk "Plugin loading failed: #{e.message}"
   end
 
   def test_004_livetext_plugin_processing_simple
     # Test if the plugin can process very simple content
     content = "Simple content"
     
-    begin
-      live = Livetext.customize(mix: "lt3scriptor", call: ".nopara")
-      body, vars = live.process(text: content)
-      assert body.is_a?(String)
-      puts "✓ Plugin processes simple content: #{body}"
-    rescue => e
-      puts "✗ Plugin processing failed: #{e.message}"
-      puts e.backtrace.first(3)
-      skip "Plugin processing needs to be fixed"
-    end
+    live = Livetext.customize(mix: "lt3scriptor", call: ".nopara")
+    body, vars = live.process(text: content)
+    assert body.is_a?(String)
+  rescue => e
+    puts "✗ Plugin processing failed: #{e.message}"
+    puts e.backtrace.first(3)
+    skip "Plugin processing needs to be fixed"
   end
 end

data/test/unit/livetext_compatibility.rb

@@ -13,9 +13,8 @@ class TestLivetextCompatibility < Minitest::Test
       live = Livetext.customize(call: ".nopara")
       body, vars = live.process(text: content)
       vars = vars.to_h
-      assert_equal "Simple text content", body.strip
+      assert_equal "<p>\nSimple text content\n</p>", body.strip
       assert vars.is_a?(Hash)
-      puts "✓ Basic Livetext processing works"
     rescue => e
       flunk "Basic Livetext processing failed: #{e.message}"
     end
@@ -31,12 +30,11 @@ class TestLivetextCompatibility < Minitest::Test
     CONTENT
     
     begin
-      live = Livetext.customize(call: ".nopara")
+      live = Livetext.customize(mix: "lt3scriptor", call: ".nopara")
       body, vars = live.process(text: content)
       vars = vars.to_h
       assert_includes body, "This is the body"
       assert vars.is_a?(Hash)
-      puts "✓ Livetext with dot commands works"
     rescue => e
       flunk "Livetext with dot commands failed: #{e.message}"
     end
@@ -44,13 +42,10 @@ class TestLivetextCompatibility < Minitest::Test
 
   def test_003_livetext_plugin_loading
     # Test if the plugin can be loaded without processing
-    begin
-      live = Livetext.customize(mix: "lt3scriptor")
-      assert live
-      puts "✓ Plugin loaded successfully"
-    rescue => e
-      flunk "Plugin loading failed: #{e.message}"
-    end
+    live = Livetext.customize(mix: "lt3scriptor")
+    assert live
+  rescue => e
+    flunk "Plugin loading failed: #{e.message}"
   end
 
   def test_004_livetext_plugin_processing
@@ -62,7 +57,6 @@ class TestLivetextCompatibility < Minitest::Test
       body, vars = live.process(text: content)
       vars = vars.to_h
       assert body.is_a?(String)
-      puts "✓ Plugin processing succeeded: #{body}"
     rescue => e
       puts "✗ Plugin processing failed: #{e.message}"
       puts e.backtrace.first(3)
@@ -76,11 +70,10 @@ class TestLivetextCompatibility < Minitest::Test
     
     begin
       live = Livetext.customize(call: ".nopara")
-      text, vars = live.process(content)
+      text, vars = live.process(text: content)
       vars = vars.to_h
       assert text.is_a?(String)
       assert vars.is_a?(Hash)
-      puts "✓ Old Livetext API works"
     rescue => e
       puts "✗ Old Livetext API failed: #{e.message}"
       skip "Old API needs to be fixed"