d-parse 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2672e347527fd59383d12db21f5a64e1cfe16e5b
+  data.tar.gz: 541544acc6be6004decf009531f9b9b6bdae15b0
+SHA512:
+  metadata.gz: aa5dcb3e12a82314066025d0c0739a64657e29bec485b414bdd705cab39848fcee448c21d811ac046b486a89ab815a958dd5066aa73b3722f2cec22d6050108c
+  data.tar.gz: b6f0b08ce5a15a067e07c98618a8da9c13b3b39828f13af2ab316d37f07be31886e5d275b8a587c1512cb5ea1fa34465ad7bb6a593980a4d161bc6b782c3b928

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'coveralls', require: false
+gem 'guard'
+gem 'guard-rake'
+gem 'rake'
+gem 'rspec'
+gem 'rubocop'

data/Gemfile.lock

@@ -0,0 +1,104 @@
+PATH
+  remote: .
+  specs:
+    d-parse (0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.3.0)
+    coderay (1.1.1)
+    coveralls (0.8.13)
+      json (~> 1.8)
+      simplecov (~> 0.11.0)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
+      tins (~> 1.6.0)
+    diff-lcs (1.2.5)
+    docile (1.1.5)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    guard (2.14.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-rake (1.0.0)
+      guard
+      rake
+    json (1.8.3)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.10)
+    method_source (0.8.2)
+    nenv (0.3.0)
+    notiffany (0.1.0)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parser (2.3.1.2)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rainbow (2.1.0)
+    rake (11.2.2)
+    rb-fsevent (0.9.7)
+    rb-inotify (0.9.7)
+      ffi (>= 0.5.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.0)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    rubocop (0.41.1)
+      parser (>= 2.3.1.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    ruby_dep (1.3.1)
+    shellany (0.0.1)
+    simplecov (0.11.2)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
+    slop (3.6.0)
+    term-ansicolor (1.3.2)
+      tins (~> 1.0)
+    thor (0.19.1)
+    tins (1.6.0)
+    unicode-display_width (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.11.2, < 2.0)
+  coveralls
+  d-parse!
+  guard
+  guard-rake
+  rake
+  rspec
+  rubocop
+
+BUNDLED WITH
+   1.12.5

data/Guardfile

@@ -0,0 +1,3 @@
+guard 'rake', task: 'default' do
+  watch(%r{^(lib|test|spec)/})
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Denis Defreyne and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,137 @@
+[![Build status](http://img.shields.io/travis/ddfreyne/d-parse.svg)](https://travis-ci.org/ddfreyne/d-parse)
+[![Code Climate](http://img.shields.io/codeclimate/github/ddfreyne/d-parse.svg)](https://codeclimate.com/github/ddfreyne/d-parse)
+[![Code Coverage](http://img.shields.io/coveralls/ddfreyne/d-parse.svg)](https://coveralls.io/r/ddfreyne/d-parse)
+
+# D★Parse
+
+_D★Parse_ is a parser combinator library for Ruby.
+
+**STATUS**: Experimental. Pre-alpha. Use at your own risk.
+
+## Example
+
+Here is a parser for a series of numbers:
+
+```ruby
+require 'd-parse'
+
+module Grammar
+  extend DParse::DSL
+
+  DIGIT = char_in('0'..'9')
+
+  ROOT =
+    seq(
+      intersperse(
+        repeat(DIGIT).capture.map { |d| d.to_i(10) },
+        char(',').ignore,
+      ).compact,
+      eof,
+    ).first
+end
+
+res = Grammar::ROOT.apply("1,2,100,582048,07,09")
+case res
+when DParse::Success
+  p res.data
+when DParse::Failure
+  $stderr.puts res.pretty_message
+  exit 1
+end
+```
+
+## Parsers
+
+* `alt(p1, p2, …)` attempts to apply any of the given parsers.
+
+* `any` parses any character.
+
+* `char_in(cs)` parses a character that is in the `cs` collection.
+
+* `char_not_in(cs)` parses a character that is not in the `cs` collection.
+
+* `char_not(c)` parses a character that is not `c`.
+
+* `char(c)` parses the single character `c`.
+
+* `eof` parses the end of file.
+
+* `fail` always fails.
+
+* `describe(p, name)` sets the name of the parser, so that parsing failures of `p` return a failure with message “expected <var>name</var>”.
+
+* `repeat(p)` tries to apply `p` as many times as possible, and never fails.
+
+* `seq(p1, p2, …)` tries to apply the given parsers in sequence.
+
+* `succeed` always succeeds, without advancing the position.
+
+Special modifiers:
+
+* `lazy { p }` references the parser `p`, which might not be defined yet. This is useful for recursive definitions.
+
+* `p.capture` sets the data of the parsing result of `p`, if successful, to the data between the start and the end of the match.
+
+* `p.ignore` sets the data of the parsing result of `p`, if successful, to `nil`. This is particularly useful in combination with `p.compact`.
+
+* `p.map { |data| … }` sets the data of the parsing result of `p`, if successful, to the return value of the block. The block gets the data of the success as an argument.
+
+* `p.first` sets the data of the parsing result of `p`, if successful, to the first element of the data of the success. This only works if the success data is an array.
+
+* `p.second` sets the data of the parsing result of `p`, if successful, to the second element of the data of the success. This only works if the success data is an array.
+
+* `p.select_odd` sets the data of the parsing result of `p`, if successful, to each odd element of the data of the success. This only works if the success data is an array.
+
+* `p.select_even` sets the data of the parsing result of `p`, if successful, to each even element of the data of the success. This only works if the success data is an array.
+
+* `p.compact` sets the data of the parsing result of `p`, if successful, to each non-nil element of the data of the success. This only works if the success data is an array. This is particularly useful in combination with `p.ignore`.
+
+## To do
+
+As mentioned above, this software is in an early state, and still lacks many features. It is not yet a fully functional parser combinator library, but it’ll hopefully get there.
+
+* Add more combinators (e.g. `repeat1`).
+
+* Add support for backtracking, so that `seq(repeat(any), string('donkey'))` can parse `superdonkey`.
+
+* Add failure descriptions to all parsers.
+
+* Allow renaming failures, so that errors can be easier to understand for hoominz.
+
+* Add tests for everything.
+
+* Add documentation.
+
+* Add support for parsing generic token streams, rather than just characters.
+
+## Commit message conventions
+
+As an experiment, I’m going to use commit message conventions slightly adapted from [Angular.js](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md)’s.
+
+```
+<type>(<scope>): <subject>
+<BLANK LINE>
+<body>
+```
+
+The following types are supported:
+
+* `feat` (new feature)
+* `fix` (bug fix)
+* `docs` (documentation)
+* `style` (formatting, …)
+* `refactor`
+* `test` (adding tests)
+* `chore` (maintenance, such as build infrastructure changes)
+
+The following scopes are supported:
+
+* `core`
+* `parsers`
+* `samples`
+
+The following rules apply to the subject:
+
+* Use the imperative, present tense.
+* Do not capitalize the first letter.
+* Do not end the subject with a period.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '-r ./spec/spec_helper.rb --color'
+  t.verbose = false
+end
+
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options  = %w(--display-cop-names --format simple)
+  task.patterns = ['lib/**/*.rb', 'spec/**/*.rb']
+end
+
+task default: [:spec, :rubocop]

data/d-parse.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/d-parse/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'd-parse'
+  s.version     = DParse::VERSION
+  s.homepage    = 'http://rubygems.org/gems/d-parse'
+  s.summary     = 'parser combinator library'
+  s.description = 'D★Parse is a library for building parser combinators.'
+
+  s.author  = 'Denis Defreyne'
+  s.email   = 'denis.defreyne@stoneship.org'
+  s.license = 'MIT'
+
+  s.files =
+    Dir['[A-Z]*'] +
+    Dir['{lib,spec,samples}/**/*'] +
+    ['d-parse.gemspec']
+  s.require_paths = ['lib']
+
+  s.rdoc_options     = ['--main', 'README.md']
+  s.extra_rdoc_files = ['LICENSE', 'README.md', 'NEWS.md']
+
+  s.required_ruby_version = '>= 2.1.0'
+
+  s.add_development_dependency('bundler', '>= 1.11.2', '< 2.0')
+end

data/lib/d-parse.rb

@@ -0,0 +1,10 @@
+module DParse
+end
+
+require_relative 'd-parse/version.rb'
+require_relative 'd-parse/position.rb'
+require_relative 'd-parse/success.rb'
+require_relative 'd-parse/failure.rb'
+require_relative 'd-parse/parser.rb'
+require_relative 'd-parse/parsers.rb'
+require_relative 'd-parse/dsl.rb'

data/lib/d-parse/dsl.rb

@@ -0,0 +1,71 @@
+module DParse
+  module DSL
+    def alt(*ps)
+      DParse::Parsers::Alt.new(*ps)
+    end
+
+    def char(c)
+      DParse::Parsers::Char.new(c)
+    end
+
+    def char_in(cs)
+      DParse::Parsers::CharIn.new(cs)
+    end
+
+    def char_not(c)
+      DParse::Parsers::CharNot.new(c)
+    end
+
+    def char_not_in(cs)
+      DParse::Parsers::CharNotIn.new(cs)
+    end
+
+    def eof
+      DParse::Parsers::EOF.new
+    end
+
+    def intersperse(a, b)
+      DParse::Parsers::Intersperse.new(a, b)
+    end
+
+    def except(a, b)
+      DParse::Parsers::Except.new(a, b)
+    end
+
+    def lazy(&block)
+      DParse::Parsers::Lazy.new(&block)
+    end
+
+    def opt(p)
+      DParse::Parsers::Opt.new(p)
+    end
+
+    def describe(p, name)
+      DParse::Parsers::Describe.new(p, name)
+    end
+
+    def repeat(p)
+      DParse::Parsers::Repeat.new(p)
+    end
+
+    def seq(*ps)
+      DParse::Parsers::Seq.new(*ps)
+    end
+
+    def string(s)
+      DParse::Parsers::String.new(s)
+    end
+
+    def fail
+      DParse::Parsers::Fail.new
+    end
+
+    def succeed
+      DParse::Parsers::Succeed.new
+    end
+
+    def whitespace_char
+      DParse::Parsers::WhitespaceChar.new
+    end
+  end
+end

data/lib/d-parse/failure.rb

@@ -0,0 +1,46 @@
+module DParse
+  class Failure
+    attr_reader :input
+    attr_reader :pos
+    attr_reader :origin
+
+    def initialize(input, pos, origin: nil)
+      @input = input
+      @pos = pos
+      @origin = origin
+    end
+
+    def map
+      self
+    end
+
+    def message
+      @_message ||= 'expected ' + (@origin ? @origin.expectation_message : '?')
+    end
+
+    def full_message
+      "#{message} at line #{@pos.line + 1}, column #{@pos.column + 1}"
+    end
+
+    def pretty_message
+      line = (input.lines[@pos.line] || '').rstrip
+      fancy_line = line.chars.map.with_index { |c, i| i == @pos.column ? "\e[31m" + c + "\e[0m" : c }.join
+
+      lines = [full_message, '', fancy_line, "\e[31m" + ' ' * @pos.column + '↑' + "\e[0m"]
+
+      lines.join("\n")
+    end
+
+    def to_s
+      "Failure(#{@pos}; #{message})"
+    end
+
+    def success?
+      false
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end