eddy 0.1.0 → 0.3.0

data/data/004010/segments/ISA.tsv

@@ -1,17 +0,0 @@
-Ref	Id	Req	Type	Min	Max	ElementName	Note
-ISA01	I01	M	ID	2	2	Authorization Information Qualifier	
-ISA02	I02	M	AN	10	10	Information	Defaults to 10 blank spaces
-ISA03	I03	M	ID	2	2	Security Information Qualifier	
-ISA04	I04	M	AN	10	10	Information	Defaults to 10 blank spaces
-ISA05	I05	M	ID	2	2	Interchange ID Qualifier	
-ISA06	I06	M	AN	15	15	Interchange Sender ID	
-ISA07	I05	M	ID	2	2	Interchange ID Qualifier	
-ISA08	I07	M	AN	15	15	Interchange Receiver ID	
-ISA09	I08	M	DT	6	6	Interchange Date	
-ISA10	I09	M	TM	4	4	Interchange Time	
-ISA11	I10	M	ID	1	1	Interchange Control Standards Identifier	
-ISA12	I11	M	ID	5	5	Interchange Control Version Number	
-ISA13	I12	M	N0	9	9	Interchange Control Number	
-ISA14	I13	M	ID	1	1	Acknowledgment Requested	
-ISA15	I14	M	ID	1	1	Usage Indicator	
-ISA16	I15	M	N/A	1	1	Component Element Separator	

data/data/schema.jsonc

@@ -1,67 +0,0 @@
-{
-  "data": [
-    {
-      "type": "class",
-      "name": "SegmentSummary",
-      "fields": [
-        {"name": "pos", "type":"String,nil"},
-        {"name": "id","type":"String"},
-        {"name": "name", "type":"String"},
-        {"name": "req", "type":"String"},
-        {"name": "purpose", "type":"String"},
-        {"name": "max_use", "type":"Integer"},
-        {"name": "repeat", "type":"Integer"},
-        {"name": "notes", "type":"String"},
-        {"name": "usage", "type":"String"},
-        {"name": "table", "type":"String", "description": "*Heading*, *Detail*, *Summary*, or *Not Defined*"},
-        {"name": "loop", "type":"String,nil"}
-      ]
-    },
-    {
-      "type": "class",
-      "name": "ElementSummary",
-      "fields": [
-        {"name": "ref", "type": "String"},
-        {"name": "id", "type": "String"},
-        {"name": "name", "type": "String"},
-        {"name": "description", "type": "String"},
-        {"name": "req", "type": "String"},
-        {"name": "type", "type": "String"},
-        {"name": "min", "type": "Integer"},
-        {"name": "max", "type": "Integer"},
-        {"name": "usage", "type": "String"},
-        {"name": "default", "type": "String,nil"}
-      ]
-    },
-    {
-      "type": "class",
-      "name": "Loop",
-      "fields" : [
-        {"name": "loopId", "type": "String"},
-        {"name": "repeat", "type": "String"},
-        {"name": "notes", "type": "String"},
-        {"name": "segments", "type": "Array<Segment>"}
-      ]
-    },
-    {
-      "type": "enum",
-      "name": "Table",
-      "values": [
-        "Heading",
-        "Detail",
-        "Summary",
-        "NotDefined"
-      ]
-    },
-    {
-      "type": "enum",
-      "name": "Req",
-      "values": [
-        "M - Mandatory",
-        "O - Optional",
-        "X - Syntax note applies",
-        "Z - Semantic note applies"
-      ]
-    }
-  ],
-}

data/lib/eddy/build/build_an.rb

@@ -1,31 +0,0 @@
-require "food_truck"
-
-module Eddy
-  module Build
-    # @param e [Hash]
-    # @return [void]
-    def self.build_an(e)
-      constructor = FoodTruck::Func.create({
-        name: "initialize",
-        body: <<~FUNC_BODY,
-          @id = "#{e[:id]}"
-          @name = "#{e[:name]}"
-          @type = "AN"
-          self.min = #{e[:min]}
-          self.max = #{e[:max]}
-        FUNC_BODY
-      }).render()
-      data = {
-        name: e[:name],
-        description: e[:description],
-        parent: "Eddy::Element::AN",
-        modules: ["Eddy", "Elements"],
-        body: constructor,
-        file_prefix: "#{e[:id]}.",
-      }
-      c = FoodTruck::Class.create(data)
-      c.generate(File.join(Eddy.root_dir, "build", "elements", "an"))
-      return nil
-    end
-  end
-end

data/lib/eddy/build/build_dt.rb

@@ -1,46 +0,0 @@
-require "food_truck"
-
-module Eddy
-  module Build
-
-    def self.build_dt(e)
-      fmt = determine_dt_format(e[:max])
-      constructor = FoodTruck::Func.create({
-        name: "initialize",
-        body: <<~FUNC_BODY,
-          @id = "#{e[:id]}"
-          @name = "#{e[:name]}"
-          @type = "DT"
-          self.min = #{e[:min]}
-          self.max = #{e[:max]}
-          super(:#{fmt})
-        FUNC_BODY
-      }).render()
-      data = {
-        name: e[:name],
-        description: e[:description],
-        parent: "Eddy::Element::DT",
-        modules: ["Eddy", "Elements"],
-        body: constructor,
-        file_prefix: "#{e[:id]}.",
-      }
-      c = FoodTruck::Class.create(data)
-      c.generate(File.join(Eddy.root_dir, "build", "elements", "dt"))
-      return nil
-    end
-
-    # @param int [Integer]
-    # @return [Symbol]
-    def self.determine_dt_format(int)
-      case int
-      when 6
-        return :yymmdd
-      when 8
-        return :ccyymmdd
-      else
-        raise Eddy::Error, "unable to determine format for dt element"
-      end
-    end
-
-  end
-end

data/lib/eddy/build/build_elements.rb

@@ -1,181 +0,0 @@
-require "food_truck"
-require "eddy/build/build_dt"
-require "eddy/build/build_tm"
-require "eddy/build/build_id"
-require "eddy/build/build_an"
-require "eddy/build/build_r_and_n"
-
-module Eddy
-  module Build
-
-    # Create folders in `build/elements`.
-    #
-    # @return [void]
-    def self.make_element_folders()
-      build_dir = File.join(Eddy.root_dir, "build")
-      dirs = ["an", "dt", "id", "n", "r", "tm"]
-      dirs.each do |dir|
-        FileUtils.mkdir_p(File.join(build_dir, "elements", dir))
-      end
-      return nil
-    end
-
-    # Delete all ruby files in `build/elements/**`.
-    #
-    # @return [void]
-    def self.clean_element_folders()
-      dirs = ["an", "dt", "id", "n", "r", "tm"]
-      dirs.each do |dir|
-        files = Dir.glob(File.join(Eddy.root_dir, "build", "elements", dir, "*.rb"))
-        File.delete(*files)
-      end
-      return nil
-    end
-
-    # Generate `Eddy::Element` classes for all data elements defined in `data/004010/elements.tsv`
-    #
-    # @return [Array<Hash>]
-    def self.generate_elements
-      elements = self.generate_element_data()
-      elements.each do |e|
-        case e[:type]
-        when "AN"
-          self.build_an(e)
-        when "B"
-          self.build_b(e)
-        when "DT"
-          self.build_dt(e)
-        when "ID"
-          self.build_id(e)
-        when /N\d*/
-          self.build_n(e)
-        # when /R\d*/
-        when "R"
-          self.build_r(e)
-        when "TM"
-          self.build_tm(e)
-        else
-          raise Eddy::Error "unable to determine element type"
-        end
-      end
-      return nil
-    end
-
-    # Generate usable data from `data/004010/elements.tsv`.
-    #
-    # @return [Array<Hash>]
-    def self.generate_element_data
-      elements_file = File.join(Eddy.data_dir, "004010", "elements.tsv")
-      data = Eddy.parse_tsv(elements_file)
-      elements = data.map do |e|
-        next if e[:type].nil? || e[:description].nil?
-        self.extract_element_data(e)
-      end
-      return elements.compact
-    end
-
-    # Build a hash with data that can be used to generate an element class.
-    #
-    # @param e [Hash]
-    # @return [Hash]
-    def self.extract_element_data(e)
-      return {
-        id: e[:id].strip,
-        min: e[:min].to_i,
-        max: e[:max].to_i,
-        name: self.normalize_name(e[:name]),
-        description: self.generate_description(e),
-        type: e[:type].strip,
-      }
-    end
-
-    # Remove dashes, underscores, spaces, slashes, periods, and parens from a string then titleize it.
-    #
-    # @param name [String]
-    # @return [String]
-    def self.normalize_name(name)
-      return name.gsub(/\s*\(.*\)|[']/, "")
-                 .gsub(%r{[.,_\-/]}, " ")
-                 .split(" ")
-                 .map(&:capitalize)
-                 .join("")
-    end
-
-    # Generate a description to use as a doc comment for an element.
-    #
-    # @param e [Hash]
-    # @return [Hash]
-    def self.generate_description(e)
-      return <<~END.strip
-        - Id: #{e[:id].strip}
-        - Name: #{e[:name].strip}
-        - Type: #{e[:type].strip}
-        - Min/Max: #{e[:min]}/#{e[:max]}
-        - Description: #{e[:description].strip}
-      END
-    end
-
-    # Determine the parent class for an element.
-    #
-    # @param data [String]
-    # @return [String]
-    def self.type_string(data)
-      case data.upcase
-      when "AN"
-        return "AN"
-      when "B"
-        return "B"
-      when "DT"
-        return "DT"
-      when "ID"
-        return "ID"
-      when /N\d*/
-        # (N) N0, N1, N2, N4, N6
-        return "N"
-      when /R\d*/
-        return "R"
-      when "TM"
-        return "TM"
-      else
-        raise Eddy::Error, "unable to determine element type (#{data.capitalize})"
-      end
-    end
-
-    # @deprecated Use specific build functions instead.
-    #
-    # @param e [Hash]
-    # @return [void]
-    def self.build_element(e)
-      constructor = FoodTruck::Func.create({
-        name: "initialize",
-        body: <<~FUNC_BODY,
-          @id = "#{e[:id]}"
-          @name = "#{e[:name]}"
-          @type = "#{e[:type]}"
-          self.min = #{e[:min]}
-          self.max = #{e[:max]}
-        FUNC_BODY
-      }).render()
-      data = {
-        name: e[:name],
-        description: e[:description],
-        parent: "Eddy::Element::#{e[:type]}",
-        modules: ["Eddy", "Elements"],
-        body: constructor,
-        file_prefix: "#{e[:id]}.",
-      }
-      c = FoodTruck::Class.create(data)
-      c.generate(File.join(Eddy.root_dir, "build", "elements"))
-      return nil
-    end
-
-    # Not sure how to handle this bad boy yet.
-    #
-    # @param e [Hash]
-    # @return [void]
-    def self.build_b(e)
-      return nil
-    end
-
-  end
-end

data/lib/eddy/build/build_id.rb

@@ -1,56 +0,0 @@
-require "food_truck"
-
-module Eddy
-  module Build
-
-    # @param e [Hash]
-    # @return [void]
-    def self.build_id(e)
-      code_list = self.build_code_list(e[:id])
-      return nil if code_list.nil?
-      constructor = FoodTruck::Func.create({
-        name: "initialize",
-        body: <<~FUNC_BODY,
-          @id = "#{e[:id]}"
-          @name = "#{e[:name]}"
-          @type = "ID"
-          self.min = #{e[:min]}
-          self.max = #{e[:max]}
-        FUNC_BODY
-      }).render()
-      data = {
-        name: e[:name],
-        description: e[:description],
-        parent: "Eddy::Element::ID",
-        modules: ["Eddy", "Elements"],
-        body: constructor + "\n\n" + code_list + "\n",
-        file_prefix: "#{e[:id]}.",
-      }
-      c = FoodTruck::Class.create(data)
-      c.generate(File.join(Eddy.root_dir, "build", "elements", "id"))
-      return nil
-    end
-
-    # @param id [String]
-    # @return [String]
-    def self.build_code_list(id)
-      file = File.join(Eddy.data_dir, "004010", "code-lists", "#{id}.tsv")
-      begin
-        data = Eddy.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"
-      return FoodTruck::Func.create({
-        name: "code_list",
-        return_type: "Array<String>",
-        body: body,
-      }).render()
-    end
-
-  end
-end

data/lib/eddy/build/build_r_and_n.rb

@@ -1,69 +0,0 @@
-require "food_truck"
-
-module Eddy
-  module Build
-
-    # @param e [Hash]
-    # @return [void]
-    def self.build_n(e)
-      decimal_points = self.determine_decimals(e[:type])
-      constructor = FoodTruck::Func.create({
-        name: "initialize",
-        body: <<~RUBY,
-          @id = "#{e[:id]}"
-          @name = "#{e[:name]}"
-          @type = "N"
-          self.min = #{e[:min]}
-          self.max = #{e[:max]}
-          self.decimal_points = #{decimal_points}
-        RUBY
-      }).render()
-      data = {
-        name: e[:name],
-        description: e[:description],
-        parent: "Eddy::Element::N",
-        modules: ["Eddy", "Elements"],
-        body: constructor,
-        file_prefix: "#{e[:id]}.",
-      }
-      c = FoodTruck::Class.create(data)
-      c.generate(File.join(Eddy.root_dir, "build", "elements", "n"))
-      return nil
-    end
-
-    # @param e [Hash]
-    # @return [void]
-    def self.build_r(e)
-      constructor = FoodTruck::Func.create({
-        name: "initialize",
-        body: <<~FUNC_BODY,
-          @id = "#{e[:id]}"
-          @name = "#{e[:name]}"
-          @type = "R"
-          self.min = #{e[:min]}
-          self.max = #{e[:max]}
-        FUNC_BODY
-      }).render()
-      data = {
-        name: e[:name],
-        description: e[:description],
-        parent: "Eddy::Element::R",
-        modules: ["Eddy", "Elements"],
-        body: constructor,
-        file_prefix: "#{e[:id]}.",
-      }
-      c = FoodTruck::Class.create(data)
-      c.generate(File.join(Eddy.root_dir, "build", "elements", "r"))
-      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