RubyGems - stupidedi - Versions diffs - 1.3.23 → 1.4.0 - Mend

stupidedi 1.3.23 → 1.4.0

Files changed (2005) hide show

data/lib/stupidedi/versions/functional_groups.rb CHANGED

@@ -1,15 +1,30 @@
 # frozen_string_literal: true
 module Stupidedi
-  using Refinements
   module Versions
     module FunctionalGroups
-      autoload :TwoThousandOne, "stupidedi/versions/functional_groups/002001"
-      autoload :ThirtyTen, 		"stupidedi/versions/functional_groups/003010"
-      autoload :ThirtyForty, 	"stupidedi/versions/functional_groups/003040"
-      autoload :ThirtyFifty, 	"stupidedi/versions/functional_groups/003050"
-      autoload :FortyTen, 		"stupidedi/versions/functional_groups/004010"
-      autoload :FiftyTen, 		"stupidedi/versions/functional_groups/005010"
+      warn "DEPRECATION WARNING: #{self} is deprecated, use Stupidedi::TransactionSets::*::Standards instead"
+      module TwoThousandOne
+      end
+      module ThirtyTen
+      end
+      module ThirtyForty
+      end
+      module ThirtyFifty
+      end
+      module FortyTen
+        # @deprecated Use Stupidedi::TransactionSets::FortyTen::Standards
+        TransactionSetDefs = Stupidedi::TransactionSets::FortyTen::Standards
+      end
+      module FiftyTen
+        # @deprecated Use Stupidedi::TransactionSets::FiftyTen::Standards
+        TransactionSetDefs = Stupidedi::TransactionSets::FiftyTen::Standards
+      end
     end
   end
 end

data/lib/stupidedi/versions/interchanges.rb CHANGED

@@ -1,14 +1,7 @@
 # frozen_string_literal: true
 module Stupidedi
-  using Refinements
   module Versions
-    module Interchanges
-      autoload :TwoHundred, "stupidedi/versions/interchanges/00200"
-      autoload :ThreeHundred, "stupidedi/versions/interchanges/00300"
-      autoload :FourHundred, "stupidedi/versions/interchanges/00400"
-      autoload :FourOhOne, "stupidedi/versions/interchanges/00401"
-      autoload :FiveOhOne, "stupidedi/versions/interchanges/00501"
-    end
+    warn "DEPRECATION WARNING: #{self}::Interchanges is deprecated, use Stupidedi::Interchanges instead"
+    Interchanges = Stupidedi::Interchanges
   end
 end

data/lib/stupidedi/writer.rb CHANGED

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
 module Stupidedi
   module Writer
     autoload :Claredi,  "stupidedi/writer/claredi"

data/lib/stupidedi/writer/claredi.rb CHANGED

@@ -3,24 +3,37 @@ module Stupidedi
   using Refinements
   module Writer
     class Claredi
       def initialize(node)
         @node = node
       end
       # @return [String]
       def write(out = StringIO.new)
-        out << "<html><head>\n#{style}</head>\n<body>\n"
+        out << %Q(<html lang="en"><head>)
+        out << %Q(<meta charset="iso-8859-1">)
+        out << style
+        out << js
+        out << "</head><body>"
         build(@node, out)
         out << "</body></html>"
-        out.string
+        out
       end
     private
+      def js
+        <<-JS
+        <script type="text/javascript">
+          function toggle() {
+            var trim = document.getElementsByClassName("trim");
+            for (var k = 0; k < trim.length; k ++)
+              trim[k].classList.toggle("hide");
+          }
+        </script>
+        JS
+      end
       # @return [String]
       def style
         <<-CSS
@@ -29,12 +42,15 @@ module Stupidedi
           .interchange, .functionalgr, .table, .loop > .label {
             font-weight: bold;
-            font-family: Georgia;
+            font-family: Optima, Trebuchet, sans-serif;
           }
           .interchange, .functionalgr, .transaction {
             margin-left:   1em;
-            margin-top:    1em;
+          }
+          .transaction {
+            margin-top:    1.5em;
             margin-bottom: 1em;
           }
@@ -46,95 +62,113 @@ module Stupidedi
           .table, .loop {
             margin-top:    0.5em;
             margin-bottom: 0.5em;
-            margin-right:  0.5em;
+            margin-left:   0.5em;
           }
           .table { margin-left: 1em; margin-bottom: 2em; }
-          .table > .label {
+          .table        > .label/*
+          .interchange  > .label,
+          .functionalgr > .label*/ {
             font-size:     1.25em;
             border-bottom: 3px solid black;
             margin-top:    1em;
             margin-bottom: 0.5em;
           }
-          .loop { border: 1px solid grey; border-left: 0; }
-          .loop > .label {
-            padding:          3px;
-            background-color: #ddd;
-          }
+          .loop { border: 1px solid grey; border-right: 0; }
+          .loop > .label { padding: 3px; background-color: #ddd; }
+          .loop > .segment { margin: 3px 0 3px 6px; }
           .segment {
-            display: inline;
-            margin-top:  0.25em;
-            background-color: #fff;
             font-weight: normal;
+            font-family: 'Andale Mono', Monospace, monospace;
           }
-          .segment > .label {
-            font-weight: normal;
-            font-family: Consolas, Monospace, monospace;
+          .segment .label:first-child { font-weight: bold; }
+          .trim { color: #bbb; display: inline; }
+          .hide { display: none; }
+          #form {
+            display:          block;
+            padding:          3px;
+            border:           1px solid #ccc;
+            margin:           3px 3px 30px 3px;
+            font-family:      Optima, Trebuchet, sans-serif;
+            background-color: #eee;
           }
         </style>
         CSS
       end
       # @return [void]
-      def build(node, out = StringIO.new)
+      def build(node, out)
         if node.element?
           if node.composite?
-            out << "*"
             tmp = StringIO.new
             node.children.each{|e| build(e, tmp) }
-            out << tmp.string.gsub(/:*$/, "")
+            tmp.string.gsub!(%r{^(<span [^>]+>):}, "\\1*")
+            tmp.string.gsub!(%r{((?:<span [^<]+>:?</span>)+)$}, %Q(<em class="trim hide">\\1</em>))
+            out << tmp.string
           elsif node.component?
-            out << "#{node}:"
+            out << %Q(<span class="label" title="#{node.definition.name}">:#{node.to_x12}</span>)
           elsif node.repeated?
-            out << "^"
-            node.children.each{|e| build(e, out) }
+            tmp = StringIO.new
+            node.children.each{|e| build(e, tmp) }
+            tmp.string.gsub!("*", "^")
+            out << tmp.string
           else
-            out << "*#{node}"
+            out << %Q(<span class="label" title="#{node.definition.name}">*#{node.to_x12}</span>)
           end
         elsif node.segment?
-          out << "<div class=segment><div class=label title='#{node.definition.name}'>"
-          out << '% 3s' % node.definition.id
-          # out << ": #{node.definition.name}</div></div>\n"
+          out << %Q(<div class="segment"><span class="label" title="#{node.definition.name}">)
+          out << node.definition.id
+          out << "</span>"
           tmp  = StringIO.new
           node.children.each{|e| build(e, tmp) }
-          tmp = tmp.string.gsub(/\**$/, "")
-          out << "#{tmp}~</div></div>\n"
+          tmp.string.gsub!(%r{((?:<span [^>]+>\*</span>)+)$}, %Q(<div class="trim hide">\\1</div>))
+          out << "#{tmp.string}~</div>\n"
         elsif node.loop?
-          m = /^(\w+) (.+)$/.match(node.definition.id)
-          id, name = m.captures
-          name = name.split(/\s+/).map(&:capitalize).join(" ")
+          if m = /^(\d\w+)(?: [:-])? (.+)$/.match(node.definition.id)
+            id   = m.captures[0]
+            name = m.captures[1]
+            name = name.split(/\s+/).map(&:capitalize).join(" ")
+            out << %Q(<div class="loop"><div class="label">#{name} (#{id})</div>\n)
+          else
+            out << %Q(<div class="loop"><div class="label">#{node.definition.id}</div>\n)
+          end
-          out << "<div class=loop><div class=label>#{name} (#{id})</div>\n"
           node.children.each{|c| build(c, out) }
           out << "</div>\n"
         elsif node.table?
-          out << "<div class=table><div class=label>#{node.definition.id}</div>\n"
+          out << %Q(<div class="table"><div class="label">#{node.definition.id}</div>\n)
           node.children.each{|c| build(c, out) }
           out << "</div>\n"
         elsif node.transaction_set?
-          out << "<div class=transaction><div class=label>Transaction Set #{node.definition.id}</div>\n"
+          out << %Q(<div class="transaction"><div class="label">Transaction Set #{node.definition.id}</div>\n)
           node.children.each{|c| build(c, out) }
           out << "</div>\n"
         elsif node.functional_group?
-          out << "<div class=functionalgr><div class=label>Functional Group #{node.definition.id}</div>\n"
+          out << %Q(<div class="functionalgr">)
+        # out << %Q(<div class="label">Functional Group (#{node.definition.id})</div>\n)
           node.children.each{|c| build(c, out) }
           out << "</div>\n"
         elsif node.interchange?
-          out << "<div class=interchange><div class=label>Interchange #{node.definition.id}</div>\n"
+          out << %Q(<div class="interchange">)
+        # out << %Q(<div class="label">Interchange (#{node.definition.id})</div>\n)
           node.children.each{|c| build(c, out) }
           out << "</div>\n"
         elsif node.transmission?
-          out << "<div class=transmission>\n"
+          out << %Q(<label id="form"><input type="checkbox" id="hide" onchange="toggle()" checked/> Hide empty suffixes</label>)
+          out << %Q(<div class="transmission">\n)
           node.children.each{|c| build(c, out) }
           out << "</div>\n"
         end

data/lib/stupidedi/writer/default.rb CHANGED

@@ -2,9 +2,7 @@ module Stupidedi
   using Refinements
   module Writer
     class Default
       # @return [Reader::Separators]
       attr_reader :separators
@@ -13,19 +11,19 @@ module Stupidedi
           zipper, separators
       end
-      #
       # @return out
-      def write
-        common  = @separators.characters & @zipper.node.characters
-        message = common.to_a.map(&:inspect).join(", ")
+      def write(out = "")
+        unless @zipper.node.transmission? or @zipper.node.interchange?
+          common  = @separators.characters & @zipper.node.characters
+          message = common.to_a.map(&:inspect).join(", ")
-        if common.present?
-          raise Exceptions::OutputError,
-            "separators #{message} occur as data"
+          if common.present?
+            raise Exceptions::OutputError,
+              "separator characters #{message} occur as data"
+          end
         end
-        out = ""
-        recurse(@zipper.node, @separators, out)
-        return out
+        out.tap { recurse(@zipper.node, @separators, out) }
       end
     private
@@ -37,30 +35,26 @@ module Stupidedi
           segment(value, separators, out)
         else
           if value.interchange?
-            value      = value.replace_separators(@separators)
-            separators = value.separators#merge(@separators)
-            raise Exceptions::OutputError,
-              "separators.segment cannot be blank" if separators.segment.blank?
-            raise Exceptions::OutputError,
-              "separators.element cannot be blank" if separators.element.blank?
-            unless separators == @separators
-              # We've inherited some separators from the interchange,
-              # so we need to re-check this condition. Note that we
-              # can't optimize this by caching @zipper.node.characters
-              # the first time (in #write), because we're only interested
-              # in conflicts between _this_ subtree (value) and the
-              # separators... not the entire tree (@zipper.node)
-              common  = separators.characters & @zipper.node.characters
+            unless separators.merge(value.separators) == separators
+              common  = separators.characters & value.characters
               message = common.to_a.map(&:inspect).join(", ")
               if common.present?
                 raise Exceptions::OutputError,
                   "separator characters #{message} occur as data"
               end
+              # Change ISA11 and ISA16
+              value = value.replace_separators(separators)
             end
+            separators = value.separators
+            raise Exceptions::OutputError,
+              "separators.segment cannot be blank" if separators.segment.blank?
+            raise Exceptions::OutputError,
+              "separators.element cannot be blank" if separators.element.blank?
           end
           value.children.each{|c| recurse(c, separators, out) }
@@ -120,8 +114,6 @@ module Stupidedi
           end
         end
       end
     end
   end
 end

data/lib/stupidedi/zipper.rb CHANGED

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
 module Stupidedi
   using Refinements
@@ -35,7 +34,6 @@ module Stupidedi
   end
   class << Zipper
     # @group Constructors
     ###########################################################################
@@ -44,5 +42,4 @@ module Stupidedi
       Zipper::Tree.build(node)
     end
   end
 end

data/lib/stupidedi/zipper/abstract_cursor.rb CHANGED

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 module Stupidedi
   using Refinements
   module Zipper
     class AbstractCursor
       # @return [#leaf?, #children, #copy]
       abstract :node
@@ -125,21 +122,21 @@ module Stupidedi
         between << rspine.head.node
-        rspine.tail.each do |zipper|
-          count  = zipper.path.position
-          zipper = zipper.first
+        rspine.tail.each do |zipper_|
+          count  = zipper_.path.position
+          zipper_ = zipper_.first
           # We have to do a bit more work to traverse the siblings in left-to-
-          # right order, because `zipper` is now the left spine. We start on
+          # right order, because `zipper_` is now the left spine. We start on
           # the first sibling and move left a fixed number of times
           count.times do
-            between.concat(zipper.flatten)
-            zipper = zipper.next
+            between.concat(zipper_.flatten)
+            zipper_ = zipper_.next
           end
-          # Now zipper is along the left spine. We don't expand it here, but the
+          # Now zipper_ is along the left spine. We don't expand it here, but the
           # next item in rspine is the next child along the left spine
-          between << zipper.node
+          between << zipper_.node
         end
         between
@@ -240,8 +237,8 @@ module Stupidedi
       def descendant(n, *ns)
         cursor = self
-        n.cons(ns).each do |n|
-          cursor = cursor.child(n)
+        n.cons(ns).each do |n_|
+          cursor = cursor.child(n_)
         end
         cursor
@@ -350,6 +347,5 @@ module Stupidedi
       # @endgroup
       #########################################################################
     end
   end
 end

data/lib/stupidedi/zipper/dangling_cursor.rb CHANGED

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
 module Stupidedi
   using Refinements
   module Zipper
     class DanglingCursor < AbstractCursor
       # @return [AbstractCursor]
       attr_reader :parent
@@ -102,6 +99,5 @@ module Stupidedi
       # @endgroup
       #########################################################################
     end
   end
 end