radd_djur 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 81c593af1a6b8fa7adbc48d74bd12a0d452cc3b8
+  data.tar.gz: 9c2d118ba3047f06b2745f69e73ea1f3b777a2d3
+SHA512:
+  metadata.gz: e665757f618377aeff4b7556fb0ed3c6d77f1e290701f82280c9768e69e481e7f0d0031b71d2cc2dd5b93f546b31e6a84322c0fdbe86be0ed893cab2ac907a7c
+  data.tar.gz: 1ef6ebb0611545820d957cd29c2c309504942238fab8fdfce57afd459848f6edc9d4dbab5e50f14b7d183c6bcf601398ae85ee85a8ba13389556d0f09f32a0eb

data/README.md

@@ -0,0 +1,101 @@
+radd\_djur - Packrat parser combinator library for Ruby
+=======================================================
+
+This project aims to provide immutable data structures for Ruby.
+
+Install
+-------
+
+```bash
+$ gem install radd_djur
+```
+
+Documentation
+-------------
+
+* [API Reference](http://rubydoc.info/github/shugo/radd_djur/frames)
+
+Example
+-------
+
+    require "radd_djur"
+
+    # Activate refinements for radd_djur DSL.
+    # In the DSL, a Ruby symbol represents a nonterminal symbol, and a Ruby
+    # string represents a terminal symbol.
+    using RaddDjur::DSL
+
+    # Define a new grammar, whose start symbol is additive.
+    g = RaddDjur::Grammar.new(:additive) {
+
+      # Grammar#define defines a new parsing rule for a nonterminal symbol.
+      # The first argument is the name of the nonterminal symbol.
+      # In the following comments, parsing rules are expressed in PEG.
+
+      # additive <- multitive '+' additive / multitive
+      define :additive do
+        :multitive.bind { |x|
+          "+".bind {
+            :additive.bind { |y|
+              ret x + y
+            }
+          }
+        } / :multitive
+      end
+
+      # multitive <- primary '*' multitive / primary
+      define :multitive do
+        :primary.bind { |x|
+          "*".bind {
+            :multitive.bind { |y|
+              ret x * y
+            }
+          }
+        } / :primary
+      end
+
+      # primary <- '(' additive ')' / digits
+      define :primary do
+        "(".bind {
+          :additive.bind { |x|
+            ")".bind {
+              ret x
+            }
+          }
+        } / :digits
+      end
+
+      # digits <- [0-9]+
+      define :digits do
+        (?0..?9).one_or_more.bind { |xs|
+          ret xs.foldl1(&:+).to_i
+        }
+      end
+    }
+    p g.parse("2*(3+4)")
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2013 Shugo Maeda
+
+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/lib/radd_djur/dsl.rb

@@ -0,0 +1,53 @@
+module RaddDjur
+  module DSL
+    refine Object do
+      def bind(&block)
+        to_parser.bind(&block)
+      end
+
+      def /(p2)
+        to_parser / p2
+      end
+
+      def optional
+        to_parser.optional
+      end
+
+      def zero_or_more
+        to_parser.zero_or_more
+      end
+
+      def one_or_more
+        to_parser.one_or_more
+      end
+
+      def to_parser
+        raise TypeError, "#{self.class} can't be converted to a Parser"
+      end
+    end
+
+    refine Symbol do
+      def to_parser
+        Grammar::Parser.new(&self)
+      end
+    end
+
+    refine String do
+      def to_parser
+        Grammar::Parsers.string(self)
+      end
+    end
+
+    refine Range do
+      def to_parser
+        Grammar::Parsers.any_char.bind { |c|
+          if self.cover?(c)
+            Grammar::Parsers.ret(c)
+          else
+            Grammar::Parsers.fail
+          end
+        }
+      end
+    end
+  end
+end

data/lib/radd_djur/grammar.rb

@@ -0,0 +1,191 @@
+require "immutable"
+require "radd_djur/dsl"
+
+using RaddDjur::DSL
+
+module RaddDjur
+  class Grammar
+    class Result
+    end
+
+    class Parsed < Result
+      attr_reader :value, :remainder
+
+      def initialize(value, remainder)
+        @value = value
+        @remainder = remainder
+      end
+
+      def succeeded?
+        true
+      end
+    end
+
+    NO_PARSE = Result.new
+
+    def NO_PARSE.succeeded?
+      false
+    end
+
+    class ParseError < StandardError; end
+
+    class Derivs
+      include Immutable
+
+      def initialize(grammar, str)
+        @grammar = grammar
+        @str = str
+        @memo = {}
+      end
+
+      def char
+        @memo[:char] ||=
+          Promise.delay {
+            if @str.empty?
+              NO_PARSE
+            else
+              Parsed.new(@str[0], Derivs.new(@grammar, @str[1..-1]))
+            end
+          }
+      end
+
+      def method_missing(mid, *args)
+        @memo[mid] ||= @grammar.parser(mid).parse(self)
+      end
+    end
+
+    module Parsers
+      include Immutable
+
+      module_function
+
+      def ret(value)
+        Parser.new { |d|
+          Promise.eager(Parsed.new(value, d))
+        }
+      end
+
+      def fail
+        Parser.new { |d|
+          Promise.eager(NO_PARSE)
+        }
+      end
+
+      def any_char
+        Parser.new(&:char)
+      end
+
+      def char(ch)
+        any_char.bind { |c|
+          if c == ch
+            ret c
+          else
+            fail
+          end
+        }
+      end
+
+      def string(str)
+        if str.empty?
+          ret ""
+        else
+          char(str[0]).bind { |c|
+            string(str[1..-1]).bind { |s|
+              ret c + s
+            }
+          }
+        end
+      end
+    end
+
+    class Parser
+      include Immutable
+      include Parsers
+
+      def initialize(&block)
+        @block = block
+      end
+
+      def to_parser
+        self
+      end
+
+      def parse(d)
+        @block.call(d)
+      end
+
+      def bind(&f2)
+        p1 = self
+        Parser.new { |d|
+          Promise.lazy {
+            result = p1.parse(d).force
+            if result.succeeded?
+              p2 = f2.call(result.value)
+              p2.to_parser.parse(result.remainder)
+            else
+              Promise.eager(NO_PARSE)
+            end
+          }
+        }
+      end
+
+      def /(p2)
+        p1 = self
+        Parser.new { |d|
+          Promise.lazy {
+            result = p1.parse(d).force
+            if result.succeeded?
+              Promise.eager(result)
+            else
+              p2.to_parser.parse(d)
+            end
+          }
+        }
+      end
+
+      def optional
+        self / ret(nil)
+      end
+
+      def zero_or_more
+        one_or_more / ret(List.empty)
+      end
+
+      def one_or_more
+        bind { |x|
+          zero_or_more.bind { |xs|
+            ret xs.cons(x)
+          }
+        }
+      end
+    end
+
+    include Parsers
+
+    def initialize(start_symbol, &block)
+      @parsers = {}
+      @start_symbol = start_symbol
+      instance_exec(&block) if block
+    end
+
+    def parse(str)
+      result = Derivs.new(self, str).send(@start_symbol).force
+      if !result.succeeded?
+        raise ParseError, "parse error"
+      end
+      result.value
+    end
+
+    def define(sym, parser = yield)
+      @parsers[sym] = parser.to_parser
+    end
+
+    def parser(sym)
+      @parsers[sym]
+    end
+
+    def method_missing(mid, *args)
+      Parser.new(&mid)
+    end
+  end
+end

data/lib/radd_djur.rb

@@ -0,0 +1,20 @@
+def with_tailcall_optimization
+  if defined?(RubyVM)
+    old_option = RubyVM::InstructionSequence.compile_option
+    RubyVM::InstructionSequence.compile_option = {
+      trace_instruction: false,
+      tailcall_optimization: true
+    }
+  end
+  begin
+    yield
+  ensure
+    if defined?(RubyVM)
+      RubyVM::InstructionSequence.compile_option = old_option
+    end
+  end
+end
+
+with_tailcall_optimization do
+  require "radd_djur/grammar"
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: radd_djur
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Shugo Maeda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: immutable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.2
+description: 
+email: shugo@ruby-lang.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/radd_djur.rb
+- lib/radd_djur/dsl.rb
+- lib/radd_djur/grammar.rb
+homepage: http://github.com/shugo/radd_djur
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Packrat parser combinator library for Ruby
+test_files: []
+has_rdoc: