eddy 0.1.0 → 0.3.0

data/lib/eddy/build/transaction_set_builder.rb

@@ -0,0 +1,218 @@
+require "ginny"
+
+module Eddy
+  module Build
+    # 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.
+    class TransactionSetBuilder
+
+      # @return [Eddy::Schema::TransactionSetSummary]
+      attr_accessor :summary
+      # @return [String] (nil)
+      attr_accessor :folder
+      # @return [Boolean] (false)
+      attr_accessor :headers
+
+      # @param folder [String] (nil)
+      # @param headers [Boolean] (false)
+      # @return [void]
+      def initialize(folder: nil, headers: false)
+        self.folder  = folder
+        self.headers = headers
+      end
+
+      # @param path [String] Path to a JSON or YAML file containing a valid Transaction Set definition.
+      # @param (see #initialize)
+      # @return [Eddy::Build::TransactionSetBuilder]
+      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
+
+      # @param summary [Eddy::Schema::TransactionSetSummary]
+      # @param (see #initialize)
+      # @return [Eddy::Build::TransactionSetBuilder]
+      def self.from_summary(summary, **kwargs)
+        builder = Eddy::Build::TransactionSetBuilder.new(**kwargs)
+        builder.summary = summary
+        return builder
+      end
+
+      # @return [String]
+      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
+
+      # @return [String]
+      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
+
+      # @return [Ginny::Class]
+      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: <<~STR,
+
+            ID = "#{self.summary.id}".freeze
+            NAME = "#{self.summary.name}".freeze
+            FUNCTIONAL_GROUP = "#{self.summary.functional_group}".freeze
+
+            #{self.constructor()}
+
+            #{self.accessors()}
+          STR
+        })
+      end
+
+      # @!group Initialize
+
+      # @return [String]
+      def constructor()
+        return Ginny::Func.create({
+          name: "initialize",
+          params: [{ name: "store", type: "Eddy::Data::Store" }],
+          body: <<~RB,
+            #{self.declarations()}
+
+
+            #{self.super_call()}
+          RB
+        }).render()
+      end
+
+      # @return [String]
+      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
+
+      # @return [String]
+      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
+
+      # @!endgroup Initialize
+
+      # @return [String]
+      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
+
+      # @param segment_id [String]
+      # @return [String]
+      def self.segment_accessor(segment_id)
+        upper = segment_id.upcase
+        lower = segment_id.downcase
+        return <<~RB.strip
+          # (see Eddy::Segments::#{upper})
+          #
+          # @yieldparam [Eddy::Segments::#{upper}] #{lower}
+          # @return [Eddy::Segments::#{upper}]
+          def #{upper}()
+            yield(@#{lower}) if block_given?
+            return @#{lower}
+          end
+        RB
+      end
+
+      # @param summary [Eddy::Schema::LoopSummary]
+      # @param t_set_name [String]
+      # @return [String]
+      def self.loop_accessor(summary, t_set_name)
+        upper = summary.loop_id.upcase
+        lower = summary.loop_id.downcase
+        return <<~RB.strip
+          # (see Eddy::TransactionSets::#{t_set_name}::Loops::#{upper})
+          #
+          #{self.loop_components(summary, t_set_name)}
+          # @return [void]
+          def L_#{upper}(&block)
+            if block_given?
+              @l_#{lower}.add_iteration(&block)
+            else
+              raise Eddy::Errors::Error, \"No block given in loop iteration\"
+            end
+            return nil
+          end
+        RB
+      end
+
+      # @param summary [Eddy::Schema::LoopSummary]
+      # @param t_set_name [String]
+      # @return [String]
+      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
+
+    end
+  end
+end

data/lib/eddy/cli/cli.rb

@@ -0,0 +1,39 @@
+require "thor"
+
+module Eddy
+  # Command Line Interface for Eddy
+  class CLI < Thor
+    desc "version", "Display version"
+    map ["-v", "--version"] => :version
+
+    # @return [void]
+    def version()
+      puts("Eddy version #{Eddy::VERSION}")
+      exit(0)
+    end
+
+    desc("segment PATH", "Build a Segment from a JSON or YAML definition")
+    method_option("build-elements", type: :boolean, default: false)
+    # @param path [String]
+    # @return [void]
+    def segment(path)
+      path = File.expand_path(path)
+      builder = Eddy::Build::SegmentBuilder.from_file(path)
+      result = builder.build(build_elements: options["build-elements"])
+      puts("Segment class generated: #{result}")
+      exit(0)
+    end
+
+    desc("set PATH", "Build a Transaction Set from a JSON or YAML definition")
+    # @param path [String]
+    # @return [void]
+    def set(path)
+      path = File.expand_path(path)
+      builder = Eddy::Build::TransactionSetBuilder.from_file(path)
+      result = builder.build()
+      puts("Transaction Set class generated: #{result}")
+      exit(0)
+    end
+
+  end
+end

data/lib/eddy/config.rb

@@ -0,0 +1,51 @@
+module Eddy
+  # Configuration for Eddy
+  class Config
+
+    # @return [String<"test", "development", "production">] ("development")
+    attr_accessor :env
+    # Method used by Eddy to persist data about EDI control numbers.
+    # @return [Symbol<:memory, :file>] (:memory)
+    attr_accessor :persistence_method
+    # @return [String]
+    attr_accessor :tmp_dir
+    # @return [String]
+    attr_accessor :build_dir
+    # @return [Boolean] (true)
+    attr_accessor :colorize_errors
+    # @return [Boolean] (true)
+    attr_accessor :validate
+
+    # @return [void]
+    def initialize()
+      self.env = "development"
+      self.persistence_method = :memory
+      self.tmp_dir = File.join(Eddy::Util.root_dir, "tmp")
+      self.build_dir = File.join(Eddy::Util.root_dir, "build")
+      self.colorize_errors = true
+      self.validate = true
+    end
+
+  end
+
+  # Configuration for Eddy
+  #
+  # @return [Eddy::Config]
+  def self.config()
+    @config ||= Config.new
+  end
+
+  # Modify Eddy's current config
+  #
+  # @example
+  #   Eddy.configure do |config|
+  #     config.persistence_method = :file
+  #   end
+  #
+  # @yieldparam [Eddy::Config] config current Eddy config
+  # @return [void]
+  def self.configure()
+    yield self.config
+  end
+
+end

data/lib/eddy/data.rb

@@ -0,0 +1,50 @@
+require "eddy/data/store"
+require "eddy/data/persistence/base"
+require "eddy/data/persistence/memory"
+
+module Eddy
+
+  # Persistent data used by Eddy.
+  # @return [Eddy::Data::Persistence::Base]
+  def self.data
+    return @data if defined? @data
+    case Eddy.config.persistence_method
+    when :memory then @data = Eddy::Data::Persistence::Memory.new()
+    when :file   then raise NotImplementedError
+    when :db     then raise NotImplementedError
+    else raise Eddy::Errors::Error, "Unsupported persistence method: #{Eddy.config.persistence_method}"
+    end
+    return @data
+  end
+
+  module Data
+
+    # @return [Integer]
+    def self.new_interchange_control_number
+      existing = Eddy.data.interchange_control_numbers()
+      new_ctrl_num = Eddy::Util.new_number(existing)
+      Eddy.data.add_interchange_control_number(new_ctrl_num)
+      return new_ctrl_num
+    end
+
+    # @param functional_group [String]
+    # @return [Integer]
+    def self.new_functional_group_control_number(functional_group)
+      existing = Eddy.data.functional_group_control_numbers(functional_group)
+      new_ctrl_num = Eddy::Util.new_number(existing)
+      Eddy.data.add_functional_group_control_number(functional_group, new_ctrl_num)
+      return new_ctrl_num
+    end
+
+    # @param transaction_set_id [String]
+    # @return [Integer]
+    def self.new_transaction_set_control_number(transaction_set_id)
+      existing = Eddy.data.transaction_set_control_numbers(transaction_set_id)
+      new_ctrl_num = Eddy::Util.new_number(existing)
+      Eddy.data.transaction_set_control_numbers(transaction_set_id, new_ctrl_num)
+      return new_ctrl_num
+    end
+
+  end
+
+end

data/lib/eddy/data/persistence/active_record.rb

@@ -0,0 +1,10 @@
+module Eddy
+  module Data
+    module Persistence
+      # Persist data to a database using Active Record.
+      class ActiveRecord
+
+      end
+    end
+  end
+end

data/lib/eddy/data/persistence/base.rb

@@ -0,0 +1,47 @@
+module Eddy
+  module Data
+    module Persistence
+      # Base class for data persistence wrappers.
+      class Base
+
+        # @return [Array<Integer>]
+        def interchange_control_numbers()
+          raise NotImplementedError
+        end
+
+        # @param _functional_group [String]
+        # @return [Array<Integer>]
+        def functional_group_control_numbers(_functional_group)
+          raise NotImplementedError
+        end
+
+        # @param _transaction_set_id [String]
+        # @return [Array<Integer>]
+        def transaction_set_control_numbers(_transaction_set_id)
+          raise NotImplementedError
+        end
+
+        # @param _new_ctrl_num [Integer]
+        # @return [Array<Integer>]
+        def add_interchange_control_number(_new_ctrl_num)
+          raise NotImplementedError
+        end
+
+        # @param _functional_group [String]
+        # @param _new_ctrl_num [Integer]
+        # @return [Array<Integer>]
+        def add_functional_group_control_number(_functional_group, _new_ctrl_num)
+          raise NotImplementedError
+        end
+
+        # @param _transaction_set_id [String]
+        # @param _new_ctrl_num [Integer]
+        # @return [Array<Integer>]
+        def add_transaction_set_control_number(_transaction_set_id, _new_ctrl_num)
+          raise NotImplementedError
+        end
+
+      end
+    end
+  end
+end

data/lib/eddy/data/persistence/file.rb

@@ -0,0 +1,50 @@
+require "fileutils"
+require "json"
+require "pathname"
+
+module Eddy
+  module Data
+    module Persistence
+      # Persist data to a local JSON file.
+      class File < Memory
+
+        # @return [void]
+        def initialize()
+          if path.file?
+            self.read()
+          else
+            super()
+          end
+        end
+
+        # Renturn a [Pathname](https://ruby-doc.org/stdlib-2.5.0/libdoc/pathname/rdoc/Pathname.html) to the JSON file used for storage.
+        #
+        # See:
+        #
+        # - [FileTest](https://ruby-doc.org/core-2.5.0/FileTest.html#method-i-file-3F)
+        #
+        # @return [Pathname]
+        def path()
+          file = File.join(Eddy.config.tmp_dir, "eddy_persistent_data.json")
+          # FileUtils.mkdir_p(File.dirname(file))
+          return Pathname.new(file)
+        end
+
+        # Read the JSON file into `@data`.
+        #
+        # @return [void]
+        def read()
+          @data = JSON.parse(File.read(self.path()), symbolize_names: symbolize)
+        end
+
+        # Write `@data` out to the JSON file. This will overwrite the file's contents.
+        #
+        # @return [void]
+        def write()
+          File.open(self.path(), "w") { |f| f.write(@data.to_json) }
+        end
+
+      end
+    end
+  end
+end