eddy 0.1.0 → 0.3.0

data/lib/eddy/schema/segment_summary.rb

@@ -0,0 +1,116 @@
+module Eddy
+  module Schema
+    # A collection of Data Elements. Used in Companion Guides to define a Transaction Set.
+    class SegmentSummary
+
+      # Indicates the order in which Segments should appear in their Level of the Transaction Set.
+      # @return [String]
+      attr_accessor :pos
+      # Short string identifying the Segment.
+      # @return [String]
+      attr_accessor :id
+      # Full name of the Segment.
+      # @return [String]
+      attr_accessor :name
+      # Documents the purpose of a Segment.
+      # @return [String]
+      attr_accessor :purpose
+      # Number of times a particular Segment may be repeated at its location in the Transaction Set.
+      # @return [Integer]
+      attr_accessor :max_use
+      # *Syntax*, *Semantic*, or *Comment* notes on a Segment.
+      # @return [String]
+      attr_accessor :notes
+      # Indicates whether or not the Segment must be used; Somewhat redundant due to `Req`.
+      # @return [String]
+      attr_accessor :usage
+      # Number of Data Elements included in the Segment.
+      # @return [Integer]
+      attr_accessor :element_count
+      # Defines if/how the Segment is required.
+      # @return [String]
+      attr_accessor :req
+      # Indicates where the Segment is located in the Transaction Set.
+      # @return [String]
+      attr_accessor :level
+      # Number of Data Elements included in the Segment.
+      # @return [Array<Eddy::Schema::ElementSummary>]
+      attr_accessor :elements
+
+      # @return [void]
+      def initialize()
+        self.elements = []
+      end
+
+      # @param params [Hash]
+      # @return [self]
+      def self.create(params = {})
+        s = new()
+        s.pos           = params[:pos]
+        s.id            = params[:id]
+        s.name          = params[:name]
+        s.purpose       = params[:purpose]
+        s.max_use       = params[:max_use]
+        s.notes         = params[:notes]
+        s.usage         = params[:usage]
+        s.element_count = params[:element_count]
+        s.req           = params[:req]
+        s.level         = params[:level]
+        s.process_elements(params[:elements])
+        return s
+      end
+
+      # @param path [String] Path to a JSON or YAML file containing a valid Segment definition.
+      # @return [self]
+      def self.from_file(path)
+        raise Eddy::Errors::Error, "Invalid segment definition" unless Eddy::Schema.valid_segment_data?(path)
+        data = Eddy::Util.read_json_or_yaml(path)
+        return Eddy::Schema::SegmentSummary.create(data)
+      end
+
+      # @param id [String]
+      # @return [self]
+      def self.default_for_id(id)
+        id.downcase!
+        if ["ge", "gs", "iea", "isa", "se", "st"].include?(id)
+          path = File.join(Eddy::Util.data_dir, "004010", "segments", "envelope", "#{id}.segment.yml")
+          return self.from_file(path)
+        end
+        path = File.join(Eddy::Util.data_dir, "004010", "segments", "#{id}.segment.yml")
+        raise Eddy::Errors::Error, "No segment found with id #{id}" unless File.file?(path)
+        return self.from_file(path)
+      end
+
+      # TODO: Only use defaults if not enough info is provided.
+      # TODO: Define *enough info*.
+      #
+      # @param elements [Array<Hash>]
+      # @return [void]
+      def process_elements(elements)
+        return if elements.nil?
+        elements.each do |el|
+          default_el = Eddy::Schema::ElementSummary.default_for_id(el[:id])
+          default_el.ref = el[:ref]
+          default_el.req = el[:req] || nil
+          self.elements << default_el
+        end
+      end
+
+      # Generate a description to use as a doc comment for a segment.
+      #
+      # @param header [Boolean] (true)
+      # @return [String]
+      def doc_comment(header: true)
+        parts = []
+        parts << "### Segment Summary:\n" if header
+        parts << <<~YARD.strip
+          - Id: #{self.id}
+          - Name: #{self.name}
+          - Purpose: #{self.purpose}
+        YARD
+        return parts.compact.join("\n")
+      end
+
+    end
+  end
+end

data/lib/eddy/schema/transaction_set_summary.rb

@@ -0,0 +1,96 @@
+module Eddy
+  module Schema
+    # An outline of all required components for an EDI transaction set implementation.
+    class TransactionSetSummary
+      # A short code identifying the Transaction Set.
+      # @return [Integer]
+      attr_accessor :id
+      # A descriptive name for the Transaction Set.
+      # @return [String]
+      attr_accessor :name
+      # A short string used to group related Transaction Sets.
+      # @return [String]
+      attr_accessor :functional_group
+      # The components that make up the Transaction Set.
+      # @return [Array<Eddy::Schema::SegmentSummary, Eddy::Schema::LoopSummary>]
+      attr_accessor :components
+
+      # @return [void]
+      def initialize()
+        self.components = []
+      end
+
+      # @param params [Hash]
+      # @return [self]
+      def self.create(params = {})
+        summary = TransactionSetSummary.new()
+        summary.id = params[:id]
+        summary.name = params[:name]
+        summary.functional_group = params[:functional_group]
+        summary.process_components(params[:components])
+        return summary
+      end
+
+      # @param path [String] Path to a JSON or YAML file containing a valid Segment definition.
+      # @return [self]
+      def self.from_file(path)
+        raise Eddy::Errors::Error, "Invalid transaction set definition" unless Eddy::Schema.valid_transaction_set_data?(path)
+        data = Eddy::Util.read_json_or_yaml(path)
+        return Eddy::Schema::TransactionSetSummary.create(data)
+      end
+
+      # @param components [Array<Hash>]
+      # @return [void]
+      def process_components(components)
+        components.each do |comp|
+          if comp.key?(:loop_id)
+            self.components << Eddy::Schema::LoopSummary.create(comp)
+          else
+            self.components << Eddy::Schema::SegmentSummary.create(comp)
+          end
+        end
+      end
+
+      # @return [String]
+      def normalized_name
+        return "TS#{self.id}"
+      end
+
+      # Generate a description to use as a doc comment for a transaction set.
+      #
+      # @param header [Boolean] (true)
+      # @return [String]
+      def doc_comment(header: true)
+        parts = []
+        parts << "### Transaction Set Summary:\n" if header
+        parts << <<~YARD.strip
+          - Id: #{self.id}
+          - Name: #{self.name}
+          - Functional Group: #{self.functional_group}
+        YARD
+        return parts.compact.join("\n")
+      end
+
+      # Return all components in a single, flattened array.
+      #
+      # @return [Array<Eddy::Schema::SegmentSummary, Eddy::Schema::LoopSummary>]
+      def all_components()
+        return self.components.map do |comp|
+          case comp
+          when Eddy::Schema::LoopSummary    then [comp, comp.all_components()]
+          when Eddy::Schema::SegmentSummary then comp
+          else raise Eddy::Errors::Error
+          end
+        end.flatten
+      end
+
+      # Return one of each kind of loop in the Transaction Set.
+      #
+      # @return [Array<Eddy::Schema::SegmentSummary, Eddy::Schema::LoopSummary>]
+      def unique_loops()
+        return self.all_components.select { |c| c.is_a?(Eddy::Schema::LoopSummary) }.uniq(&:loop_id)
+      end
+
+    end
+  end
+end

data/lib/eddy/schema/validate.rb

@@ -0,0 +1,41 @@
+require "pathname"
+require "json_schemer"
+
+module Eddy
+  module Schema
+
+    # Check a Segment definition file against Eddy's JSON schema.
+    #
+    # @param path [String] Path to the file.
+    # @return [Boolean]
+    def self.valid_segment_data?(path)
+      schema = Pathname.new(File.join(Eddy::Util.data_dir, "schema", "segment_summary.json"))
+      schemer = JSONSchemer.schema(schema, ref_resolver: "net/http")
+      data = Eddy::Util.read_json_or_yaml(path, symbolize: false)
+      schemer.valid?(data)
+    end
+
+    # Check a Loop definition file against Eddy's JSON schema.
+    #
+    # @param path [String] Path to the file.
+    # @return [Boolean]
+    def self.valid_loop_data?(path)
+      schema = Pathname.new(File.join(Eddy::Util.data_dir, "schema", "loop_summary.json"))
+      schemer = JSONSchemer.schema(schema, ref_resolver: "net/http")
+      data = Eddy::Util.read_json_or_yaml(path, symbolize: false)
+      schemer.valid?(data)
+    end
+
+    # Check a Transaction Set definition file against Eddy's JSON schema.
+    #
+    # @param path [String] Path to the file.
+    # @return [Boolean]
+    def self.valid_transaction_set_data?(path)
+      schema = Pathname.new(File.join(Eddy::Util.data_dir, "schema", "transaction_set_summary.json"))
+      schemer = JSONSchemer.schema(schema, ref_resolver: "net/http")
+      data = Eddy::Util.read_json_or_yaml(path, symbolize: false)
+      schemer.valid?(data)
+    end
+
+  end
+end

data/lib/eddy/util.rb

@@ -0,0 +1,16 @@
+module Eddy
+  # Assorted helper functions.
+  module Util; end
+end
+
+require "eddy/util/new_number"
+require "eddy/util/normalize"
+require "eddy/util/trim"
+require "eddy/util/read"
+require "eddy/util/clean_folder"
+require "eddy/util/timestamp"
+require "eddy/util/time"
+
+require "eddy/util/paths"
+
+require "eddy/util/edi_data"

data/lib/eddy/util/clean_folder.rb

@@ -0,0 +1,14 @@
+module Eddy
+  module Util
+    # Delete all files from a folder; returns number of deleted files.
+    #
+    # @param path [String] Path to the folder.
+    # @return [Integer]
+    def self.clean_folder(path)
+      dir = File.expand_path(path)
+      children = Dir.entries(dir).select { |f| File.file?(File.join(dir, f)) }
+      deleted = File.unlink(*children)
+      return deleted
+    end
+  end
+end

data/lib/eddy/util/edi_data.rb

@@ -0,0 +1,153 @@
+module Eddy
+  module Util
+    # @!group EDI Data
+
+    # Return raw data from `data/004010/elements.tsv`.
+    #
+    #
+    # @example Example return value
+    #   [
+    #     {:id=>"1", :name=>"Route Code", :type=>"AN", :min=>"1", :max=>"13", :description=>"Mutually defined route code"},
+    #     {:id=>"2", :name=>"Number of Accepted Transaction Sets", :type=>"N0", :min=>"1", :max=>"6", :description=>"Number of accepted Transaction Sets in a Functional Group"},
+    #     {:id=>"3", :name=>"Free Form Message", :type=>"AN", :min=>"1", :max=>"60", :description=>"Free-form text"},
+    #     ...,
+    #   ]
+    #
+    # @return [Array<Hash>]
+    def self.raw_element_data()
+      return Eddy::Util.parse_tsv(File.join(Eddy::Util.data_dir, "004010", "elements.tsv"))
+    end
+
+    # Returns a hash where the keys are Element ids and the values are unprocessed Element names.
+    #
+    # @example Example return value
+    #   {
+    #     "1"  => "Route Code",
+    #     "2"  => "Number of Accepted Transaction Sets",
+    #     "3"  => "Free Form Message",
+    #     "4"  => "Air Carrier Code",
+    #     "5"  => "Airport Code",
+    #     "7"  => "Bank Account Number",
+    #     "8"  => "Bank Client Code",
+    #     "9"  => "Late Reason Code",
+    #     "11" => "Billing Code",
+    #     ...,
+    #   }
+    #
+    # @return [Hash<String, String>]
+    def self.element_ids()
+      file = File.join(Eddy::Util.data_dir, "004010", "elements-short.tsv")
+      data = {}
+      CSV.foreach(file, { col_sep: "\t", quote_char: "\x00", headers: false }) do |row|
+        next if row ==  ["id", "name"]
+        data[row[0]] = row[1]
+      end
+      return data
+    end
+
+    # Returns a hash where the keys are Segment ids and the values are unprocessed Segment names.
+    #
+    # @example Example return value
+    #   {
+    #     "AAA" => "Request Validation",
+    #     "ACD" => "Account Description",
+    #     "ACK" => "Line Item Acknowledgment",
+    #     "ACS" => "Ancillary Charges",
+    #     "ACT" => "Account Identification",
+    #     "AD1" => "Adjustment Amount",
+    #     "ADI" => "Animal Disposition",
+    #     ...,
+    #   }
+    #
+    # @return [Hash<String, String>]
+    def self.segment_ids()
+      file = File.join(Eddy::Util.data_dir, "004010", "segments.tsv")
+      data = {}
+      CSV.foreach(file, { col_sep: "\t", quote_char: "\x00" }) do |row|
+        next if row ==  ["id", "name"]
+        data[row[0]] = row[1]
+      end
+      return data
+    end
+
+    # Return the full name of an Element with the given id.
+    #
+    # @example
+    #   Eddy::Util.element_name_by_id("93") #=> "Name"
+    #
+    # @param id [String] ID of the Element to look up.
+    # @return [Hash]
+    def self.element_name_by_id(id)
+      data = Eddy::Util.element_ids()
+      return data[id] if data.key?(id)
+      raise Eddy::Errors::Error, "No element found with id #{id}"
+    end
+
+    # Return the full name of a Segment with the given id.
+    #
+    # @example
+    #   Eddy::Util.segment_name_by_id("N2") #=> "Additional Name Information"
+    #
+    # @param id [String] ID of the Segment to look up.
+    # @return [Hash]
+    def self.segment_name_by_id(id)
+      data = Eddy::Util.segment_ids()
+      return data[id] if data.key?(id)
+      raise Eddy::Errors::Error, "No segment found with id #{id}"
+    end
+
+    # List the names of Elements for which Ruby classes have already been built.
+    #
+    # @example
+    #   Eddy::Util.list_element_classes() #=> ["166", "326", "349", "234", ...]
+    #
+    # @return [Array<String>]
+    def self.list_element_classes()
+      dir = File.join(Eddy::Util.root_dir, "lib", "definitions", "elements", "**", "*.rb")
+      files = Dir.glob(dir)
+      return files.map { |f| File.basename(f).sub(/\..*/, "").upcase }
+    end
+
+    # List the names of Segments for which Ruby classes have already been built.
+    #
+    # @example
+    #   Eddy::Util.list_segment_classes() #=> ["TD5", "N4", "TD1", "BIG", ...]
+    #
+    # @return [Array<String>]
+    def self.list_segment_classes()
+      dir = File.join(Eddy::Util.root_dir, "lib", "definitions", "segments", "**", "*.rb")
+      files = Dir.glob(dir)
+      return files.map { |f| File.basename(f).sub(/\..*/, "").upcase }
+    end
+
+    # List Segment definition files in `data/004010/segments`.
+    #
+    # @example Example return value
+    #   [
+    #     "~/.rbenv/versions/2.6.5/lib/gems/eddy-0.0.0/data/004010/segments/ack.segment.yml",
+    #     "~/.rbenv/versions/2.6.5/lib/gems/eddy-0.0.0/data/004010/segments/bak.segment.yml",
+    #     ...,
+    #   ]
+    #
+    # @return [Array<String>]
+    def self.list_segment_definitions()
+      dir = File.join(Eddy::Util.data_dir, "004010", "segments")
+      files = Dir.entries(dir).select { |f| File.file?(File.join(dir, f)) }
+      return files.map { |f| File.join(dir, f) }.sort
+    end
+
+    # List names of Elements with Ruby files currently in `Eddy.config.build_dir/elements`.
+    #
+    # @example
+    #   Eddy::Util.list_built_elements() #=> []
+    #
+    # @return [Array<String>]
+    def self.list_built_elements()
+      dir = File.join(Eddy.config.build_dir, "elements", "**", "*.rb")
+      files = Dir.glob(dir)
+      return files.map { |f| File.basename(f).sub(/\..*/, "").upcase }
+    end
+
+    # @!endgroup EDI Data
+  end
+end

data/lib/eddy/util/new_number.rb

@@ -0,0 +1,24 @@
+module Eddy
+  module Util
+
+    # Given an array of numbers, returns the lowest number not included in the array.
+    #
+    # @param existing [Array<Integer>]
+    # @return [Integer]
+    def self.new_number(existing)
+      n = nil
+      i = 1
+      loop do
+        if existing.include?(i)
+          i += 1
+          next
+        else
+          n = i
+          break
+        end
+      end
+      return n
+    end
+
+  end
+end