tediparse 2.0.0

data/lib/ruby/array.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine Array do
+      def blank?
+        empty?
+      end
+
+      def present?
+        not empty?
+      end
+
+      # Return the first item. Raises an `IndexError` if the Array is `empty?`.
+      #
+      # @example
+      #   [1, 2, 3].head  #=> 1
+      #
+      def head
+        raise IndexError, "head of empty array" if empty?
+        x, = self
+        x
+      end
+
+      # True if `#at` is defined for the given `n`
+      #
+      # @example
+      #   [1, 2, 3].defined_at?(0)    #=> true
+      #   [].defined_at?(0)           #=> false
+      #
+      def defined_at?(n)
+        n < length and -n <= length
+      end
+
+      # @group Selection
+      #############################################################################
+
+      # Selects all elements except the first.
+      #
+      # @example
+      #   [1, 2, 3].tail  #=> [2, 3]
+      #   [1].tail        #=> []
+      #   [].tail         #=> []
+      #
+      # @return [Array]
+      def tail
+        _, *xs = self
+        xs
+      end
+
+      # Selects all elements except the last `n` ones.
+      #
+      # @example
+      #   [1, 2, 3].init      #=> [1, 2]
+      #   [1, 2, 3].init(2)   #=> [1]
+      #   [].tail             #=> []
+      #
+      # @return [Array]
+      def init(n = 1)
+        raise ArgumentError, "n cannot be negative" if n < 0
+        slice(0..-(n + 1)) or []
+      end
+
+      # Select all elements except the first `n` ones.
+      #
+      # @example
+      #   [1, 2, 3].drop(1)   #=> [2, 3]
+      #   [1, 3, 3].drop(2)   #=> [3]
+      #   [].drop(10)         #=> []
+      #
+      # @return [Array]
+      def drop(n)
+        raise ArgumentError, "n cannot be negative" if n < 0
+        slice(n..-1) or []
+      end
+
+      # Select the first `n` elements.
+      #
+      # @example
+      #   [1, 2, 3].take(2)  #=> [1, 2]
+      #   [1, 2, 3].take(0)  #=> []
+      #
+      # @return [Array]
+      def take(n)
+        raise ArgumentError, "n cannot be negative" if n < 0
+        slice(0, n) or []
+      end
+
+      # Split the array in two at the given position.
+      #
+      # @example
+      #   [1, 2, 3].split_at(2)   #=> [[1,2], [3]]
+      #   [1, 2, 3].split_at(0)   #=> [[], [1,2,3]]
+      #
+      # @return [(Array, Array)]
+      def split_at(n)
+        n = length + n if n < 0
+        return take(n), drop(n)
+      end
+
+      # @endgroup
+      #############################################################################
+
+      # @group Filtering
+      #############################################################################
+
+      # Drops the longest prefix of elements that satisfy the predicate.
+      #
+      # @return [Array]
+      def drop_while(&block)
+        # This is in tail call form
+        if not empty? and yield(head)
+          tail.drop_while(&block)
+        else
+          self
+        end
+      end
+
+      # Drops the longest prefix of elements that do not satisfy the predicate.
+      #
+      # @return [Array]
+      def drop_until(&block)
+        # This is in tail call form
+        unless empty? or yield(head)
+          tail.drop_until(&block)
+        else
+          self
+        end
+      end
+
+      # Takes the longest prefix of elements that satisfy the predicate.
+      #
+      # @return [Array]
+      def take_while(accumulator = [], &block)
+        # This is in tail call form
+        if not empty? and yield(head)
+          tail.take_while(head.snoc(accumulator), &block)
+        else
+          accumulator
+        end
+      end
+
+      # Takes the longest prefix of elements that do not satisfy the predicate.
+      #
+      # @return [Array]
+      def take_until(accumulator = [], &block)
+        # This is in tail call form
+        unless empty? or yield(head)
+          tail.take_until(head.snoc(accumulator), &block)
+        else
+          accumulator
+        end
+      end
+
+      # Splits the array into prefix/suffix pair according to the predicate.
+      #
+      # @return [(Array, Array)]
+      def split_until(&block)
+        prefix = take_while(&block)
+        suffix = drop(prefix.length)
+        return prefix, suffix
+      end
+
+      # Splits the array into prefix/suffix pair according to the predicate.
+      #
+      # @return [(Array, Array)]
+      def split_when(&block)
+        prefix = take_until(&block)
+        suffix = drop(prefix.length)
+        return prefix, suffix
+      end
+
+      # Returns a list of sublists, where each sublist contains only equal
+      # elements. Equality is determined by a two-argument block parameter.
+      # The concatenation of the result is equal to the original argument.
+      #
+      # @example
+      #   "abba".split(//).group_seq(&:==) #=> [["y"], ["a"], ["b", "b"], ["a"]]
+      #
+      # @return [[Array]]
+      def runs(&block)
+        unless empty?
+          as, bs = tail.split_until{|x| block.call(head, x) }
+          head.cons(as).cons(bs.runs(&block))
+        else
+          []
+        end
+      end
+
+      # @endgroup
+      #############################################################################
+
+      # Accumulate elements using the `+` method, optionally
+      # transforming them first using a block
+      #
+      # @example
+      #   ["a", "b", "cd"].sum             #=> "abcd"
+      #   ["a", "b", "cd"].sum(&:length)   #=> 4
+      #
+      def sum(&block)
+        if block_given?
+          tail.inject(yield(head)){|sum,e| sum + yield(e) }
+        else
+          tail.inject(head){|sum,e| sum + e }
+        end
+      end
+
+      # Count the number of elements that satisfy the predicate
+      #
+      # @example
+      #   ["abc", "de", "fg", "hi"].count{|s| s.length == 2 } #=> 3
+      #   ["a", "b", "a", "c", "a"].count("a")                #=> 3
+      #   [1, 3, 5, 9, 0].count                               #=> 5
+      #
+      # @return [Integer]
+      def count(*args)
+        if block_given?
+          inject(0){|n, e| yield(e) ? n + 1 : n }
+        elsif args.empty?
+          size
+        else
+          inject(0){|n, e| e == args.first ? n + 1 : n }
+        end
+      end
+    end
+  end
+end

data/lib/ruby/blank.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine String do
+      # True if the string is `empty?` or contains all whitespace
+      #
+      # @example
+      #   "abc".blank?    #=> false
+      #   "   ".blank?    #=> true
+      #   "".blank?       #=> true
+      #
+      def blank?
+        self !~ /\S/
+      end
+
+      def present?
+        self =~ /\S/
+      end
+    end
+
+    refine NilClass do
+      # Always `true`. Note this overrides {Object#blank?} which returns false.
+      #
+      # @example
+      #   nil.blank?    #=> true
+      #
+      def blank?
+        true
+      end
+
+      def present?
+        false
+      end
+    end
+
+    refine Object do
+      # Always `false`. Note that {NilClass#blank?} is overridden to return `true`
+      #
+      # @example
+      #   false.blank?    #=> false
+      #   100.blank?      #=> false
+      #
+      def blank?
+        false
+      end
+
+      def present?
+        true
+      end
+    end
+  end
+end

data/lib/ruby/exception.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine Exception do
+      def print(name: nil, io: $stderr)
+        ansi = Stupidedi::Color.ansi
+        io.puts "warning: #{ansi.red("#{self.class} #{message}")}"
+        io.puts " module: #{name}" unless name.nil?
+        io.puts backtrace.map{|x| "  " + x}.join("\n")
+        io.puts
+      end
+    end
+  end
+end

data/lib/ruby/hash.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine Hash do
+      def defined_at?(x)
+        include?(x)
+      end
+
+      def at(x)
+        self[x]
+      end
+    end
+  end
+end

data/lib/ruby/module.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine Module do
+      # Creates an abstract method
+      #
+      # @example
+      #   class Collection
+      #     abstract :size
+      #     abstract :add, :args => %w(item)
+      #   end
+      #
+      # @return [void]
+      def abstract(name, *params)
+        if params.last.is_a?(Hash)
+          # abstract :method, :args => %w(a b c)
+          params = params.last[:args]
+        end
+
+        file, line, = Stupidedi.caller
+
+        if params.empty?
+          class_eval(<<-RUBY, file, line.to_i - 1)
+            def #{name}(*args)
+              raise NoMethodError,
+                "method \#{self.class.name}.#{name} is abstract"
+            end
+          RUBY
+        else
+          class_eval(<<-RUBY, file, line.to_i - 1)
+            def #{name}(*args)
+              raise NoMethodError,
+                "method \#{self.class.name}.#{name}(#{params.join(", ")}) is abstract"
+            end
+          RUBY
+        end
+      end
+
+      def def_delegators(target, *methods)
+        file, line, = Stupidedi.caller
+
+        for m in methods
+          if m.to_s =~ /=$/
+            class_eval(<<-RUBY, file, line.to_i - 1)
+              def #{m}(value)
+                #{target}.#{m}(value)
+              end
+            RUBY
+          else
+            class_eval(<<-RUBY, file, line.to_i - 1)
+              def #{m}(*args, &block)
+                #{target}.#{m}(*args, &block)
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby/object.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine Object do
+      # @group List Constructors
+      #############################################################################
+
+      # Prepend the item to the front of a new list
+      #
+      # @example
+      #   1.cons              #=> [1]
+      #   1.cons(2.cons)      #=> [1, 2]
+      #   1.cons([0, 0, 0])   #=> [1, 0, 0, 0]
+      #
+      # @return [Array]
+      def cons(array = [])
+        [self] + array
+      end
+
+      # Append the item to rear of a new list
+      #
+      # @example
+      #   1.snoc              #=> [1]
+      #   1.snoc(2.snoc)      #=> [2, 1]
+      #   1.snoc([0, 0, 0])   #=> [0, 0, 0, 1]
+      #
+      # @return [Array]
+      def snoc(array = [])
+        array + [self]
+      end
+
+      # @group Combinators
+      #############################################################################
+
+      # Yields `self` to a block argument
+      #
+      # @example
+      #   nil.bind{|a| a.nil? }   #=> true
+      #   100.bind{|a| a.nil? }   #=> false
+      #
+      def bind
+        yield self
+      end
+
+      # @endgroup
+      #############################################################################
+
+      # Return the "eigenclass" where singleton methods reside
+      #
+      # @return [Class]
+      def eigenclass
+        class << self; self; end
+      end
+    end
+  end
+end

data/lib/ruby/string.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine String do
+      # Return the one-character string at the given index
+      #
+      # @example
+      #   "abc".at(0)   #=> "a"
+      #   "abc".at(2)   #=> "c"
+      #
+      # @param [Integer] n zero-based index of the character to read
+      #
+      # @return [String]
+      def at(n)
+        raise ArgumentError, "n must be positive" if n < 0
+        self[n, 1] unless n >= length
+      end
+
+      # Return the string with `n` characters removed from the front
+      #
+      # @example
+      #   "abc".drop(0)   #=> "abc"
+      #   "abc".drop(2)   #=> "c"
+      #
+      # @param [Integer] n number of characters to drop (`n > 0`)
+      #
+      # @return [String]
+      def drop(n)
+        raise ArgumentError, "n must be positive" if n < 0
+        (length >= n) ? self[n..-1] : ""
+      end
+
+      # Return the first `n` characters from the front
+      #
+      # @example
+      #   "abc".take(0)   #=> ""
+      #   "abc".take(2)   #=> "ab"
+      #
+      # @param [Integer] n number of characters to select (`n > 0`)
+      #
+      # @return [String]
+      def take(n)
+        raise ArgumentError, "n must be positive" if n < 0
+        self[0, n]
+      end
+
+      # Split the string in two at the given position
+      #
+      # @example
+      #   "abc".split_at(0)   #=> ["", "abc"]
+      #   "abc".split_at(2)   #=> ["ab", "c"]
+      #
+      # @param [Integer] n number of characters at which to split (`n > 0`)
+      #
+      # @return [Array(String, String)]
+      def split_at(n)
+        [take(n), drop(n)]
+      end
+
+      # True if the string is long enough such that {#at} is defined for the
+      # given `n`
+      #
+      # @example
+      #   "abc".defined_at?(0)  #=> true
+      #   "abc".defined_at?(3)  #=> false
+      def defined_at?(n)
+        n < length
+      end
+
+      # To make String compatible with the {Stupidedi::Reader::Input} interface,
+      # we have to define `#position`... shameful!
+      def position
+        nil
+      end
+
+      # Join multi-line string into a single line, removing leading whitespace
+      # from the beginning of each line
+      #
+      # @example
+      #   "this is a
+      #   multiline string".join #=> "this is a multiline string"
+      #
+      # @return [String]
+      def join
+        gsub(/\n[ \t]+/, " ")
+      end
+    end
+  end
+end

data/lib/ruby/to_d.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+require "bigdecimal"
+require "rational"
+
+module Stupidedi
+  module Refinements
+    refine BigDecimal do
+      # @return [BigDecimal] self
+      def to_d
+        self
+      end
+    end
+
+    BIGDECIMAL = /\A[+-]?            (?# optional leading sign            )
+                  (?:
+                    (?:\d+\.?\d*)  | (?# whole with optional decimal or ..)
+                    (?:\d*?\.?\d+) ) (?# optional whole with decimal      )
+                  (?:E[+-]?\d+)?     (?# optional exponent                )
+                 \Z/ix
+
+    refine String do
+      # Converts the string to a BigDecimal after validating the format. If the
+      # string does not match the pattern for a valid number, an `ArgumentError`
+      # is raised.
+      #
+      # @example
+      #   "1.0".to_d  #=> BigDecimal("1.0")
+      #
+      # @return [BigDecimal]
+      def to_d
+        if BIGDECIMAL =~ self
+          BigDecimal(to_s)
+        else
+          raise ArgumentError, "#{inspect} is not a valid number"
+        end
+      end
+    end
+
+    refine Integer do
+      # Converts the integer to a BigDecimal
+      #
+      # @example
+      #   10.to_d   #=> BigDecimal("10")
+      #
+      # @return [BigDecimal]
+      def to_d
+        BigDecimal(to_s)
+      end
+    end
+
+    refine Rational do
+      # Converts the rational to a BigDecimal
+      #
+      # @example
+      #   Rational(3, 4).to_d   #=> BigDecimal("3") / BigDecimal("4")
+      #
+      # @return [BigDecimal]
+      def to_d
+        numerator.to_d / denominator.to_d
+      end
+    end
+
+    refine Float do
+      # Raises a `TypeError` exception. The reason this method is defined at
+      # all is to produce a more meaningful error than `NoSuchMethod`.
+      #
+      # @return [void]
+      def to_d
+        # The problem is there isn't a way to know the correct precision,
+        # since there are (many) values that cannot be represented exactly
+        # using Floats. For instance, we can't assume which value is correct
+        #
+        #   "%0.10f" % 1.8 #=> "1.8000000000"
+        #   "%0.20f" % 1.8 #=> "1.80000000000000004441"
+        #
+        # The programmer should convert the Float to a String using whatever
+        # precision he chooses, and call #to_d on the String.
+        raise TypeError, "cannot convert Float to BigDecimal"
+      end
+    end
+  end
+end

data/lib/ruby/to_date.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine Time do
+      def to_date
+        Date.civil(year, month, day)
+      end
+    end
+
+    refine String do
+      def to_date
+        Date.parse(self)
+      end
+    end
+
+    refine Date do
+      def to_date
+        self
+      end
+    end
+
+    class << Date
+      public :parse
+    end
+  end
+end

data/lib/ruby/to_time.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine Time do
+      # @return [Time]
+      def to_time
+        self
+      end
+    end
+
+    class << Time
+      public :parse
+    end
+
+    refine String do
+      def to_time
+        Time.parse(self)
+      end
+    end
+  end
+end

data/lib/ruby/try.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Stupidedi
+  module Refinements
+    refine Object do
+      # @group Combinators
+      #############################################################################
+
+      # Sends the arguments to `self` or yields `self` (when `self` is non-`nil`).
+      # This is overridden by {NilClass#try}, which always returns `nil`.
+      #
+      # @example
+      #   "non-nil".try(&:length)       #=> 7
+      #   nil.try(&:length)             #=> nil
+      #
+      #   "non-nil".try(:slice, 0, 3)   #=> "non"
+      #   nil.try(:slice, 0, 3)         #=> nil
+      #
+      def try(*args, &block)
+        if args.empty?
+          yield self
+        else
+          __send__(*args, &block)
+        end
+      end
+    end
+
+    refine NilClass do
+      # @group Combinators
+      #############################################################################
+
+      # Returns `nil` (when `self` is `nil`). This overrides {Object#try}
+      #
+      # @example
+      #   "non-nil".try(&:length) #=> 7
+      #   nil.try(&:length)       #=> nil
+      #
+      #   "non-nil".try(:slice, 0, 3)   #=> "non"
+      #   nil.try(:slice, 0, 3)         #=> nil
+      #
+      # @return nil
+      def try(*args)
+        self
+      end
+    end
+  end
+end

data/lib/stupidedi/builder.rb

@@ -0,0 +1,6 @@
+module Stupidedi
+  warn "DEPRECATION WARNING: Stupidedi::Builder is depecated, use Stupidedi::Parser instead"
+
+  # @deprecated Use Stupidedi::Parser instead
+  Builder = Parser
+end