scriptorium 0.0.3 → 0.7.2

data/test/rubytext/rubytext_testing_guide.md

@@ -0,0 +1,277 @@
+# RubyText Testing Guide
+
+## Overview
+
+Testing curses-based applications like RubyText is challenging because they're inherently interactive and terminal-dependent. This guide outlines a comprehensive testing strategy that balances automation with practical reality.
+
+## Testing Challenges
+
+### **1. Terminal Dependencies**
+- Different terminals behave differently
+- Terminal capabilities vary (colors, Unicode, etc.)
+- Screen sizes and resolutions differ
+
+### **2. Interactive Nature**
+- User input is time-sensitive
+- Screen state changes dynamically
+- Hard to capture and verify visual output
+
+### **3. Platform Differences**
+- Unix/Linux vs macOS vs Windows
+- Different curses implementations
+- Terminal emulator variations
+
+## Testing Strategy
+
+### **1. Component Testing (Recommended)**
+
+Test individual components in isolation:
+
+```ruby
+# Test menu logic without curses
+def test_menu_logic
+  menu = RubyText::Menu.new(["Option 1", "Option 2"])
+  assert_equal 2, menu.options.length
+  assert_equal "Option 1", menu.options[0]
+end
+
+# Test screen buffer logic
+def test_screen_buffer
+  screen = RubyText::Screen.new(80, 24)
+  screen.puts("Hello")
+  assert_includes screen.buffer, "Hello"
+end
+```
+
+### **2. PTY-Based Integration Testing**
+
+Use PTY for realistic terminal interaction:
+
+```ruby
+def test_basic_interaction
+  PTY.spawn('ruby -e "require \"rubytext\"; RubyText.start { puts \"Hello\"; gets }"') do |read, write, pid|
+    begin
+      read.expect(/Hello/, 5)
+      write.puts "q"
+      Process.wait(pid)
+      assert_equal 0, $?.exitstatus
+    ensure
+      Process.kill('TERM', pid) rescue nil
+    end
+  end
+end
+```
+
+### **3. Regression Testing with Screenshots**
+
+Capture expected screen states:
+
+```ruby
+def test_screen_regression
+  # Capture current screen
+  current_screen = capture_screen do
+    run_rubytext_app_with_input(["help", "quit"])
+  end
+  
+  # Compare with expected
+  expected_screen = File.read("test/fixtures/expected_help_screen.txt")
+  assert_equal expected_screen, current_screen
+end
+```
+
+### **4. Automated Demo Testing**
+
+Automate your existing demo/slideshow:
+
+```ruby
+def test_demo_automation
+  PTY.spawn('ruby demo.rb --automated') do |read, write, pid|
+    begin
+      # Navigate through slides
+      read.expect(/Slide 1/, 5)
+      write.puts "n"  # next
+      read.expect(/Slide 2/, 5)
+      write.puts "q"  # quit
+      
+      Process.wait(pid)
+      assert_equal 0, $?.exitstatus
+    ensure
+      Process.kill('TERM', pid) rescue nil
+    end
+  end
+end
+```
+
+## Test Categories
+
+### **Core Functionality**
+- [ ] Menu creation and navigation
+- [ ] Screen rendering and layout
+- [ ] Input handling (keyboard, mouse)
+- [ ] Color and style support
+- [ ] Window management
+
+### **User Interface**
+- [ ] Menu interactions
+- [ ] Form input
+- [ ] Dialog boxes
+- [ ] Progress indicators
+- [ ] Error messages
+
+### **Performance**
+- [ ] Large content rendering
+- [ ] Screen refresh speed
+- [ ] Memory usage
+- [ ] Input responsiveness
+
+### **Error Handling**
+- [ ] Invalid input
+- [ ] Terminal errors
+- [ ] Resource limits
+- [ ] Graceful degradation
+
+### **Platform Compatibility**
+- [ ] Different terminals
+- [ ] Screen sizes
+- [ ] Color support
+- [ ] Unicode support
+
+## Implementation Examples
+
+### **1. Menu Testing**
+
+```ruby
+class MenuTest < Minitest::Test
+  def test_menu_creation
+    menu = RubyText::Menu.new(["Option 1", "Option 2"])
+    assert_equal 2, menu.options.length
+  end
+  
+  def test_menu_interaction
+    PTY.spawn('ruby -e "require \"rubytext\"; RubyText.start { menu = RubyText::Menu.new([\"A\", \"B\"]); puts menu.show; gets }"') do |read, write, pid|
+      begin
+        read.expect(/A/, 5)
+        write.puts "\r"  # Select first option
+        result = read.expect(/A/, 5)
+        assert result
+      ensure
+        Process.kill('TERM', pid) rescue nil
+      end
+    end
+  end
+end
+```
+
+### **2. Screen Testing**
+
+```ruby
+class ScreenTest < Minitest::Test
+  def test_screen_rendering
+    PTY.spawn('ruby -e "require \"rubytext\"; RubyText.start { puts \"Test\"; gets }"') do |read, write, pid|
+      begin
+        result = read.expect(/Test/, 5)
+        assert result, "Screen should display content"
+      ensure
+        Process.kill('TERM', pid) rescue nil
+      end
+    end
+  end
+end
+```
+
+### **3. Input Testing**
+
+```ruby
+class InputTest < Minitest::Test
+  def test_keyboard_input
+    PTY.spawn('ruby -e "require \"rubytext\"; RubyText.start { key = RubyText.getch; puts \"Key: #{key}\"; gets }"') do |read, write, pid|
+      begin
+        write.puts "a"
+        result = read.expect(/Key: a/, 5)
+        assert result, "Should detect key press"
+      ensure
+        Process.kill('TERM', pid) rescue nil
+      end
+    end
+  end
+end
+```
+
+## Testing Tools
+
+### **1. PTY (Pseudo-Terminal)**
+- Realistic terminal interaction
+- Captures input/output
+- Good for integration testing
+
+### **2. Screen Capture**
+- Capture screen states
+- Compare with expected output
+- Good for regression testing
+
+### **3. Mock Terminals**
+- Test logic without curses
+- Faster execution
+- Good for unit testing
+
+### **4. Automated Demos**
+- Test real user workflows
+- Verify end-to-end functionality
+- Good for acceptance testing
+
+## Best Practices
+
+### **1. Test Structure**
+- Separate unit tests from integration tests
+- Use descriptive test names
+- Group related tests together
+
+### **2. Error Handling**
+- Test error conditions
+- Verify graceful degradation
+- Check error messages
+
+### **3. Performance**
+- Test with realistic data sizes
+- Monitor memory usage
+- Check response times
+
+### **4. Platform Coverage**
+- Test on multiple platforms
+- Use CI/CD for automated testing
+- Document platform-specific issues
+
+## Manual Testing Checklist
+
+Since automated testing can't cover everything, maintain a manual testing checklist:
+
+### **Visual Verification**
+- [ ] Colors display correctly
+- [ ] Text alignment is proper
+- [ ] Screen layout is clean
+- [ ] Unicode characters render
+
+### **Interaction Testing**
+- [ ] Menu navigation works
+- [ ] Keyboard shortcuts function
+- [ ] Mouse input responds
+- [ ] Error messages are clear
+
+### **Performance Testing**
+- [ ] Large content renders quickly
+- [ ] Screen updates are smooth
+- [ ] Input is responsive
+- [ ] Memory usage is reasonable
+
+## Conclusion
+
+Testing RubyText requires a multi-faceted approach:
+
+1. **Unit test the core logic** (menus, screens, input handling)
+2. **Integration test with PTY** (real terminal interaction)
+3. **Regression test with screenshots** (visual verification)
+4. **Manual test the complex interactions** (user experience)
+
+The key is to **automate what you can** and **accept that some testing will always be manual**. Focus on testing the critical paths and user workflows, and use your existing demo/slideshow as a foundation for automated testing.
+
+Remember: **Perfect automated testing of curses applications is impossible, but good testing is definitely achievable!**

data/test/run_automated_tests.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+# Set up environment
+ENV['PATH'] = "#{ENV['HOME']}/.rbenv/shims:#{ENV['PATH']}"
+
+puts "\n" + "="*60
+puts "Running all automated tests..."
+puts "="*60
+
+# Run unit tests
+puts "\n--- Running unit tests ---"
+system("ruby test/all")
+
+# Run manual tests in automated mode
+puts "\n--- Running manual tests in automated mode ---"
+
+manual_tests = [
+  "test/manual/test1.rb",
+  "test/manual/test2.rb", 
+  "test/manual/test3.rb blog1",
+  "test/manual/test4.rb",
+  "test/manual/test5.rb",
+  "test/manual/test_banner_combinations.rb",
+  "test/manual/test_banner_features.rb",
+  "test/manual/test_complex_header.rb",
+  "test/manual/test_empty_header.rb",
+  "test/manual/test_banner_in_header.rb",
+  "test/manual/test_radial_custom.rb",
+  "test/manual/test_radial_large_radius.rb",
+  "test/manual/test_svg_debug.rb"
+]
+
+manual_tests.each do |test|
+  puts "\nRunning: #{test}"
+  result = system("ruby #{test} --automated")
+  if result
+    puts "✓ PASSED"
+  else
+    puts "✗ FAILED"
+  end
+end
+
+puts "\n" + "="*60
+puts "All automated tests completed!"
+puts "="*60 

data/test/support/preview_utils.rb

@@ -0,0 +1,88 @@
+require 'fileutils'
+require 'shellwords'
+
+module PreviewUtils
+  DEFAULT_CONFIG = {
+    "posts.per.page"      => "5",
+    "entry.title.size"    => "1.1em",
+    "entry.blurb.size"    => "0.75em",
+    "entry.date.size"     => "0.7em",
+    "entry.date.width"    => "14%",
+    "entry.cellpadding"   => "6",
+    "entry.margin.bottom" => "6px",
+    "entry.title.color"   => "#000000",
+    "entry.blurb.color"   => "#666666",
+    "entry.date.color"    => "#888888",
+    "entry.line.height"   => "1.1",
+    "entry.date.alignment"=> "right",
+    "entry.date.spacing"  => "0.1em",
+    "entry.date.format"   => "month dd break yyyy",
+    "index.margin.top"    => "10px"
+  }.freeze
+
+  def self.write_post_index_config(repo_path, view_name, overrides = {})
+    config = DEFAULT_CONFIG.merge(overrides.transform_keys(&:to_s))
+    cfg_dir = File.join(repo_path, 'views', view_name, 'config')
+    FileUtils.mkdir_p(cfg_dir)
+    lines = config.map { |k,v| "#{k} #{v}" }.join("\n") + "\n"
+    File.write(File.join(cfg_dir, 'post_index.txt'), lines)
+  end
+
+  def self.seed_posts(api, titles_and_blurbs)
+    Array(titles_and_blurbs).each do |tb|
+      if tb.is_a?(Array)
+        api.create_post(tb[0], tb[1] || "")
+      else
+        api.create_post(tb.to_s, "")
+      end
+    end
+  end
+
+  def self.reference_image_in_post(repo_path, post_id4, filename)
+    src = File.join(repo_path, 'posts', post_id4, 'source.lt3')
+    File.write(src, ".image #{filename}\n\nHello")
+  end
+
+  def self.paths(repo_path, view_name)
+    base = File.expand_path(File.join(repo_path, 'views', view_name))
+    index_file = File.join(base, 'output', 'index.html')
+    post_index = File.join(base, 'output', 'post_index.html')
+    page1 = File.join(base, 'output', 'page1.html')
+
+    # Try to find first post slug from 0001
+    slug = nil
+    meta = File.join(repo_path, 'posts', '0001', 'meta.txt')
+    if File.exist?(meta)
+      line = File.read(meta).lines.grep(/^post.slug\s+/).first
+      slug = line.split.last if line
+    end
+    post_html = slug ? File.join(base, 'output', 'posts', slug) : nil
+
+    {
+      index_file: index_file,
+      post_index: post_index,
+      page1: page1,
+      post_html: post_html,
+      preview_index_url: "http://localhost:4567/preview/#{view_name}/index.html",
+      preview_post_url: (slug ? "http://localhost:4567/preview/#{view_name}/posts/#{slug}" : nil)
+    }
+  end
+
+  def self.interactive_open(label:, paths: [], urls: [])
+    puts "\n[Manual] Opening #{label}..."
+    # Always open local files
+    paths.compact.each do |target|
+      next if target.to_s.empty?
+      system("open #{Shellwords.escape(target)}")
+    end
+    # Also open server URLs (user asked to issue open commands)
+    urls.compact.each do |u|
+      next if u.to_s.empty?
+      system("open #{Shellwords.escape(u)}")
+    end
+    puts "[Manual] Press Enter to continue..."
+    STDIN.gets
+  end
+end
+
+

data/test/syntax_highlighting_test.lt3

@@ -0,0 +1,124 @@
+.title Syntax Highlighting Test - Ruby, Elixir, JavaScript
+.blurb Testing Rouge syntax highlighting for multiple languages
+.views testview
+.tags syntax,rouge,highlighting,manual-test
+
+.syntax_css
+
+This post tests the integrated Rouge syntax highlighter with three different programming languages.
+
+## Ruby Code Example
+
+.code ruby
+class User
+  attr_accessor :name, :email
+  
+  def initialize(name, email)
+    @name = name
+    @email = email
+  end
+  
+  def greet
+    puts "Hello, #{@name}!"
+  end
+  
+  def valid_email?
+    email.match?(/\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i)
+  end
+end
+
+user = User.new("Alice", "alice@example.com")
+user.greet
+.end
+
+## Elixir Code Example
+
+.code elixir
+defmodule Calculator do
+  def add(a, b), do: a + b
+  def subtract(a, b), do: a - b
+  def multiply(a, b), do: a * b
+  def divide(a, b) when b != 0, do: a / b
+  def divide(_, 0), do: {:error, "Division by zero"}
+  
+  def calculate(operation, a, b) do
+    case operation do
+      :add -> add(a, b)
+      :subtract -> subtract(a, b)
+      :multiply -> multiply(a, b)
+      :divide -> divide(a, b)
+      _ -> {:error, "Unknown operation"}
+    end
+  end
+end
+
+# Test the calculator
+result = Calculator.calculate(:add, 5, 3)
+IO.puts("5 + 3 = #{result}")
+.end
+
+## JavaScript Code Example
+
+.code javascript
+class TodoList {
+  constructor() {
+    this.todos = [];
+    this.nextId = 1;
+  }
+  
+  addTodo(text, completed = false) {
+    const todo = {
+      id: this.nextId++,
+      text: text,
+      completed: completed,
+      createdAt: new Date()
+    };
+    
+    this.todos.push(todo);
+    return todo;
+  }
+  
+  toggleTodo(id) {
+    const todo = this.todos.find(t => t.id === id);
+    if (todo) {
+      todo.completed = !todo.completed;
+    }
+    return todo;
+  }
+  
+  removeTodo(id) {
+    const index = this.todos.findIndex(t => t.id === id);
+    if (index > -1) {
+      return this.todos.splice(index, 1)[0];
+    }
+    return null;
+  }
+  
+  getCompletedTodos() {
+    return this.todos.filter(t => t.completed);
+  }
+  
+  getPendingTodos() {
+    return this.todos.filter(t => !t.completed);
+  }
+}
+
+// Usage example
+const todoList = new TodoList();
+todoList.addTodo("Learn Rouge syntax highlighting");
+todoList.addTodo("Test multiple languages");
+todoList.addTodo("Write documentation", true);
+
+console.log("Pending todos:", todoList.getPendingTodos().length);
+console.log("Completed todos:", todoList.getCompletedTodos().length);
+.end
+
+## Test Results
+
+Each code block above should display with proper syntax highlighting:
+
+- **Ruby**: Keywords in red, strings in blue, variables in orange
+- **Elixir**: Functions in purple, atoms in green, strings in blue  
+- **JavaScript**: Keywords in red, functions in purple, strings in blue
+
+The highlighting should work automatically thanks to our Rouge integration!

data/test/test_gem_assets.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/scriptorium'
+
+puts "=== Scriptorium Gem Asset Test ==="
+puts "Gem version: #{Scriptorium::VERSION}"
+puts
+
+# Test that we can access the StandardFiles class
+predef = Scriptorium::StandardFiles.new
+puts "✅ StandardFiles class accessible"
+
+# Test post template generation
+template = predef.support_data('templates/post.lt3')
+puts "✅ Post template generated (#{template.lines.count} lines)"
+
+# Test that clipboard function is in common.js
+common_js = predef.common_js
+if common_js.include?('copyPermalinkToClipboard')
+  puts "✅ Clipboard function found in common.js"
+else
+  puts "❌ Clipboard function NOT found in common.js"
+end
+
+# Test template with variables
+vars = {
+  :'post.title' => 'Test Post',
+  :'post.pubdate' => '2025-08-14',
+  :'post.date' => '2025-08-14',
+  :'post.tags' => 'test, gem',
+  :'post.body' => 'This is a test post from the installed gem.',
+  :reddit_button => ''
+}
+
+result = template % vars
+puts "✅ Template variable substitution works"
+puts "✅ Generated HTML contains copy button: #{result.include?('copyPermalinkToClipboard')}"
+
+# Test that the copy button is present
+if result.include?('Copy link')
+  puts "✅ Copy link button present in generated HTML"
+else
+  puts "❌ Copy link button NOT present in generated HTML"
+end
+
+puts
+puts "=== Asset Test Complete ==="
+puts "All gem assets are working correctly!"