pegex 0.0.1

data/.gemspec

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+GemSpec = Gem::Specification.new do |gem|
+  gem.name = 'pegex'
+  gem.version = '0.0.1'
+  gem.license = 'MIT'
+  gem.required_ruby_version = '>= 1.9.1'
+
+  gem.authors << 'Ingy döt Net'
+  gem.email = 'ingy@ingy.net'
+  gem.summary = 'Acmeist PEG Parsing Framework'
+  gem.description = <<-'.'
+Pegex is a Acmeist parser framework. It allows you to easily create parsers
+that will work equivalently in lots of programming languages!
+.
+  gem.homepage = 'http://pegex.org'
+
+  gem.files = `git ls-files`.lines.map{|l|l.chomp}
+
+  gem.add_development_dependency 'testml-lite', '>= 0.0.1'
+end

data/CHANGELOG.yaml

@@ -0,0 +1,3 @@
+- version: 0.0.1
+  date:    Wed Dec 19 16:06:49 PST 2012
+  changes: Ported from Pegex.pm CPAN module.

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    pegex (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    testml-lite (0.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pegex!
+  testml-lite (>= 0.0.1)

data/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright © 2012 Ingy döt Net
+
+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 NON-INFRINGEMENT. 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.rdoc

@@ -0,0 +1,78 @@
+= Pegex - Acmeist PEG Parsing Framework
+
+Pegex is a Acmeist parser framework. It allows you to easily create
+parsers that will work equivalently in lots of programming languages!
+
+= Synopsis
+
+    require 'pegex'
+    result = pegex(grammar).parse(input)
+
+or with options:
+
+    require 'pegex'
+    require 'my_receiver_class'
+    parser = pegex(grammar, MyReceiverClass)
+    result = parser.parse(input)
+
+or more explicitly:
+
+    require 'pegex/parser'
+    require 'pegex/grammar'
+    pegex_grammar = Pegex::Grammar.new do |g|
+      g.text = grammar
+    end
+    parser = Pegex::Parser.new do |p|
+      p.grammar = pegex_grammar
+    end
+    result = parser.parse(input)
+
+= Description
+
+Pegex is a Acmeist parser framework. It allows you to easily create parsers
+that will work equivalently in lots of programming languages!
+
+Pegex gets it name by combining Parsing Expression Grammars (PEG), with
+Regular Expessions (Regex). That's actually what Pegex does.
+
+PEG is the cool new way to elegantly specify recursive descent grammars. The
+Perl 6 language is defined in terms of a self modifying PEG language called
+*Perl 6 Rules*. Regexes are familiar to programmers of most modern
+programming languages. Pegex defines a simple PEG syntax, where all the
+terminals are regexes. This means that Pegex can be quite fast and powerful.
+
+Pegex attempts to be the simplest way to define new (or old) Domain Specific
+Languages (DSLs) that need to be used in several programming languages and
+environments.
+
+= Usage
+
+The +pegex.rb+ module itself is just a trivial way to use the
+Pegex framework. It is only intended for the simplest of uses.
+
++pegex.rb+ defines a single function, +pegex+, which takes a Pegex grammar
+string as input. You may also pass in a receiver class or object.
+
+    parser = pegex(grammar, MyReceiver)
+
+The +pegex+ function returns a Pegex::Parser object, on which you would
+typically call the +parse()+ method, which (on success) will return a data
+structure of the parsed data.
+
+See Pegex::API for more details.
+
+= Documentation
+
+This Pegex library was ported to Ruby from the Perl module:
+http://search.cpan.org/dist/Pegex/
+
+The code and tests were fully ported from Perl to Ruby. Pegex should work
+exactly the same in both languages. The documentation and examples have not yet
+been fully ported, but they will be soon enough. For now, refer to the Perl
+docs.
+
+You can start here: http://search.cpan.org/dist/Pegex/lib/Pegex.pod
+
+= Copyright
+
+Copyright (c) 2012 Ingy döt Net. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,64 @@
+# Load Gem constants from the gemspec
+GemSpecFile = '.gemspec'
+load GemSpecFile
+GemName = GemSpec.name
+GemVersion = GemSpec.version
+GemDir = "#{GemName}-#{GemVersion}"
+GemFile = "#{GemDir}.gem"
+DevNull = '2>/dev/null'
+
+# Require the Rake libraries
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+
+task :default => 'help'
+
+CLEAN.include GemDir, GemFile, 'data.tar.gz', 'metadata.gz'
+
+desc 'Run the tests'
+task :test do
+  Rake::TestTask.new do |t|
+    t.verbose = true
+    t.test_files = FileList['test/*.rb']
+  end
+end
+
+desc 'Build the gem'
+task :build => [:clean, :test] do
+  sh "gem build #{GemSpecFile}"
+end
+
+desc 'Install the gem'
+task :install => [:build] do
+  sh "gem install #{GemFile}"
+end
+
+desc 'Build, unpack and inspect the gem'
+task :distdir => [:build] do
+  sh "tar xf #{GemFile} #{DevNull}"
+  Dir.mkdir GemDir
+  Dir.chdir GemDir
+  sh "tar xzf ../data.tar.gz #{DevNull}"
+  puts "\n>>> Entering sub-shell for #{GemDir}..."
+  system ENV['SHELL']
+end
+
+desc 'Build and push the gem'
+task :release => [:build] do
+  sh "gem push #{GemFile}"
+end
+
+desc 'Print a description of the gem'
+task :desc do
+  puts "Gem: '#{GemName}' (version #{GemVersion})"
+  puts
+  puts GemSpec.description.gsub /^/, '  '
+end
+
+desc 'List the Rakefile tasks'
+task :help do
+  puts 'The following rake tasks are available:'
+  puts
+  puts `rake -T`.gsub /^/, '  '
+end

data/lib/pegex/compiler.rb

@@ -0,0 +1,91 @@
+require 'pegex/parser'
+require 'pegex/pegex/grammar'
+require 'pegex/pegex/ast'
+require 'pegex/grammar/atoms'
+
+class Pegex::Compiler
+  attr_accessor :tree
+
+  def initialize
+    @tree = {}
+    @_tree = {}
+    @atoms = Pegex::Grammar::Atoms.new.atoms
+  end
+
+  def compile grammar
+    parse grammar
+    combinate
+    native
+    return self
+  end
+
+  def parse input
+    parser = Pegex::Parser.new do |p|
+      p.grammar = Pegex::Pegex::Grammar.new
+      p.receiver = Pegex::Pegex::AST.new
+    end
+
+    @tree = parser.parse input
+
+    return self
+  end
+
+  def combinate rule=nil
+    (rule ||= @tree['+toprule']) or return self
+
+    @tree.keys.grep(/^\+/).each {|k| @_tree[k] = @tree[k]}
+
+    combinate_rule rule
+    @tree = @_tree
+    return self
+  end
+
+  def combinate_rule rule
+    return if @_tree[rule]
+    object = @_tree[rule] = @tree[rule]
+    combinate_object object
+  end
+
+  def combinate_object object
+    if (sub = object['.sep'])
+      combinate_object sub
+    end
+    if object['.rgx']
+      combinate_re object
+    elsif (rule = object['.ref'])
+      if @tree[rule]
+        combinate_rule rule
+      end
+    elsif object['.any']
+      object['.any'].each {|elem| combinate_object elem}
+    elsif object['.all']
+      object['.all'].each {|elem| combinate_object elem}
+    elsif object['.err']
+    else
+      puts "Can't combinate:"
+      XXX object
+    end
+  end
+
+  def combinate_re regex
+    re = regex['.rgx'].clone
+    loop do
+      re.gsub! /(~+)/ do |m|
+        "<ws#{$1.length}>"
+      end
+      re.gsub! /<(\w+)>/ do |m|
+        if @tree[$1]
+          @tree[$1]['.rgx'] or fail "'#{$1}' not defined as a single RE"
+        else
+          @atoms[$1] or fail "'#{$1}' not defined in the grammar"
+        end
+      end
+      break if re == regex['.rgx']
+      regex['.rgx'] = re.clone
+    end
+  end
+
+  def native
+    # TODO
+  end
+end

data/lib/pegex/grammar/atoms.rb

@@ -0,0 +1,96 @@
+class Pegex::Grammar::Atoms
+  attr_accessor :atoms
+
+  def initialize
+    @atoms = {
+      # Default whitespace rules for that use '~'
+      'ws'      => '<WS>',
+      'ws1'     => '<ws>*',
+      'ws2'     => '<ws>+',
+
+      # Special rules
+      'ALWAYS'  => '',
+      'NEVER'   => '(?!)',
+
+      # Basics
+      'ALL'     => '[\s\S]',    # Every char (including newline and space)
+      'ANY'     => '.',         # Any char (except newline)
+      'SPACE'   => '\ ',        # ASCII space char
+      'TAB'     => '\t',        # Horizontal tab
+      'WS'      => '\s',        # Whitespace
+      'NS'      => '\S',        # Not Space
+      'NL'      => '\n',        # Newline
+      'BREAK'   => '\n',        # Line break (more readable alias for NL)
+      'CR'      => '\r',        # Carriage return
+      'EOL'     => '\r?\n',     # Unix/DOS line ending
+      'DOS'     => '\r\n',      # Windows/DOS line ending
+      'EOS'     => '\z',        # End of stream/string/file
+
+      # Common character classes
+      'WORD'    => '\w',
+      'BLANK'   => '[\ \t]',
+      'ALPHA'   => '[a-zA-Z]',
+      'LOWER'   => '[a-z]',
+      'UPPER'   => '[A-Z]',
+      'DIGIT'   => '[0-9]',
+      'OCTAL'   => '[0-7]',
+      'HEX'     => '[0-9a-fA-F]',
+      'ALNUM'   => '[a-zA-Z0-9]',
+      'CONTROL' => '[\x00-\x1f]',
+      'HICHAR'  => '[\x7f-\x{ffff}]',
+
+      # Ranges - for use inside character classes
+      'WORDS'   => '0-9A-Za-z_',
+      'BLANKS'  => '\ \t',
+      'ALPHAS'  => 'a-zA-Z',
+      'LOWERS'  => 'a-z',
+      'UPPERS'  => 'A-Z',
+      'DIGITS'  => '0-9',
+      'OCTALS'  => '0-7',
+      'HEXS'    => '0-9a-fA-F',
+      'ALNUMS'  => 'a-zA-Z0-9',
+      'CONTROLS' => '\x00-\x1f',
+      'HICHARS' => '\x7f-\x{ffff}',
+
+      # Paired punctuation
+      'SINGLE'  => "'",
+      'DOUBLE'  => '"',
+      'GRAVE'   => '`',
+      'LPAREN'  => '\(',
+      'RPAREN'  => '\)',
+      'LCURLY'  => '\{',
+      'RCURLY'  => '\}',
+      'LSQUARE' => '\[',
+      'RSQUARE' => '\]',
+      'LANGLE'  => '<',
+      'RANGLE'  => '>',
+
+      # Other ASCII punctuation
+      'BANG'    => '!',
+      'AT'      => '\@',
+      'HASH'    => '\#',
+      'DOLLAR'  => '\$',
+      'PERCENT' => '%',
+      'CARET'   => '\^',
+      'AMP'     => '&',
+      'STAR'    => '\*',
+      'TILDE'   => '\~',
+      'UNDER'   => '_',
+      'DASH'    => '\-',
+      'PLUS'    => '\+',
+      'EQUAL'   => '=',
+      'PIPE'    => '\|',
+      'BACK'    => '\\\\',
+      'COLON'   => ':',
+      'SEMI'    => ';',
+      'COMMA'   => ',',
+      'DOT'     => '\.',
+      'QMARK'   => '\?',
+      'SLASH'   => '/',
+
+      # Special rules for named control chars
+      'BS'      => '\x08',    # Backspace
+      'FF'      => '\x12',    # Formfeed
+    }
+  end
+end

data/lib/pegex/grammar.rb

@@ -0,0 +1,21 @@
+require 'pegex'
+class Pegex::Grammar
+  attr_accessor :text
+
+  def initialize
+    yield self if block_given?
+    @tree ||= make_tree
+  end
+
+  def tree
+    return @tree if @tree
+    fail "Can't create a #{self.class} grammar. No grammar text" unless @text
+    return @tree = make_tree
+  end
+
+  def make_tree
+    require 'pegex/compiler'
+    return @tree = Pegex::Compiler.new.compile(@text).tree
+  end
+end
+

data/lib/pegex/input.rb

@@ -0,0 +1,41 @@
+require 'pegex'
+
+class Pegex::Input
+  attr_accessor :string
+
+  def initialize
+    @is_eof = false
+    @is_open = false
+    @is_close = false
+    yield self
+  end
+
+  def read
+    buffer = @buffer
+    @buffer = nil
+    @eof = true
+    return buffer
+  end
+
+  def open
+    if defined? @string
+      @buffer = @string
+    else
+      fail "Pegex::Input::open failed. No source to open"
+    end
+    @is_open = true
+  end
+
+  def close
+    fail "Attempted to close an unopen Pegex::Input object" \
+      if @is_close
+    @is_open = false
+    @is_close = true
+    @buffer = nil
+    return self
+  end
+
+  def open?
+    @is_open
+  end
+end