Class: Suma::SchemaConfig::Config

Inherits:
Lutaml::Model::Serializable
  • Object
show all
Defined in:
lib/suma/schema_config/config.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(**args) ⇒ Config

Returns a new instance of Config.



14
15
16
17
 
# File 'lib/suma/schema_config/config.rb', line 14

def initialize(**args)
  @path = path_relative_to_absolute(path) if path
  super(**args)
end

Instance Attribute Details

#output_path ⇒ Object

Returns the value of attribute output_path.



12
13
14
 
# File 'lib/suma/schema_config/config.rb', line 12

def output_path
  @output_path
end

Class Method Details

.from_file(path) ⇒ Object 



27
28
29
30
31
 
# File 'lib/suma/schema_config/config.rb', line 27

def self.from_file(path)
  from_yaml(File.read(path)).tap do |x|
    x.set_initial_path(path)
  end
end

Instance Method Details

#base_path ⇒ Object 



19
20
21
 
# File 'lib/suma/schema_config/config.rb', line 19

def base_path
  File.dirname(@path)
end

#concat(another_config) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/suma/schema_config/config.rb', line 109

def concat(another_config)
  unless another_config.is_a?(self.class)
    raise StandardError, "Can only concat a SchemaConfig::Config object."
  end

  # We need to update the relative paths when paths exist
  if path && another_config.path && path != another_config.path
    new_config = another_config.dup
    new_config.update_path(path)
  end

  schemas.concat(another_config.schemas)
end

#path_absolute_to_relative(absolute_path, container_path) ⇒ Object 



87
88
89
90
91
92
93
94
 
# File 'lib/suma/schema_config/config.rb', line 87

def path_absolute_to_relative(absolute_path, container_path)
  container_path ||= @path
  return absolute_path unless container_path

  p = Pathname.new(container_path)
  container = p.directory? ? p.to_s : p.dirname
  Pathname.new(absolute_path).relative_path_from(container).to_s
end

#path_relative_to_absolute(relative_path) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/suma/schema_config/config.rb', line 75

def path_relative_to_absolute(relative_path)
  eval_path = Pathname.new(relative_path)
  return relative_path if eval_path.absolute?

  # Or based on current working directory?
  return relative_path unless @path

  # ... but if this calculates path, we end up expanding it anyway

  Pathname.new(File.dirname(@path)).join(eval_path).expand_path.to_s
end

#save_to_path(filename) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/suma/schema_config/config.rb', line 123

def save_to_path(filename)
  new_config = dup.tap do |c|
    c.path = filename
    c.update_path(File.dirname(filename))
    c.output_path = filename
  end

  File.open(filename, "w") do |f|
    Utils.log "Writing #{filename}..."
    f.write(new_config.to_yaml)
    Utils.log "Done."
  end
end

#schemas_from_yaml(model, value) ⇒ Object 



47
48
49
50
51
 
# File 'lib/suma/schema_config/config.rb', line 47

def schemas_from_yaml(model, value)
  model.schemas = value.map do |k, v|
    Schema.new(id: k, path: path_relative_to_absolute(v["path"]))
  end
end

#schemas_to_yaml(model, doc) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
# File 'lib/suma/schema_config/config.rb', line 53

def schemas_to_yaml(model, doc)
  doc["schemas"] = model.schemas.sort_by(&:id).to_h do |schema|
    # We are outputting the schemas collection file to the directory where
    # the collection config is at (assumed to be Dir.pwd), not to the
    # directory we sourced the manifest from, e.g.
    # documents/iso-10303-41/schemas.yaml.

    # So the schema.container_path = @config.path is not
    # in fact needed, as the files are already absolute. This notion of
    # using @path to create relative paths was misconceived
    [
      schema.id,
      {
        "path" => path_absolute_to_relative(
          schema.path,
          model.output_path || Dir.pwd,
        ),
      },
    ]
  end
end

#set_initial_path(new_path) ⇒ Object 



39
40
41
42
43
44
45
 
# File 'lib/suma/schema_config/config.rb', line 39

def set_initial_path(new_path)
  @path = path_relative_to_absolute(new_path)
  schemas.each do |schema|
    schema.path = path_relative_to_absolute(schema.path)
    schema.container_path = File.expand_path(@path)
  end
end

#to_file(to_path = path) ⇒ Object 



33
34
35
36
37
 
# File 'lib/suma/schema_config/config.rb', line 33

def to_file(to_path = path)
  File.open(to_path, "w") do |f|
    f.write(to_yaml)
  end
end

#update_path(new_path) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/suma/schema_config/config.rb', line 96

def update_path(new_path)
  if @path.nil?
    @path = new_path
    return @path
  end

  old_base_path = File.dirname(@path)
  new_base_path = File.dirname(new_path)
  update_schema_path(old_base_path, new_base_path)

  @path = new_path
end

#update_schema_path(old_base_path, new_base_path) ⇒ Object 



137
138
139
140
141
142
143
144
145
146
 
# File 'lib/suma/schema_config/config.rb', line 137

def update_schema_path(old_base_path, new_base_path)
  schemas.each do |schema|
    schema_path = Pathname.new(schema.path)
    next if schema_path.absolute?

    schema_path = (Pathname.new(old_base_path) + schema_path).cleanpath
    # This is the new relative schema_path
    schema.path = schema_path.relative_path_from(new_base_path)
  end
end