stupidedi 1.1.0

data/lib/stupidedi/editor/transmission_ed.rb

@@ -0,0 +1,90 @@
+module Stupidedi
+  module Editor
+
+    class TransmissionEd < AbstractEd
+
+      # @return [Config]
+      attr_reader :config
+
+      # @return [Time]
+      attr_reader :received
+
+      def initialize(config, received)
+        @config, @received =
+          config, received
+      end
+
+      # @return [ResultSet]
+      def critique(machine)
+        ResultSet.new.tap do |acc|
+          m, index = machine.first, Hash.new{|h,k| h[k] = [] }
+
+          # Collect all the ISA13 elements within this transmission
+          while m.defined?
+            m = m.flatmap do |isa|
+              critique_isa(isa, acc)
+
+              # There isn't a well-defined constraint in the specs regarding
+              # the uniqueness of control numbers, but one of the foundation
+              # standards documents suggests the combination of ISA05, ISA06,
+              # ISA07, ISA08, and ISA13 "shall be unique within a reasonably
+              # extended time frame whose boundaries shall be defined by
+              # trading partner agreement".
+              isa.element(5).tap do |e5|
+                isa.element(6).tap do |e6|
+                  isa.element(7).tap do |e7|
+                    isa.element(8).tap do |e8|
+                      isa.element(13).tap do |e13|
+                        key  = []
+                        key <<  e5.node.to_s
+                        key <<  e6.node.to_s
+                        key <<  e7.node.to_s
+                        key <<  e8.node.to_s
+                        key << e13.node.to_s
+
+                        isa.segment.tap{|s| index[key] << s }
+                      end
+                    end
+                  end
+                end
+              end
+
+              isa.find!(:ISA)
+            end
+          end
+
+          edit(:ISA) do
+            index.each do |key, dupes|
+              dupes.tail.each do |s|
+                acc.ta105(s, "R", "025",
+                  "control number must be unique per sender and receiver")
+              end
+            end
+          end
+        end
+      end
+
+    private
+
+      #
+      # @see FiveOhOne#critique
+      #
+      def critique_isa(isa, acc)
+        isa.segment.tap do |x|
+          unless x.node.invalid?
+            envelope_def = x.node.definition.parent.parent
+
+            # Invoke the version-specific interchange editor
+            if config.editor.defined_at?(envelope_def)
+              editor = config.editor.at(envelope_def)
+              editor.new(config, received).critique(isa, acc)
+            end
+          else
+            acc.ta105(x, "R", "003", x.node.reason)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/stupidedi/editor.rb

@@ -0,0 +1,37 @@
+module Stupidedi
+  module Editor
+
+    autoload :Result,       "stupidedi/editor/result"
+    autoload :TA105,        "stupidedi/editor/result"
+    autoload :AK905,        "stupidedi/editor/result"
+    autoload :IK304,        "stupidedi/editor/result"
+    autoload :IK403,        "stupidedi/editor/result"
+    autoload :IK502,        "stupidedi/editor/result"
+    autoload :ClaimStatus,  "stupidedi/editor/result"
+    autoload :Warning,      "stupidedi/editor/result"
+    autoload :Error,        "stupidedi/editor/result"
+    autoload :ResultSet,    "stupidedi/editor/result_set"
+
+    autoload :AbstractEd,         "stupidedi/editor/abstract_ed"
+    autoload :FiveOhOneEd,        "stupidedi/editor/00501"
+    autoload :FiftyTenEd,         "stupidedi/editor/005010"
+    autoload :TransactionSetEd,   "stupidedi/editor/transaction_set_ed"
+    autoload :TransmissionEd,     "stupidedi/editor/transmission_ed"
+
+    autoload :X221, "stupidedi/editor/X221-HP835"
+    autoload :X222, "stupidedi/editor/X222-HC837"
+
+    # TA1
+    autoload :InterchangeAck,
+      "stupidedi/editor/interchange_ack"
+
+    # FA 999
+    autoload :ImplementationAck,
+      "stupidedi/editor/implementation_ack"
+
+    # HN 277CA
+    autoload :ClaimAck,
+      "stupidedi/editor/claim_ack"
+
+  end
+end

data/lib/stupidedi/either.rb

@@ -0,0 +1,287 @@
+module Stupidedi
+  class Either
+
+    # @return [Boolean]
+    abstract :defined?
+
+    ###########################################################################
+    # @group Filtering the Value
+
+    # @return [Either]
+    abstract :select, :args => %w(reason='select' &block)
+
+    # @return [Either]
+    abstract :reject, :args => %w(reason='reject' &block)
+
+    # @endgroup
+    ###########################################################################
+
+    ###########################################################################
+    # @group Transforming the Value
+
+    # @return [Either]
+    abstract :map, :args => %w(&block)
+
+    # @return [Either]
+    abstract :flatmap, :args => %w(&block)
+
+    # @return [Either]
+    abstract :or, :args => %w(&block)
+
+    # @return [Either]
+    abstract :explain, :args => %w(&block)
+
+    # @return [Object]
+    abstract :fetch, :args => %w(default)
+
+    # @endgroup
+    ###########################################################################
+
+    class Success < Either
+
+      def initialize(value)
+        @value = value
+      end
+
+      def copy(changes = {})
+        Success.new \
+          changes.fetch(:value, @value)
+      end
+
+      # @return true
+      def defined?
+        true
+      end
+
+      def fetch(default)
+        @value
+      end
+
+      #########################################################################
+      # @group Filtering the Value
+
+      # @return [Either]
+      # @yieldparam value
+      # @yieldreturn [Boolean]
+      def select(reason = "select", &block)
+        if deconstruct(block)
+          self
+        else
+          failure(reason)
+        end
+      end
+
+      # @return [Either]
+      # @yieldparam value
+      # @yieldreturn [Boolean]
+      def reject(reason = "reject", &block)
+        if deconstruct(block)
+          failure(reason)
+        else
+          self
+        end
+      end
+
+      # @endgroup
+      #########################################################################
+
+      #########################################################################
+      # @group Transforming the Value
+
+      # @return [Success]
+      # @yieldparam value
+      # @yieldreturn value
+      def map(&block)
+        copy(:value => deconstruct(block))
+      end
+
+      # @return [Either]
+      # @yieldparam value
+      # @yieldreturn [Either]
+      def flatmap(&block)
+        result = deconstruct(block)
+
+        if result.is_a?(Either)
+          result
+        else
+          raise TypeError, "block did not return an instance of Either"
+        end
+      end
+
+      # @return [Success]
+      def or
+        self
+      end
+
+      # @return [Success]
+      def explain
+        self
+      end
+
+      # @endgroup
+      #########################################################################
+
+      def tap(&block)
+        deconstruct(block); self
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        other.is_a?(Either) and other.select{|x| x == @value }.defined?
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("Either.success")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @value
+        end
+      end
+
+      # @return [String]
+      def inspect
+        "Either.success(#{@value.inspect})"
+      end
+
+    private
+
+      def deconstruct(block)
+        block.call(@value)
+      end
+
+      def failure(reason)
+        Either::Failure.new(reason)
+      end
+    end
+
+    class Failure < Either
+
+      attr_reader :reason
+
+      def initialize(reason)
+        @reason = reason
+      end
+
+      # @return [Failure]
+      def copy(changes = {})
+        Failure.new \
+          changes.fetch(:reason, @reason)
+      end
+
+      # @return false
+      def defined?
+        false
+      end
+
+      def fetch(default)
+        default
+      end
+
+      #########################################################################
+      # @group Filtering the Value
+
+      # @return [Failure]
+      def select(reason = nil)
+        self
+      end
+
+      # @return [Failure]
+      def reject(reason = nil)
+        self
+      end
+
+      # @endgroup
+      #########################################################################
+
+      #########################################################################
+      # @group Transforming the Value
+
+      # @return [Failure]
+      def map
+        self
+      end
+
+      # @return [Failure]
+      def flatmap
+        self
+      end
+
+      # @return [Either]
+      # @yieldparam reason
+      # @yieldreturn [Either]
+      def or(&block)
+        result = deconstruct(block)
+
+        if result.is_a?(Either)
+          result
+        else
+          raise TypeError, "block did not return an instance of Either"
+        end
+      end
+
+      # @return [Failure]
+      # @yieldparam reason
+      # @yieldreturn reason
+      def explain(&block)
+        copy(:reason => deconstruct(block))
+      end
+
+      # @endgroup
+      #########################################################################
+
+      def tap
+        self
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        other.is_a?(self.class) and other.reason == @reason
+      end
+
+      # @return [void]
+      def pretty_print(q)
+        q.text("Either.failure")
+        q.group(2, "(", ")") do
+          q.breakable ""
+          q.pp @reason
+        end
+      end
+
+      # @return [String]
+      def inspect
+        "Either.failure(#{@reason.inspect})"
+      end
+
+    private
+
+      def deconstruct(block)
+        block.call(@reason)
+      end
+    end
+
+  end
+
+  class << Either
+    ###########################################################################
+    # @group Constructors
+
+    # @return [Success]
+    def success(value)
+      Either::Success.new(value)
+    end
+
+    # @return [Failure]
+    def failure(reason)
+      Either::Failure.new(reason)
+    end
+
+    # @endgroup
+    ###########################################################################
+  end
+
+  Either.eigenclass.send(:protected, :new)
+  Either::Success.eigenclass.send(:public, :new)
+  Either::Failure.eigenclass.send(:public, :new)
+
+end

data/lib/stupidedi/exceptions/invalid_element_error.rb

@@ -0,0 +1,8 @@
+module Stupidedi
+  module Exceptions
+
+    class InvalidElementError < StupidediError
+    end
+
+  end
+end

data/lib/stupidedi/exceptions/invalid_schema_error.rb

@@ -0,0 +1,8 @@
+module Stupidedi
+  module Exceptions
+
+    class InvalidSchemaError < StupidediError
+    end
+
+  end
+end

data/lib/stupidedi/exceptions/output_error.rb

@@ -0,0 +1,8 @@
+module Stupidedi
+  module Exceptions
+
+    class OutputError < StupidediError
+    end
+
+  end
+end

data/lib/stupidedi/exceptions/parse_error.rb

@@ -0,0 +1,8 @@
+module Stupidedi
+  module Exceptions
+
+    class ParseError < StupidediError
+    end
+
+  end
+end

data/lib/stupidedi/exceptions/stupidedi_error.rb

@@ -0,0 +1,8 @@
+module Stupidedi
+  module Exceptions
+
+    class StupidediError < StandardError
+    end
+
+  end
+end

data/lib/stupidedi/exceptions/tokenize_error.rb

@@ -0,0 +1,8 @@
+module Stupidedi
+  module Exceptions
+
+    class TokenizeError < StupidediError
+    end
+
+  end
+end

data/lib/stupidedi/exceptions/zipper_error.rb

@@ -0,0 +1,8 @@
+module Stupidedi
+  module Exceptions
+
+    class ZipperError < StupidediError
+    end
+
+  end
+end

data/lib/stupidedi/exceptions.rb

@@ -0,0 +1,11 @@
+module Stupidedi
+  module Exceptions
+    autoload :StupidediError,         "stupidedi/exceptions/stupidedi_error"
+    autoload :InvalidElementError,    "stupidedi/exceptions/invalid_element_error"
+    autoload :InvalidSchemaError,     "stupidedi/exceptions/invalid_schema_error"
+    autoload :OutputError,            "stupidedi/exceptions/output_error"
+    autoload :ParseError,             "stupidedi/exceptions/parse_error"
+    autoload :TokenizeError,          "stupidedi/exceptions/tokenize_error"
+    autoload :ZipperError,            "stupidedi/exceptions/zipper_error"
+  end
+end