Class: Factorix::Dependency::Entry

Inherits:
Data
  • Object
show all
Defined in:
lib/factorix/dependency/entry.rb,
lib/factorix/dependency/entry.rb

Overview

Represents a single MOD dependency

This class encapsulates a MOD dependency with its type (required, optional, etc.) and optional version requirement.

Examples:

Creating dependencies

# Required dependency on base MOD
base_mod = MOD[name: "base"]
dep1 = Dependency::Entry[mod: base_mod, type: :required, version_requirement: nil]

# Optional dependency with version requirement
some_mod = MOD[name: "some-mod"]
requirement = MODVersionRequirement[operator: ">=", version: MODVersion.from_string("1.2.0")]
dep2 = Dependency::Entry[mod: some_mod, type: :optional, version_requirement: requirement]

# Incompatible MOD
bad_mod = MOD[name: "bad-mod"]
dep3 = Dependency::Entry[mod: bad_mod, type: :incompatible, version_requirement: nil]

Constant Summary collapse

REQUIRED =

Dependency type constants

:required
OPTIONAL = 
:optional
HIDDEN_OPTIONAL = 
:hidden
INCOMPATIBLE = 
:incompatible
LOAD_NEUTRAL = 
:load_neutral

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(mod:, type:, version_requirement: nil) ⇒ Entry

Create a new Entry

Parameters:

  • mod (MOD) —

    The dependent MOD

  • type (Symbol) —

    Type of dependency (:required, :optional, :hidden, :incompatible, :load_neutral)

  • version_requirement (MODVersionRequirement, nil) (defaults to: nil) —

    Version requirement (nil if no requirement)

Raises:

  • (ArgumentError) —

    if mod is not a MOD instance

  • (ArgumentError) —

    if type is not valid

  • (ArgumentError) —

    if version_requirement is not nil or MODVersionRequirement



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/factorix/dependency/entry.rb', line 58

def initialize(mod:, type:, version_requirement: nil)
  unless mod.is_a?(MOD)
    raise ArgumentError, "mod must be a MOD instance, got #{mod.class}"
  end

  unless VALID_TYPES.include?(type)
    raise ArgumentError, "Invalid dependency type: #{type}. Must be one of: #{VALID_TYPES.join(", ")}"
  end

  if version_requirement && !version_requirement.is_a?(MODVersionRequirement)
    raise ArgumentError, "version_requirement must be a MODVersionRequirement or nil, got #{version_requirement.class}"
  end

  super
end

Instance Attribute Details

#mod ⇒ MOD (readonly)

Returns The dependent MOD.

Returns:

  • (MOD) —

    The dependent MOD



6
7
8
 
# File 'lib/factorix/dependency/entry.rb', line 6

def mod
  @mod
end

#type ⇒ Symbol (readonly)

Returns Type of dependency (:required, :optional, :hidden, :incompatible, :load_neutral).

Returns:

  • (Symbol) —

    Type of dependency (:required, :optional, :hidden, :incompatible, :load_neutral)



6
7
8
 
# File 'lib/factorix/dependency/entry.rb', line 6

def type
  @type
end

#version_requirement ⇒ MODVersionRequirement? (readonly)

Returns Version requirement (nil if no requirement).

Returns:



6
7
8
 
# File 'lib/factorix/dependency/entry.rb', line 6

def version_requirement
  @version_requirement
end

Instance Method Details

#incompatible? ⇒ Boolean

Check if this is an incompatible (conflicting) dependency

Returns:

  • (Boolean) —

    true if dependency is incompatible



87
 
# File 'lib/factorix/dependency/entry.rb', line 87

def incompatible? = type == INCOMPATIBLE

#load_neutral? ⇒ Boolean

Check if this dependency does not affect load order

Returns:

  • (Boolean) —

    true if dependency is load-neutral



92
 
# File 'lib/factorix/dependency/entry.rb', line 92

def load_neutral? = type == LOAD_NEUTRAL

#optional? ⇒ Boolean

Check if this is an optional dependency (including hidden optional)

Returns:

  • (Boolean) —

    true if dependency is optional or hidden optional



82
 
# File 'lib/factorix/dependency/entry.rb', line 82

def optional? = type == OPTIONAL || type == HIDDEN_OPTIONAL

#required? ⇒ Boolean

Check if this is a required dependency

Returns:

  • (Boolean) —

    true if dependency is required



77
 
# File 'lib/factorix/dependency/entry.rb', line 77

def required? = type == REQUIRED

#satisfied_by?(version) ⇒ Boolean

Check if a given version satisfies this dependency’s version requirement

Parameters:

Returns:

  • (Boolean) —

    true if version requirement is satisfied, or true if no requirement exists



98
99
100
101
102
 
# File 'lib/factorix/dependency/entry.rb', line 98

def satisfied_by?(version)
  return true unless version_requirement

  version_requirement.satisfied_by?(version)
end

#to_s ⇒ String

Return string representation of the dependency

Returns:

  • (String) —

    String representation (e.g., “? some-mod >= 1.2.0”)



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/factorix/dependency/entry.rb', line 107

def to_s
  result = case type
           when REQUIRED then ""
           when OPTIONAL then "? "
           when HIDDEN_OPTIONAL then "(?) "
           when INCOMPATIBLE then "! "
           when LOAD_NEUTRAL then "~ "
           else
             raise ArgumentError, "Unexpected dependency type: #{type}"
           end

  result += mod.name
  result += " #{version_requirement}" if version_requirement
  result
end