cabriolet 0.1.2 → 0.2.0

data/lib/cabriolet/file_entry.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # Represents a file to be added to an archive
+  #
+  # Single responsibility: Encapsulate file metadata and data access.
+  # Supports both disk files and memory data, providing unified interface
+  # for file operations across all format compressors.
+  #
+  # @example Adding a disk file
+  #   entry = FileEntry.new(
+  #     source: "/path/to/file.txt",
+  #     archive_path: "docs/file.txt"
+  #   )
+  #
+  # @example Adding memory data
+  #   entry = FileEntry.new(
+  #     data: "Hello, World!",
+  #     archive_path: "greeting.txt"
+  #   )
+  class FileEntry
+    attr_reader :source_path, :archive_path, :data, :options
+
+    # Initialize a file entry
+    #
+    # @param source [String, nil] Path to source file on disk
+    # @param data [String, nil] File data in memory
+    # @param archive_path [String] Path within the archive
+    # @param options [Hash] Format-specific options
+    # @raise [ArgumentError] if validation fails
+    def initialize(archive_path:, source: nil, data: nil, **options)
+      @source_path = source
+      @data = data
+      @archive_path = archive_path
+      @options = options
+
+      validate!
+    end
+
+    # Check if file data is from disk
+    #
+    # @return [Boolean] true if file is on disk
+    def from_disk?
+      !@source_path.nil?
+    end
+
+    # Check if file data is in memory
+    #
+    # @return [Boolean] true if data is in memory
+    def from_memory?
+      !@data.nil?
+    end
+
+    # Read file data (from disk or memory)
+    #
+    # @return [String] File contents
+    def read_data
+      return @data if from_memory?
+
+      File.binread(@source_path)
+    end
+
+    # Get file size
+    #
+    # @return [Integer] File size in bytes
+    def size
+      return @data.bytesize if from_memory?
+
+      File.size(@source_path)
+    end
+
+    # Get file stat (disk files only)
+    #
+    # @return [File::Stat, nil] File stat or nil for memory files
+    def stat
+      return nil if from_memory?
+
+      File.stat(@source_path)
+    end
+
+    # Get modification time
+    #
+    # @return [Time] Modification time (current time for memory files)
+    def mtime
+      return Time.now if from_memory?
+
+      stat&.mtime || Time.now
+    end
+
+    # Get file attributes
+    #
+    # @return [Integer] File attributes flags
+    def attributes
+      return @options[:attributes] if @options[:attributes]
+      return Constants::ATTRIB_ARCH if from_memory?
+
+      calculate_disk_attributes
+    end
+
+    # Get compression flag from options
+    #
+    # @return [Boolean] Whether to compress this file
+    def compress?
+      @options.fetch(:compress, true)
+    end
+
+    private
+
+    # Validate entry parameters
+    #
+    # @raise [ArgumentError] if invalid
+    def validate!
+      if @source_path.nil? && @data.nil?
+        raise ArgumentError,
+              "Must provide either source or data"
+      end
+
+      if @source_path && @data
+        raise ArgumentError,
+              "Cannot provide both source and data"
+      end
+
+      if @source_path
+        unless File.exist?(@source_path)
+          raise ArgumentError,
+                "File not found: #{@source_path}"
+        end
+
+        unless File.file?(@source_path)
+          raise ArgumentError,
+                "Not a file: #{@source_path}"
+        end
+      end
+
+      raise ArgumentError, "Archive path required" if @archive_path.nil?
+    end
+
+    # Calculate attributes from disk file stat
+    #
+    # @return [Integer] Attribute flags
+    def calculate_disk_attributes
+      file_stat = stat
+      return Constants::ATTRIB_ARCH unless file_stat
+
+      attribs = Constants::ATTRIB_ARCH
+
+      # Read-only flag
+      attribs |= Constants::ATTRIB_READONLY unless file_stat.writable?
+
+      # Executable flag (Unix systems)
+      attribs |= Constants::ATTRIB_EXEC if file_stat.executable?
+
+      attribs
+    end
+  end
+end

data/lib/cabriolet/file_manager.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "file_entry"
+
+module Cabriolet
+  # Manages collection of files for archive creation
+  #
+  # Single responsibility: File list management and enumeration.
+  # Provides unified interface for adding files from disk or memory,
+  # and supports standard Ruby enumeration patterns.
+  #
+  # @example Basic usage
+  #   manager = FileManager.new
+  #   manager.add_file("/path/to/file.txt", "docs/file.txt")
+  #   manager.add_data("Hello", "greeting.txt")
+  #   manager.each { |entry| puts entry.archive_path }
+  class FileManager
+    include Enumerable
+
+    # Initialize empty file manager
+    def initialize
+      @entries = []
+    end
+
+    # Add file from disk
+    #
+    # @param source_path [String] Path to source file
+    # @param archive_path [String, nil] Path in archive (nil = use basename)
+    # @param options [Hash] Format-specific options
+    # @return [FileEntry] Added entry
+    # @raise [ArgumentError] if file doesn't exist
+    def add_file(source_path, archive_path = nil, **options)
+      archive_path ||= File.basename(source_path)
+
+      entry = FileEntry.new(
+        source: source_path,
+        archive_path: archive_path,
+        **options,
+      )
+
+      @entries << entry
+      entry
+    end
+
+    # Add file from memory
+    #
+    # @param data [String] File data
+    # @param archive_path [String] Path in archive
+    # @param options [Hash] Format-specific options
+    # @return [FileEntry] Added entry
+    def add_data(data, archive_path, **options)
+      entry = FileEntry.new(
+        data: data,
+        archive_path: archive_path,
+        **options,
+      )
+
+      @entries << entry
+      entry
+    end
+
+    # Enumerate entries (Enumerable interface)
+    #
+    # @yield [FileEntry] Each file entry
+    def each(&)
+      @entries.each(&)
+    end
+
+    # Check if empty
+    #
+    # @return [Boolean] true if no files added
+    def empty?
+      @entries.empty?
+    end
+
+    # Get count of entries
+    #
+    # @return [Integer] Number of entries
+    def size
+      @entries.size
+    end
+    alias count size
+
+    # Get entry by index
+    #
+    # @param index [Integer] Entry index
+    # @return [FileEntry, nil] Entry or nil if out of bounds
+    def [](index)
+      @entries[index]
+    end
+
+    # Get all entries
+    #
+    # @return [Array<FileEntry>] Copy of entries array
+    def all
+      @entries.dup
+    end
+
+    # Clear all entries
+    #
+    # @return [self]
+    def clear
+      @entries.clear
+      self
+    end
+
+    # Calculate total size of all files
+    #
+    # @return [Integer] Total size in bytes
+    def total_size
+      @entries.sum(&:size)
+    end
+
+    # Get files from disk
+    #
+    # @return [Array<FileEntry>] Disk-based entries
+    def disk_files
+      @entries.select(&:from_disk?)
+    end
+
+    # Get files from memory
+    #
+    # @return [Array<FileEntry>] Memory-based entries
+    def memory_files
+      @entries.select(&:from_memory?)
+    end
+
+    # Find entry by archive path
+    #
+    # @param path [String] Archive path to find
+    # @return [FileEntry, nil] Entry or nil if not found
+    def find_by_path(path)
+      @entries.find { |entry| entry.archive_path == path }
+    end
+
+    # Check if archive path exists
+    #
+    # @param path [String] Archive path to check
+    # @return [Boolean] true if path exists
+    def path_exists?(path)
+      !find_by_path(path).nil?
+    end
+  end
+end

data/lib/cabriolet/hlp/command_handler.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require_relative "../cli/base_command_handler"
+require_relative "decompressor"
+require_relative "compressor"
+
+module Cabriolet
+  module HLP
+    # Command handler for HLP (Help) format
+    #
+    # This handler implements the unified command interface for HLP files,
+    # wrapping the existing HLP::Decompressor and HLP::Compressor classes.
+    # Supports both QuickHelp and Windows Help formats.
+    #
+    class CommandHandler < Commands::BaseCommandHandler
+      # List HLP file contents
+      #
+      # Displays information about the HLP file including format type,
+      # and lists all contained files with their sizes.
+      #
+      # @param file [String] Path to the HLP file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def list(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+
+        display_header(header, file)
+        display_files(decompressor, header)
+
+        decompressor.close(header)
+      end
+
+      # Extract files from HLP archive
+      #
+      # Extracts all files from the HLP file to the specified output directory.
+      # Supports both QuickHelp and Windows Help formats.
+      #
+      # @param file [String] Path to the HLP file
+      # @param output_dir [String] Output directory path (default: current directory)
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def extract(file, output_dir = nil, _options = {})
+        validate_file_exists(file)
+
+        output_dir ||= "."
+        output_dir = ensure_output_dir(output_dir)
+
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+
+        count = decompressor.extract_all(header, output_dir)
+        decompressor.close(header)
+
+        puts "Extracted #{count} file(s) to #{output_dir}"
+      end
+
+      # Create a new HLP archive
+      #
+      # Creates an HLP file from source files using QuickHelp format.
+      #
+      # @param output [String] Output HLP file path
+      # @param files [Array<String>] List of input files to add
+      # @param options [Hash] Additional options
+      # @option options [String] :format HLP format (:quickhelp, :winhelp)
+      # @return [void]
+      # @raise [ArgumentError] if no files specified
+      def create(output, files = [], options = {})
+        raise ArgumentError, "No files specified" if files.empty?
+
+        files.each do |f|
+          raise ArgumentError, "File does not exist: #{f}" unless File.exist?(f)
+        end
+
+        format = parse_format_option(options[:format])
+
+        if format == :winhelp
+          create_winhelp(output, files, options)
+        else
+          create_quickhelp(output, files, options)
+        end
+      end
+
+      # Display detailed HLP file information
+      #
+      # Shows comprehensive information about the HLP structure,
+      # including format type, file count, and metadata.
+      #
+      # @param file [String] Path to the HLP file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def info(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+
+        display_hlp_info(header, file)
+
+        decompressor.close(header)
+      end
+
+      # Test HLP file integrity
+      #
+      # Verifies the HLP file structure.
+      #
+      # @param file [String] Path to the HLP file
+      # @param options [Hash] Additional options (unused)
+      # @return [void]
+      def test(file, _options = {})
+        validate_file_exists(file)
+
+        decompressor = Decompressor.new
+        header = decompressor.open(file)
+
+        puts "Testing #{file}..."
+        # TODO: Implement full integrity testing
+        format_name = if header.respond_to?(:version)
+                        version_value = header.version
+                        # Convert BinData objects to integer for comparison
+                        version_int = version_value.to_i if version_value.respond_to?(:to_i)
+
+                        if version_value.is_a?(Integer) || version_int&.positive?
+                          "QUICKHELP v#{version_value}"
+                        elsif version_value.is_a?(Symbol)
+                          version_value.to_s.upcase.sub("WINHELP", "WinHelp ")
+                        else
+                          "unknown"
+                        end
+                      end
+        puts "OK: HLP file structure is valid (#{format_name} format)"
+
+        decompressor.close(header)
+      end
+
+      private
+
+      # Display HLP header information
+      #
+      # @param header [Object] The HLP header object
+      # @param file [String] Original file path
+      # @return [void]
+      def display_header(header, file)
+        format_name = if header.respond_to?(:version)
+                        version_value = header.version
+                        # Convert BinData objects to integer for comparison
+                        version_int = version_value.to_i if version_value.respond_to?(:to_i)
+
+                        if version_value.is_a?(Integer) || version_int&.positive?
+                          "QUICKHELP v#{version_value}"
+                        elsif header.version.is_a?(Symbol)
+                          header.version.to_s.upcase.sub("WINHELP", "WinHelp ")
+                        else
+                          header.version.to_s
+                        end
+                      end
+        puts "HLP File: #{file}"
+        puts "Format: #{format_name || 'unknown'}"
+        puts "\nFiles:"
+      end
+
+      # Display list of files in HLP
+      #
+      # @param decompressor [Decompressor] The decompressor instance
+      # @param header [Object] The HLP header object
+      # @return [void]
+      def display_files(_decompressor, header)
+        if header.respond_to?(:files)
+          header.files.each do |f|
+            puts "  #{f.filename} (#{f.length} bytes)"
+          end
+        else
+          puts "  (File listing not available for this format)"
+        end
+      end
+
+      # Display comprehensive HLP information
+      #
+      # @param header [Object] The HLP header object
+      # @param file [String] Original file path
+      # @return [void]
+      def display_hlp_info(header, file)
+        puts "HLP File Information"
+        puts "=" * 50
+        puts "Filename: #{file}"
+
+        if header.respond_to?(:version)
+          version_value = header.version
+          # Convert BinData objects to integer for comparison
+          version_int = version_value.to_i if version_value.respond_to?(:to_i)
+
+          format_name = if version_value.is_a?(Integer) || version_int&.positive?
+                          "QUICKHELP v#{version_value}"
+                        elsif version_value.is_a?(Symbol)
+                          version_value.to_s.upcase.sub("WINHELP", "WinHelp ")
+                        else
+                          version_value.to_s
+                        end
+          puts "Format: #{format_name}"
+        end
+
+        if header.respond_to?(:length)
+          puts "Size: #{header.length} bytes"
+        end
+
+        if header.respond_to?(:files)
+          puts "Files: #{header.files.size}"
+          puts ""
+          puts "Files:"
+          header.files.each do |f|
+            puts "  #{f.filename}"
+            puts "    Size: #{f.length} bytes"
+          end
+        end
+      end
+
+      # Create QuickHelp format HLP file
+      #
+      # @param output [String] Output file path
+      # @param files [Array<String>] Input files
+      # @param options [Hash] Additional options
+      # @return [void]
+      def create_quickhelp(output, files, _options)
+        compressor = Compressor.new
+
+        files.each do |f|
+          # Default: add files with compression
+          archive_name = File.basename(f)
+          compressor.add_file(f, "/#{archive_name}", compress: true)
+        end
+
+        puts "Creating #{output} with #{files.size} file(s) (QuickHelp format)" if verbose?
+        bytes = compressor.generate(output)
+        puts "Created #{output} (#{bytes} bytes, #{files.size} files)"
+      end
+
+      # Create Windows Help format HLP file
+      #
+      # @param output [String] Output file path
+      # @param files [Array<String>] Input files
+      # @param options [Hash] Additional options
+      # @return [void]
+      def create_winhelp(output, files, _options)
+        compressor = Compressor.create_winhelp
+
+        files.each do |f|
+          archive_name = File.basename(f)
+          # WinHelp compression uses different API
+          compressor.add_file(f, "/#{archive_name}")
+        end
+
+        puts "Creating #{output} with #{files.size} file(s) (WinHelp format)" if verbose?
+        bytes = compressor.generate(output)
+        puts "Created #{output} (#{bytes} bytes, #{files.size} files)"
+      end
+
+      # Parse format option to symbol
+      #
+      # @param format_value [String, Symbol] The format type
+      # @return [Symbol] The format symbol
+      def parse_format_option(format_value)
+        return :quickhelp if format_value.nil?
+
+        format = format_value.to_sym
+        valid_formats = %i[quickhelp winhelp]
+
+        # Map :hlp to default :quickhelp format
+        format = :quickhelp if format == :hlp
+
+        unless valid_formats.include?(format)
+          raise ArgumentError,
+                "Invalid HLP format: #{format_value}. " \
+                "Valid options: #{valid_formats.join(', ')}"
+        end
+
+        format
+      end
+    end
+  end
+end