baldr 0.0.0 → 0.3.0

data/lib/baldr/grammar.rb

@@ -0,0 +1,16 @@
+module Baldr::Grammar
+
+  def self.for_version(version)
+    case version.length
+      when 4
+        self.const_get("Version#{version}")
+      when 5
+        self.const_get("Version#{version[2..4]}0")
+      when 6
+        self.const_get("Version#{version[2..5]}")
+      else
+        raise "unknown standard version number: #{version}"
+    end
+  end
+
+end

data/lib/baldr/loop.rb

@@ -1,28 +1,26 @@
 class Baldr::Loop
 
-  def initialize(id, builder)
-    @elements = []
-    @children = []
-    @builder = builder
-    @id = id.upcase.to_s
+  attr_reader :id, :segments
+
+  def initialize(id)
+    @segments = []
+    @id = id
+  end
+
+  def add(segment)
+    @segments << segment
+  end
+
+  def count
+    @segments.length
   end
 
-  def method_missing(method, *args, &block)
-    if method.to_s.start_with?(@id)
-      element = method.to_s[-2..-1].to_i - 1
-      @elements[element] = args[0]
-    else
-      child = VanillaX12::Segment.new(method, @builder)
-      child.instance_eval &block if block_given?
-      @children << child
-    end
+  def number_of_segments
+    @segments.map(&:number_of_segments).sum
   end
 
-  def draw
-    a = [@id] + @elements
-    s = @builder.separators
-    result = ["#{a.join(s[:element])}#{s[:segment]}"] + @children.map{ |c| c.draw }
-    result.join("\n")
+  def current_segment
+    @segments.last
   end
 
 end

data/lib/baldr/parser.rb

@@ -0,0 +1,107 @@
+class Baldr::Parser
+
+  attr_reader :error, :envelopes, :separators, :input
+
+  def initialize(input)
+    parse(input)
+  end
+
+  def successful?
+    @error.nil?
+  end
+
+  protected
+
+  def parse(input)
+    @input = input
+    @separators = detect_separators(input)
+    @envelopes = build_tree(split_segments(input, separators))
+    @envelopes.each { |e| Baldr::Validator.validate! e }
+    self
+  rescue Baldr::Error => e
+    @error = e.message
+  end
+
+  def detect_separators(input)
+    io = StringIO.new(input)
+
+    isa = io.gets(3)
+    raise Baldr::Error, "doesn't begin with ISA..." unless isa == 'ISA'
+
+    element = io.getbyte
+
+    15.times { io.bytes { |b| break if b == element } }
+    component = io.getbyte
+
+    segment = []
+    io.bytes do |b|
+      break if b.chr =~ /[A-Z]/
+      segment << b
+    end
+
+    {
+      element: element.chr,
+      segment: segment,
+      component: component.chr
+    }
+  end
+
+  def split_segments(input, separators)
+    segments = []
+    buffer = []
+    skip = 0
+
+    io = StringIO.new(input)
+    io.bytes do |b|
+      if skip > 0
+        skip -= 1
+      else
+        if b == separators[:segment].first
+          segments << buffer.pack('c*').split(separators[:element])
+          skip = separators[:segment].length - 1
+          buffer = []
+        else
+          buffer << b
+        end
+      end
+    end
+
+    raise Baldr::Error, 'invalid characters in the end of interchange' if skip > 0
+
+    segments
+  end
+
+  def build_tree(source)
+    grammar = Baldr::Grammar::Envelope::STRUCTURE
+    loop = build_segment(source.to_enum, grammar, nil)
+    loop.segments
+  end
+
+  def build_segment(enumerator, grammar, version)
+    current = enumerator.peek
+
+    while grammar[:id] == current[0]
+      loop ||= Baldr::Loop.new(current[0])
+      segment = Baldr.const_get((grammar[:class] || :segment).to_s.camelize).new(current[0])
+      segment.elements = current[1..-1]
+      loop.add segment
+
+      enumerator.next
+
+      version ||= segment.sub_version
+      sub_grammar = segment.sub_grammar(version) || grammar
+      sub_grammar.fetch(:level, []).each do |g|
+        child = build_segment(enumerator, g, version)
+        segment.children << child if child
+      end
+
+      current = enumerator.peek
+    end
+
+    loop
+
+  rescue StopIteration
+    return loop
+  end
+
+end

data/lib/baldr/renderer/json.rb

@@ -0,0 +1,16 @@
+module Baldr::Renderer::Json
+
+  extend self
+
+  def draw(segment, params = {})
+    draw_segment(segment).to_json
+  end
+
+  def draw_segment(segment)
+    node = ActiveSupport::OrderedHash.new
+    segment.elements.each.with_index { |e, i| node["#{segment.id}#{'%02d' % i}"] = e if e.present? }
+    segment.children.each { |loop| node[loop.id] = loop.segments.map { |s| draw_segment(s) } }
+    node
+  end
+
+end

data/lib/baldr/renderer/x12.rb

@@ -0,0 +1,27 @@
+module Baldr::Renderer::X12
+
+  extend self
+
+  DEFAULT_SEPARATORS = {
+    element: '*',
+    segment: '~',
+    component: '>',
+  }.freeze
+
+  def draw(segment, params = {})
+    separators = params[:separators] || DEFAULT_SEPARATORS
+    separators[:segment] = separators[:segment].pack('c*') if separators[:segment].is_a?(Array)
+    draw_segment(segment, separators).join
+  end
+
+  def draw_segment(segment, separators)
+    a = [segment.id] + segment.elements
+
+    ["#{a.join(separators[:element])}#{separators[:segment]}"] + segment.children.map{ |l| draw_loop(l, separators) }
+  end
+
+  def draw_loop(loop, separators)
+    loop.segments.map { |s| draw_segment(s, separators) }
+  end
+
+end

data/lib/baldr/renderer.rb

@@ -0,0 +1,3 @@
+module Baldr::Renderer
+
+end

data/lib/baldr/segment.rb

@@ -1,28 +1,136 @@
 class Baldr::Segment
 
-  def initialize(id, builder)
+  attr_accessor :id, :children, :elements
+
+  def self.helpers_for_elements(hash)
+    hash.each do |element, method|
+      self.class_eval <<-RUBY
+        def #{method}
+          self['#{element}']
+        end
+
+        def #{method}=(value)
+          self['#{element}'] = value
+        end
+      RUBY
+    end
+  end
+
+  def initialize(id)
     @elements = []
     @children = []
-    @builder = builder
-    @id = id.upcase.to_s
+    @id = id.to_s.upcase
+  end
+
+  def fetch(key, default = nil)
+    self[key] || default
+  end
+
+  def []=(key, value)
+    key = key.to_s
+    if key.start_with?(@id) && key.length == @id.length + 2
+      element = key[-2..-1].to_i - 1
+      @elements[element] = value
+    elsif !key.start_with?(@id) && key.length > 3 && key =~ /[0-9]{2}$/
+      loop = @children.select { |l| l.id == key[0..-3] }.first
+      if loop
+        if loop.segments.length == 1
+          loop.segments.first[key] = value
+        else
+          raise Buldr::Error, 'there are more than 1 segment in loop. you can\'t assign from here' if loop.segments.length > 1
+        end
+      else
+        raise Buldr::Error, "segment #{key[0..-3]} not found"
+      end
+    else
+      raise Buldr::Error, "unable to assign #{key}"
+    end
+  end
+
+  def [](key)
+    key = key.to_s
+    if key.start_with?(@id) && key.length == @id.length + 2
+      element = key[-2..-1].to_i - 1
+      @elements[element]
+    elsif !key.start_with?(@id) && key.length > 3 && key =~ /[0-9]{2}$/
+      loop = @children.select { |l| l.id == key[0..-3] }.first
+      if loop
+        if loop.segments.length == 1
+          loop.segments.first[key]
+        else
+          raise Buldr::Error, 'there are more than 1 segment in loop. use it as enum' if loop.segments.length > 1
+        end
+      end
+    elsif key =~ /^[A-z][A-Z0-9]{1,2}$/
+      loop = @children.select { |l| l.id == key }.first
+      if loop
+        loop.segments.to_enum
+      end
+    end
   end
 
   def method_missing(method, *args, &block)
-    if method.to_s.start_with?(@id)
-      element = method.to_s[-2..-1].to_i - 1
+    m = method.to_s
+    if m.start_with?(@id) && m.length == @id.length + 2
+      element = m[-2..-1].to_i - 1
       @elements[element] = args[0]
+    elsif m =~ /^[A-Z][A-Z0-9]{1,2}$/
+      segment = Baldr::Segment.new(m)
+      segment.instance_eval &block if block_given?
+      get_loop(m).add segment
     else
-      child = VanillaX12::Loop.new(method, @builder)
-      child.instance_eval &block if block_given?
-      @children << child
+      super
     end
   end
 
-  def draw
-    a = [@id] + @elements
-    s = @builder.separators
-    result = ["#{a.join(s[:element])}#{s[:segment]}"] + @children.map{ |c| c.draw }
-    result.join("\n")
+  def sub_version
+
+  end
+
+  def sub_grammar(version)
+
+  end
+
+  def prepare!
+
+  end
+
+  def custom_validate!(version)
+
+  end
+
+  def number_of_segments
+    1 + @children.map(&:number_of_segments).sum
+  end
+
+  def add(segment)
+    get_loop(segment.id).add segment
+  end
+
+  protected
+
+  def generate_control_number(digits)
+    "%0#{digits}d" % Random.rand(10 ** (digits + 1))
+  end
+
+  def get_trailer(trailer_id)
+    if @children.last && @children.last.segments.first.id == trailer_id
+      trailer = @children.last.segments.first
+    else
+      trailer = Baldr::Segment.new(trailer_id)
+      add trailer
+    end
+    trailer
+  end
+
+  def get_loop(loop_id)
+    if @children.last && @children.last.id.to_s == loop_id
+      @children.last
+    else
+      loop = Baldr::Loop.new(loop_id)
+      @children << loop
+      loop
+    end
   end
 
 end

data/lib/baldr/transaction.rb

@@ -0,0 +1,40 @@
+class Baldr::Transaction < Baldr::Segment
+
+  helpers_for_elements(
+    'ST01' => :transaction_set_code,
+    'ST02' => :transaction_control_number,
+  )
+
+  def initialize(id = 'ST')
+    super(id)
+  end
+
+  def prepare!
+    trailer = get_trailer('SE')
+
+    trailer['SE01'] = number_of_segments.to_s
+
+    self.transaction_control_number ||= generate_control_number(9)
+    trailer['SE02'] = transaction_control_number
+  end
+
+  def sub_grammar(version)
+    version.for_transaction_set(transaction_set_code)::STRUCTURE
+  end
+
+  def functional_group(version)
+    version.for_transaction_set(transaction_set_code)::FUNCTIONAL_GROUP
+  end
+
+  def custom_validate!(version)
+    trailer = @children.last.segments.first
+    total_number = number_of_segments
+    if trailer['SE01'].to_i != total_number
+      raise "wrong segments number: #{trailer['SE01']} in SE01, but real number is #{total_number}"
+    end
+    if trailer['SE02'] != transaction_control_number
+      raise "transaction set control numbers don't match: #{trailer['SE02']} in SE02 and #{transaction_control_number} in ST02"
+    end
+  end
+
+end

data/lib/baldr/validator.rb

@@ -0,0 +1,93 @@
+module Baldr::Validator
+
+  extend self
+
+  def validate!(envelope)
+    grammar = Baldr::Grammar::Envelope::STRUCTURE
+    record_defs = Baldr::Grammar::Envelope::RECORD_DEFS
+    validate_tree!(envelope, grammar, record_defs, nil)
+  end
+
+  protected
+
+  def validate_tree!(segment, grammar, record_defs, version)
+    raise Baldr::Error, "unknown segment #{segment.id}" unless record_defs[segment.id]
+
+    record_defs[segment.id].each.with_index do |r, i|
+      element = segment.elements[i]
+      check_required(r, element)
+      self.send("check_#{r[:type]}", r, element) unless element.nil?
+    end
+
+    version ||= segment.sub_version
+    record_defs = version::RECORD_DEFS if version
+    sub_grammar = segment.sub_grammar(version) || grammar
+
+    l = 0
+    sub_grammar.fetch(:level, []).each do |g|
+      loop = segment.children[l]
+      if loop && loop.id.to_s == g[:id]
+        check_loop_count(loop, g)
+
+        loop.segments.each { |child| validate_tree!(child, g, record_defs, version) }
+
+        l += 1
+      else
+        raise Baldr::Error, "segment #{g[:id]} is required, but #{loop.id} was found" if g[:min] > 0
+      end
+    end
+
+    segment.custom_validate!(version)
+  end
+
+  def check_loop_count(loop, grammar)
+    raise Baldr::Error, "#{loop.id} loop is too long: #{loop.count} segments, maximum #{grammar[:max]}" if loop.count > grammar[:max]
+    raise Baldr::Error, "#{loop.id} loop is too short: #{loop.count} segments, minimum #{grammar[:min]}" if loop.count < grammar[:min]
+  end
+
+  def check_required(r, element)
+    if r[:required] && (element.nil? || element.size == 0)
+      raise Baldr::Error, "element #{r[:id]} is required"
+    end
+  end
+
+  def check_string(r, element)
+    check_max_and_min_for_string(r, element)
+  end
+
+  def check_id(r, element)
+    check_max_and_min_for_string(r, element)
+
+  end
+
+  def check_max_and_min_for_string(r, element)
+    if r[:max] && element.length > r[:max]
+      raise Baldr::Error, "#{r[:id]} is too long: #{element.length} characters, maximum #{r[:max]}"
+    end
+
+    if r[:min] && element.length < r[:min]
+      raise Baldr::Error, "#{r[:id]} is too short: #{element.length} characters, minimum #{r[:min]}"
+    end
+  end
+
+  def check_time(r, element)
+
+  end
+
+  def check_date(r, element)
+
+  end
+
+  def check_number(r, element)
+
+  end
+
+  def check_real(r, element)
+
+  end
+
+  def check_complex(r, element)
+
+  end
+
+end

data/lib/baldr/version.rb

@@ -1,3 +1,3 @@
 module Baldr
-  VERSION = '0.0.0'
+  VERSION = '0.3.0'
 end

data/lib/baldr.rb

@@ -1 +1,29 @@
-require 'baldr/version'
+require 'baldr/version'
+
+require 'baldr/builder'
+require 'baldr/parser'
+require 'baldr/segment'
+require 'baldr/envelope'
+require 'baldr/transaction'
+require 'baldr/functional_group'
+require 'baldr/loop'
+require 'baldr/validator'
+
+require 'baldr/error'
+
+require 'baldr/renderer'
+require 'baldr/renderer/x12'
+require 'baldr/renderer/json'
+
+require 'baldr/grammar'
+require 'baldr/grammar/envelope'
+require 'baldr/grammar/version4010'
+require 'baldr/grammar/version4010/set204'
+require 'baldr/grammar/version4010/set210'
+require 'baldr/grammar/version4010/set214'
+require 'baldr/grammar/version4010/set810'
+require 'baldr/grammar/version4010/set850'
+require 'baldr/grammar/version4010/set855'
+require 'baldr/grammar/version4010/set856'
+require 'baldr/grammar/version4010/set990'
+require 'baldr/grammar/version4010/set997'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: baldr
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2013-02-06 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
 description: Lightweight EDI X12 translator
 email: stanislav@spiridonov.pro
 executables: []
@@ -19,9 +35,29 @@ extra_rdoc_files: []
 files:
 - lib/baldr.rb
 - lib/baldr/builder.rb
-- lib/baldr/grammar/set997.rb
+- lib/baldr/envelope.rb
+- lib/baldr/error.rb
+- lib/baldr/functional_group.rb
+- lib/baldr/grammar.rb
+- lib/baldr/grammar/envelope.rb
+- lib/baldr/grammar/version4010.rb
+- lib/baldr/grammar/version4010/set204.rb
+- lib/baldr/grammar/version4010/set210.rb
+- lib/baldr/grammar/version4010/set214.rb
+- lib/baldr/grammar/version4010/set810.rb
+- lib/baldr/grammar/version4010/set850.rb
+- lib/baldr/grammar/version4010/set855.rb
+- lib/baldr/grammar/version4010/set856.rb
+- lib/baldr/grammar/version4010/set990.rb
+- lib/baldr/grammar/version4010/set997.rb
 - lib/baldr/loop.rb
+- lib/baldr/parser.rb
+- lib/baldr/renderer.rb
+- lib/baldr/renderer/json.rb
+- lib/baldr/renderer/x12.rb
 - lib/baldr/segment.rb
+- lib/baldr/transaction.rb
+- lib/baldr/validator.rb
 - lib/baldr/version.rb
 homepage: https://github.com/spiridonov/baldr
 licenses: []