stupidedi 1.1.0

data/spec/support/quickcheck/serialized_edi.rb

@@ -0,0 +1,399 @@
+require "support/quickcheck"
+
+class QuickCheck
+
+  #
+  #
+  #
+  class SerializedEdi < ::QuickCheck
+
+    #
+    #
+    #
+    module Macro
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def property(*args, &setup)
+          QuickCheck.property(self, *args, &setup)
+        end
+      end
+    end
+
+    has_parameter :separators,
+      Stupidedi::Reader::Separators.new(":", "^", "*", "~")
+
+    def is_delimiter?(c)
+      separators.segment    == c or
+      separators.element    == c or
+      separators.component  == c or
+      separators.repetition == c
+    end
+
+    # @return [Delegators::Char]
+    def char
+      Delegators::Char.new(self)
+    end
+
+    # @return [Delegators::Stream]
+    def stream
+      Delegators::Stream.new(self)
+    end
+
+    # @return [Delegators::SimpleElement]
+    # @return [String]
+    def element(element_def = nil)
+      delegator = Delegators::SimpleElement.new(self)
+
+      if element_def.respond_to?(:min_length)
+        min = element_def.min_length
+        max = element_def.max_length
+      end
+
+      case element_def
+      when nil
+        delegator
+      when Stupidedi::FiftyTen::Definitions::ElementTypes::Nn
+        with(:size, choose([min, max])) { delegator.nn }
+      when Stupidedi::FiftyTen::Definitions::ElementTypes::R
+        with(:size, choose([min, max])) { delegator.r  }
+      when Stupidedi::FiftyTen::Definitions::ElementTypes::ID
+        with(:size, choose([min, max])) { delegator.id }
+      when Stupidedi::FiftyTen::Definitions::ElementTypes::AN
+        with(:size, choose([min, max])) { delegator.an }
+      when Stupidedi::FiftyTen::Definitions::ElementTypes::DT
+        with(:size, choose([min, max])) { delegator.dt }
+      when Stupidedi::FiftyTen::Definitions::ElementTypes::TM
+        with(:size, choose([min, max])) { delegator.tm }
+      when Stupidedi::FiftyTen::Definitions::ElementTypes::CompositeElementDef
+        composite(element_def)
+      else
+        raise ArgumentError
+      end
+    end
+
+    # @return [Delegators::CompositeElement]
+    # @return [String]
+    def composite(element_def = nil)
+      case element_def
+      when nil
+        Delegators::CompositeElement.new(self)
+      when Stupidedi::Schema::CompositeElementDef
+        # Generate each component element
+        elements = element_def.component_element_uses.map do |use|
+          if use.required?
+            value { element(use.definition) }
+          else
+            value { choose([element(use.definition), element.blank]) }
+          end
+        end
+
+        # Collapse the suffix of blank elements
+        suffix, elements = elements.reverse.split_until(&:empty?)
+        elements.reverse.join(separators.component)
+      else
+        raise ArgumentError
+      end
+    end
+
+    # @return [Delegators::Segment]
+    def segment
+      Delegators::Segment.new(self)
+    end
+
+    # @return [Delegators::Document]
+    def document
+      Delegators::Document.new(self)
+    end
+
+    # @return [Delegators::Current]
+    def current
+      Delegators::Current.new(self)
+    end
+
+    #
+    #
+    #
+    class Delegator < Stupidedi::BlankSlate
+      def initialize(quickcheck)
+        @quickcheck = quickcheck
+      end
+
+    private
+
+      def method_missing(name, *args, &block)
+        @quickcheck.__send__(name, *args, &block)
+      end
+    end
+
+    #
+    #
+    #
+    module Delegators
+
+      #
+      #
+      #
+      class Char < Delegator
+
+        # Generate a single basic character
+        #
+        # @return [Character]
+        def basic
+          choose(Stupidedi::Reader.basic_characters).tap{|c| guard(!is_delimiter?(c)) }
+        end
+
+        # Generate a single control character
+        #
+        # @return [Character]
+        def control
+          choose(Stupidedi::Reader.control_characters).tap{|c| guard(!is_delimiter?(c)) }
+        end
+
+        # Generate a single extended character
+        #
+        # @return [Character]
+        def extended
+          choose(Stupidedi::Reader.extended_characters).tap{|c| guard(!is_delimiter?(c)) }
+        end
+
+        # Generate a single delimiter character
+        #
+        # @return [Character]
+        def delimiter
+          choose [separators.segment,
+                  separators.element,
+                  separators.component,
+                  separators.repetition]
+        end
+      end
+
+      #
+      #
+      #
+      class Stream < Delegator
+
+        # Generate a sized string of control characters
+        #
+        # @return [String]
+        def control
+          (1..size).inject(""){|s,_| s << char.control }
+        end
+
+        # Generate a sized string of basic characters
+        #
+        # @return [String]
+        def basic
+          (1..size).inject(""){|s,_| s << char.basic }
+        end
+
+        # Generate a sized string of extended characters
+        #
+        # @return [String]
+        def extended
+          (1..size).inject(""){|s,_| s << char.extended }
+        end
+
+        # Generate a sized string of spaces
+        #
+        # @return [String]
+        def space(length = size)
+          " " * length
+        end
+
+        # Randomly insert control characters into the string
+        #
+        # @return [String]
+        def agitate(string)
+          cs = string.split(//)
+
+          # Generate `cs.length + 1` control characters
+          xs = (0..cs.length).inject([]){|s,_| s << choose(["", char.control]) }
+
+          agitated = ""
+          xs.zip(cs){|pad, c| agitated << pad << c.to_s }
+
+          agitated
+        end
+
+        # Pad the ends of the string with sized random spaces. The combined
+        # length of the left and right padding is `sized`
+        #
+        # @return [String]
+        def pad(string)
+          left  = space(between(0, size))
+          right = space(between(0, size - left.length))
+          left << string << right
+        end
+      end
+
+      #
+      #
+      #
+      class SimpleElement < Delegator
+
+        # Generate a string representing a blank element
+        #
+        # @return [String]
+        def blank
+          ""
+        end
+
+        # Generate a sized string representing a non-empty numeric element (Nn).
+        # The leading sign character is not counted against `size`
+        #
+        # @return [String]
+        def nn
+          choose(["", "+", "-"]) << string(:digit)
+        end
+
+        # Generate a sized string representing a non-empty decimal element (R).
+        # The leading sign character, optional exponent (E) indicator and its
+        # sign character are not counted against `size`
+        #
+        # @return [String]
+        def r(length = size)
+          decimal  = with(:size, between(0, length)) { string(:digit) }
+          exponent = with(:size, between(0, decimal.length)) { string(:digit) }
+          whole    = with(:size, length - decimal.length - exponent.length) { string(:digit) }
+
+          decimal =
+            if decimal.empty?
+              choose(["", "."])
+            else
+              ".#{decimal}"
+            end
+
+          unless exponent.empty?
+            exponent = "E#{choose(["", "-", "+"])}#{exponent}"
+          end
+
+          whole = "#{choose(["", "-", "+"])}#{whole}"
+
+          "#{whole}#{decimal}#{exponent}"
+        end
+
+        # Generate a sized string representing an identifier element (ID)
+        #
+        # @return [String]
+        def id
+          (1..size).inject("") do |s,_|
+            s << choose([char.basic, char.extended])
+          end.tap{|s| guard(!s.blank?) }
+        end
+
+        # Generate a sized string representing a string element (AN)
+        #
+        # @return [String]
+        def an
+          (1..size).inject("") do |s,_|
+            s << choose([char.basic, char.extended])
+          end.tap{|s| guard(!s.blank?) }
+        end
+
+        # Generate a sized string representing a date (DT)
+        #
+        # @return [String]
+        def dt
+          year  = between(0, 9999)
+          month = between(1, 12)
+          day   = between(1, 31)
+
+          # Ensure this is a valid date
+          guard(begin Date.civil(year, month, day); rescue ArgumentError; false end)
+
+          case size
+          when 6 then "%02d%02d%02d" % [year.modulo(100), month, day]
+          when 8 then "%04d%02d%02d" % [year, month, day]
+          else raise "Size must be 6 or 8, but it is #{size}"
+          end
+        end
+
+        # Generate a sized string representing a time (TM)
+        #
+        # @return [String]
+        def tm
+          case size
+          when 2 then "%02d" % between(0, 23)
+          when 4 then "%02d%02d" % [between(0, 23).abs, between(0, 59).abs]
+          else
+            raise "Size must be 2, 4, 6, or greater than 6, but it is #{size}" if size < 6
+            hour   = between(0, 23)
+            minute = between(0, 59)
+            second = between(0, 59)
+            fract  = with(:size, size - 6) { string(:digit) }
+            "%02d%02d%02d%s" % [hour, minute, second, fract]
+          end
+        end
+      end
+
+      #
+      #
+      #
+      class CompositeElement < Delegator
+        # @todo
+      end
+
+      #
+      #
+      #
+      class Segment < Delegator
+
+        # @private
+        SEGMENT_ID = /^[A-Z][A-Z0-9]{1,2}$/
+
+        def generate(name, *elements)
+          # @todo
+        end
+
+      private
+
+        def method_missing(name, *arguments, &block)
+          if SEGMENT_ID =~ name.to_s
+            generate(name)
+          else
+            super
+          end
+        end
+      end
+
+      #
+      #
+      #
+      class Document < Delegator
+
+        # Generate four random delimiters with the restriction that they cannot
+        # be control characters, spaces, tabs, numbers, letters, underscores, or
+        # numerical symbols, and each delimiter must be unique.
+        #
+        # @return [Reader::Separators]
+        def delimiters
+          possible  = Stupidedi::Reader.basic_characters
+          possible << Stupidedi::Reader.extended_characters
+          possible -= QuickCheck::Characters.of(/[ \t0-9a-z_.+-]/i)
+
+          delimiters = []
+
+          4.times do
+            delimiters << value do
+              choose(possible).tap{|x| guard(!delimiters.include?(x)) }
+            end
+          end
+
+          Stupidedi::Reader::Sepatarors.new(*delimiters)
+        end
+      end
+
+      #
+      #
+      #
+      class Current < Delegator
+        # @todo
+      end
+
+    end
+
+  end
+end

data/spec/support/quickcheck.rb

@@ -0,0 +1,302 @@
+#
+# This class is designed to be subclassed, to avoid polluting the minimal
+# base class. Subclasses can add parameters with the macro "has_parameter",
+# and parameters are inherited when subclassing.
+#
+# @see https://github.com/hayeah/rantly
+#
+class QuickCheck
+  autoload :Characters, "support/quickcheck/characters"
+  autoload :Property,   "support/quickcheck/property"
+
+  def initialize
+    @bindings = []
+  end
+end
+
+class << QuickCheck
+  def property(base, *args, &setup)
+    QuickCheck::Property.new(base, new, *args, &setup)
+  end
+
+  # Generate `count` values, returning nil
+  def each(count, limit = 10, &block)
+    new.each(count, limit, &block)
+  end
+
+  # Generate an array of `count` values
+  def map(count, limit = 10, &block)
+    new.map(count, limit, &block)
+  end
+
+  # Generate a single value
+  def value(limit = 10,  &block)
+    new.value(limit, &block)
+  end
+
+  def generate(count, limit, setup, &block)
+    new.generate(count, limit, setup, &block)
+  end
+
+  # @return [Class]
+  def default
+    @default ||= (superclass == Object) ?
+      Class.new.new :
+      Class.new(superclass).new
+  end
+
+  # @return [void]
+  def has_parameter(name, value)
+    scope = self
+    define_method(name) { instance_variable_get("@_parameter_#{name}") || scope.default.send(name) }
+    default.class.send(:define_method, name) { value }
+  end
+end
+
+class QuickCheck
+  module Macro
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def property(*args, &setup)
+        QuickCheck.property(self, *args, &setup)
+      end
+    end
+  end
+
+  class GuardFailure < StandardError; end
+
+  class NoMoreTries < StandardError
+
+    # @return [Integer]
+    attr_reader :limit
+
+    # @return [Integer]
+    attr_reader :tries
+
+    def initialize(limit, tries)
+      @limit, @tries = limit, tries
+    end
+
+    # @return [String]
+    def to_s
+      "Exceeded limit #{limit}: #{tries} failed guards"
+    end
+  end
+
+  # Controls the size of sized generators: array, string
+  has_parameter :size, 6
+
+  # Generate `count` values, returning nil
+  def each(count, limit = 10, &setup)
+    generate(count, limit, setup)
+  end
+
+  # Generate an array of `count` values
+  def map(count, limit = 10, &setup)
+    acc = []; generate(count, limit, setup) {|x| acc << x }; acc
+  end
+
+  # Generate a single value
+  def value(limit = 10, &setup)
+    generate(1, limit, setup) {|x| return x }
+  end
+
+  def generate(count, limit, setup, &block)
+    retries  = count * limit
+    failures = successes = 0
+
+    @bindings.push(eval("self", block.binding))
+
+    while successes < count
+      raise NoMoreTries.new(count * limit, failures) if retries < 0
+
+      begin
+        retries -= 1
+        value    = instance_eval(&setup)
+      rescue GuardFailure
+        failures += 1
+      else
+        successes += 1
+        yield(value) if block_given?
+      end
+    end
+
+    @bindings.pop
+  end
+
+  def guard(condition)
+    raise GuardFailure unless condition
+  end
+
+  # Called with a block, sets `parameters` temporarily while evaluating the
+  # block, and returns the value of the block. Without a block, this permanently
+  # sets `parameters`
+  def with(*parameters)
+    parameters = Hash[*parameters]
+
+    if block_given?
+      # Copy current parameters to a safe place
+      prev = instance_variables.grep(/@_parameter/).inject({}) do |hash, name|
+        hash.update(name => instance_variable_get(name))
+      end
+
+      # Update the given parameters
+      parameters.each{|name, value| instance_variable_set("@_parameter_#{name}", value) }
+
+      begin
+        yield
+      ensure
+        # Remove all the parameters
+        instance_variables.each do |name|
+          next unless /^@_parameter_/ =~ name
+          remove_instance_variable(name)
+        end
+
+        # Restore previous parameters from the copy
+        prev.each{|name, value| instance_variable_set(name, value) }
+      end
+    else
+      parameters.each{|name, value| instance_variable_set("@_parameter_#{name}", value) }
+    end
+  end
+
+  INTMIN = 2 ** (0.size * 8 - 2) - 1
+  INTMAX = -INTMIN + 1
+
+  # Returns the given parameter
+  def literal(x); x end
+
+  # Generates an integer
+  def integer(magnitude = nil)
+    case magnitude
+    when Range   then between(magnitude.end, magnitude.begin)
+    when Integer then between(magnitude, -magnitude)
+    else              between(INTMAX, INTMIN) end
+  end
+
+  # Generates a float
+  alias float rand
+
+  # Generates a value between the given range
+  def between(lo, hi = nil)
+    case lo
+    when Numeric
+      rand(hi + 1 - lo) + lo
+    when Range
+      # @todo: #to_a is wasteful for large Ranges
+      lo.to_a.bind{|a| a[between(0, a.length - 1)] }
+    end
+  end
+
+  # Generates true or false
+  def boolean
+    rand(2) == 0
+  end
+
+  # Generates a sized array by iteratively evaluating `block`
+  def array(&block)
+    @bindings.push(eval("self", block.binding))
+
+    (1..size).inject([]) {|a,_| a << instance_eval(&block) }.tap do
+      @bindings.pop
+    end
+  end
+
+  # Generates a character the given character class
+  def character(type = :print)
+    chars = case type
+            when Regexp then Characters.of(type)
+            when Symbol then Characters::CLASSES[type] end
+
+    raise ArgumentError, "unrecognized character type #{type.inspect}" unless chars
+    choose(chars)
+  end
+
+  # Generates a sized string of the given character class
+  def string(type = :print)
+    chars = case type
+            when Regexp then Characters.of(type)
+            when Symbol then Characters::CLASSES[type] end
+
+    raise ArgumentError, "unrecognized character type #{type.inspect}" unless chars
+    acc = ""; size.times { acc << choose(chars) }; acc
+  end
+
+  # Generate a weighted value by calling the tail of each element
+  #
+  # @example
+  #   freq [1, :literal, "one"],
+  #        [2, :string],
+  #        [3, :string, :alpha],
+  #        [4, [:string, :alpha]],
+  #        [5, lambda{ with(:size, 2) { string }}],
+  #        [6, lambda{|x| with(:size, x) { string }}, 2]
+  def freq(*pairs)
+    total = 0
+    pairs = pairs.map do |p|
+      case p
+      when Symbol, String, Proc
+        total += 1; [1, p]
+      when Array
+        total += p.head; p
+      end
+    end
+
+    index = between(1, total)
+    pairs.each do |p|
+      weight, generator, *args = p
+      if index <= weight
+        return call(generator, *args)
+      else
+        index -= weight
+      end
+    end
+  end
+
+  # Generates an element from the given array of values
+  def choose(values)
+    values[between(0, values.length - 1)]
+  end
+
+  # Executes `call` on a random element from the given array of values
+  def branch(generators)
+    call(choose(generators))
+  end
+
+  # Executes the given generator
+  #
+  # @example
+  #   call(:integer)
+  #   call(:choose, [1,2,3])
+  #   call([:choose, [1,2,3]])
+  #   call(lambda { choose([1,2,3]) }
+  def call(generator, *args)
+    case generator
+    when Symbol, String
+      send(generator, *args)
+    when Array
+      send(generator.head, *generator.tail)
+    when Proc
+      @bindings.push(eval("self", generate.binding))
+
+      instance_eval { generator.call(*args) }.tap do
+        @bindings.pop
+      end
+    else
+      raise ArgumentError, "unrecognized generator type #{generator.inspect}"
+    end
+  end
+
+private
+
+  def method_missing(name, *args, &block)
+    unless @bindings.empty?
+      @bindings.last.__send__(name, *args, &block)
+    else
+      super
+    end
+  end
+end