eddy 0.1.0 → 0.3.0

data/lib/eddy.rb

@@ -2,10 +2,32 @@
 module Eddy; end
 
 require "eddy/version"
-require "eddy/error"
-require "eddy/helpers"
-require "eddy/element"
-require "eddy/segment"
-require "eddy/transaction_set"
-require "eddy/build/build_elements"
-Dir.glob(File.join(__dir__, "eddy", "definitions", "manual", "**/*.rb")).each { |file| require file }
+require "eddy/errors"
+require "eddy/util"
+require "eddy/config"
+require "eddy/data"
+
+Dir.glob(File.join(__dir__, "eddy", "schema", "*.rb")).sort.each { |file| require file }
+
+require "eddy/models/element"
+require "eddy/models/segment"
+require "eddy/models/loop"
+require "eddy/models/transaction_set"
+
+require "eddy/write/interchange"
+require "eddy/write/simple_interchange"
+require "eddy/write/functional_group"
+
+require "eddy/parse"
+
+require "eddy/build/build"
+
+# Dir.glob(File.join(__dir__, "definitions", "elements", "manual", "**", "*.rb")).sort.each         { |file| require file }
+# Dir.glob(File.join(__dir__, "definitions", "segments", "manual", "**", "*.rb")).sort.each         { |file| require file }
+# Dir.glob(File.join(__dir__, "definitions", "transaction_sets", "manual", "**", "*.rb")).sort.each { |file| require file }
+
+Dir.glob(File.join(__dir__, "definitions", "elements", "**", "*.rb")).sort.each         { |file| require file }
+Dir.glob(File.join(__dir__, "definitions", "segments", "**", "*.rb")).sort.each         { |file| require file }
+Dir.glob(File.join(__dir__, "definitions", "transaction_sets", "**", "*.rb")).sort.each { |file| require file }
+
+require "eddy/cli/cli"

data/lib/eddy/build/build.rb

@@ -0,0 +1,47 @@
+require "fileutils"
+
+require "eddy/build/elements/elements"
+require "eddy/build/segment_builder"
+require "eddy/build/loop_builder"
+require "eddy/build/transaction_set_builder"
+
+module Eddy
+  # Generate Ruby classes for modeling Semgents & Data Element logic, notes, and validation.
+  module Build
+
+    # @return [void]
+    def self.make_folders()
+      folders = [
+        File.join(Eddy.config.build_dir, "segments"),
+        File.join(Eddy.config.build_dir, "elements"),
+        File.join(Eddy.config.build_dir, "transaction_sets"),
+      ]
+      folders.each { |f| FileUtils.mkdir_p(f) }
+    end
+
+    # @return [void]
+    def self.clean_folders()
+      folders = [
+        File.join(Eddy.config.build_dir, "segments"),
+        File.join(Eddy.config.build_dir, "elements"),
+        File.join(Eddy.config.build_dir, "transaction_sets"),
+      ]
+      folders.each { |f| Eddy::Util.clean_folder(f) }
+    end
+
+    # @return [void]
+    def self.build_all_segments()
+      files = Eddy::Util.list_segment_definitions()
+      files.each do |f|
+        builder = Eddy::Build::SegmentBuilder.from_file(f)
+        builder.build(build_elements: true)
+      end
+    end
+
+    # @return [void]
+    def self.build_all_elements()
+      Eddy::Build::Elements.generate_elements()
+    end
+
+  end
+end

data/lib/eddy/build/elements/element.rb

@@ -0,0 +1,67 @@
+require "ginny"
+
+module Eddy
+  module Build
+    module Elements
+
+      # @param el [Eddy::Schema::ElementSummary]
+      # @return [Array<Hash>]
+      def self.element_params(el)
+        return [
+          { name: "val", type: el.yard_type, optional: true, keyword: true },
+          { name: "req", type: "String",     optional: true, keyword: true },
+          { name: "ref", type: "String",     optional: true, keyword: true },
+        ]
+      end
+
+      # @param el [Eddy::Schema::ElementSummary]
+      # @return [String]
+      def self.default_constructor(el)
+        return Ginny::Func.create({
+          name: "initialize",
+          params: self.element_params(el),
+          body: <<~RB,
+            @id = "#{el.id}"
+            @name = "#{el.name}"
+            @description = "#{el.description}"
+            super(
+              min: #{el.min},
+              max: #{el.max},
+              req: req,
+              ref: ref,
+              val: val,
+            )
+          RB
+        }).render()
+      end
+
+      # @param el [Eddy::Schema::ElementSummary]
+      # @param body [String]
+      # @return [Ginny::Class]
+      def self.ginny_class(el, body)
+        return Ginny::Class.create({
+          classify_name: false,
+          name:          Eddy::Util.normalize_id(el.id),
+          description:   el.doc_comment,
+          parent:        "Eddy::Element::#{el.edi_type}",
+          modules:       ["Eddy", "Elements"],
+          body:          body,
+        })
+      end
+
+      # @param el [Eddy::Schema::ElementSummary]
+      # @param test [Boolean] (false) When true, returns output as a string instead of writing to a file.
+      # @return [void]
+      def self.element(el, test: false)
+        c = self.ginny_class(el, self.default_constructor(el))
+        return c.render if test
+        c.generate(
+          File.join(Eddy::Util.root_dir, "build", "elements"),
+          file: "#{el.id}.#{Eddy::Util.snake_case(el.name)}.rb",
+        )
+        return nil
+      end
+
+    end
+  end
+end

data/lib/eddy/build/elements/elements.rb

@@ -0,0 +1,46 @@
+require "eddy/build/elements/element"
+require "eddy/build/elements/n"
+require "eddy/build/elements/id"
+
+module Eddy
+  # Generate Ruby classes for modeling Data Element logic, notes, and validation.
+  module Build
+    module Elements
+
+      # Generate `Eddy::Element` classes for all data elements defined in `data/004010/elements.tsv`
+      #
+      # @param elements [Array<Eddy::Schema::ElementSummary>]
+      # @return [void]
+      def self.generate_elements(elements = self.generate_element_data())
+        existing = (Eddy::Util.list_element_classes() + Eddy::Util.list_built_elements()).uniq()
+        elements.each do |el|
+          next if existing.include?(el.id)
+          existing.append(el.id)
+          case el.edi_type()
+          when "B"  then next
+          when "ID" then self.id(el)
+          when "N"  then self.n(el)
+          when "AN" then self.element(el)
+          when "DT" then self.element(el)
+          when "R"  then self.element(el)
+          when "TM" then self.element(el)
+          end
+        end
+        return nil
+      end
+
+      # Generate usable data from `data/004010/elements.tsv`.
+      #
+      # @return [Array<Eddy::Schema::ElementSummary>]
+      def self.generate_element_data()
+        data = Eddy::Util.raw_element_data()
+        elements = data.map do |el|
+          next if el[:type].nil? || el[:description].nil?
+          Eddy::Schema::ElementSummary.create(el)
+        end
+        return elements.compact
+      end
+
+    end
+  end
+end

data/lib/eddy/build/elements/id.rb

@@ -0,0 +1,55 @@
+require "ginny"
+
+module Eddy
+  module Build
+    module Elements
+
+      # @param el [Eddy::Schema::ElementSummary]
+      # @param test [Boolean] (false) When true, returns output as a string instead of writing to a file.
+      # @return [void]
+      def self.id(el, test: false)
+        code_list = self.build_code_list(el.id)
+        return nil if code_list.nil?
+        c = self.ginny_class(
+          el,
+          ("\n" + self.default_constructor(el) + "\n\n" + code_list + "\n"),
+          # "\n#{self.default_constructor(el)}\n\n#{code_list}\n",
+        )
+        return c.render if test
+        c.generate(
+          File.join(Eddy::Util.root_dir, "build", "elements"),
+          file: "#{el.id}.#{Eddy::Util.snake_case(el.name)}.rb",
+        )
+        return nil
+      end
+
+      # @param id [String]
+      # @return [String]
+      def self.build_code_list(id)
+        file = File.join(Eddy::Util.data_dir, "004010", "code-lists", "#{id}.tsv")
+        begin
+          data = Eddy::Util.parse_tsv(file)
+        rescue Errno::ENOENT
+          puts("Missing code-list for element #{id}")
+          return nil
+        rescue CSV::MalformedCSVError => e
+          puts("Error reading csv file '#{file}':#{e}")
+          return nil
+        end
+        # body = "return [\n" + data.map { |c| %("#{c[:id]}").indent(2) }.join(",\n") + "\n]\n"
+        body = ""
+        body << "return [\n"
+        data.each do |c|
+          body << %("#{c[:id]}", # #{c[:definition]}\n).indent(2)
+        end
+        body << "]\n"
+        return Ginny::Func.create({
+          name: "code_list",
+          return_type: "Array<String>",
+          body: body,
+        }).render()
+      end
+
+    end
+  end
+end

data/lib/eddy/build/elements/n.rb

@@ -0,0 +1,48 @@
+require "ginny"
+
+module Eddy
+  module Build
+    module Elements
+
+      # @param el [Eddy::Schema::ElementSummary]
+      # @param test [Boolean] (false) When true, returns output as a string instead of writing to a file.
+      # @return [void]
+      def self.n(el, test: false)
+        decimal_points = self.determine_decimals(el.type)
+        constructor = Ginny::Func.create({
+          name:   "initialize",
+          params: self.element_params(el),
+          body:   <<~RB,
+            @id = "#{el.id}"
+            @name = "#{el.name}"
+            @description = "#{el.description}"
+            super(
+              min: #{el.min},
+              max: #{el.max},
+              req: req,
+              ref: ref,
+              val: val,
+              decimals: #{decimal_points},
+            )
+          RB
+        }).render()
+        c = self.ginny_class(el, constructor)
+        return c.render if test
+        c.generate(
+          File.join(Eddy::Util.root_dir, "build", "elements"),
+          file: "#{el.id}.#{Eddy::Util.snake_case(el.name)}.rb",
+        )
+        return nil
+      end
+
+      # @param type [String]
+      # @return [Integer]
+      def self.determine_decimals(type)
+        match = type.match(/(?<=N)(?<decimal>\d)/)
+        return 0 if match.nil?
+        return match[:decimal].to_i
+      end
+
+    end
+  end
+end

data/lib/eddy/build/loop_builder.rb

@@ -0,0 +1,93 @@
+require "ginny"
+
+module Eddy
+  module Build
+    # Generate Ruby code from JSON/YAML EDI definitions.
+    class LoopBuilder
+
+      # @return [Eddy::Schema::LoopSummary]
+      attr_accessor :summary
+      # @return [String] (nil)
+      attr_accessor :folder
+      # Namespace the Loop is within.
+      # @return [String]
+      attr_accessor :t_set_id
+
+      # @param folder [String] (nil)
+      # @param t_set_id [Boolean] ("")
+      # @return [void]
+      def initialize(folder: nil, t_set_id: "")
+        self.folder   = folder
+        self.t_set_id = t_set_id
+      end
+
+      # @param summary [Eddy::Schema::LoopSummary]
+      # @param (see #initialize)
+      # @return [Eddy::Build::LoopBuilder]
+      def self.from_summary(summary, **kwargs)
+        lb = Eddy::Build::LoopBuilder.new(**kwargs)
+        lb.summary = summary
+        return lb
+      end
+
+      # @return [Ginny::Class]
+      def ginny_class()
+        return Ginny::Class.create({
+          classify_name: false,
+          parent: "Eddy::Loop::Base",
+          name: self.summary.loop_id,
+          description: summary.doc_comment(header: true),
+          body: <<~STR.strip,
+            # @param store [Eddy::Data::Store]
+            # @return [void]
+            def initialize(store)
+              super(store)
+              @repeat = #{self.summary.repeat}
+              @components = [
+              #{self.components(self.t_set_id)}
+              ]
+            end
+
+            #{self.class.add_ideration(self.summary, self.t_set_id)}
+          STR
+        })
+      end
+
+      # @param t_set_id [Integer]
+      # @return [String]
+      def components(t_set_id)
+        comps = []
+        self.summary.components.each do |comp|
+          case comp
+          when Eddy::Schema::SegmentSummary
+            comps << "  Eddy::Segments::#{comp.id.upcase},"
+          when Eddy::Schema::LoopSummary
+            comps << "  Eddy::TransactionSets::#{t_set_id}::Loops::#{comp.loop_id.upcase},"
+          end
+        end
+        return comps.join("\n  ")
+      end
+
+      # @param summary [Eddy::Schema::LoopSummary]
+      # @param t_set_id [String]
+      # @return [String]
+      def self.add_ideration(summary, t_set_id)
+        yield_params = []
+        summary.components.each do |comp|
+          case comp
+          when Eddy::Schema::SegmentSummary
+            yield_params << "#   @yieldparam [Eddy::Segments::#{comp.id.upcase}] #{comp.id.downcase}"
+          when Eddy::Schema::LoopSummary
+            yield_params << "#   @yieldparam [Eddy::TransactionSets::#{t_set_id}::Loops::#{comp.loop_id.upcase}] l_#{comp.loop_id.downcase}"
+          end
+        end
+        return <<~YARD.strip
+          # @!method add_iteration(&block)
+          #{yield_params.join("\n")}
+          #   @return [void]
+        YARD
+      end
+
+    end
+  end
+end

data/lib/eddy/build/segment_builder.rb

@@ -0,0 +1,169 @@
+require "set"
+require "ginny"
+
+module Eddy
+  module Build
+    # Generate Ruby code from JSON/YAML EDI definitions.
+    class SegmentBuilder
+
+      # @return [Eddy::Schema::SegmentSummary]
+      attr_accessor :summary
+      # @return [String] (nil)
+      attr_accessor :folder
+      # A hash of element names that appear more than once in the segment.
+      # @return [Hash{String => Integer}]
+      attr_accessor :duplicate_elements
+
+      # @param folder [String] (nil)
+      # @return [void]
+      def initialize(folder: nil)
+        self.folder = folder
+      end
+
+      # @param path [String] Path to a JSON or YAML file containing a valid Segment definition.
+      # @param (see #initialize)
+      # @return [Eddy::Build::SegmentBuilder]
+      def self.from_file(path, **kwargs)
+        raise Eddy::Errors::Error, "Invalid segment definition" unless Eddy::Schema.valid_segment_data?(path)
+        data = Eddy::Util.read_json_or_yaml(path)
+        sb = Eddy::Build::SegmentBuilder.new(**kwargs)
+        sb.summary = Eddy::Schema::SegmentSummary.create(data)
+        return sb
+      end
+
+      # @param summary [Eddy::Schema::SegmentSummary]
+      # @param (see #initialize)
+      # @return [Eddy::Build::SegmentBuilder]
+      def self.from_summary(summary, **kwargs)
+        sb = Eddy::Build::SegmentBuilder.new(**kwargs)
+        sb.summary = summary
+        return sb
+      end
+
+      # Generated the Segment and return the name of the file where it was written.
+      #
+      # @param build_elements [Boolean] (false)
+      # @return [String]
+      def build(build_elements: false)
+        Eddy::Build.make_folders()
+        if build_elements
+          Eddy::Build::Elements.generate_elements(self.summary.elements)
+        end
+        path = self.folder || File.join(Eddy.config.build_dir, "segments")
+        result = self.ginny_class.generate(path)
+        return result
+      end
+
+      # @return [Ginny::Class]
+      def ginny_class()
+        return Ginny::Class.create({
+          classify_name: false,
+          modules: ["Eddy", "Segments"],
+          parent: "Eddy::Segment",
+          name: summary.id,
+          description: summary.doc_comment(header: true),
+          body: <<~STR,
+
+            #{self.constructor()}
+
+            #{self.accessors()}
+          STR
+        })
+      end
+
+      # @return [String]
+      def constructor()
+        return Ginny::Func.create({
+          name: "initialize",
+          params: [{ name: "store", type: "Eddy::Data::Store" }],
+          body: <<~RB,
+            @id = "#{summary.id}"
+            @name = "#{summary.name}"
+            #{self.declarations()}
+
+
+
+            #{self.super_call()}
+          RB
+        }).render()
+      end
+
+      # @return [String]
+      def declarations()
+        decs = ""
+        self.summary.elements.each do |el|
+          req = el.req.nil? ? "nil" : '"' + el.req + '"'
+          decs << %(@#{el.ref.to_s.downcase} = Eddy::Elements::#{Eddy::Util.normalize_id(el.id)}.new(ref: "#{el.ref.to_s.upcase}", req: #{req})\n)
+        end
+        return decs
+      end
+
+      # @return [String]
+      def super_call()
+        super_call = "super(\n"
+        super_call << "  store,\n"
+        self.summary.elements.each { |el| super_call << "  @#{el.ref.to_s.downcase},\n" }
+        super_call << ")"
+        return super_call
+      end
+
+      # @return [String]
+      def accessors()
+        self.find_duplicate_elements()
+        defs = self.summary.elements.map do |el|
+          Eddy::Build::SegmentBuilder.element_accessor_v2(el, self.duplicate_elements)
+        end
+        return defs.join("\n\n")
+      end
+
+      # @param el [Eddy::Schema::ElementSummary]
+      # @param header [Symbol] (see Eddy::Schema::ElementSummary#doc_comment)
+      # @return [String]
+      def self.element_accessor_v1(el, header: :summary)
+        return <<~RB.strip
+          #{el.doc_comment(header: header).gsub(/^/, '# ').gsub(/([[:blank:]]+)$/, '')}
+          #
+          # @param arg [#{el.yard_type}]
+          # @return [void]
+          def #{el.ref.upcase}=(arg)
+            @#{el.ref.downcase}.value = arg
+          end
+        RB
+      end
+
+      # @param el [Eddy::Schema::ElementSummary]
+      # @param dupes [Hash]
+      # @param header [Boolean] (false)
+      # @return [String]
+      def self.element_accessor_v2(el, dupes, header: :ref)
+        if dupes.key?(el.name)
+          normal_name = el.normalized_name + dupes[el.name].to_s
+          dupes[el.name] += 1
+        else
+          normal_name = el.normalized_name
+        end
+        return <<~RB.strip
+          #{el.doc_comment(header: header).gsub(/^/, '# ').gsub(/([[:blank:]]+)$/, '')}
+          #
+          # @param arg [#{el.yard_type}]
+          # @return [void]
+          def #{el.ref.upcase}=(arg)
+            @#{el.ref.downcase}.value = arg
+          end
+          alias #{normal_name}= #{el.ref.upcase}=
+        RB
+      end
+
+      # @return [void]
+      def find_duplicate_elements()
+        names = self.summary.elements.map(&:name)
+        s = Set.new()
+        dupes = names.reject { |e| s.add?(e) }.uniq
+        self.duplicate_elements = {}
+        dupes.each { |d| self.duplicate_elements[d] = 1 }
+        return nil
+      end
+
+    end
+  end
+end