scriptorium 0.6.1 → 0.7.2

data/test/unit/parse_cmd_test.rb

@@ -0,0 +1,260 @@
+require 'minitest/autorun'
+require_relative '../../lib/scriptorium'
+require_relative '../test_helpers'
+
+class ParseCmdTest < Minitest::Test
+  # Extract the parse_cmd method from the TUI class for testing
+  private def parse_cmd(cmdstr)
+    parts = cmdstr.split
+    return [:unknown_command, ""] if parts.empty?
+    
+    # Handle 2-word commands and single-word commands with arguments
+    if parts.length >= 2
+      # Check if first two words form a known 2-word command
+      two_word_cmd = parts[0..1].join(" ")
+      case two_word_cmd.downcase
+      when "list views", "list posts", "list drafts", "list assets", "list widgets", "list themes", "list backups",
+           "change view", "new view", "new post", "upload asset", "copy asset", "delete asset",
+           "delete theme", "delete backup", "asset info", "configure deployment", "add widget", "config widget",
+           "config social", "config reddit", "clone theme"
+        cmd = two_word_cmd
+        args = parts[2..-1]
+      else
+        # Check if first word is a single-word command that can take parameters
+        first_word = parts[0].downcase
+        case first_word
+        when "cv", "backup", "restore"  # Single-word commands that take parameters
+          # First word can take parameters, rest are arguments
+          cmd = first_word
+          args = parts[1..-1]
+        else
+          # Unknown command - treat as unknown 2-word command
+          cmd = two_word_cmd
+          args = parts[2..-1]
+        end
+      end
+    else
+      cmd = parts[0]
+      args = []
+    end
+    
+    cmd = cmd.downcase
+
+    case cmd
+    when "help", "h"
+      [:show_help]
+    when "view"
+      [:show_current_view]
+    when "cv"
+      [:change_view, args]
+    when "lsv"
+      [:list_views]
+    when "lsp"
+      [:list_posts]
+    when "lsd"
+      [:list_drafts]
+    when "version", "v"
+      [:show_version]
+    when "deploy"
+      [:deploy_current_view]
+    when "preview"
+      [:preview_current_view]
+    when "browse"
+      [:browse_deployed_view]
+    when "generate"
+      [:generate_current_view]
+    when "quit", "q"
+      [:exit, 0]
+    when "list views"
+      [:list_views]
+    when "list posts"
+      [:list_posts]
+    when "list drafts"
+      [:list_drafts]
+    when "list assets"
+      [:list_assets, args]
+    when "list widgets"
+      [:list_widgets]
+    when "list themes"
+      [:list_themes]
+    when "list backups"
+      [:list_backups]
+    when "change view"
+      [:change_view, args]
+    when "new view"
+      args.empty? ? [:create_view] : [:create_view, args]
+    when "new post"
+      [:create_post, args]
+    when "upload asset"
+      [:upload_asset, args]
+    when "copy asset"
+      [:copy_asset, args]
+    when "delete asset"
+      [:delete_asset, args]
+    when "delete theme"
+      [:delete_theme, args]
+    when "delete backup"
+      [:delete_backup, args]
+    when "asset info"
+      [:asset_info, args]
+    when "configure deployment"
+      [:configure_deployment, args]
+    when "add widget"
+      [:add_widget, args]
+    when "config widget"
+      [:config_widget, args]
+    when "config social"
+      [:config_social]
+    when "config reddit"
+      [:config_reddit]
+    when "clone theme"
+      [:clone_theme, args]
+    when "backup"
+      [:create_backup, args]
+    when "restore"
+      [:restore_backup, args]
+    else
+      [:unknown_command, cmd]
+    end
+  end
+
+  def test_001_parse_cmd_basic_commands
+    # Test basic single-word commands
+    assert_equal [:show_help], parse_cmd("help")
+    assert_equal [:show_help], parse_cmd("h")
+    assert_equal [:show_current_view], parse_cmd("view")
+    assert_equal [:list_views], parse_cmd("lsv")
+    assert_equal [:list_posts], parse_cmd("lsp")
+    assert_equal [:list_drafts], parse_cmd("lsd")
+    assert_equal [:show_version], parse_cmd("version")
+    assert_equal [:show_version], parse_cmd("v")
+    assert_equal [:deploy_current_view], parse_cmd("deploy")
+    assert_equal [:preview_current_view], parse_cmd("preview")
+    assert_equal [:browse_deployed_view], parse_cmd("browse")
+    assert_equal [:generate_current_view], parse_cmd("generate")
+    assert_equal [:exit, 0], parse_cmd("quit")
+    assert_equal [:exit, 0], parse_cmd("q")
+  end
+
+  def test_002_parse_cmd_list_commands
+    # Test list commands
+    assert_equal [:list_views], parse_cmd("list views")
+    assert_equal [:list_posts], parse_cmd("list posts")
+    assert_equal [:list_drafts], parse_cmd("list drafts")
+    assert_equal [:list_assets, ["assets", "global"]], parse_cmd("list assets assets global")
+    assert_equal [:list_widgets], parse_cmd("list widgets")
+    assert_equal [:list_themes], parse_cmd("list themes")
+    assert_equal [:list_backups], parse_cmd("list backups")
+  end
+
+  def test_003_parse_cmd_change_commands
+    # Test change commands
+    assert_equal [:change_view, ["myview"]], parse_cmd("change view myview")
+  end
+
+  def test_004_parse_cmd_new_commands
+    # Test new commands
+    assert_equal [:create_view], parse_cmd("new view")
+    assert_equal [:create_view, ["myview"]], parse_cmd("new view myview")
+    assert_equal [:create_post, ["mypost"]], parse_cmd("new post mypost")
+  end
+
+  def test_005_parse_cmd_asset_commands
+    # Test asset commands
+    assert_equal [:upload_asset, ["myfile", "global"]], parse_cmd("upload asset myfile global")
+    assert_equal [:copy_asset, ["myfile", "from", "to"]], parse_cmd("copy asset myfile from to")
+    assert_equal [:delete_asset, ["myfile", "global"]], parse_cmd("delete asset myfile global")
+    assert_equal [:asset_info, ["myfile", "global"]], parse_cmd("asset info myfile global")
+  end
+
+  def test_006_parse_cmd_configure_commands
+    # Test configure commands
+    assert_equal [:configure_deployment, ["myview"]], parse_cmd("configure deployment myview")
+  end
+
+  def test_007_parse_cmd_widget_commands
+    # Test widget commands
+    assert_equal [:add_widget, ["mywidget"]], parse_cmd("add widget mywidget")
+    assert_equal [:config_widget, ["mywidget"]], parse_cmd("config widget mywidget")
+  end
+
+  def test_008_parse_cmd_config_commands
+    # Test config commands
+    assert_equal [:config_social], parse_cmd("config social")
+    assert_equal [:config_reddit], parse_cmd("config reddit")
+  end
+
+  def test_009_parse_cmd_clone_commands
+    # Test clone commands
+    assert_equal [:clone_theme, ["mytheme"]], parse_cmd("clone theme mytheme")
+  end
+
+  def test_010_parse_cmd_theme_commands
+    # Test theme commands
+    assert_equal [:delete_theme, ["mytheme"]], parse_cmd("delete theme mytheme")
+  end
+
+  def test_015_parse_cmd_backup_commands
+    # Test backup commands
+    assert_equal [:create_backup, []], parse_cmd("backup")
+    assert_equal [:create_backup, ["full"]], parse_cmd("backup full")
+    assert_equal [:create_backup, ["incr"]], parse_cmd("backup incr")
+    assert_equal [:create_backup, ["full", "Before", "major", "changes"]], parse_cmd("backup full Before major changes")
+    assert_equal [:create_backup, ["incr", "Added", "new", "post"]], parse_cmd("backup incr Added new post")
+  end
+
+  def test_016_parse_cmd_restore_commands
+    # Test restore commands
+    assert_equal [:restore_backup, []], parse_cmd("restore")
+    assert_equal [:restore_backup, ["20250902-120000-full"]], parse_cmd("restore 20250902-120000-full")
+    assert_equal [:restore_backup, ["20250902-120000-full", "safe"]], parse_cmd("restore 20250902-120000-full safe")
+    assert_equal [:restore_backup, ["20250902-130000-incr", "merge"]], parse_cmd("restore 20250902-130000-incr merge")
+    assert_equal [:restore_backup, ["20250902-140000-incr", "destroy"]], parse_cmd("restore 20250902-140000-incr destroy")
+  end
+
+  def test_017_parse_cmd_delete_backup_commands
+    # Test delete backup commands
+    assert_equal [:delete_backup, []], parse_cmd("delete backup")
+    assert_equal [:delete_backup, ["20250902-120000-full"]], parse_cmd("delete backup 20250902-120000-full")
+    assert_equal [:delete_backup, ["20250902-130000-incr"]], parse_cmd("delete backup 20250902-130000-incr")
+  end
+
+  def test_011_parse_cmd_edge_cases
+    # Test edge cases
+    assert_equal [:unknown_command, "invalid"], parse_cmd("invalid")
+    assert_equal [:unknown_command, ""], parse_cmd("")
+    assert_equal [:unknown_command, ""], parse_cmd("   ")  # split() removes whitespace
+    assert_equal [:show_help], parse_cmd("help")
+    assert_equal [:show_help], parse_cmd("  help  ")
+  end
+
+  def test_012_parse_cmd_complex_args
+    # Test commands with complex arguments
+    assert_equal [:change_view, ["my", "view", "with", "spaces"]], parse_cmd("change view my view with spaces")
+    assert_equal [:create_view, ["my", "view", "with", "spaces"]], parse_cmd("new view my view with spaces")
+    assert_equal [:list_assets, ["global", "with", "spaces"]], parse_cmd("list assets global with spaces")
+  end
+
+  def test_013_parse_cmd_abbreviated_commands
+    # Test abbreviated commands
+    assert_equal [:change_view, ["myview"]], parse_cmd("cv myview")
+    assert_equal [:list_views], parse_cmd("lsv")
+    assert_equal [:list_posts], parse_cmd("lsp")
+    assert_equal [:list_drafts], parse_cmd("lsd")
+  end
+
+  def test_014_parse_cmd_unknown_commands
+    # Test unknown commands
+    assert_equal [:unknown_command, "list invalid"], parse_cmd("list invalid")
+    assert_equal [:unknown_command, "change invalid"], parse_cmd("change invalid")
+    assert_equal [:unknown_command, "new invalid"], parse_cmd("new invalid")
+    assert_equal [:unknown_command, "upload invalid"], parse_cmd("upload invalid")
+    assert_equal [:unknown_command, "copy invalid"], parse_cmd("copy invalid")
+    assert_equal [:unknown_command, "delete invalid"], parse_cmd("delete invalid")
+    assert_equal [:unknown_command, "asset invalid"], parse_cmd("asset invalid")
+    assert_equal [:unknown_command, "configure invalid"], parse_cmd("configure invalid")
+    assert_equal [:unknown_command, "add invalid"], parse_cmd("add invalid")
+    assert_equal [:unknown_command, "config invalid"], parse_cmd("config invalid")
+    assert_equal [:unknown_command, "clone invalid"], parse_cmd("clone invalid")
+  end
+end

data/test/unit/{symlink_test.rb → permalink_copy_test.rb}

@@ -1,12 +1,12 @@
-# Test file for symlink functionality
-# Tests the clean URL symlink generation for posts
+# Test file for permalink copy functionality
+# Tests the clean URL copy generation for posts
 
 require 'minitest/autorun'
 require_relative '../../lib/scriptorium'
 require_relative '../test_helpers'
 require 'fileutils'
 
-class TestSymlinkFunctionality < Minitest::Test
+class TestPermalinkCopy < Minitest::Test
   include Scriptorium::Helpers
   include TestHelpers
 
@@ -55,10 +55,10 @@ class TestSymlinkFunctionality < Minitest::Test
   end
 
   # ========================================
-  # Symlink generation tests
+  # Permalink copy generation tests
   # ========================================
 
-  def test_006_symlink_creation_for_post
+  def test_006_permalink_copy_creation_for_post
     # Create a test post
     post_title = "My First Test Post"
     post_body = "This is the body of my test post."
@@ -81,16 +81,16 @@ class TestSymlinkFunctionality < Minitest::Test
     assert File.exist?(numbered_path), "Numbered post file should exist: #{numbered_path}"
     assert File.exist?(clean_symlink_path), "Clean symlink should exist: #{clean_symlink_path}"
     
-    # Clean symlink should be a symlink
-    assert File.symlink?(clean_symlink_path), "Clean symlink should be a symlink"
+    # Clean copy should exist
+    assert File.exist?(clean_symlink_path), "Clean copy should exist"
     
-    # Symlink should point to the numbered file
-    symlink_target = File.readlink(clean_symlink_path)
-    expected_target = numbered_slug
-    assert_equal expected_target, symlink_target, "Symlink should point to numbered file"
+    # Copy should have same content as numbered file
+    copy_content = File.read(clean_symlink_path)
+    numbered_content = File.read(numbered_path)
+    assert_equal numbered_content, copy_content, "Copy should have same content as numbered file"
   end
 
-  def test_007_symlink_points_to_correct_file
+  def test_007_permalink_copy_has_correct_content
     # Create a test post with a specific title
     post_title = "Another Test Post"
     post_body = "This is another test post."
@@ -106,17 +106,17 @@ class TestSymlinkFunctionality < Minitest::Test
     clean_slug = clean_slugify(post_title) + ".html"
     clean_symlink_path = @view.dir/:output/:permalink/clean_slug
     
-    assert File.symlink?(clean_symlink_path), "Should be a symlink"
+    assert File.exist?(clean_symlink_path), "Should be a copy"
     
-    # Get the actual target
-    symlink_target = File.readlink(clean_symlink_path)
+    # Get the actual content to verify it's a copy
+    copy_content = File.read(clean_symlink_path)
+    target_content = File.read(@view.dir/:output/:permalink/slugify(post_num, post_title) + ".html")
     
-    # Expected target should be the numbered slug
-    expected_slug = slugify(post_num, post_title) + ".html"
-    assert_equal expected_slug, symlink_target, "Symlink should point to correct numbered file"
+    # Expected content should match the numbered file
+    assert_equal target_content, copy_content, "Copy should have same content as numbered file"
   end
 
-  def test_008_symlink_overwrites_existing
+  def test_008_permalink_copy_overwrites_existing
     # Create a test post
     post_title = "Duplicate Test Post"
     post_body = "This is a test post."
@@ -125,17 +125,17 @@ class TestSymlinkFunctionality < Minitest::Test
     draft_name = @repo.create_draft(title: post_title, body: post_body)
     post_num = @repo.finish_draft(draft_name)
     
-    # Generate the post (should create symlink)
+    # Generate the post (should create copy)
     @repo.generate_post(post_num)
     
-    # Check that symlink exists
+    # Check that copy exists
     clean_slug = clean_slugify(post_title) + ".html"
     clean_symlink_path = @view.dir/:output/:permalink/clean_slug
     
-    assert File.symlink?(clean_symlink_path), "Symlink should exist"
+    assert File.exist?(clean_symlink_path), "Copy should exist"
     
-    # Get the target
-    original_target = File.readlink(clean_symlink_path)
+    # Get the original content
+    original_content = File.read(clean_symlink_path)
     
     # Now create another post with the same clean slug (different numbered slug)
     post_title2 = "Duplicate Test Post"  # Same title, different post
@@ -144,20 +144,20 @@ class TestSymlinkFunctionality < Minitest::Test
     draft_name2 = @repo.create_draft(title: post_title2, body: post_body2)
     post_num2 = @repo.finish_draft(draft_name2)
     
-    # Generate the second post (should overwrite symlink)
+    # Generate the second post (should overwrite copy)
     @repo.generate_post(post_num2)
     
-    # Check that symlink still exists and points to the new target
-    assert File.symlink?(clean_symlink_path), "Symlink should still exist"
+    # Check that copy still exists and has new content
+    assert File.exist?(clean_symlink_path), "Copy should still exist"
     
-    new_target = File.readlink(clean_symlink_path)
-    expected_target = slugify(post_num2, post_title2) + ".html"
+    new_content = File.read(clean_symlink_path)
+    expected_content = File.read(@view.dir/:output/:permalink/slugify(post_num2, post_title2) + ".html")
     
-    assert_equal expected_target, new_target, "Symlink should point to new target"
-    refute_equal original_target, new_target, "Symlink should have been updated"
+    assert_equal expected_content, new_content, "Copy should have new content"
+    refute_equal original_content, new_content, "Copy should have been updated"
   end
 
-  def test_009_symlink_with_special_characters_in_title
+  def test_009_permalink_copy_with_special_characters_in_title
     # Test with a title that has special characters
     post_title = "Post with Special Characters: & < > \" ' !"
     post_body = "This post has special characters in the title."
@@ -169,21 +169,20 @@ class TestSymlinkFunctionality < Minitest::Test
     # Generate the post
     @repo.generate_post(post_num)
     
-    # Check that symlink exists with cleaned slug
+    # Check that copy exists with cleaned slug
     clean_slug = clean_slugify(post_title) + ".html"
     clean_symlink_path = @view.dir/:output/:permalink/clean_slug
     
-    assert File.exist?(clean_symlink_path), "Symlink should exist for cleaned title"
-    assert File.symlink?(clean_symlink_path), "Should be a symlink"
+    assert File.exist?(clean_symlink_path), "Copy should exist for cleaned title"
     
-    # Check that the symlink points to the correct numbered file
-    symlink_target = File.readlink(clean_symlink_path)
-    expected_target = slugify(post_num, post_title) + ".html"
-    assert_equal expected_target, symlink_target, "Symlink should point to correct numbered file"
+    # Check that the copy has the same content as the numbered file
+    copy_content = File.read(clean_symlink_path)
+    expected_content = File.read(@view.dir/:output/:permalink/slugify(post_num, post_title) + ".html")
+    assert_equal expected_content, copy_content, "Copy should have same content as numbered file"
   end
 
-  def test_010_symlink_deployment_ready
-    # Test that symlinks are created in the correct location for deployment
+  def test_010_permalink_copy_deployment_ready
+    # Test that permalink copies are created in the correct location for deployment
     post_title = "Deployment Test Post"
     post_body = "This post tests deployment readiness."
     
@@ -194,20 +193,19 @@ class TestSymlinkFunctionality < Minitest::Test
     # Generate the post
     @repo.generate_post(post_num)
     
-    # Check that symlink is in the correct deployment location
+    # Check that copy is in the correct deployment location
     clean_slug = clean_slugify(post_title) + ".html"
     clean_symlink_path = @view.dir/:output/:permalink/clean_slug
     
     # Verify the path structure
     assert_equal @view.dir/:output/:permalink/clean_slug, clean_symlink_path
-    assert File.exist?(clean_symlink_path), "Symlink should exist in deployment location"
+    assert File.exist?(clean_symlink_path), "Copy should exist in deployment location"
     
-    # Verify it's a symlink
-    assert File.symlink?(clean_symlink_path), "Should be a symlink"
+    # Verify it's a copy (not a symlink)
+    assert !File.symlink?(clean_symlink_path), "Should not be a symlink"
     
-    # Verify the target exists and is accessible
-    symlink_target = File.readlink(clean_symlink_path)
-    target_path = @view.dir/:output/:permalink/symlink_target
-    assert File.exist?(target_path), "Symlink target should exist"
+    # Verify the copy has content
+    copy_content = File.read(clean_symlink_path)
+    assert copy_content.length > 0, "Copy should have content"
   end
 end