cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/plugin_validator.rb

@@ -0,0 +1,422 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # Validates plugin classes and configurations
+  #
+  # The PluginValidator provides comprehensive validation for plugins
+  # including inheritance checks, metadata validation, version
+  # compatibility, and safety scanning.
+  #
+  # @example Validate a plugin class
+  #   result = PluginValidator.validate(MyPlugin)
+  #   if result[:valid]
+  #     puts "Plugin is valid"
+  #   else
+  #     puts "Errors: #{result[:errors].join(', ')}"
+  #   end
+  class PluginValidator
+    # Required metadata fields
+    REQUIRED_METADATA = %i[name version author description
+                           cabriolet_version].freeze
+
+    # Dangerous method names to check for
+    DANGEROUS_METHODS = %w[
+      system exec spawn ` fork eval instance_eval class_eval
+      module_eval binding const_set remove_const send __send__
+      method_missing respond_to_missing?
+    ].freeze
+
+    class << self
+      # Validate a plugin class
+      #
+      # Performs comprehensive validation including inheritance, metadata,
+      # version compatibility, and safety checks.
+      #
+      # @param plugin_class [Class] Plugin class to validate
+      #
+      # @return [Hash] Validation result with:
+      #   - :valid [Boolean] True if all checks pass
+      #   - :errors [Array<String>] List of validation errors (empty if
+      #     valid)
+      #   - :warnings [Array<String>] List of warnings (non-fatal issues)
+      #
+      # @example Validate a plugin
+      #   result = PluginValidator.validate(MyPlugin)
+      #   result[:valid] #=> true
+      #   result[:errors] #=> []
+      #   result[:warnings] #=> ["Uses eval in setup method"]
+      def validate(plugin_class)
+        errors = []
+        warnings = []
+
+        # Check inheritance
+        inherit_errors = validate_inheritance(plugin_class)
+        errors.concat(inherit_errors)
+
+        # If inheritance fails, stop here
+        return { valid: false, errors: errors, warnings: warnings } unless
+          inherit_errors.empty?
+
+        # Create instance to check metadata
+        begin
+          instance = plugin_class.new(nil)
+          metadata = instance.metadata
+
+          # Validate metadata
+          meta_errors = validate_metadata(metadata)
+          errors.concat(meta_errors)
+
+          # Check version compatibility
+          if metadata[:cabriolet_version]
+            version_errors = validate_version_compatibility(
+              metadata[:cabriolet_version],
+              Cabriolet::VERSION,
+            )
+            errors.concat(version_errors)
+          end
+
+          # Validate dependencies
+          if metadata[:dependencies]
+            dep_warnings = validate_dependencies(metadata[:dependencies])
+            warnings.concat(dep_warnings)
+          end
+        rescue NotImplementedError => e
+          errors << "Plugin does not implement required method: " \
+                    "#{e.message}"
+        rescue StandardError => e
+          errors << "Failed to instantiate plugin: #{e.message}"
+        end
+
+        # Safety checks
+        safety_warnings = check_safety(plugin_class)
+        warnings.concat(safety_warnings)
+
+        {
+          valid: errors.empty?,
+          errors: errors,
+          warnings: warnings,
+        }
+      end
+
+      # Validate plugin inheritance
+      #
+      # Checks that the plugin class properly inherits from
+      # Cabriolet::Plugin.
+      #
+      # @param plugin_class [Class] Plugin class to validate
+      #
+      # @return [Array<String>] List of inheritance errors (empty if valid)
+      #
+      # @example Valid inheritance
+      #   PluginValidator.validate_inheritance(MyPlugin)
+      #   #=> []
+      #
+      # @example Invalid inheritance
+      #   PluginValidator.validate_inheritance(Object)
+      #   #=> ["Plugin must inherit from Cabriolet::Plugin"]
+      def validate_inheritance(plugin_class)
+        errors = []
+
+        unless plugin_class.is_a?(Class)
+          errors << "Plugin must be a class, got #{plugin_class.class}"
+          return errors
+        end
+
+        unless plugin_class < Plugin
+          errors << "Plugin must inherit from Cabriolet::Plugin"
+        end
+
+        errors
+      end
+
+      # Validate plugin metadata
+      #
+      # Checks that all required metadata fields are present and valid.
+      #
+      # @param metadata [Hash] Plugin metadata to validate
+      #
+      # @return [Array<String>] List of metadata errors (empty if valid)
+      #
+      # @example Valid metadata
+      #   meta = { name: "test", version: "1.0", ... }
+      #   PluginValidator.validate_metadata(meta)
+      #   #=> []
+      #
+      # @example Missing fields
+      #   PluginValidator.validate_metadata({})
+      #   #=> ["Missing required metadata: name, version, ..."]
+      def validate_metadata(metadata)
+        errors = []
+
+        unless metadata.is_a?(Hash)
+          errors << "Metadata must be a Hash"
+          return errors
+        end
+
+        # Check required fields
+        missing = REQUIRED_METADATA - metadata.keys
+        unless missing.empty?
+          errors << "Missing required metadata: #{missing.join(', ')}"
+        end
+
+        # Validate field types and formats
+        if metadata[:name]
+          unless metadata[:name].is_a?(String) &&
+              !metadata[:name].empty?
+            errors << "Plugin name must be a non-empty string"
+          end
+
+          if metadata[:name].is_a?(String) && metadata[:name] =~ /^[a-z0-9_-]+$/
+            # Valid format - do nothing
+          elsif metadata[:name].is_a?(String)
+            errors << "Plugin name must contain only lowercase letters, " \
+                      "numbers, hyphens, and underscores"
+          end
+        end
+
+        if metadata[:version] && !valid_version?(metadata[:version])
+          errors << "Plugin version must be a valid semantic version " \
+                    "(e.g., '1.0.0')"
+        end
+
+        if metadata[:author] && !(metadata[:author].is_a?(String) &&
+                 !metadata[:author].empty?)
+          errors << "Plugin author must be a non-empty string"
+        end
+
+        if metadata[:description] && !(metadata[:description].is_a?(String) &&
+                 !metadata[:description].empty?)
+          errors << "Plugin description must be a non-empty string"
+        end
+
+        # Optional fields validation
+        if metadata[:homepage] && !metadata[:homepage].empty? && !valid_url?(metadata[:homepage])
+          errors << "Plugin homepage must be a valid URL"
+        end
+
+        if metadata[:dependencies] && !metadata[:dependencies].is_a?(Array)
+          errors << "Plugin dependencies must be an array"
+        end
+
+        if metadata[:tags] && !metadata[:tags].is_a?(Array)
+          errors << "Plugin tags must be an array"
+        end
+
+        errors
+      end
+
+      # Validate version compatibility
+      #
+      # Checks if the plugin's required Cabriolet version matches the
+      # current version.
+      #
+      # @param plugin_version [String] Required Cabriolet version
+      # @param cabriolet_version [String] Current Cabriolet version
+      #
+      # @return [Array<String>] List of version errors (empty if
+      #   compatible)
+      #
+      # @example Compatible version
+      #   PluginValidator.validate_version_compatibility("~> 0.1", "0.1.0")
+      #   #=> []
+      #
+      # @example Incompatible version
+      #   PluginValidator.validate_version_compatibility(">= 2.0", "0.1.0")
+      #   #=> ["Plugin requires Cabriolet version >= 2.0, ..."]
+      def validate_version_compatibility(plugin_version, cabriolet_version)
+        errors = []
+
+        # Parse version requirement
+        if plugin_version.start_with?("~>")
+          # Pessimistic version constraint
+          required = plugin_version.sub("~>", "").strip
+          unless version_compatible?(cabriolet_version, required, :pessimistic)
+            errors << "Plugin requires Cabriolet version ~> #{required}, " \
+                      "but #{cabriolet_version} is installed"
+          end
+        elsif plugin_version.start_with?(">=")
+          # Minimum version
+          required = plugin_version.sub(">=", "").strip
+          unless version_compatible?(cabriolet_version, required, :gte)
+            errors << "Plugin requires Cabriolet version >= #{required}, " \
+                      "but #{cabriolet_version} is installed"
+          end
+        elsif plugin_version.start_with?("=")
+          # Exact version
+          required = plugin_version.sub("=", "").strip
+          unless cabriolet_version == required
+            errors << "Plugin requires exact Cabriolet version #{required}, " \
+                      "but #{cabriolet_version} is installed"
+          end
+        end
+
+        errors
+      end
+
+      # Validate plugin dependencies
+      #
+      # Checks if dependency specifications are valid. This performs
+      # format validation only; actual dependency resolution happens at
+      # load time.
+      #
+      # @param dependencies [Array<String>] Dependency specifications
+      #
+      # @return [Array<String>] List of validation warnings
+      #
+      # @example Valid dependencies
+      #   deps = ["other-plugin >= 1.0"]
+      #   PluginValidator.validate_dependencies(deps)
+      #   #=> []
+      def validate_dependencies(dependencies)
+        warnings = []
+
+        unless dependencies.is_a?(Array)
+          warnings << "Dependencies must be an array"
+          return warnings
+        end
+
+        dependencies.each do |dep|
+          unless dep.is_a?(String)
+            warnings << "Each dependency must be a string"
+            next
+          end
+
+          parts = dep.split
+          if parts.empty?
+            warnings << "Empty dependency specification"
+          elsif !/^[a-z0-9_-]+$/.match?(parts[0])
+            warnings << "Invalid dependency name: #{parts[0]}"
+          end
+        end
+
+        warnings
+      end
+
+      # Check plugin for potentially dangerous code
+      #
+      # Scans the plugin's source code for dangerous method calls that
+      # might pose security risks.
+      #
+      # @param plugin_class [Class] Plugin class to check
+      #
+      # @return [Array<String>] List of safety warnings
+      #
+      # @example Safe plugin
+      #   PluginValidator.check_safety(MySafePlugin)
+      #   #=> []
+      #
+      # @example Potentially dangerous plugin
+      #   PluginValidator.check_safety(MyDangerousPlugin)
+      #   #=> ["Uses system call in setup method"]
+      def check_safety(plugin_class)
+        warnings = []
+
+        # Get source location
+        begin
+          methods_to_check = %i[setup activate metadata]
+
+          methods_to_check.each do |method_name|
+            next unless plugin_class.method_defined?(method_name, false)
+
+            method_obj = plugin_class.instance_method(method_name)
+            source_location = method_obj.source_location
+
+            if source_location && File.exist?(source_location[0])
+              source = File.read(source_location[0])
+
+              DANGEROUS_METHODS.each do |dangerous|
+                pattern = /\b#{Regexp.escape(dangerous)}\b/
+                if source&.match?(pattern)
+                  warnings << "Plugin uses potentially dangerous method " \
+                              "'#{dangerous}' " \
+                              "in #{source_location[0]}"
+                end
+              end
+            end
+          end
+        rescue StandardError => e
+          warnings << "Could not perform safety check: #{e.message}"
+        end
+
+        warnings
+      end
+
+      private
+
+      # Check if a version string is valid
+      #
+      # @param version [String] Version string to check
+      #
+      # @return [Boolean] True if valid
+      def valid_version?(version)
+        version.is_a?(String) && version =~ /^\d+\.\d+(\.\d+)?$/
+      end
+
+      # Check if a URL is valid
+      #
+      # @param url [String] URL string to check
+      #
+      # @return [Boolean] True if valid
+      def valid_url?(url)
+        url.is_a?(String) && url =~ %r{^https?://}
+      end
+
+      # Check version compatibility
+      #
+      # @param actual [String] Actual version
+      # @param required [String] Required version
+      # @param constraint [Symbol] Constraint type (:gte, :pessimistic)
+      #
+      # @return [Boolean] True if compatible
+      def version_compatible?(actual, required, constraint)
+        actual_parts = actual.split(".").map(&:to_i)
+        required_parts = required.split(".").map(&:to_i)
+
+        case constraint
+        when :gte
+          compare_versions(actual_parts, required_parts) >= 0
+        when :pessimistic
+          # ~> 1.2 means >= 1.2 and < 2.0
+          # ~> 1.2.3 means >= 1.2.3 and < 1.3
+          return false if compare_versions(actual_parts,
+                                           required_parts).negative?
+
+          upper = required_parts.dup
+          if required_parts.length >= 3
+            # Patch-level constraint
+            upper[1] += 1
+            upper[2] = 0
+          else
+            # Minor-level constraint
+            upper[0] += 1
+            upper[1] = 0
+          end
+
+          compare_versions(actual_parts, upper).negative?
+        else
+          false
+        end
+      end
+
+      # Compare version part arrays
+      #
+      # @param v1 [Array<Integer>] Version 1 parts
+      # @param v2 [Array<Integer>] Version 2 parts
+      #
+      # @return [Integer] -1, 0, or 1
+      def compare_versions(v1, v2)
+        max_length = [v1.length, v2.length].max
+
+        max_length.times do |i|
+          p1 = v1[i] || 0
+          p2 = v2[i] || 0
+
+          return -1 if p1 < p2
+          return 1 if p1 > p2
+        end
+
+        0
+      end
+    end
+  end
+end

data/lib/cabriolet/quantum_shared.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # Shared Quantum compression constants and models
+  # Used by both Compressors::Quantum and Decompressors::Quantum
+  module QuantumShared
+    # Frame size (32KB per frame)
+    FRAME_SIZE = 32_768
+
+    # Match constants
+    MIN_MATCH = 3
+    MAX_MATCH = 259
+
+    # Position slot tables (same as in qtmd.c)
+    POSITION_BASE = [
+      0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384,
+      512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12_288, 16_384,
+      24_576, 32_768, 49_152, 65_536, 98_304, 131_072, 196_608, 262_144,
+      393_216, 524_288, 786_432, 1_048_576, 1_572_864
+    ].freeze
+
+    EXTRA_BITS = [
+      0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
+      9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
+      17, 17, 18, 18, 19, 19
+    ].freeze
+
+    LENGTH_BASE = [
+      0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 14, 18, 22, 26,
+      30, 38, 46, 54, 62, 78, 94, 110, 126, 158, 190, 222, 254
+    ].freeze
+
+    LENGTH_EXTRA = [
+      0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
+      3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0
+    ].freeze
+
+    # Represents a symbol in an arithmetic coding model
+    class ModelSymbol
+      attr_accessor :sym, :cumfreq
+
+      def initialize(sym, cumfreq)
+        @sym = sym
+        @cumfreq = cumfreq
+      end
+    end
+
+    # Represents an arithmetic coding model
+    class Model
+      attr_accessor :shiftsleft, :entries, :syms
+
+      def initialize(syms, entries)
+        @syms = syms
+        @entries = entries
+        @shiftsleft = 4
+      end
+    end
+
+    # Find position slot for a given offset
+    #
+    # @param offset [Integer] Position offset
+    # @return [Integer] Position slot index
+    def self.find_position_slot(offset)
+      return 0 if offset < 4
+
+      # Binary search through POSITION_BASE
+      low = 1
+      high = POSITION_BASE.size - 1
+
+      while low < high
+        mid = (low + high + 1) / 2
+        if POSITION_BASE[mid] <= offset
+          low = mid
+        else
+          high = mid - 1
+        end
+      end
+
+      low
+    end
+
+    # Find length slot for a given length
+    #
+    # @param length [Integer] Match length
+    # @return [Integer] Length slot index
+    def self.find_length_slot(length)
+      return 0 if length < 4
+
+      # Binary search through LENGTH_BASE
+      low = 1
+      high = LENGTH_BASE.size - 1
+
+      while low < high
+        mid = (low + high + 1) / 2
+        if LENGTH_BASE[mid] <= length
+          low = mid
+        else
+          high = mid - 1
+        end
+      end
+
+      low
+    end
+  end
+end

data/lib/cabriolet/system/io_system.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "file_handle"
+require_relative "memory_handle"
+
 module Cabriolet
   module System
     # IOSystem provides an abstraction layer for file I/O operations,

data/lib/cabriolet/system/memory_handle.rb

@@ -19,13 +19,19 @@ module Cabriolet
 
       # Read bytes from memory
       #
-      # @param bytes [Integer] Number of bytes to read
+      # @param bytes [Integer, nil] Number of bytes to read (nil = read all remaining)
       # @return [String] Bytes read (binary encoding)
-      def read(bytes)
+      def read(bytes = nil)
         return "" if @pos >= @data.bytesize
 
-        result = @data.byteslice(@pos, bytes) || ""
-        @pos += result.bytesize
+        if bytes.nil?
+          # Read all remaining data
+          result = @data.byteslice(@pos..-1) || ""
+          @pos = @data.bytesize
+        else
+          result = @data.byteslice(@pos, bytes) || ""
+          @pos += result.bytesize
+        end
         result
       end
 
@@ -77,6 +83,13 @@ module Cabriolet
         @pos
       end
 
+      # Rewind to the beginning of the handle
+      #
+      # @return [Integer] New position (0)
+      def rewind
+        @pos = 0
+      end
+
       # Close the handle
       #
       # @return [void]