Module: Kettle::Jem::TemplateLock

Defined in:
lib/kettle/jem.rb

Constant Summary collapse

VERSION = 
1
TEMPLATE_STATE_KEY = 
"template_state"
FILES_KEY = 
"files"
MAINTENANCE_CHANGELOG_SUBKEY = 
"maintenance_changelog"

Class Method Summary collapse

Class Method Details

.build_lock(template_state:, file_records:) ⇒ Object 



2187
2188
2189
2190
2191
2192
2193
 
# File 'lib/kettle/jem.rb', line 2187

def build_lock(template_state:, file_records:)
  {
    "version" => VERSION,
    TEMPLATE_STATE_KEY => template_state,
    FILES_KEY => file_records.sort.to_h
  }
end

.file_record(lock, relative_path) ⇒ Object 



2154
2155
2156
2157
 
# File 'lib/kettle/jem.rb', line 2154

def file_record(lock, relative_path)
  record = files(lock)[relative_path.to_s]
  record.is_a?(Hash) ? record : {}
end

.files(lock) ⇒ Object 



2149
2150
2151
2152
 
# File 'lib/kettle/jem.rb', line 2149

def files(lock)
  value = lock.is_a?(Hash) ? lock[FILES_KEY] : nil
  value.is_a?(Hash) ? value : {}
end

.legacy_path(project_root) ⇒ Object 



2098
2099
2100
 
# File 'lib/kettle/jem.rb', line 2098

def legacy_path(project_root)
  File.join(project_root.to_s, LEGACY_KETTLE_LOCK_PATH)
end

.load(project_root:, config_path: nil) ⇒ Object 



2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
 
# File 'lib/kettle/jem.rb', line 2102

def load(project_root:, config_path: nil)
  lock_path = path(project_root)
  legacy_lock_path = legacy_path(project_root)
  lock = if File.exist?(lock_path)
    data = YAML.safe_load_file(lock_path, permitted_classes: [], aliases: false)
    data.is_a?(Hash) ? data : {}
  elsif File.exist?(legacy_lock_path)
    data = YAML.safe_load_file(legacy_lock_path, permitted_classes: [], aliases: false)
    data.is_a?(Hash) ? data : {}
  else
    {}
  end
  legacy = config_path ? TemplateChecksums.load_state(config_path: config_path) : {}
  merge_legacy(lock, legacy)
rescue
  {}
end

.maintenance_changelog(lock) ⇒ Object 



2159
2160
2161
2162
 
# File 'lib/kettle/jem.rb', line 2159

def maintenance_changelog(lock)
  value = lock.dig(TEMPLATE_STATE_KEY, MAINTENANCE_CHANGELOG_SUBKEY)
  value.is_a?(Hash) ? value : {}
end

.maintenance_changelog_paths(project_root:, key:) ⇒ Object 



2164
2165
2166
2167
2168
2169
 
# File 'lib/kettle/jem.rb', line 2164

def maintenance_changelog_paths(project_root:, key:)
  state = maintenance_changelog(load(project_root: project_root))
  return unless state.key?(key.to_s)

  Array(state.fetch(key.to_s)).map(&:to_s).uniq.sort
end

.merge_legacy(lock, legacy) ⇒ Object 



2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
 
# File 'lib/kettle/jem.rb', line 2120

def merge_legacy(lock, legacy)
  return lock unless legacy.is_a?(Hash) && !legacy.empty?

  merged = lock.dup
  state = (merged[TEMPLATE_STATE_KEY].is_a?(Hash) ? merged[TEMPLATE_STATE_KEY].dup : {})
  state["version"] ||= legacy[TemplateChecksums::VERSION_SUBKEY]
  state["applied_at"] ||= legacy[TemplateChecksums::APPLIED_AT_SUBKEY]
  state["changelog_replay"] ||= legacy[TemplateChecksums::CHANGELOG_REPLAY_SUBKEY] if legacy[TemplateChecksums::CHANGELOG_REPLAY_SUBKEY]
  state["checksums"] ||= legacy[TemplateChecksums::CHECKSUMS_SUBKEY] if legacy[TemplateChecksums::CHECKSUMS_SUBKEY]
  merged["version"] ||= VERSION
  merged[TEMPLATE_STATE_KEY] = state unless state.empty?
  merged[FILES_KEY] ||= {}
  merged
end

.path(project_root) ⇒ Object 



2094
2095
2096
 
# File 'lib/kettle/jem.rb', line 2094

def path(project_root)
  File.join(project_root.to_s, KETTLE_LOCK_PATH)
end

.remove_legacy(project_root) ⇒ Object 



2141
2142
2143
2144
2145
2146
2147
 
# File 'lib/kettle/jem.rb', line 2141

def remove_legacy(project_root)
  legacy_lock_path = legacy_path(project_root)
  return false unless File.exist?(legacy_lock_path)

  File.delete(legacy_lock_path)
  true
end

.update_maintenance_changelog_paths(project_root:, key:, paths:) ⇒ Object 



2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
 
# File 'lib/kettle/jem.rb', line 2171

def update_maintenance_changelog_paths(project_root:, key:, paths:)
  lock = load(project_root: project_root)
  template_state = lock.fetch(TEMPLATE_STATE_KEY, {}).dup
  changelog = maintenance_changelog(lock).dup
  normalized_paths = Array(paths).map(&:to_s).uniq.sort
  return false if changelog[key.to_s] == normalized_paths

  changelog[key.to_s] = normalized_paths
  template_state[MAINTENANCE_CHANGELOG_SUBKEY] = changelog
  lock[TEMPLATE_STATE_KEY] = template_state
  lock["version"] ||= VERSION
  lock[FILES_KEY] ||= {}
  write(project_root: project_root, lock: lock)
  true
end

.write(project_root:, lock:) ⇒ Object 



2135
2136
2137
2138
2139
 
# File 'lib/kettle/jem.rb', line 2135

def write(project_root:, lock:)
  lock_path = path(project_root)
  FileUtils.mkdir_p(File.dirname(lock_path))
  File.write(lock_path, YAML.dump(lock).to_s)
end