d-parse 0.1

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

@@ -0,0 +1,16 @@
+module DParse
+  module Parsers
+    class Opt < DParse::Parser
+      def self.new(parser)
+        DParse::Parsers::Alt.new(
+          parser,
+          DParse::Parsers::Succeed.new,
+        )
+      end
+
+      def initialize(*)
+        raise ArgumentError, "#{self.class} is not supposed to be initialized"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module DParse
+  module Parsers
+    class String < DParse::Parser
+      def self.new(string)
+        DParse::Parsers::Seq.new(*string.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/whitespace_char.rb

@@ -0,0 +1,15 @@
+module DParse
+  module Parsers
+    class WhitespaceChar < DParse::Parser
+      WS = [' ', "\t"].freeze
+
+      def self.new
+        DParse::Parsers::CharIn.new(WS)
+      end
+
+      def initialize(*)
+        raise ArgumentError, "#{self.class} is not supposed to be initialized"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/modifiers/capturing.rb

@@ -0,0 +1,13 @@
+module DParse
+  module Parsers
+    class Capturing < DParse::Parser
+      def self.new(parser)
+        parser.map { |_data, result, old_pos| result.input[old_pos.index...result.pos.index] }
+      end
+
+      def initialize(*)
+        raise ArgumentError, "#{self.class} is not supposed to be initialized"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/modifiers/describe.rb

@@ -0,0 +1,28 @@
+module DParse
+  module Parsers
+    class Describe < DParse::Parser
+      def initialize(parser, name)
+        @parser = parser
+        @name = name
+      end
+
+      def read(input, pos)
+        res = @parser.read(input, pos)
+        case res
+        when DParse::Success
+          res
+        when DParse::Failure
+          Failure.new(res.input, res.pos, origin: self)
+        end
+      end
+
+      def inspect
+        "#{@name}()"
+      end
+
+      def expectation_message
+        @name
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/modifiers/ignore.rb

@@ -0,0 +1,17 @@
+module DParse
+  module Parsers
+    class Ignore < DParse::Parser
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def read(input, pos)
+        @parser.read(input, pos).map { |_| nil }
+      end
+
+      def inspect
+        "ignore(#{@parser.inspect})"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/modifiers/lazy.rb

@@ -0,0 +1,18 @@
+module DParse
+  module Parsers
+    class Lazy < DParse::Parser
+      def initialize(&block)
+        raise ArgumentError, 'Expected block' unless block_given?
+        @block = block
+      end
+
+      def read(input, pos)
+        @block.call.read(input, pos)
+      end
+
+      def inspect
+        'lazy(?)'
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/modifiers/map.rb

@@ -0,0 +1,24 @@
+module DParse
+  module Parsers
+    class Map < DParse::Parser
+      def initialize(parser, &block)
+        @parser = parser
+        @block = block
+      end
+
+      def read(input, pos)
+        res = @parser.read(input, pos)
+        case res
+        when Success
+          Success.new(input, res.pos, data: @block.call(res.data, res, pos), best_failure: res.best_failure)
+        when Failure
+          res
+        end
+      end
+
+      def inspect
+        "map(#{@parser}, <proc>)"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/any.rb

@@ -0,0 +1,22 @@
+module DParse
+  module Parsers
+    class Any < DParse::Parser
+      def read(input, pos)
+        char = input[pos.index]
+        if char
+          Success.new(input, pos.advance(char))
+        else
+          Failure.new(input, pos, origin: self)
+        end
+      end
+
+      def inspect
+        'any()'
+      end
+
+      def expectation_message
+        'any character except end of file'
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/bind.rb

@@ -0,0 +1,25 @@
+module DParse
+  module Parsers
+    class Bind < DParse::Parser
+      def initialize(parser, &block)
+        @parser = parser
+        @block = block
+      end
+
+      def read(input, pos)
+        res = @parser.read(input, pos)
+        case res
+        when Success
+          other_parser = @block.call(res.data)
+          other_parser.read(input, res.pos)
+        when Failure
+          res
+        end
+      end
+
+      def inspect
+        "bind(#{@parser}, <proc>)"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/char.rb

@@ -0,0 +1,27 @@
+module DParse
+  module Parsers
+    class Char < DParse::Parser
+      def initialize(char)
+        raise ArgumentError, 'Expected input to have one char' unless char.length == 1
+        @char = char
+      end
+
+      def read(input, pos)
+        char = input[pos.index]
+        if char == @char
+          Success.new(input, pos.advance(char))
+        else
+          Failure.new(input, pos, origin: self)
+        end
+      end
+
+      def inspect
+        "char(#{@char.inspect})"
+      end
+
+      def expectation_message
+        display(@char)
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/char_not.rb

@@ -0,0 +1,27 @@
+module DParse
+  module Parsers
+    class CharNot < DParse::Parser
+      def initialize(char)
+        raise ArgumentError, 'Expected input to have one char' unless char.length == 1
+        @char = char
+      end
+
+      def read(input, pos)
+        char = input[pos.index]
+        if char != @char && char
+          Success.new(input, pos.advance(char))
+        else
+          Failure.new(input, pos, origin: self)
+        end
+      end
+
+      def inspect
+        "char_not(#{@char.inspect})"
+      end
+
+      def expectation_message
+        "any character not equal to #{display(@char)}"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/char_not_in.rb

@@ -0,0 +1,30 @@
+module DParse
+  module Parsers
+    class CharNotIn < DParse::Parser
+      def initialize(chars)
+        unless chars.all? { |char| char.length == 1 }
+          raise ArgumentError, 'Expected input to have one char'
+        end
+
+        @chars = chars
+      end
+
+      def read(input, pos)
+        char = input[pos.index]
+        if char && @chars.all? { |c| char != c }
+          Success.new(input, pos.advance(char))
+        else
+          Failure.new(input, pos, origin: self)
+        end
+      end
+
+      def inspect
+        "char_not_in(#{@chars.inspect})"
+      end
+
+      def expectation_message
+        "any character not in #{@chars.map { |c| display(c) }.join(', ')}"
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/eof.rb

@@ -0,0 +1,21 @@
+module DParse
+  module Parsers
+    class EOF < DParse::Parser
+      def read(input, pos)
+        if input.size == pos.index
+          Success.new(input, pos)
+        else
+          Failure.new(input, pos, origin: self)
+        end
+      end
+
+      def inspect
+        'eof()'
+      end
+
+      def expectation_message
+        'end of input'
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/except.rb

@@ -0,0 +1,33 @@
+module DParse
+  module Parsers
+    class Except < DParse::Parser
+      def initialize(parser, bad_parser)
+        @parser = parser
+        @bad_parser = bad_parser
+      end
+
+      def read(input, pos)
+        res = @parser.read(input, pos)
+        case res
+        when Success
+          bad_res = @bad_parser.read(input, pos)
+          if bad_res.is_a?(Success) && bad_res.pos.index == res.pos.index
+            Failure.new(input, pos, origin: self)
+          else
+            res
+          end
+        when Failure
+          res
+        end
+      end
+
+      def inspect
+        "except(#{@parser.inspect}, #{@bad_parser.inspect})"
+      end
+
+      def expectation_message
+        @parser.expectation_message + ', not ' + @bad_parser.expectation_message
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/fail.rb

@@ -0,0 +1,17 @@
+module DParse
+  module Parsers
+    class Fail < DParse::Parser
+      def read(input, pos)
+        Failure.new(input, pos, origin: self)
+      end
+
+      def inspect
+        'fail()'
+      end
+
+      def expectation_message
+        'nothing (always fail)'
+      end
+    end
+  end
+end

data/lib/d-parse/parsers/primitives/succeed.rb

@@ -0,0 +1,13 @@
+module DParse
+  module Parsers
+    class Succeed < DParse::Parser
+      def read(input, pos)
+        Success.new(input, pos)
+      end
+
+      def inspect
+        'succeed()'
+      end
+    end
+  end
+end

data/lib/d-parse/position.rb

@@ -0,0 +1,31 @@
+module DParse
+  class Position
+    attr_reader :index
+    attr_reader :line
+    attr_reader :column
+
+    def initialize(index: 0, line: 0, column: 0)
+      @index = index
+      @line = line
+      @column = column
+    end
+
+    FAR_BEHIND = new(index: -1, line: -1, column: -1)
+
+    def advance(char)
+      Position.new(
+        index: @index + 1,
+        line: char == "\n" ? @line + 1 : @line,
+        column: char == "\n" ? 0 : @column + 1,
+      )
+    end
+
+    def to_s
+      "line #{@line + 1}, column #{@column + 1}"
+    end
+
+    def inspect
+      "Pos(#{@index}; #{@line}:#{@column})"
+    end
+  end
+end

data/lib/d-parse/success.rb

@@ -0,0 +1,35 @@
+module DParse
+  class Success
+    attr_reader :input
+    attr_reader :pos
+    attr_reader :data
+    attr_reader :best_failure
+
+    def initialize(input, pos, data: nil, best_failure: nil)
+      @input = input
+      @pos = pos
+      @data = data
+      @best_failure = best_failure
+    end
+
+    def map
+      self.class.new(@input, @pos, data: yield(@data), best_failure: @best_failure)
+    end
+
+    def with_best_failure(failure)
+      self.class.new(@input, @pos, data: @data, best_failure: failure)
+    end
+
+    def to_s
+      "Success(#{@pos}; #{@data}#{@best_failure ? '; best failure = ' + best_failure.inspect : ''})"
+    end
+
+    def success?
+      true
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end