Module: Pray::FormatSerialize

Defined in:
lib/pray/format_serialize.rb

Class Method Summary collapse

Class Method Details

.find_package(manifest, name) ⇒ Object 



119
120
121
 
# File 'lib/pray/format_serialize.rb', line 119

def find_package(manifest, name)
  manifest.packages.find { |package| package.name == name }
end

.format_destination_entry(entry, manifest) ⇒ Object 



110
111
112
113
114
115
116
117
 
# File 'lib/pray/format_serialize.rb', line 110

def format_destination_entry(entry, manifest)
  if entry.kind == "local"
    return %(pray "#{entry.path}")
  end

  package = find_package(manifest, entry.name)
  package ? ManifestMethods.format_package_declaration(package) : %(pray "#{entry.name}")
end

.format_source(source) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/pray/format_serialize.rb', line 93

def format_source(source)
  parts = [%(source "#{source.name}")]
  case source.kind
  when "path"
    parts << %(path: "#{source.url}")
  when "git"
    url = source.url.delete_prefix("git+")
    parts << %(git: "#{url}")
  else
    parts << %("#{source.url}")
  end
  parts << %(distribution: "#{source.subdir}") if source.subdir
  parts << %(tag: "#{source.tag}") if source.tag
  parts << %(rev: "#{source.rev}") if source.rev
  parts.join(", ")
end

.grouped_packages(manifest) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/pray/format_serialize.rb', line 123

def grouped_packages(manifest)
  groups = {}
  manifest.packages.each do |package|
    next if package.groups.empty?

    key = package.groups.dup
    groups[key] ||= []
    groups[key] << package
  end
  groups.sort_by { |names, _| names }.map { |names, packages| [names, packages] }
end

.serialize_recommended(manifest) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/pray/format_serialize.rb', line 7

def serialize_recommended(manifest)
  lines = [%(prayfile "#{manifest.prayfile_version}")]

  unless manifest.sources.empty?
    lines << ""
    manifest.sources.each { |source| lines << format_source(source) }
  end

  unless manifest.symbols.empty?
    lines << ""
    lines << "pray do"
    manifest.symbols.sort.each do |key, value|
      lines << %(  #{key} "#{value}")
    end
    lines << "end"
  end

  manifest.targets.each do |target|
    next unless target.scoped

    lines << ""
    case target.mode
    when "compose"
      path = target.outputs.first || ""
      lines << %(compose "#{path}" do)
      target.entries.each do |entry|
        lines << "  #{format_destination_entry(entry, manifest)}"
      end
      lines << "end"
    when "tree"
      path = target.skills.first || ""
      lines << %(tree "#{path}" do)
      target.entries.each do |entry|
        next unless entry.kind == "package"

        package = find_package(manifest, entry.name)
        lines << "  #{ManifestMethods.format_package_declaration(package)}" if package
      end
      lines << "end"
    end
  end

  file_packages = manifest.packages.select(&:file)
  unless file_packages.empty?
    lines << ""
    file_packages.each { |package| lines << ManifestMethods.format_package_declaration(package) }
  end

  unbound = manifest.packages.select { |package| !package.bound && !package.file && package.groups.empty? }
  unless unbound.empty?
    lines << ""
    unbound.each { |package| lines << ManifestMethods.format_package_declaration(package) }
  end

  grouped_packages(manifest).each do |group_names, packages|
    lines << ""
    lines << "group #{group_names.map { |name| ":#{name}" }.join(", ")} do"
    packages.each { |package| lines << "  #{ManifestMethods.format_package_declaration(package)}" }
    lines << "end"
  end

  manifest.targets.each do |target|
    next if target.scoped || !target_has_extras?(target)

    lines << ""
    lines << "target :#{target.name} do"
    target.commands.each { |command| lines << %(  commands "#{command}") }
    target.rules.each { |rule| lines << %(  rules "#{rule}") }
    lines << "  max_bytes #{target.max_bytes}" if target.max_bytes
    lines << "end"
  end

  if manifest.render != RenderPolicy.default
    lines << ""
    lines << "render mode: :#{manifest.render.mode}, conflict: :#{manifest.render.conflict}, " \
             "churn: :#{manifest.render.churn}"
  end

  lines << ""
  lines.join("\n")
end

.target_has_extras?(target) ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
 
# File 'lib/pray/format_serialize.rb', line 89

def target_has_extras?(target)
  !target.commands.empty? || !target.rules.empty? || !target.max_bytes.nil?
end