parsby 0.1.0

data/lib/parsby/example/csv_parser.rb

@@ -0,0 +1,41 @@
+require 'parsby'
+
+# This is based on:
+# 
+# RFC 4180: Common Format and MIME Type for Comma-Separated Values (CSV) Files
+module Parsby::Example
+  module CsvParser
+    include Parsby::Combinators
+    extend self
+
+    def parse(io)
+      csv.parse io
+    end
+
+    define_combinator :csv do
+      many(record) < eof
+    end
+
+    define_combinator :record do
+      sep_by(lit(","), cell) < (eol | eof)
+    end
+
+    define_combinator :cell do
+      quoted_cell | non_quoted_cell
+    end
+
+    define_combinator :quoted_cell do
+      non_quote = join(many(any_char.that_fail(lit('"'))))
+      inner = sep_by(lit('""'), non_quote).fmap {|r| r.join '"' }
+      lit('"') > inner < lit('"')
+    end
+
+    define_combinator :non_quoted_cell do
+      join(many(any_char.that_fail(lit(",") | lit("\"") | eol)))
+    end
+
+    define_combinator :eol do
+      lit("\r\n") | lit("\n")
+    end
+  end
+end

data/lib/parsby/example/json_parser.rb

@@ -0,0 +1,92 @@
+require 'parsby'
+
+module Parsby::Example
+  module JsonParser
+    include Parsby::Combinators
+    extend self
+
+    def parse(io)
+      (spaced(value) < eof).parse io
+    end
+
+    define_combinator :value do
+      null | bool | number | string | array | object
+    end
+
+    define_combinator :null do
+      lit("null") > pure(nil)
+    end
+
+    define_combinator :bool do
+      choice(
+        lit("true") > pure(true),
+        lit("false") > pure(false),
+      )
+    end
+
+    # This has been adopted as Parsby::Combinators#fractional_decimal, but
+    # we leave this definition here since this module is supposed to be an
+    # example of using Parsby, and this works well for showing how to use
+    # `group` and `fmap`.
+    define_combinator :number  do
+      sign = lit("-") | lit("+")
+      group(
+        optional(sign),
+        decimal,
+        optional(group(
+          lit("."),
+          decimal,
+        )),
+        optional(group(
+          lit("e") | lit("E"),
+          optional(sign),
+          decimal,
+        )),
+      ).fmap do |(sign, whole, (_, fractional), (_, exponent_sign, exponent))|
+        n = whole
+        n += fractional.to_f / 10 ** fractional.to_s.length if fractional
+        n *= -1 if sign == "-"
+        if exponent
+          e = exponent
+          e *= -1 if exponent_sign == "-"
+          n *= 10 ** e
+        end
+        n
+      end
+    end
+
+    define_combinator :string do
+      between(lit('"'), lit('"'),
+        join(many(choice(
+          any_char.that_fails(lit('"') | lit("\\")),
+          lit("\\") > choice(
+            lit('"'),
+            lit("\\"),
+            lit("/"),
+            lit("f") > pure("\f"),
+            lit("b") > pure("\b"),
+            lit("r") > pure("\r"),
+            lit("n") > pure("\n"),
+            lit("t") > pure("\t"),
+            lit("u") > join(hex_digit * 4).fmap {|s| [s.hex].pack("U") },
+          ),
+        )))
+      )
+    end
+
+    define_combinator :array do
+      between(lit("["), ws > lit("]"), sep_by(lit(","), spaced(lazy { value })))
+    end
+
+    define_combinator :object do
+      between(lit("{"), ws > lit("}"),
+        sep_by(lit(","),
+          spaced(group(
+            string < spaced(lit(":")),
+            lazy { value }
+          )),
+        )
+      ).fmap(&:to_h)
+    end
+  end
+end

data/lib/parsby/example/lisp_parser.rb

@@ -0,0 +1,135 @@
+require "parsby"
+
+module Parsby::Example
+  module LispParser
+    include Parsby::Combinators
+    extend self
+
+    def parse(io)
+      sexp_sequence.parse io
+    end
+
+    define_combinator :sexp_sequence do
+      many(spaced(sexp)) < eof
+    end
+
+    define_combinator :sexp, wrap: false do
+      splicer.start {|m| lazy { choice(m.end(abbrev), m.end(atom), m.end(list)) } }
+    end
+
+    # Add comments to definition of whitespace. whitespace is defined using
+    # whitespace_1, so we cover both with this.
+    define_combinator :whitespace_1 do
+      join(many_1(super() | comment))
+    end
+
+    define_combinator :comment do
+      lit(";") \
+        + join(many(any_char.that_fails(lit("\n")))) \
+        + (lit("\n") | (eof > pure("")))
+    end
+
+    # Parses sexps with abbreviations, like '(foo bar) or `(foo ,bar).
+    define_combinator :abbrev do
+      ~splicer.start do
+        choice(
+          lit("'") > sexp.fmap {|s| [:quote, [s, nil]]},
+          lit("`") > sexp.fmap {|s| [:quasiquote, [s, nil]]},
+          lit(",@") > sexp.fmap {|s| [:"unquote-splicing", [s, nil]]},
+          lit(",") > sexp.fmap {|s| [:unquote, [s, nil]]},
+        )
+      end
+    end
+
+    define_combinator :list do
+      braces = {"(" => ")", "[" => "]"}
+
+      ~splicer.start do |m|
+        m.end(char_in(braces.keys.join)).then do |opening_brace|
+          spaced(list_insides(m)) < m.end(lit(braces[opening_brace]))
+        end
+      end
+    end
+
+    define_combinator :list_insides do |splicing_marker|
+      optional(
+        group(
+          splicing_marker.end(sexp),
+          choice(
+            spaced(splicing_marker.end(lit("."))) > splicing_marker.end(sexp),
+            whitespace > lazy { list_insides(splicing_marker) },
+          ),
+        )
+      )
+    end
+
+    define_combinator :atom do
+      ~choice(number, string, self.nil, symbol)
+    end
+
+    define_combinator :nil, wrap: false do
+      splicer.start { ilit("nil") > pure(nil) }
+    end
+
+    define_combinator :symbol_char do
+      char_in(
+        [
+          *('a'..'z'),
+          *('A'..'Z'),
+          *('0'..'9'),
+          # Got list from R6RS; removed '.' for simplicity.
+          *%w(! $ % & * + - / : < = > ? @ ^ _ ~),
+        ].flatten.join
+      )
+    end
+
+    define_combinator :symbol do
+      ~splicer.start { join(many_1(symbol_char)).fmap(&:to_sym) }
+    end
+
+    define_combinator :hex_digit do
+      char_in(
+        [*("0".."9"), *("a".."f"), *("A".."F")]
+          .flatten
+          .join
+      )
+    end
+
+    define_combinator :escape_sequence do
+      lit("\\") > choice([
+        lit("\"") > pure("\""),
+        lit("n") > pure("\n"),
+        lit("t") > pure("\t"),
+        lit("r") > pure("\r"),
+        lit("x") > (hex_digit * 2)
+          .fmap {|(d1, d2)| (d1 + d2).to_i(16).chr },
+        lit("\\"),
+      ])
+    end
+
+    define_combinator :string do
+      ~splicer.start do
+        between(lit('"'), lit('"'),
+          join(many(choice(
+            any_char.that_fails(lit("\\") | lit('"')),
+            escape_sequence,
+          )))
+        )
+      end
+    end
+
+    define_combinator :number do
+      ~splicer.start do
+        group(
+          optional(lit("-") | lit("+")),
+          decimal,
+          optional(group(lit("."), optional(decimal))),
+        ).fmap do |(sign, whole_part, (_, fractional_part))|
+          n = whole_part
+          n += (fractional_part || 0).to_f / 10 ** fractional_part.to_s.length
+          sign == "-" ? -n : n
+        end
+      end
+    end
+  end
+end

data/lib/parsby/version.rb

@@ -0,0 +1,3 @@
+class Parsby
+  VERSION = "0.1.0"
+end

data/parsby.gemspec

@@ -0,0 +1,42 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "parsby/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "parsby"
+  spec.version       = Parsby::VERSION
+  spec.authors       = ["Jorge Luis Martinez Gomez"]
+  spec.email         = ["jol@jol.dev"]
+
+  spec.summary       = %q{Parser combinator library inspired by Haskell's Parsec}
+  #spec.description   = %q{TODO: Write a longer description or delete this line.}
+  #spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  #if spec.respond_to?(:metadata)
+  #  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  #  #spec.metadata["homepage_uri"] = spec.homepage
+  #  #spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  #else
+  #  raise "RubyGems 2.0 or newer is required to protect against " \
+  #    "public gem pushes."
+  #end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: parsby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jorge Luis Martinez Gomez
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- jol@jol.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/all-methods
+- bin/console
+- bin/methods-with-pending-documentation
+- bin/setup
+- bin/tested-methods
+- bin/vestigial-methods
+- lib/parsby.rb
+- lib/parsby/combinators.rb
+- lib/parsby/example/arithmetic_parser.rb
+- lib/parsby/example/csv_parser.rb
+- lib/parsby/example/json_parser.rb
+- lib/parsby/example/lisp_parser.rb
+- lib/parsby/version.rb
+- parsby.gemspec
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.6.11
+signing_key:
+specification_version: 4
+summary: Parser combinator library inspired by Haskell's Parsec
+test_files: []