stupidedi 1.1.0

data/lib/stupidedi/guides/005010/X231-FA999.rb

@@ -0,0 +1,123 @@
+module Stupidedi
+  module Guides
+    module FiftyTen
+      module X231
+
+        b = GuideBuilder
+        d = Schema
+        r = SegmentReqs
+        e = ElementReqs
+        s = Versions::FunctionalGroups::FiftyTen::SegmentDefs
+        t = Versions::FunctionalGroups::FiftyTen::TransactionSetDefs
+
+        FA999 = b.build(t::FA999,
+          d::TableDef.header("Table 1 - Header",
+            b::Segment(100, s::ST, "Transaction Set Header",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Transaction Set Identifier Code", b::Values("999")),
+              b::Element(e::Required,    "Transaction Set Control Number"),
+              b::Element(e::Required,    "Implementation Guide Version Name", b::Values("005010X231"))),
+            b::Segment(200, s::AK1, "Functional Group Response Header",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Functional Identifier Code"),
+              b::Element(e::Required,    "Group Control Number"),
+              b::Element(e::Required,    "Version, Release, or Industry Identifier Code")),
+
+            d::LoopDef.build("2000 TRANSACTION SET RESPONSE HEADER",
+              d::RepeatCount.unbounded,
+              b::Segment(300, s::AK2, "Transaction Set Response Header",
+                r::Situational, d::RepeatCount.bounded(1),
+                b::Element(e::Required,    "Transaction Set Identifier Code"),
+                b::Element(e::Required,    "Transaction Set Control Number"),
+                b::Element(e::Situational, "Implementation Convention Reference")),
+
+              d::LoopDef.build("2100 ERROR IDENTIFICATION",
+                d::RepeatCount.unbounded,
+                b::Segment(400, s::IK3, "Error Identification",
+                  r::Situational, d::RepeatCount.bounded(1),
+                  b::Element(e::Required,    "Segment ID Code"),
+                  b::Element(e::Required,    "Segment Position in Transaction Set"),
+                  b::Element(e::Situational, "Loop Identifier Code"),
+                  b::Element(e::Required,    "Implementation Segment Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "I4", "I6", "I7", "I8", "I9"))),
+                b::Segment(500, s::CTX, "Segment Context",
+                  r::Situational, d::RepeatCount.bounded(9),
+                  b::Element(e::Required,    "CONTEXT IDENTIFICATION",
+                    b::Element(e::Required,    "Context Name", b::Values("SITUATIONAL TRIGGER")),
+                    b::Element(e::NotUsed,     "Context Reference")),
+                  b::Element(e::Required,    "Segment ID Code"),
+                  b::Element(e::Required,    "Segment Position in Transaction Set"),
+                  b::Element(e::Situational, "Loop Identifier Code"),
+                  b::Element(e::Situational, "POSITION IN SEGMENT",
+                    b::Element(e::Required,    "Element Position in Segment"),
+                    b::Element(e::Situational, "Component Data Element Position in Composite"),
+                    b::Element(e::Situational, "Repeating Data Element Position")),
+                  b::Element(e::Situational, "REFERENCE IN SEGMENT",
+                    b::Element(e::Required,     "Data Element Reference Number"),
+                    b::Element(e::Situational,  "Component Data Element Reference Number"))),
+                b::Segment(500, s::CTX, "Business Unit Identifier",
+                  r::Situational, d::RepeatCount.bounded(1),
+                  b::Element(e::Required,    "CONTEXT IDENTIFICATION",
+                    b::Element(e::Required,    "Context Name", b::Values("TRN02", "NM109", "PATIENT NAME NM109", "SUBSCRIBER NAME NM109", "ENT01", "SUBSCRIBER NUMBER REF02", "CLM01")),
+                    b::Element(e::Required,    "Context Reference")),
+                  b::Element(e::NotUsed,     "Segment ID Code"),
+                  b::Element(e::NotUsed,     "Segment Position in Transaction Set"),
+                  b::Element(e::NotUsed,     "Loop Identifier Code"),
+                  b::Element(e::NotUsed,     "POSITION IN SEGMENT"),
+                  b::Element(e::NotUsed,     "REFERENCE IN SEGMENT")),
+
+                d::LoopDef.build("2110 IMPLEMENTATION DATA ELEMENT NOTE",
+                  d::RepeatCount.unbounded,
+                  b::Segment(600, s::IK4, "Implementation Data Element Note",
+                    r::Situational, d::RepeatCount.bounded(1),
+                    b::Element(e::Required,    "POSITION IN SEGMENT",
+                      b::Element(e::Required,    "Element Position in Segment"),
+                      b::Element(e::Situational, "Component Data Element Position in Composite"),
+                      b::Element(e::Situational, "Repeating Data Element Position")),
+                    b::Element(e::Situational, "Data Element Reference Number"),
+                    b::Element(e::Required,    "Implementation Data Element Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "12", "13", "I10", "I11", "I12", "I13", "I6", "I9")),
+                    b::Element(e::Situational, "Copy of Bad Data Element")),
+                  b::Segment(700, s::CTX, "Element Context",
+                    r::Situational, d::RepeatCount.bounded(10),
+                    b::Element(e::Required,    "CONTEXT IDENTIFICATION",
+                      b::Element(e::Required,    "Context Name", b::Values("SITUATIONAL TRIGGER")),
+                      b::Element(e::NotUsed,     "Context Reference")),
+                    b::Element(e::Required,    "Segment ID Code"),
+                    b::Element(e::Required,    "Segment Position in Transaction Set"),
+                    b::Element(e::Situational, "Loop Identifier Code"),
+                    b::Element(e::Situational, "POSITION IN SEGMENT",
+                      b::Element(e::Required,    "Element Position in Segment"),
+                      b::Element(e::Situational, "Component Data Element Position in Composite"),
+                      b::Element(e::Situational, "Repeating Data Element Position")),
+                    b::Element(e::Situational, "REFERENCE IN SEGMENT",
+                      b::Element(e::Required,     "Data Element Reference Number"),
+                      b::Element(e::Situational,  "Component Data Element Reference Number"))))),
+
+              b::Segment(800, s::IK5, "Implementation Transaction Set Response Trailer",
+                r::Required, d::RepeatCount.bounded(1),
+                b::Element(e::Required,    "Transaction Set Acknowledgement Code", b::Values("A", "E", "M", "R", "W", "X")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I6")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I6")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I6")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I6")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I6")))),
+
+            b::Segment( 900, s::AK9, "Functional Group Response Trailer",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Functional Group Acknowledgement Code", b::Values("A", "E", "M", "P", "R", "W", "X")),
+              b::Element(e::Required,    "Number of Transaction Sets Included"),
+              b::Element(e::Required,    "Number of Received Transaction Sets"),
+              b::Element(e::Required,    "Number of Accepted Transaction Sets"),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26")),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26")),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26")),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26")),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26"))),
+            b::Segment(200, s::SE, "Transaction Set Trailer",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Transaction Segment Count"),
+              b::Element(e::Required,    "Transaction Set Control Number"))))
+
+      end
+    end
+  end
+end

data/lib/stupidedi/guides/005010/X231A1-FA999.rb

@@ -0,0 +1,119 @@
+module Stupidedi
+  module Guides
+    module FiftyTen
+      module X231A1
+
+        b = GuideBuilder
+        d = Schema
+        r = SegmentReqs
+        e = ElementReqs
+        s = Versions::FunctionalGroups::FiftyTen::SegmentDefs
+        t = Versions::FunctionalGroups::FiftyTen::TransactionSetDefs
+
+        FA999 = b.build(t::FA999,
+          d::TableDef.header("Table 1 - Header",
+            b::Segment(100, s::ST, "Transaction Set Header",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Transaction Set Identifier Code", b::Values("999")),
+              b::Element(e::Required,    "Transaction Set Control Number"),
+              b::Element(e::Required,    "Implementation Guide Version Name", b::Values("005010X231A1"))),
+            b::Segment(200, s::AK1, "Functional Group Response Header",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Functional Identifier Code"),
+              b::Element(e::Required,    "Group Control Number"),
+              b::Element(e::Required,    "Version, Release, or Industry Identifier Code")),
+
+            d::LoopDef.build("2000 TRANSACTION SET RESPONSE HEADER",
+              d::RepeatCount.unbounded,
+              b::Segment(300, s::AK2, "Transaction Set Response Header",
+                r::Situational, d::RepeatCount.bounded(1),
+                b::Element(e::Required,    "Transaction Set Identifier Code"),
+                b::Element(e::Required,    "Transaction Set Control Number"),
+                b::Element(e::Situational, "Implementation Convention Reference")),
+
+              d::LoopDef.build("2100 ERROR IDENTIFICATION",
+                d::RepeatCount.unbounded,
+                b::Segment(400, s::IK3, "Error Identification",
+                  r::Situational, d::RepeatCount.bounded(1),
+                  b::Element(e::Required,    "Segment ID Code"),
+                  b::Element(e::Required,    "Segment Position in Transaction Set"),
+                  b::Element(e::Situational, "Loop Identifier Code"),
+                  b::Element(e::Required,    "Implementation Segment Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "I4", "I6", "I7", "I8", "I9"))),
+                b::Segment(500, s::CTX, "Segment Context",
+                  r::Situational, d::RepeatCount.bounded(9),
+                  b::Element(e::Required,    "CONTEXT IDENTIFICATION",
+                    b::Element(e::Required,    "Context Name", b::Values("SITUATIONAL TRIGGER")),
+                    b::Element(e::NotUsed,     "Context Reference")),
+                  b::Element(e::Required,    "Segment ID Code"),
+                  b::Element(e::Required,    "Segment Position in Transaction Set"),
+                  b::Element(e::Situational, "Loop Identifier Code"),
+                  b::Element(e::Situational, "POSITION IN SEGMENT",
+                    b::Element(e::Required,    "Element Position in Segment"),
+                    b::Element(e::Situational, "Component Data Element Position in Composite"),
+                    b::Element(e::Situational, "Repeating Data Element Position")),
+                  b::Element(e::NotUsed,     "REFERENCE IN SEGMENT")),
+                b::Segment(500, s::CTX, "Business Unit Identifier",
+                  r::Situational, d::RepeatCount.bounded(1),
+                  b::Element(e::Required,    "CONTEXT IDENTIFICATION",
+                    b::Element(e::Required,    "Context Name", b::Values("TRN02", "NM109", "PATIENT NAME NM109", "SUBSCRIBER NAME NM109", "ENT01", "SUBSCRIBER NUMBER REF02", "CLM01")),
+                    b::Element(e::Required,    "Context Reference")),
+                  b::Element(e::NotUsed,     "Segment ID Code"),
+                  b::Element(e::NotUsed,     "Segment Position in Transaction Set"),
+                  b::Element(e::NotUsed,     "Loop Identifier Code"),
+                  b::Element(e::NotUsed,     "POSITION IN SEGMENT"),
+                  b::Element(e::NotUsed,     "REFERENCE IN SEGMENT")),
+
+                d::LoopDef.build("2110 IMPLEMENTATION DATA ELEMENT NOTE",
+                  d::RepeatCount.unbounded,
+                  b::Segment(600, s::IK4, "Implementation Data Element Note",
+                    r::Situational, d::RepeatCount.bounded(1),
+                    b::Element(e::Required,    "POSITION IN SEGMENT",
+                      b::Element(e::Required,    "Element Position in Segment"),
+                      b::Element(e::Situational, "Component Data Element Position in Composite"),
+                      b::Element(e::Situational, "Repeating Data Element Position")),
+                    b::Element(e::Situational, "Data Element Reference Number"),
+                    b::Element(e::Required,    "Implementation Data Element Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "12", "13", "I10", "I11", "I12", "I13", "I6", "I9")),
+                    b::Element(e::Situational, "Copy of Bad Data Element")),
+                  b::Segment(700, s::CTX, "Element Context",
+                    r::Situational, d::RepeatCount.bounded(10),
+                    b::Element(e::Required,    "CONTEXT IDENTIFICATION",
+                      b::Element(e::Required,    "Context Name", b::Values("SITUATIONAL TRIGGER")),
+                      b::Element(e::NotUsed,     "Context Reference")),
+                    b::Element(e::Required,    "Segment ID Code"),
+                    b::Element(e::Required,    "Segment Position in Transaction Set"),
+                    b::Element(e::Situational, "Loop Identifier Code"),
+                    b::Element(e::Situational, "POSITION IN SEGMENT",
+                      b::Element(e::Required,    "Element Position in Segment"),
+                      b::Element(e::Situational, "Component Data Element Position in Composite"),
+                      b::Element(e::Situational, "Repeating Data Element Position")),
+                    b::Element(e::NotUsed,     "REFERENCE IN SEGMENT")))),
+
+              b::Segment(800, s::IK5, "Implementation Transaction Set Response Trailer",
+                r::Required, d::RepeatCount.bounded(1),
+                b::Element(e::Required,    "Transaction Set Acknowledgement Code", b::Values("A", "E", "M", "R", "W", "X")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I5", "I6")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I5", "I6")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I5", "I6")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I5", "I6")),
+                b::Element(e::Situational, "Implementation Transaction Set Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "15", "16", "17", "18", "19", "23", "24", "25", "26", "27", "I5", "I6")))),
+
+            b::Segment( 900, s::AK9, "Functional Group Response Trailer",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Functional Group Acknowledgement Code", b::Values("A", "E", "M", "P", "R", "W", "X")),
+              b::Element(e::Required,    "Number of Transaction Sets Included"),
+              b::Element(e::Required,    "Number of Received Transaction Sets"),
+              b::Element(e::Required,    "Number of Accepted Transaction Sets"),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26")),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26")),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26")),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26")),
+              b::Element(e::Situational, "Functional Group Syntax Error Code", b::Values("1", "2", "3", "4", "5", "6", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "23", "24", "25", "26"))),
+            b::Segment(200, s::SE, "Transaction Set Trailer",
+              r::Required, d::RepeatCount.bounded(1),
+              b::Element(e::Required,    "Transaction Segment Count"),
+              b::Element(e::Required,    "Transaction Set Control Number"))))
+
+      end
+    end
+  end
+end

data/lib/stupidedi/guides/005010/element_reqs.rb

@@ -0,0 +1,38 @@
+module Stupidedi
+  module Guides
+    module FiftyTen
+
+      #
+      # @see X222.pdf 2.2 Implementation Usage
+      #
+      module ElementReqs
+
+        # Declares that this element must always be sent. Required elements
+        # within Situational segments when the segment occurs.
+        #
+        # Similarly, required component elements within situational composite
+        # elements only occur when the composite element occurs.
+        Required = Schema::ElementReq.new(true,  false, "R")
+
+        # Use of this element varies, depending on data content and business
+        # context as described in the defining rule. The defining rule is
+        # documented in a Situational Rule attached to the element.
+        #
+        # There are two forms of Situational Rules. The first is "Required when
+        # <condition>. If not required by <condition>, the element may be
+        # provided at the discretion of the sender, but it cannot be required or
+        # requested by the receiver.'
+        #
+        # The other form is "Required when <condition>. If not required by
+        # <condition>, do not send". The element described by the rule cannot
+        # occur except when the condition holds.
+        Situational = Schema::ElementReq.new(false, false, "S")
+
+        # This element must never be sent.
+        NotUsed = Schema::ElementReq.new(false, true,  "N")
+
+      end
+
+    end
+  end
+end

data/lib/stupidedi/guides/005010/guide_builder.rb

@@ -0,0 +1,180 @@
+module Stupidedi
+  module Guides
+    module FiftyTen
+
+      #
+      # {GuideBuilder} is a simple DSL for construction an implementation guide.
+      #
+      module GuideBuilder
+      end
+
+      class << GuideBuilder
+
+        # @return [Schema::TransactionSetDef]
+        def build(transaction_set_def, *table_defs)
+          transaction_set_def.copy(:table_defs => table_defs)
+        end
+
+        # @group Element Constraints
+        #######################################################################
+
+        # @param [String, ...] values
+        def Values(*values)
+          [:Values, values]
+        end
+
+        # @param [Integer] n
+        def MaxLength(n)
+          [:MaxLength, n]
+        end
+
+        # @param [Integer] n
+        def MaxPrecision(n)
+          [:MaxPrecision, n]
+        end
+
+        # @endgroup
+        #######################################################################
+
+        # @group Definition Constructors
+        #######################################################################
+
+        # @param [Schema::ElementReq] requirement
+        # @param [String] name
+        def Element(requirement, name, *constraints)
+          [:Element, requirement, name, constraints]
+        end
+
+        # @return [SegmentUse]
+        def Segment(position, segment_def, name, requirement, repeat_count, *elements)
+          unless elements.length == segment_def.element_uses.length
+            raise Exceptions::InvalidSchemaError,
+              "segment #{segment_def.id} has #{segment_def.element_uses.length}" <<
+              " elements but #{elements.length} arguments were specified"
+          end
+
+          element_index = "00"
+          element_uses  = elements.zip(segment_def.element_uses).map do |e, u|
+            e_tag, e_requirement, e_name, e_arguments = e
+            element_index.succ!
+
+            unless e_tag == :Element
+              raise Exceptions::InvalidSchemaError,
+                "given argument for #{segment_def.id}#{element_index} must be Element(...)"
+            end
+
+            if u.composite?
+              e_repeat_count, e_arguments = e_arguments.partition{|x| x.is_a?(Schema::RepeatCount) }
+
+              changes = Hash.new
+              changes[:requirement] = e_requirement
+
+              if e_repeat_count.length == 1
+                changes[:repeat_count] = e_repeat_count.head
+              elsif e_repeat_count.length > 1
+                raise Exceptions::InvalidSchemaError,
+                  "more than one RepeatCount was specified"
+              end
+
+              unless e_requirement.forbidden?
+                unless e_arguments.length == u.definition.component_uses.length
+                  raise Exceptions::InvalidSchemaError,
+                    "composite element #{u.definition.id} at #{segment_def.id}" <<
+                    "#{element_index} has #{u.definition.element_uses.length}" <<
+                    " component elements but #{e_arguments.length} were given"
+                end
+
+                # ComponentElementUses
+                component_index = "00"
+                component_uses  = e_arguments.zip(u.definition.component_uses).map do |e, c|
+                  c_tag, c_requirement, c_name, c_arguments = e
+                  component_index.succ!
+
+                  unless c_tag == :Element
+                    raise Exceptions::InvalidSchemaError,
+                      "given argument for #{segment_def.id}#{element_index}" <<
+                      "-#{component_index} must be Element(...)"
+                  end
+
+                  mod_element(c, c_requirement, c_name, c_arguments)
+                end
+
+                changes[:definition] = u.definition.copy(:name           => e_name,
+                                                         :component_uses => component_uses)
+              else
+                changes[:definition] = u.definition.copy(:name => e_name)
+              end
+
+              u.copy(changes)
+            else
+              mod_element(u, e_requirement, e_name, e_arguments)
+            end
+          end
+
+          segment_def.copy(:name => name).
+            copy(:element_uses => element_uses).
+            use(position, requirement, repeat_count)
+        end
+
+        # @endgroup
+        #######################################################################
+
+       private
+
+        # @return [Schema::SimpleElementUse]
+        def mod_element(element_use, requirement, name, arguments)
+          unless requirement.is_a?(Schema::ElementReq)
+            raise Exceptions::InvalidSchemaError,
+              "first argument to Element must be a Schema::ElementReq but got #{requirement.inspect}"
+          end
+
+          unless name.is_a?(String)
+            raise Exceptions::InvalidSchemaError,
+              "element name must be a String"
+          end
+
+          changes = Hash.new # changes to SegmentUse
+          dhanges = Hash.new # changes to SegmentDef
+
+          changes[:requirement] = requirement
+          changes[:definition]  = element_use.definition.copy(:name => name)
+
+          repeat_count = arguments.select{|x| x.is_a?(Schema::RepeatCount) }
+
+          if repeat_count.length == 1
+            changes[:repeat_count] = repeat_count.head
+          elsif repeat_count.length > 1
+            raise Exceptions::InvalidSchemaError,
+              "more than one RepeatCount specified for this Element"
+          end
+
+          allowed_values = arguments.select{|x| x.is_a?(Array) and x.head == :Values }
+
+          if allowed_values.length == 1
+            changes[:allowed_values] = element_use.allowed_values.replace(allowed_values.head.last)
+          elsif allowed_values.length > 1
+            raise Exceptions::InvalidSchemaError,
+              "more than one Values specified for this Element"
+          end
+
+          max_length = arguments.select{|x| x.is_a?(Array) and x.head == :MaxLength }
+
+          if max_length.length == 1
+            dhanges[:max_length] = max_length.head.last
+          elsif max_length.length > 1
+            raise Exceptions::InvalidSchemaError,
+              "more than one MaxLength specified for this Element"
+          end
+
+          if dhanges.empty?
+            element_use.copy(changes)
+          else
+            element_use.copy(changes.merge(:definition =>
+              element_use.definition.copy(dhanges)))
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/stupidedi/guides/005010/segment_reqs.rb

@@ -0,0 +1,32 @@
+module Stupidedi
+  module Guides
+    module FiftyTen
+
+      #
+      # @see X222.pdf 2.2 Implementation Usage
+      #
+      module SegmentReqs
+
+        # Declares that this segment must always be sent. Required segments
+        # within Situational loops only occur when the loop occurs.
+        Required = Schema::SegmentReq.new(true,  false, "R")
+
+        # Use of this segment varies, depending on data content and business
+        # context as described in the defining rule. The defining rule is
+        # documented in a Situational Rule attached to the segment.
+        #
+        # There are two forms of Situational Rules. The first is "Required when
+        # <condition>. If not required by <condition>, the segment may be
+        # provided at the discretion of the sender, but it cannot be required or
+        # requested by the receiver.'
+        #
+        # The other form is "Required when <condition>. If not required by
+        # <condition>, do not send". The segment described by the rule cannot
+        # occur except when the condition holds.
+        Situational = Schema::SegmentReq.new(false, false, "S")
+
+      end
+
+    end
+  end
+end

data/lib/stupidedi/guides/005010.rb

@@ -0,0 +1,64 @@
+module Stupidedi
+  module Guides
+
+    #
+    # @see Stupidedi::Versions::FunctionalGroups::FiftyTen
+    #
+    module FiftyTen
+
+      autoload :SegmentReqs,  "stupidedi/guides/005010/segment_reqs"
+      autoload :ElementReqs,  "stupidedi/guides/005010/element_reqs"
+
+      autoload :GuideBuilder, "stupidedi/guides/005010/guide_builder"
+
+      module X214
+        autoload :HN277,  "stupidedi/guides/005010/X214-HN277"
+      end
+
+      module X221
+        autoload :HP835,  "stupidedi/guides/005010/X221-HP835"
+      end
+
+      module X221A1
+        autoload :HP835,  "stupidedi/guides/005010/X221A1-HP835"
+      end
+
+      module X222
+        autoload :HC837P,  "stupidedi/guides/005010/X222-HC837P"
+      end
+
+      module X222A1
+        autoload :HC837P,  "stupidedi/guides/005010/X222A1-HC837P"
+      end
+
+    # module X223
+    #   autoload :HC837I,  "stupidedi/guides/005010/X223-HC837I"
+    # end
+
+    # module X223A1
+    #   autoload :HC837I,  "stupidedi/guides/005010/X223A1-HC837I"
+    # end
+
+    # module X224
+    #   autoload :HC837D,  "stupidedi/guides/005010/X224-HC837D"
+    # end
+
+    # module X224A1
+    #   autoload :HC837D,  "stupidedi/guides/005010/X224A1-HC837D"
+    # end
+
+    # module X224A2
+    #   autoload :HC837D,  "stupidedi/guides/005010/X224A2-HC837D"
+    # end
+
+      module X231
+        autoload :FA999,  "stupidedi/guides/005010/X231-FA999"
+      end
+
+      module X231A1
+        autoload :FA999,  "stupidedi/guides/005010/X231A1-FA999"
+      end
+
+    end
+  end
+end

data/lib/stupidedi/guides.rb

@@ -0,0 +1,5 @@
+module Stupidedi
+  module Guides
+    autoload :FiftyTen, "stupidedi/guides/005010"
+  end
+end

data/lib/stupidedi/inspect.rb

@@ -0,0 +1,26 @@
+module Stupidedi
+
+  #
+  # When an exception is raised, in some cases `#inspect` is called on a
+  # huge object graph to generate the message `"undefined method '...' for
+  # <Stupidedi::Schema::TransactionSetDef:0x...>"`. This can take several
+  # seconds, since `Object#inspect` descends recursively into each instance
+  # variable.
+  #
+  # This mixin defines an alternative default implementation for `#inspect`,
+  # which should be significantly faster than the default Ruby implementation
+  # since it does not descend into the object.
+  #
+  module Inspect
+
+    # @return [String]
+    def inspect
+      if self.class.name.empty?
+        "#<\#<Class:0x#{self.class.object_id.abs.to_s(16)}>"
+      else
+        "#<#{self.class.name}"
+      end << ":0x#{object_id.abs.to_s(16)} ...>"
+    end
+  end
+
+end