cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/extraction/file_extraction_work.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "fractor"
+
+module Cabriolet
+  module Extraction
+    # Work item for file extraction using Fractor
+    class FileExtractionWork < Fractor::Work
+      # Initialize work item for extracting a single file
+      #
+      # @param file [Object] File object from archive (responds to :name, :data)
+      # @param output_dir [String] Output directory path
+      # @param preserve_paths [Boolean] Whether to preserve directory structure
+      # @param overwrite [Boolean] Whether to overwrite existing files
+      def initialize(file, output_dir:, preserve_paths: true, overwrite: false)
+        super({
+          file: file,
+          output_dir: output_dir,
+          preserve_paths: preserve_paths,
+          overwrite: overwrite,
+        })
+      end
+
+      # The file object to extract
+      #
+      # @return [Object] File from archive
+      def file
+        input[:file]
+      end
+
+      # Output directory for extraction
+      #
+      # @return [String] Directory path
+      def output_dir
+        input[:output_dir]
+      end
+
+      # Whether to preserve directory structure
+      #
+      # @return [Boolean]
+      def preserve_paths
+        input[:preserve_paths]
+      end
+
+      # Whether to overwrite existing files
+      #
+      # @return [Boolean]
+      def overwrite
+        input[:overwrite]
+      end
+
+      # Unique identifier for this work item (filename based)
+      #
+      # @return [String] Unique identifier
+      def id
+        file.name
+      end
+    end
+  end
+end

data/lib/cabriolet/extraction/file_extraction_worker.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Cabriolet
+  module Extraction
+    # Worker for extracting files using Fractor
+    class FileExtractionWorker < Fractor::Worker
+      # Process a file extraction work item
+      #
+      # @param work [FileExtractionWork] Work item to process
+      # @return [Fractor::WorkResult] Result of extraction
+      def process(work)
+        output_path = build_output_path(work)
+
+        # Check if file exists and skip if not overwriting
+        if ::File.exist?(output_path) && !work.overwrite
+          return skipped_result(work, "File already exists")
+        end
+
+        # Create parent directory
+        dir = ::File.dirname(output_path)
+        FileUtils.mkdir_p(dir) unless ::File.directory?(dir)
+
+        # Get file data
+        data = work.file.data
+        unless data
+          return skipped_result(work, "No data available")
+        end
+
+        # Write file data
+        ::File.binwrite(output_path, data)
+
+        # Preserve file attributes if available
+        preserve_file_attributes(output_path, work.file)
+
+        # Return success result
+        Fractor::WorkResult.new(
+          result: {
+            path: output_path,
+            size: data.bytesize,
+            name: work.file.name,
+          },
+          work: work,
+        )
+      rescue StandardError => e
+        # Return error result
+        Fractor::WorkResult.new(
+          error: {
+            message: e.message,
+            class: e.class.name,
+            backtrace: e.backtrace.first(5),
+          },
+          work: work,
+        )
+      end
+
+      private
+
+      # Build the output path for a file
+      #
+      # @param work [FileExtractionWork] Work item containing file and options
+      # @return [String] Full output path
+      def build_output_path(work)
+        # Normalize path separators (Windows archives use backslashes)
+        clean_name = work.file.name.gsub("\\", "/")
+
+        if work.preserve_paths
+          ::File.join(work.output_dir, clean_name)
+        else
+          ::File.join(work.output_dir, ::File.basename(clean_name))
+        end
+      end
+
+      # Preserve file attributes (timestamps, etc.)
+      #
+      # @param path [String] Path to extracted file
+      # @param file [Object] File object from archive
+      def preserve_file_attributes(path, file)
+        # Try various timestamp attributes that different formats use
+        if file.respond_to?(:datetime) && file.datetime
+          ::File.utime(::File.atime(path), file.datetime, path)
+        elsif file.respond_to?(:mtime) && file.mtime
+          atime = file.respond_to?(:atime) ? file.atime : ::File.atime(path)
+          ::File.utime(atime, file.mtime, path)
+        end
+      end
+
+      # Create a skipped result
+      #
+      # @param work [FileExtractionWork] Work item that was skipped
+      # @param reason [String] Reason for skipping
+      # @return [Fractor::WorkResult] Skipped result
+      def skipped_result(work, reason)
+        Fractor::WorkResult.new(
+          result: {
+            status: :skipped,
+            name: work.file.name,
+            reason: reason,
+          },
+          work: work,
+        )
+      end
+    end
+  end
+end

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/format_base.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # FormatBase provides common functionality for all format-specific compressors
+  # and decompressors, reducing code duplication and establishing consistent patterns.
+  class FormatBase
+    # Initialize a format handler with common dependencies
+    #
+    # @param io_system [System::IOSystem, nil] I/O system for file operations
+    # @param algorithm_factory [AlgorithmFactory, nil] Factory for compression algorithms
+    def initialize(io_system = nil, algorithm_factory = nil)
+      @io_system = io_system || System::IOSystem.new
+      @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
+    end
+
+    protected
+
+    # Execute a block with file handles, automatically closing them after completion
+    #
+    # @param input_path [String] Path to input file
+    # @param output_path [String, nil] Path to output file (optional)
+    # @yield [Array<System::FileHandle>] File handles for input and output
+    # @return [Object] Return value of the block
+    def with_file_handles(input_path, output_path = nil)
+      input_handle = @io_system.open(input_path, Constants::MODE_READ)
+      output_handle = if output_path
+                        @io_system.open(output_path,
+                                        Constants::MODE_WRITE)
+                      end
+
+      begin
+        yield [input_handle, output_handle].compact
+      ensure
+        @io_system.close(input_handle) if input_handle
+        @io_system.close(output_handle) if output_handle
+      end
+    end
+
+    # Create a compressor using the algorithm factory
+    #
+    # @param algorithm [Symbol] Compression algorithm type
+    # @param input [System::FileHandle, System::MemoryHandle] Input handle
+    # @param output [System::FileHandle, System::MemoryHandle] Output handle
+    # @param size [Integer] Data size
+    # @param options [Hash] Additional options for the compressor
+    # @return [Object] Compressor instance
+    def create_compressor(algorithm, input, output, size, **options)
+      @algorithm_factory.create(
+        algorithm,
+        :compressor,
+        @io_system,
+        input,
+        output,
+        size,
+        **options,
+      )
+    end
+
+    # Create a decompressor using the algorithm factory
+    #
+    # @param algorithm [Symbol] Compression algorithm type
+    # @param input [System::FileHandle, System::MemoryHandle] Input handle
+    # @param output [System::FileHandle, System::MemoryHandle] Output handle
+    # @param size [Integer] Data size
+    # @param options [Hash] Additional options for the decompressor
+    # @return [Object] Decompressor instance
+    def create_decompressor(algorithm, input, output, size, **options)
+      @algorithm_factory.create(
+        algorithm,
+        :decompressor,
+        @io_system,
+        input,
+        output,
+        size,
+        **options,
+      )
+    end
+  end
+end