Module: Mmi::PropertyAttributes

Included in:
Asset, AssetsProcessor, ModFileProcessor, Modloader::Fabric, Source::Github, Source::Modrinth, Source::Url
Defined in:
lib/mmi/property_attributes.rb

Defined Under Namespace

Modules: ClassMethods Classes: ValidationError

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.prepended(klass) ⇒ Object 



59
60
61
 
# File 'lib/mmi/property_attributes.rb', line 59

def self.prepended(klass)
  klass.extend(ClassMethods)
end

Instance Method Details

#[](key) ⇒ Object 



11
12
13
 
# File 'lib/mmi/property_attributes.rb', line 11

def [](key)
  @hash[key]
end

#initialize(hash) ⇒ Object 



3
4
5
 
# File 'lib/mmi/property_attributes.rb', line 3

def initialize(hash)
  @hash = hash
end

#parse! ⇒ Object 



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/mmi/property_attributes.rb', line 120

def parse!
  validate_constraints!
  
  self.class.registered_properties.each do |method_name, configuration|
    if !@hash.key?(configuration.key)
      if configuration.required || !configuration.default.nil?
        parsed_property_store[method_name] = configuration.default
      else
        # Do nothing.
      end
    elsif configuration.type.nil?
      parsed_property_store[method_name] = self[configuration.key]
    else
      deduced_type =
        if self.class.valid_hash_type?(configuration.type)
          configuration.type[:types].fetch(self[configuration.key][configuration.type[:field]])
        else
          configuration.type
        end
      
      initializer_proc = proc do |item|
        deduced_type.parse(item)
      end
      
      parsed_property_store[method_name] =
        self[configuration.key].then do |value|
          value.is_a?(Array) ? value.map(&initializer_proc) : initializer_proc[value]
        end
    end
  end
  
  self
end

#parsed_property_store ⇒ Object 



63
64
65
 
# File 'lib/mmi/property_attributes.rb', line 63

def parsed_property_store
  @parsed_property_store ||= {}
end

#to_h ⇒ Object 



7
8
9
 
# File 'lib/mmi/property_attributes.rb', line 7

def to_h
  @hash
end

#update_properties!(properties) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
# File 'lib/mmi/property_attributes.rb', line 154

def update_properties!(properties)
  raise(ArgumentError, 'argument must be a Hash'                                ) if !properties.is_a?(Hash)
  raise(ArgumentError, 'argument can only have keys that are defined properties') if (properties.keys - self.class.registered_properties.keys).any?
  
  old_property_store     = @parsed_property_store
  @parsed_property_store = nil
  
  old_properties = properties.map do |method_name, value|
    key = self.class.registered_properties[method_name].key
    
    old_value = @hash[key]
    
    if !value.nil?
      @hash[key] = value
    elsif @hash.key?(key)
      @hash.delete(key)
    end
    
    [method_name, old_value]
  end
  
  parse!
rescue ValidationError
  @parsed_property_store = old_property_store
  
  old_properties.each do |method_name, old_value|
    key = self.class.registered_properties[method_name].key
    
    if !old_value.nil?
      @hash[key] = old_value
    elsif @hash.key?(key)
      @hash.delete(key)
    end
  end
  
  raise
end

#validate_constraints! ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/mmi/property_attributes.rb', line 69

def validate_constraints!
  errors =
    self.class.registered_properties.map do |method_name, configuration|
      [
        method_name,
        [].tap do |property_errors|
          if configuration.required && !@hash.key?(configuration.key)
            property_errors << "missing field #{configuration.key}"
          elsif !configuration.required && @hash.key?(configuration.key)
            if (missing_requires = configuration.requires.reject{ |e| @hash.key?(e) }).any?
              property_errors << "missing required field(s) #{missing_requires.map(&:inspect).join(', ')}"
            end
            
            if (present_conflicts = configuration.conflicts.select{ |e| @hash.key?(e) }).any?
              property_errors << "conflicting with field(s) #{present_conflicts.map(&:inspect).join(', ')}"
            end
          end
          
          if @hash.key?(configuration.key) && self.class.valid_hash_type?(configuration.type)
            if !@hash.fetch(configuration.key).is_a?(Hash)
              property_errors << "field #{configuration.key.inspect} must be a Hash"
            elsif !@hash.fetch(configuration.key).key?(configuration.type[:field]) || !configuration.type[:types].keys.include?(@hash.fetch(configuration.key).fetch(configuration.type[:field]))
              property_errors << "field #{configuration.key.inspect} must have key #{configuration.type[:field].inspect} with one of values #{configuration.type[:types].keys.map(&:inspect).join(', ')}"
            end
          end
          
          if @hash.key?(configuration.key) && configuration.validate
            deduced_proc =
              if configuration.validate.is_a?(Symbol)
                self.class.method(configuration.validate)
              else
                configuration.validate
              end
            
            deduced_proc.call(@hash[configuration.key], property_errors)
          end
        end,
      ]
    end.select do |_, property_errors|
      property_errors.any?
    end.to_h
  
  if errors.none?
    true
  else
    raise(ValidationError, errors.map do |method_name, property_errors|
      "#{method_name}: #{property_errors.join(', ')}"
    end.join('; '))
  end
end