d-parse 0.1

data/lib/d-parse/parser.rb

@@ -0,0 +1,102 @@
+module DParse
+  class Parser
+    def apply(input)
+      # FIXME: convert input to chars first
+      read(input, DParse::Position.new)
+    end
+
+    def match?(input)
+      apply(input).success?
+    end
+
+    def read(_input, _pos)
+      raise NotImplementedError
+    end
+
+    def expectation_message
+      '?'
+    end
+
+    def inspect
+      raise NotImplementedError
+    end
+
+    def to_s
+      inspect
+    end
+
+    def first
+      map { |d| d[0] }
+    end
+
+    def second
+      map { |d| d[1] }
+    end
+
+    def select_odd
+      map { |d| d.select.with_index { |_, i| i.odd? } }
+    end
+
+    def select_even
+      map { |d| d.select.with_index { |_, i| i.even? } }
+    end
+
+    def flatten
+      map { |d| d.is_a?(Array) ? d.reduce(:+) : d }
+    end
+
+    def compact
+      map { |d, _, _| d.compact }
+    end
+
+    def map(&block)
+      DParse::Parsers::Map.new(self, &block)
+    end
+
+    def ignore
+      DParse::Parsers::Ignore.new(self)
+    end
+
+    def bind(&block)
+      DParse::Parsers::Bind.new(self, &block)
+    end
+
+    def capture
+      DParse::Parsers::Capturing.new(self)
+    end
+
+    private
+
+    def display(char)
+      case char
+      when nil
+        'end of input'
+      when "\n"
+        'line break (LF)'
+      when "\r"
+        'line break (CR)'
+      else
+        quote_char =
+          if char == '\''
+            '"'
+          else
+            '\''
+          end
+
+        display_char =
+          case char
+          when '\\'
+            '\\'
+          when '"'
+            '"'
+          when '\''
+            '\''
+          else
+            char.inspect.gsub(/^"|"$/, '')
+          end
+
+        quote_char + display_char + quote_char
+      end
+    end
+  end
+end

data/lib/d-parse/parsers.rb

@@ -0,0 +1,26 @@
+require_relative 'parsers/primitives/any'
+require_relative 'parsers/primitives/bind'
+require_relative 'parsers/primitives/char'
+require_relative 'parsers/primitives/char_not'
+require_relative 'parsers/primitives/char_not_in'
+require_relative 'parsers/primitives/eof'
+require_relative 'parsers/primitives/fail'
+require_relative 'parsers/primitives/except'
+require_relative 'parsers/primitives/succeed'
+
+require_relative 'parsers/combinators/alt'
+require_relative 'parsers/combinators/seq'
+require_relative 'parsers/combinators/repeat'
+
+require_relative 'parsers/modifiers/capturing'
+require_relative 'parsers/modifiers/lazy'
+require_relative 'parsers/modifiers/map'
+require_relative 'parsers/modifiers/ignore'
+require_relative 'parsers/modifiers/describe'
+
+require_relative 'parsers/highlevel/char_in'
+require_relative 'parsers/highlevel/intersperse'
+require_relative 'parsers/highlevel/opt'
+require_relative 'parsers/highlevel/json'
+require_relative 'parsers/highlevel/string'
+require_relative 'parsers/highlevel/whitespace_char'

data/lib/d-parse/parsers/combinators/alt.rb

@@ -0,0 +1,32 @@
+module DParse
+  module Parsers
+    class Alt < DParse::Parser
+      def initialize(*parsers)
+        # FIXME: ensure >0 parsers are provided
+        @parsers = parsers
+      end
+
+      def read(input, pos)
+        init = DParse::Failure.new(input, DParse::Position::FAR_BEHIND)
+        @parsers.reduce(init) do |old_res, parser|
+          case old_res
+          when DParse::Success
+            old_res
+          when DParse::Failure
+            new_res = parser.read(input, pos)
+            case new_res
+            when DParse::Success
+              new_res.with_best_failure(old_res)
+            when DParse::Failure
+              [old_res, new_res].max_by { |r| r.pos.index }
+            end
+          end
+        end
+      end
+
+      def inspect
+        "alt(#{@parsers.map(&:inspect).join(',')})"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/combinators/repeat.rb

@@ -0,0 +1,42 @@
+module DParse
+  module Parsers
+    class Repeat < DParse::Parser
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def read(input, pos)
+        prev_res = Success.new(input, pos, data: [])
+        best_failure = nil
+
+        loop do
+          new_res = @parser.read(input, prev_res.pos)
+          best_failure = find_best_failure(best_failure, new_res)
+
+          if prev_res.pos.index == new_res.pos.index
+            return prev_res.with_best_failure(best_failure)
+          end
+
+          case new_res
+          when Success
+            prev_res = new_res.map { |d| prev_res.data + [d] }
+          else
+            return prev_res.with_best_failure(best_failure)
+          end
+        end
+      end
+
+      def inspect
+        "repeat(#{@parser})"
+      end
+
+      private
+
+      def find_best_failure(*results)
+        results
+          .select { |r| r.is_a?(DParse::Failure) }
+          .max_by { |r| r.pos.index }
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/combinators/seq.rb

@@ -0,0 +1,49 @@
+module DParse
+  module Parsers
+    class Seq < DParse::Parser
+      attr_reader :parsers
+
+      def initialize(*parsers)
+        @parsers = parsers
+      end
+
+      def read(input, pos)
+        @parsers.reduce(Success.new(input, pos, data: [])) do |res, parser|
+          case res
+          when Success
+            new_res = parser.read(input, res.pos).map { |d| res.data + [d] }
+            with_best_failure(new_res, res)
+          when Failure
+            res
+          end
+        end
+      end
+
+      def inspect
+        "seq(#{@parsers.map(&:inspect).join(',')})"
+      end
+
+      private
+
+      # Returns a Success or Failure that most accurately describes the
+      # failure, meaning the result that has the highest position.
+      def with_best_failure(new_res, res)
+        results = [new_res, res]
+        results += [new_res.best_failure] if new_res.is_a?(Success)
+        results += [res.best_failure] if res.is_a?(Success)
+
+        best_failure =
+          results
+          .select { |r| r.is_a?(DParse::Failure) }
+          .max_by { |r| r.pos.index }
+
+        case new_res
+        when Success
+          new_res.with_best_failure(best_failure)
+        when Failure
+          best_failure
+        end
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/highlevel/char_in.rb

@@ -0,0 +1,13 @@
+module DParse
+  module Parsers
+    class CharIn < DParse::Parser
+      def self.new(chars)
+        DParse::Parsers::Alt.new(*chars.map { |c| DParse::Parsers::Char.new(c) })
+      end
+
+      def initialize(*)
+        raise ArgumentError, "#{self.class} is not supposed to be initialized"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/highlevel/intersperse.rb

@@ -0,0 +1,18 @@
+module DParse
+  module Parsers
+    class Intersperse < DParse::Parser
+      def self.new(a, b)
+        DParse::Parsers::Seq.new(
+          a,
+          DParse::Parsers::Repeat.new(
+            DParse::Parsers::Seq.new(b, a),
+          ).flatten.map { |d| d || [] },
+        ).map { |d| [d[0]] + d[1] }
+      end
+
+      def initialize(*)
+        raise ArgumentError, "#{self.class} is not supposed to be initialized"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/highlevel/json.rb

@@ -0,0 +1,237 @@
+module DParse
+  module Parsers
+    class JSON < DParse::Parser
+      def self.new
+        extend DParse::DSL
+
+        json_value = nil # Undefined for now
+
+        whitespace =
+          repeat(
+            alt(
+              char(' '),
+              char("\t"),
+              char("\r"),
+              char("\n"),
+            ),
+          )
+
+        # String
+
+        json_digit_hex =
+          alt(
+            char_in('0'..'9'),
+            char_in('a'..'f'),
+            char_in('A'..'F'),
+          )
+
+        json_string =
+          seq(
+            char('"').ignore,
+            repeat(
+              alt(
+                char_not_in(%w(" \\ )).capture,
+                seq(
+                  char('\\').ignore,
+                  alt(
+                    char_in(%w(" \\ / b f n r t)).capture,
+                    seq(
+                      char('u').capture,
+                      seq(
+                        json_digit_hex,
+                        json_digit_hex,
+                        json_digit_hex,
+                        json_digit_hex,
+                      ).capture,
+                    ),
+                  ),
+                ).compact,
+              ),
+            ),
+            char('"').ignore,
+          ).compact.first.map do |d, _, _|
+            new_chars =
+              d.map do |char|
+                case char
+                when ::String
+                  char
+                when ::Array
+                  case char[0]
+                  when '"'
+                    '"'
+                  when '\\'
+                    '\\'
+                  when '/'
+                    '/'
+                  when 'b'
+                    "\b"
+                  when 'f'
+                    "\f"
+                  when 'n'
+                    "\n"
+                  when 'r'
+                    "\r"
+                  when 't'
+                    "\t"
+                  else
+                    if char[0].is_a?(Array) && char[0][0] == 'u'
+                      char[0][1].to_i(16).chr(Encoding::UTF_8)
+                    else
+                      raise "Unexpected escape sequence #{char[0].inspect}"
+                    end
+                  end
+                else
+                  raise "??? #{char.inspect} (#{char.class})"
+                end
+              end
+
+            new_chars.join('')
+          end
+
+        # Array
+
+        json_elements =
+          intersperse(
+            lazy { json_value },
+            seq(
+              whitespace,
+              char(','),
+              whitespace,
+            ).ignore,
+          ).compact
+
+        json_array =
+          seq(
+            char('[').ignore,
+            whitespace.ignore,
+            json_elements,
+            whitespace.ignore,
+            char(']').ignore,
+          ).compact.first
+
+        # Misc
+
+        json_true =
+          string('true').map { true }
+
+        json_false =
+          string('false').map { false }
+
+        json_null =
+          string('null').map { nil }
+
+        # Number
+
+        json_digit =
+          char_in('0'..'9')
+
+        json_number =
+          seq(
+            opt(char('-')).capture,
+            alt(
+              char('0'),
+              seq(
+                char_in('1'..'9'),
+                repeat(json_digit),
+              ),
+            ).capture,
+            opt(
+              seq(
+                char('.').ignore,
+                repeat(json_digit).capture,
+              ).compact,
+            ),
+            opt(
+              seq(
+                alt(char('e'), char('E')),
+                alt(char('+'), char('-'), succeed).capture,
+                repeat(json_digit).capture,
+              ).compact,
+            ),
+          ).map do |d, _, _|
+            sign_char          = d[0]
+            digits_before_dot  = d[1]
+            digits_after_dot   = d[2]
+            sci_data           = d[3]
+
+            base =
+              if digits_after_dot
+                [sign_char, digits_before_dot, '.', digits_after_dot].join('').to_f
+              else
+                [sign_char, digits_before_dot].join('').to_i(10)
+              end
+
+            factor =
+              if sci_data
+                sign_char = sci_data[0]
+                exponent  = sci_data[1]
+
+                unsigned_factor = exponent.to_i(10)
+
+                case sign_char
+                when '+', ''
+                  10**unsigned_factor
+                when '-'
+                  - 10**unsigned_factor
+                end
+              else
+                1
+              end
+
+            base * factor
+          end
+
+        # Object
+
+        json_pair =
+          seq(
+            json_string,
+            whitespace.ignore,
+            char(':').ignore,
+            whitespace.ignore,
+            lazy { json_value },
+          ).compact
+
+        json_pairs =
+          intersperse(
+            json_pair,
+            seq(
+              whitespace,
+              char(','),
+              whitespace,
+            ).ignore,
+          ).compact.map { |d| Hash[d] }
+
+        json_object =
+          seq(
+            char('{').ignore,
+            whitespace.ignore,
+            json_pairs,
+            whitespace.ignore,
+            char('}').ignore,
+          ).compact.first
+
+        # Value
+
+        json_value =
+          alt(
+            json_string,
+            json_number,
+            json_object,
+            json_array,
+            json_true,
+            json_false,
+            json_null,
+          )
+
+        # All
+
+        json_object
+      end
+
+      def initialize(*)
+        raise ArgumentError, "#{self.class} is not supposed to be initialized"
+      end
+    end
+  end
+end