Class: Eddy::Build::TransactionSetBuilder

Inherits:
Object
  • Object
show all
Defined in:
lib/eddy/build/transaction_set_builder.rb

Overview

Generate Ruby code from JSON/YAML EDI definitions.

  • Validate definition file
  • Create Summary
  • For Segments, check that we have a default definition for each.
    • Generate segments?
  • For Elements, check that we have a default definition for each.
    • Apply any input over default element attributes.

Instance Attribute Summary collapse

Initialize collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(folder: nil, headers: false) ⇒ void

Parameters:

  • folder (String) (defaults to: nil) —

    (nil)

  • headers (Boolean) (defaults to: false) —

    (false)



25
26
27
28
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 25

def initialize(folder: nil, headers: false)
  self.folder  = folder
  self.headers = headers
end

Instance Attribute Details

#folder ⇒ String

Returns (nil).

Returns:

  • (String) —

    (nil)



18
19
20
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 18

def folder
  @folder
end

#headers ⇒ Boolean

Returns (false).

Returns:

  • (Boolean) —

    (false)



20
21
22
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 20

def headers
  @headers
end

#summary ⇒ Eddy::Schema::TransactionSetSummary

Returns:



16
17
18
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 16

def summary
  @summary
end

Class Method Details

.from_file(path, **kwargs) ⇒ Eddy::Build::TransactionSetBuilder

Parameters:

  • path (String) —

    Path to a JSON or YAML file containing a valid Transaction Set definition.

  • folder (String) —

    (nil)

  • headers (Boolean) —

    (false)

Returns:

Raises:



33
34
35
36
37
38
39
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 33

def self.from_file(path, **kwargs)
  raise Eddy::Errors::Error, "Invalid transaction set definition" unless Eddy::Schema.valid_transaction_set_data?(path)
  data = Eddy::Util.read_json_or_yaml(path)
  builder = Eddy::Build::TransactionSetBuilder.new(**kwargs)
  builder.summary = Eddy::Schema::TransactionSetSummary.create(data)
  return builder
end

.from_summary(summary, **kwargs) ⇒ Eddy::Build::TransactionSetBuilder

Parameters:

Returns:



44
45
46
47
48
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 44

def self.from_summary(summary, **kwargs)
  builder = Eddy::Build::TransactionSetBuilder.new(**kwargs)
  builder.summary = summary
  return builder
end

.loop_accessor(summary, t_set_name) ⇒ String

Parameters:

Returns:

  • (String) 


181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 181

def self.loop_accessor(summary, t_set_name)
  upper = summary.loop_id.upcase
  lower = summary.loop_id.downcase
  return "    # (see Eddy::TransactionSets::\#{t_set_name}::Loops::\#{upper})\n    #\n    \#{self.loop_components(summary, t_set_name)}\n    # @return [void]\n    def L_\#{upper}(&block)\n      if block_given?\n        @l_\#{lower}.add_iteration(&block)\n      else\n        raise Eddy::Errors::Error, \\\"No block given in loop iteration\\\"\n      end\n      return nil\n    end\n  RB\nend\n".strip

.loop_components(summary, t_set_name) ⇒ String

Parameters:

Returns:

  • (String) 


203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 203

def self.loop_components(summary, t_set_name)
  comps = []
  summary.components.each do |comp|
    case comp
    when Eddy::Schema::SegmentSummary
      comps << "# @yieldparam [Eddy::Segments::#{comp.id.upcase}] #{comp.id.downcase}"
    when Eddy::Schema::LoopSummary
      comps << "# @yieldparam [Eddy::TransactionSets::#{t_set_name}::Loops::#{comp.loop_id.upcase}] l_#{comp.loop_id.downcase}"
    end
  end
  return comps.join("\n")
end

.segment_accessor(segment_id) ⇒ String

Parameters:

  • segment_id (String)

Returns:

  • (String) 


163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 163

def self.segment_accessor(segment_id)
  upper = segment_id.upcase
  lower = segment_id.downcase
  return "    # (see Eddy::Segments::\#{upper})\n    #\n    # @yieldparam [Eddy::Segments::\#{upper}] \#{lower}\n    # @return [Eddy::Segments::\#{upper}]\n    def \#{upper}()\n      yield(@\#{lower}) if block_given?\n      return @\#{lower}\n    end\n  RB\nend\n".strip

Instance Method Details

#accessors ⇒ String

Returns:

  • (String) 


145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 145

def accessors()
  defs = self.summary.components.map do |comp|
    case comp
    when Eddy::Schema::SegmentSummary
      Eddy::Build::TransactionSetBuilder.segment_accessor(comp.id)
    when Eddy::Schema::LoopSummary
      if comp.repeat == 1
        Eddy::Build::TransactionSetBuilder.segment_accessor(comp.loop_id)
      else
        Eddy::Build::TransactionSetBuilder.loop_accessor(comp, self.summary.normalized_name)
      end
    end
  end
  return defs.join("\n\n")
end

#build ⇒ String

Returns:

  • (String) 


51
52
53
54
55
56
57
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 51

def build()
  root_path = self.folder || File.join(Eddy::Util.root_dir, "build", "transaction_sets")
  path = File.join(root_path, self.summary.id.to_s)
  FileUtils.mkdir_p(path)
  File.open(File.join(path, "loops.rb"), "a") { |f| f.write(self.render_loops) }
  return self.ginny_class.generate(path)
end

#constructor ⇒ String

Returns:

  • (String) 


91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 91

def constructor()
  return Ginny::Func.create({
    name: "initialize",
    params: [{ name: "store", type: "Eddy::Data::Store" }],
    body: "      \#{self.declarations()}\n\n\n      \#{self.super_call()}\n    RB\n  }).render()\nend\n",

#declarations ⇒ String

Returns:

  • (String) 


105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 105

def declarations()
  decs = ""
  self.summary.components.each do |comp|
    case comp
    when Eddy::Schema::SegmentSummary
      decs << "@#{comp.id.downcase} = Eddy::Segments::#{comp.id.upcase}.new(store)\n"
    when Eddy::Schema::LoopSummary
      if comp.repeat == 1
        decs << "@#{comp.loop_id.downcase} = Eddy::Segments::#{comp.loop_id.upcase}.new(store)\n"
      else
        decs << "@l_#{comp.loop_id.downcase} = Eddy::TransactionSets::#{self.summary.normalized_name}::Loops::#{comp.loop_id.upcase}.new(store)\n"
      end
    end
  end
  return decs
end

#ginny_class ⇒ Ginny::Class

Returns:

  • (Ginny::Class) 


68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 68

def ginny_class()
  return Ginny::Class.create({
    classify_name: false,
    modules: ["Eddy", "TransactionSets", self.summary.normalized_name],
    parent: "Eddy::TransactionSet",
    name: self.summary.normalized_name,
    description: self.summary.doc_comment(header: true),
    body: "\n      ID = \"\#{self.summary.id}\".freeze\n      NAME = \"\#{self.summary.name}\".freeze\n      FUNCTIONAL_GROUP = \"\#{self.summary.functional_group}\".freeze\n\n      \#{self.constructor()}\n\n      \#{self.accessors()}\n    STR\n  })\nend\n",

#render_loops ⇒ String

Returns:

  • (String) 


60
61
62
63
64
65
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 60

def render_loops()
  loops = self.summary.unique_loops.map do |l|
    Eddy::Build::LoopBuilder.from_summary(l, t_set_id: self.summary.normalized_name).ginny_class.render()
  end.join("\n\n")
  return Ginny.mod(("\n" + loops + "\n"), "Eddy", "TransactionSets", self.summary.normalized_name, "Loops")
end

#super_call ⇒ String

Returns:

  • (String) 


123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/eddy/build/transaction_set_builder.rb', line 123

def super_call()
  super_call = "super(\n"
  super_call << "  store,\n"
  self.summary.components.each do |comp|
    case comp
    when Eddy::Schema::SegmentSummary
      super_call << "  @#{comp.id.downcase},\n"
    when Eddy::Schema::LoopSummary
      if comp.repeat == 1
        super_call << "  @#{comp.loop_id.downcase},\n"
      else
        super_call << "  @l_#{comp.loop_id.downcase},\n"
      end
    end
  end
  super_call << ")"
  return super_call
end