scriptorium 0.0.2 → 0.6.1

data/test/wizard_test.rb

@@ -0,0 +1,123 @@
+#!/usr/bin/env ruby
+
+require 'open3'
+require 'timeout'
+require 'minitest/autorun'
+require_relative '../lib/scriptorium'
+
+class WizardTest < Minitest::Test
+  def setup
+    @test_repo_path = "scriptorium-TEST"
+    cleanup_test_repo
+  end
+
+  def teardown
+    cleanup_test_repo
+  end
+
+  def test_001_wizard_first_view_flow
+    # Test the wizard flow for creating the first view
+    # This should create a new repository and set up the first view
+    
+    # Ensure clean start
+    cleanup_test_repo
+    
+    # Run the wizard
+    result = system("echo -e 'y\n4\nn' | ruby bin/scriptorium")
+    assert result, "Wizard should complete successfully"
+    
+    # Verify repository was created
+    assert Dir.exist?(TEST_REPO_PATH), "Repository should be created"
+    
+    # Verify sample view was created
+    sample_view_path = File.join(TEST_REPO_PATH, "views", "sample")
+    assert Dir.exist?(sample_view_path), "Sample view should be created"
+    
+    # Verify config files were created
+    config_path = File.join(TEST_REPO_PATH, "config")
+    assert Dir.exist?(config_path), "Config directory should be created"
+    
+    # Verify current view is set
+    current_view_file = File.join(config_path, "currentview.txt")
+    assert File.exist?(current_view_file), "Current view file should be created"
+    assert_equal "sample", File.read(current_view_file).strip, "Current view should be 'sample'"
+  end
+
+  def test_002_wizard_method_exists
+    # Test that the wizard method exists and can be called
+    # This is a basic smoke test to ensure the wizard is available
+    
+    # Load the scriptorium binary to access the wizard method
+    load 'bin/scriptorium'
+    
+    # The wizard method should be available in the TUI class
+    assert defined?(TUI), "TUI class should be defined"
+    assert TUI.instance_methods.include?(:wizard), "TUI should have wizard method"
+  end
+
+  def test_003_wizard_with_new_repo
+    # Test wizard behavior when creating a completely new repository
+    # This tests the full wizard flow including repository creation
+    
+    # Ensure clean start
+    cleanup_test_repo
+    
+    # Create a new API instance to simulate fresh start
+    api = Scriptorium::API.new(testmode: true)
+    
+    # Verify no repository exists initially
+    refute Dir.exist?(TEST_REPO_PATH), "Repository should not exist initially"
+    
+    # Run wizard with new repo creation
+    result = system("echo -e 'y\n4\ny\ntestview\nTest View\nTest Subtitle\nn\nn\nn\nn\nn' | ruby bin/scriptorium")
+    assert result, "Wizard should complete successfully with new repo"
+    
+    # Verify repository was created
+    assert Dir.exist?(TEST_REPO_PATH), "Repository should be created"
+    
+    # Verify test view was created
+    test_view_path = File.join(TEST_REPO_PATH, "views", "testview")
+    assert Dir.exist?(test_view_path), "Test view should be created"
+    
+    # Verify view config
+    view_config = File.join(test_view_path, "config.txt")
+    assert File.exist?(view_config), "View config should be created"
+    config_content = File.read(view_config)
+    assert_includes config_content, "title    Test View", "View title should be set"
+    assert_includes config_content, "subtitle Test Subtitle", "View subtitle should be set"
+  end
+
+  def await_output(stdout, expected_str, timeout_secs = 10)
+    buffer = ""
+    start_time = Time.now
+    
+    loop do
+      if Time.now - start_time > timeout_secs
+        raise "Timeout waiting for '#{expected_str}'. Buffer: #{buffer.inspect}"
+      end
+      
+      begin
+        chunk = stdout.read_nonblock(1000)
+        buffer += chunk
+        puts "Buffer: #{buffer.inspect}"
+        
+        if buffer.include?(expected_str)
+          puts "Found expected string: #{expected_str.inspect}"
+          return buffer
+        end
+      rescue IO::EAGAINWaitReadable, IO::EWOULDBLOCKWaitReadable
+        sleep 0.1
+      rescue EOFError
+        raise "EOF reached while waiting for '#{expected_str}'. Buffer: #{buffer.inspect}"
+      end
+    end
+  end
+
+  private
+
+  def cleanup_test_repo
+    if Dir.exist?(@test_repo_path)
+      FileUtils.rm_rf(@test_repo_path)
+    end
+  end
+end 

data/ui/README.md

@@ -0,0 +1,67 @@
+# Scriptorium UI Directory
+
+This directory contains all user interface implementations for Scriptorium.
+
+## Structure
+
+```
+ui/
+├── tui/                    # Terminal User Interface
+│   ├── bin/scriptorium     # TUI executable
+│   ├── lib/                # TUI-specific code
+│   └── test/               # TUI-specific tests
+├── web/                    # Web User Interface (future)
+│   ├── app/                # Web app code
+│   ├── public/             # Static assets
+│   └── test/               # Web-specific tests
+└── common/                 # Shared UI utilities
+    ├── lib/                # Common UI libraries
+    └── test/               # Common UI tests
+```
+
+## TUI (Terminal User Interface)
+
+The current TUI implementation provides a command-line interface for Scriptorium.
+
+- **Location**: `ui/tui/bin/scriptorium`
+- **Features**: Interactive commands, view management, post creation, deployment
+- **Dependencies**: Readline (optional), core Scriptorium library
+
+## Web UI (Future)
+
+Planned web interface for Scriptorium.
+
+- **Status**: Not yet implemented
+- **Planned Features**: Web-based post editing, view management, real-time preview
+- **Technology**: To be determined (Sinatra, Rails, or other framework)
+
+## Common Utilities
+
+Shared code that can be used by multiple UI implementations.
+
+- **Location**: `ui/common/lib/`
+- **Purpose**: API wrappers, validation, common UI patterns
+- **Usage**: Imported by TUI, Web UI, and future interfaces
+
+## Development
+
+### Adding a new UI
+
+1. Create a new directory under `ui/`
+2. Follow the established structure (bin/, lib/, test/)
+3. Import common utilities from `ui/common/lib/`
+4. Update the gemspec to include the new UI files
+
+### Testing
+
+Each UI has its own test directory for UI-specific tests. Common functionality is tested in `ui/common/test/`.
+
+### Dependencies
+
+- **TUI**: Minimal dependencies, uses core Scriptorium library
+- **Web UI**: Will have additional web framework dependencies
+- **Common**: No additional dependencies beyond core Scriptorium
+
+## Migration Notes
+
+The TUI was moved from `bin/scriptorium` to `ui/tui/bin/scriptorium` to better organize the codebase and prepare for multiple UI implementations. 

data/ui/common/lib/ui_common.rb

@@ -0,0 +1,8 @@
+# Common UI utilities that can be shared between different interfaces
+module Scriptorium
+  module UI
+    module Common
+      # Shared utilities for all UI implementations
+    end
+  end
+end 

data/ui/rubytext/README.md

@@ -0,0 +1,191 @@
+# Scriptorium RubyText UI
+
+## Overview
+
+The RubyText UI brings back the sophisticated interactive interface from Runeblog, providing a middle ground between the simple TUI and the web app. It offers:
+
+- **Rich interactive menus** - File selection, configuration, widget management
+- **Context-aware interface** - Shows current view, status, and available actions
+- **Direct file editing** - Integrated editor support with syntax highlighting
+- **Visual feedback** - Colors, bold text, clear screens, progress indicators
+- **Widget management** - Manage pages, links, navbar, and other widgets
+- **Real-time preview** - Live preview of changes as you make them
+
+## Architecture
+
+### Core Components
+
+1. **Main Interface** (`ui/rubytext/bin/scriptorium-rubytext`)
+   - Entry point with auto-discovery and setup
+   - Context display and command processing
+   - Error handling and recovery
+
+2. **Menu System** (`ui/rubytext/lib/menus.rb`)
+   - Interactive menus for file selection
+   - Configuration management
+   - Widget management interfaces
+
+3. **REPL System** (`ui/rubytext/lib/repl.rb`)
+   - Command processing and execution
+   - Context management
+   - Help system and documentation
+
+4. **Editor Integration** (`ui/rubytext/lib/editor.rb`)
+   - Direct file editing with syntax highlighting
+   - Editor selection and configuration
+   - File validation and error handling
+
+5. **Widget Management** (`ui/rubytext/lib/widgets.rb`)
+   - Page management
+   - Link management
+   - Navbar configuration
+   - Asset management
+
+## Key Features
+
+### Interactive Menus
+
+```ruby
+# File selection menu
+files = Dir.glob("*.rb")
+num, selected = STDSCR.menu(title: "Select file:", items: files)
+edit_file(selected) if selected
+
+# Configuration menu
+config_items = {
+  "General Settings" => "config/general.txt",
+  "View Settings" => "config/view.txt",
+  "Theme Settings" => "config/theme.txt"
+}
+num, target = STDSCR.menu(title: "Edit configuration:", items: config_items)
+edit_file(target) if target
+```
+
+### Context-Aware Interface
+
+```ruby
+# Shows current context in prompt
+def display_context
+  view_name = @repo.current_view&.name || "No view"
+  print fx("[#{view_name}] ", Red, :bold)
+end
+```
+
+### Direct File Editing
+
+```ruby
+# Integrated editor with syntax highlighting
+def edit_file(file, editor: nil)
+  editor ||= @repo.config.editor || "vim"
+  system("#{editor} #{file}")
+  refresh_screen
+end
+```
+
+### Widget Management
+
+```ruby
+# Manage pages widget
+def manage_pages
+  pages_dir = @view.dir/"pages"
+  files = Dir.glob("#{pages_dir}/*.html")
+  
+  menu_items = files.map { |f| File.basename(f) } + ["[New Page]"]
+  num, selected = STDSCR.menu(title: "Manage Pages:", items: menu_items)
+  
+  case selected
+  when "[New Page]"
+    create_new_page
+  else
+    edit_page(selected)
+  end
+end
+```
+
+## Implementation Plan
+
+### Phase 1: Core Interface
+- [ ] Basic RubyText integration
+- [ ] Context display and command processing
+- [ ] Simple menu system
+- [ ] File editing integration
+
+### Phase 2: Rich Menus
+- [ ] Interactive file selection
+- [ ] Configuration management
+- [ ] Widget management interfaces
+- [ ] Help system
+
+### Phase 3: Advanced Features
+- [ ] Real-time preview
+- [ ] Asset management
+- [ ] Deployment integration
+- [ ] Performance optimization
+
+## Usage Examples
+
+### Basic Usage
+
+```bash
+# Start RubyText UI
+scriptorium-rubytext
+
+# Context-aware prompt
+[sample] help                    # Show help
+[sample] new post               # Create new post
+[sample] list posts             # List posts in current view
+[sample] config                 # Edit configuration
+[sample] manage pages           # Manage pages widget
+```
+
+### Interactive Menus
+
+```
+Select file:
+  1. config/general.txt
+  2. config/view.txt
+  3. config/theme.txt
+  4. [Cancel]
+
+Enter choice (1-4): 2
+```
+
+### Widget Management
+
+```
+Manage Pages:
+  1. about.html
+  2. contact.html
+  3. [New Page]
+  4. [Cancel]
+
+Enter choice (1-4): 3
+```
+
+## Benefits Over Current TUI
+
+1. **More Interactive** - Rich menus vs. command-line only
+2. **Better Visual Feedback** - Colors, bold text, clear screens
+3. **Direct File Editing** - Integrated editor support
+4. **Widget Management** - Visual management of pages, links, etc.
+5. **Context Awareness** - Always shows current view and status
+6. **Error Recovery** - Better error handling and recovery
+
+## Benefits Over Web App
+
+1. **Lighter Weight** - No web server, no browser needed
+2. **Faster** - Direct file system access
+3. **SSH Friendly** - Works over SSH connections
+4. **Offline** - No internet connection required
+5. **Familiar** - Terminal-based interface for command-line users
+
+## Dependencies
+
+- `rubytext` gem - Curses-based UI framework
+- `scriptorium` core - Core Scriptorium functionality
+- `livetext` - Content processing and generation
+
+## Testing
+
+See `test/rubytext/` for comprehensive testing strategy and implementation.
+