rdparser 0.1.1

data/.gitignore

@@ -0,0 +1,7 @@
+.bundle/
+coverage/
+files/
+test_files/
+Gemfile.lock
+.yardoc/
+pkg/

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@rdparser --create

data/Gemfile

@@ -0,0 +1,2 @@
+source :gemcutter
+gemspec

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rake'
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+
+require 'rake/packagetask'
+require 'rubygems/package_task'
+
+RDPARSER_GEMSPEC = eval(File.read(File.expand_path("../rdparser.gemspec", __FILE__)))
+
+desc 'Default: run specs'
+task :default => 'spec'
+
+namespace :spec do
+  desc 'Run all specs in spec directory (format=progress)'
+  RSpec::Core::RakeTask.new(:progress) do |t|
+    t.pattern = './spec/**/*_spec.rb'
+    t.rspec_opts = ['--color', '--format=progress']
+  end
+
+  desc 'Run all specs in spec directory (format=documentation)'
+  RSpec::Core::RakeTask.new(:documentation) do |t|
+    t.pattern = './spec/**/*_spec.rb'
+    t.rspec_opts = ['--color', '--format=documentation']
+  end
+end
+
+task :spec => 'spec:progress'
+
+desc 'Generate documentation for the a4-core plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RDParser'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--charset=UTF-8'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Gem::PackageTask.new(RDPARSER_GEMSPEC) do |p|
+  p.gem_spec = RDPARSER_GEMSPEC
+end

data/lib/patches/array.rb

@@ -0,0 +1,10 @@
+# Provide Array with method that appends hashes, but concatenates arrays
+module RDParser
+  module ArrayExtensions
+    def append_or_blend(i)
+      i.class == Hash ? self << i : self.concat(i)
+    end
+  end
+end
+
+Array.send :include, RDParser::ArrayExtensions

data/lib/rdparser.rb

@@ -0,0 +1,12 @@
+require 'strscan'
+require File.expand_path('../patches/array.rb', __FILE__)
+
+# A Simple Recursive Descending (LL) Parser for Ruby
+module RDParser
+  require File.expand_path('../rdparser/exceptions.rb', __FILE__)
+  autoload :RDParser, File.expand_path('../rdparser/rdparser.rb', __FILE__)
+  autoload :Scanner,  File.expand_path('../rdparser/scanner.rb', __FILE__)
+
+  # change to true to get flooded with debug messages during parsing
+  DEBUG = false
+end

data/lib/rdparser/exceptions.rb

@@ -0,0 +1,4 @@
+module RDParser
+  # raised when Parser cannot get through the entire string.
+  class ParserError < StandardError; end
+end

data/lib/rdparser/rdparser.rb

@@ -0,0 +1,195 @@
+class RDParser::RDParser
+  # Class used to accept Ruby metafoo when specifying grammars with a block and virtual methods
+  class GenericBlockToHashCreator; def method_missing(m, *args); @h ||= {}; @h[m] = args.first; @h; end; end
+
+  # Creates a parser based on a certain grammar provided either as a hash or as
+  # methods within a block (that then uses GrammarCreator)
+  def initialize(grammar = '')
+    @grammar = grammar == '' ? yield(GenericBlockToHashCreator.new) : grammar.dup
+  end
+
+  # Parse content using the parser object's grammar set
+  def parse(rule, content, options = {})
+    # @depth is used to make debugging output look nice and nested
+    @depth = -1
+
+    # Create a string scanner object based on the content
+    @content = RDParser::Scanner.new(content, :slurp_whitespace => !options[:manual_whitespace])
+
+    # Kick off the show by parsing from the rule specified
+    result = parse_section(rule.to_sym).flatten
+
+    # Raises ParserError when cannot get parse the entire content and :partial is not set.
+    raise ParserError, %{Cannot parse the entire content! (error was on position ##{@content.position}: "#{content[0...@content.position]}|#{content[@content.position..@content.position]}|#{content[@content.position+1..-1]}")} unless options[:partial] == true or @content.eos?
+
+    result
+  end
+
+  # Parse the content based on the rulesets for a particular grammar context
+  def parse_section(rule)
+    # Increase the depth of parsing - used for debug messages currently
+    @depth += 1
+
+    # For each distinct set of rules within a ruleset, get parsing..
+    sub_rulesets(rule).each do |ruleset|
+      RDParser::DEBUG && debug_message("RULE SET : #{ruleset}")
+
+      # By default, we assume failure!
+      success = false
+      output = []
+
+      # Keep a local copy of the current position to roll back to if things get hairy..
+      was_position = @content.position            
+
+      # Go through each rule in this ruleset
+      sub_rules(ruleset).each do |r|
+        RDParser::DEBUG && debug_message("Running rule '#{r}' against '#{@content.lookahead}'")
+        suboutput = []
+
+        # Match a rule with 1 or more occurrences (e.g. "rule(s)") 
+        if r =~ /(\w+)(\(s\))$/
+          r = $1
+
+          # Force the first occurrence to succeed or break this sub-ruleset
+          unless result = match_for_rule(r.to_sym)
+            success = false
+            break
+          end
+
+          suboutput.append_or_blend result
+
+          # Now pick up any of the "or more" occurrences for free
+          while result = match_for_rule(r.to_sym)
+            suboutput.append_or_blend result
+          end
+
+          # Match a rule with 0 or more occurrences (e.g. "rule(s?)")
+        elsif r =~ /(\w+)(\(s\?\))$/
+          r = $1
+          while result = match_for_rule(r.to_sym)
+            suboutput.append_or_blend result
+          end
+
+          # Match a rule with 0 or 1 occurrences (e.g. "rules(?)")
+        elsif r =~ /(\w+)(\(\?\))$/
+          r = $1
+          if result = match_for_rule(r.to_sym)
+            suboutput.append_or_blend result
+          end
+
+          # Match a rule that has one single occurrence
+        else
+          unless result = match_for_rule(r.to_sym)
+            success = false
+            break
+          end
+
+          suboutput.append_or_blend result
+        end
+
+        success = true
+
+        # Append the output from this rule to the output we'll use later..
+        output += suboutput 
+      end
+
+      # We've either processed all the rules for this ruleset, or.. it failed      
+      if success
+        RDParser::DEBUG && debug_message("Success of all rules in #{ruleset}")
+
+        # No need to check any more rulesets! We've just passed one,
+        # so drop the depth a notch, we're headed back up the tree of recursion!
+        @depth -= 1
+        RDParser::DEBUG && debug_message("SUCCEED: #{ruleset}", :passback)
+        return output
+      else
+        RDParser::DEBUG && debug_message("failed #{ruleset}.. moving on")
+
+        # If the rule set failed, revert the position back to that we stored earlier
+        @content.rollback_to(was_position)
+
+        # And clean the output.. because any output we got from a broken rule is as useful
+        # as an ashtray on a motorbike, a chocolate teapot, or ice cutlery.
+        RDParser::DEBUG && debug_message("FAIL: #{ruleset}", :passback)
+      end
+    end
+
+    # Well nothing passed, so this rule was totally bogus. Great. We've totally wasted our time.
+    @depth -= 1
+    return false
+  end
+
+  # Parse the content based on a single subrule
+  def match_for_rule(rule)
+    RDParser::DEBUG && debug_message("TRYING #{rule}")
+    output = []
+    rule_data = @grammar[rule]
+
+    # If the rule is a string literal "likethis" then match it
+    if rule.to_s =~ /^\"(.+)\"$/
+      m = $1
+      if @content.scan(m)
+        RDParser::DEBUG && debug_message("GOT #{m}")
+        output << {rule => m}
+      else
+        return false
+      end
+
+      # Is the rule a regular expression?
+    elsif rule_data.class == Regexp
+      # If we get a match.. do stuff!
+      if c = @content.scan(rule_data)
+        RDParser::DEBUG && debug_message("GOT IT --> #{c}")
+        output << {rule => c}
+      else
+        # If we get no match, go and cry to mommy^H^H^H^H^Hhead up the recursion ladder
+        return false
+      end
+
+      # Is the rule a string of other rules?
+    elsif rule_data.class == String
+      # A RULE THAT HAS RULES?? RECURSION IN THE HOUSE!
+      response = parse_section(rule)
+
+      # But did it really work out as planned?
+      if response
+        # Yes.. so celebrate and process the response.
+        RDParser::DEBUG && debug_message("GOT #{rule}")
+        return {rule => response}
+      else
+        # No.. so throw a hissyfit
+        RDParser::DEBUG && debug_message("NOT GOT #{rule}")
+        return false
+      end
+    end    
+    output
+  end
+
+  # Splits a ruleset into its constituent rules or matches by whitespace
+  def sub_rules(ruleset); ruleset.split(/\s+/); end
+
+  # Extracts all rulesets from a single rule
+  # e.g. 'rule1 rule2 | rule3 | rule4 rule 5' is three rule sets separated by bars
+  def sub_rulesets(rule); @grammar[rule].split(/\s+\|\s+/); end
+
+  # A 'pretty printer' for RDParser's syntax trees (pp just doesn't cut it for these beasties)
+  # There's probably a nice iterative way of doing this but I'm tired.
+  def RDParser.text_syntax_tree(v, depth = 0, output = '')
+    if v.class == Array
+      v.each { |a| output = text_syntax_tree(a, depth, output) }
+    elsif v.class == Hash
+      v.each do |a, b|
+        output += ("  " * depth) + a.to_s
+        b.class == String ? output += " => #{b}\n" : output = text_syntax_tree(b, depth + 1, output + "\n")
+      end
+    end
+    output
+  end  
+
+  # Prints a debugging message if debug mode is enabled
+  def debug_message(message, priority = true)
+    # Let's different types of message through
+    return if priority != RDParser::DEBUG
+    puts "#{("  " * @depth.to_i) if @depth && @depth > -1 } #{message}"
+  end
+end

data/lib/rdparser/scanner.rb

@@ -0,0 +1,56 @@
+# Attached class below for simplicity of transfer at the moment.. but this should really be
+# separated.
+
+# Scanner is basically a proxy class for StringScanner that adds some convenience features.
+# Could probably be a subclass actually, but this was a quick, scrappy job so I could get
+# onto the fun stuff in RDParser!
+class RDParser::Scanner
+  def initialize(string, options = {})
+    @options = options
+    @scanner = StringScanner.new(string.dup)
+    @rollback_pointers = []
+  end
+
+  def position
+    @scanner.pos
+  end
+
+  def eos?
+    @scanner.eos?
+  end
+
+  def rollback_position
+    @rollback_pointers.last
+  end
+
+  def lookahead
+    @scanner.peek(10)
+  end
+
+  def scan(regexp)
+    space = @options[:slurp_whitespace] && @options[:slurp_whitespace] == true ? /\s*/ : //
+      if regexp.class == String
+        regexp = Regexp.new(regexp.gsub(/\(|\)|\+|\|/) { |a| '\\' + a })
+      end
+    if match = @scanner.scan(/(#{space}(#{regexp}))/)
+      @rollback_pointers << (@scanner.pos - match.length)
+      @options[:slurp_whitespace] && @options[:slurp_whitespace] == true ? match.sub(/^\s*/, '') : match
+    else
+      nil
+    end
+  end
+
+  def rollback
+    begin
+      (@scanner.pos = @rollback_pointers.pop) && true
+    rescue
+      nil
+    end
+  end
+
+  def rollback_to(posi)
+    @scanner.pos = posi
+    @rollback_pointers.delete_if { |p| p >= posi }
+  end
+end
+

data/lib/rdparser/version.rb

@@ -0,0 +1,3 @@
+module RDParser
+  VERSION = "0.1.1"
+end

data/rdparser.gemspec

@@ -0,0 +1,27 @@
+require File.expand_path("../lib/rdparser/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name              = "rdparser"
+  s.version           = RDParser::VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.authors           = ["Peter Cooper", "Bence Golda"]
+  s.email             = ["golda@bitandpixel.hu"]
+  s.homepage          = "http://www.rubyinside.com/recursive-descent-parser-for-ruby-300.html"
+  s.summary           = "rdparser-#{RDParser::VERSION}"
+  s.description       = "A Simple Recursive Descending (LL) Parser for Ruby"
+  s.rubyforge_project = "rdparser"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "spork"
+  s.add_development_dependency "watchr"
+
+  s.files             = `git ls-files`.split("\n")
+  s.executables       = `git ls-files`.split("\n").select{|f| f =~ /^bin/}
+  #s.extra_rdoc_files  = [ "README.markdown" ]
+  s.rdoc_options      = ["--charset=UTF-8"]
+  s.require_path      = 'lib'
+end
+

data/spec/examples/a4_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../../support/spec_helper', __FILE__)
+
+describe 'A4::Authorization::Parser' do
+  include ParserHelper
+
+  parser do |p|
+    p.expression    'expression_u binary expression | expression_u'
+    p.expression_u  'unary expression_u | "(" expression ")" | role'
+    p.binary        /and|or/
+    p.unary         /not/
+    p.role          'role_name preposition instance_name | role_name preposition class_name | role_name'
+    p.preposition   /of|on|in|at|for|to/
+    p.instance_name /:[a-z][a-zA-Z0-9]*/
+    p.class_name    /[A-Z][a-zA-Z0-9:]*/
+    p.role_name     /[a-z][-_a-zA-Z0-9]*/
+  end
+
+  it { should parse("role") }
+  it { should parse("role1") }
+  it { should parse("role1 and role2") }
+  it { should parse("role1 or role2") }
+  it { should parse("(role)") }
+  it { should parse("(role1) and (role2) or (role3)") }
+  it { should parse("(role1 and role2) or (role3)") }
+  it { should parse("reader of Klass") }
+  it { should parse("reader of :instance") }
+  it { should parse("admin or reader of Post or (writer of :instance and guest)") }
+  it { should parse("role-with-dashes") }
+  it { should parse("role_with_underscores") }
+
+end
+

data/spec/support/parser_helper.rb

@@ -0,0 +1,28 @@
+module ParserHelper
+  def self.included base
+    base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
+    base.send :include, const_get("InstanceMethods") if const_defined?("InstanceMethods")
+  end
+
+  module ClassMethods
+    def parser &block
+      subject { RDParser::RDParser.new(&block) }
+    end
+  end
+
+  module InstanceMethods
+    def parse expression, root=:expression
+      class << (o=Object.new)
+        def description
+          %{should parse "#{@_expression}" starting with :#{@_root}}
+        end
+        def matches? parser
+          parser.parse(@_root, @_expression).kind_of?(Array)
+        end
+      end
+      o.instance_variable_set('@_expression', expression)
+      o.instance_variable_set('@_root', root)
+      o
+    end
+  end
+end

data/spec/support/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'simplecov'
+SimpleCov.start
+
+require 'rspec'
+require File.expand_path('../../../lib/rdparser.rb', __FILE__)
+
+Dir[File.expand_path('../**/*.rb', __FILE__)].each {|f| require f}
+
+RSpec.configure do |config|
+  config.alias_it_should_behave_like_to(:it_should_behave_like, '')
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
+end
+

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: rdparser
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Peter Cooper
+- Bence Golda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-17 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &15362520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15362520
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &15362100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15362100
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &15361680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15361680
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &15361260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15361260
+- !ruby/object:Gem::Dependency
+  name: spork
+  requirement: &15360840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15360840
+- !ruby/object:Gem::Dependency
+  name: watchr
+  requirement: &15360420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15360420
+description: A Simple Recursive Descending (LL) Parser for Ruby
+email:
+- golda@bitandpixel.hu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Rakefile
+- lib/patches/array.rb
+- lib/rdparser.rb
+- lib/rdparser/exceptions.rb
+- lib/rdparser/rdparser.rb
+- lib/rdparser/scanner.rb
+- lib/rdparser/version.rb
+- rdparser.gemspec
+- spec/examples/a4_spec.rb
+- spec/support/parser_helper.rb
+- spec/support/spec_helper.rb
+homepage: http://www.rubyinside.com/recursive-descent-parser-for-ruby-300.html
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2323939059109042522
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2323939059109042522
+requirements: []
+rubyforge_project: rdparser
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: rdparser-0.1.1
+test_files: []