rip-parser 0.1.0

data/spec/fixtures/syntax_sample.rip

@@ -0,0 +1,96 @@
+# start with a comment
+
+import "something"
+import(:other)
+
+answers = [ 42, +42, -42 ]; deserts = [ 3.14, +3.14, -3.14 ]
+
+CAT = System.String.upper_case(:cat)
+
+# heredoc
+<<FOO
+
+multi-line
+
+\ttry one today!
+
+FOO
+
+
+/reg-ex/
+
+
+[
+	`v,
+	`\n,
+	`\u0123
+]
+
+
+please-dont-ever-do-this = (((((foo).bar()).baz)))
+
+factorial = (n, m = 0) -> {
+	if (n.==(0)) {
+		m
+	} else {
+		self(n.-(1), n.+(m))
+	}
+}
+
+answer = 42
+super-answer = factorial(answer)
+
+:range: 0..9.map
+
+map = { :answer: 42 }
+
+=> { -> { 42 } }
+-> { :cat }
+
+lambda = => {
+	(x) -> { x }
+}
+
+overload = (n) -> {
+	lambda(n)
+}
+
+Person = class {
+	aaa = 3.14
+
+	self.bbb = ~> {
+		@.aaa
+	}
+
+	@.ccc = -> {
+		@.name
+	}
+
+	@.initialize = => {
+		(name<String>) -> {
+			@.name = name
+		}
+	}
+
+	Nested = class { }
+}
+
+System = class {
+	String = import "./string"
+}
+
+"a#{b.c}d"
+/a#{b.c}d/
+
+rip_initial_commit = 2012-02-12T00:24:00-0500
+
+lunch-time = 12:30:00.today()
+
+space = 100_000km
+mariana = -10_994km
+
+foo()
+list[42]
+a.b.c
+
+1.a.+(2.b).-(3.c).*(4.d)

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'pry'
+
+require_relative '../source/rip-parser'
+
+pattern = Pathname.new(__dir__).join('support/**/*.rb')
+Pathname.glob(pattern).each(&method(:require))
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus => true
+  config.filter_run_excluding :blur => true
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.order = 'random'
+
+  config.color = true
+end

data/spec/support/helpers.rb

@@ -0,0 +1,57 @@
+module RSpecHelpers
+  def profile_parslet(rip, parslet = :lines)
+    binding.pry
+
+    result = RubyProf.profile do
+      parser(rip).send(parslet).parse_tree
+    end
+
+    result.eliminate_methods!([
+      /Array/,
+      /Class/,
+      /Enumerable/,
+      /Fixnum/,
+      /Hash/,
+      /Kernel/,
+      /Module/,
+      /Object/,
+      /Proc/,
+      /Regexp/,
+      /String/,
+      /Symbol/
+    ])
+
+    tree = RubyProf::CallInfoPrinter.new(result)
+    tree.print(STDOUT)
+  end
+
+  def location_for(options = {})
+    origin = options[:origin] || Pathname.pwd
+    offset = options[:offset] || 0
+    line = options[:line] || 1
+    column = options[:column] || 1
+    Rip::Parser::Location.new(origin, offset, line, column)
+  end
+
+  # http://apidock.com/rails/String/strip_heredoc
+  def strip_heredoc(string)
+    indent = string.scan(/^[ \t]*(?=\S)/).min.size
+    string.gsub(/^[ \t]{#{indent}}/, '')
+  end
+
+  def clean_inspect(ast)
+    ast.inspect
+      .gsub(/@\d+/, '')
+      .gsub('\\"', '\'')
+      .gsub(/:0x[0-9a-f]+/, '')
+      .gsub('Rip::Nodes::', '')
+      .gsub('Rip::Utilities::Location ', '')
+      .gsub(/ @location=\#\<([^>]+)>/, '@\1')
+  end
+end
+
+RSpec.configure do |config|
+  config.include RSpecHelpers
+
+  config.extend RSpecHelpers
+end

data/spec/support/parslet.rb

@@ -0,0 +1 @@
+require 'parslet/rig/rspec'

data/spec/support/shared_examples.rb

@@ -0,0 +1,9 @@
+shared_examples 'debug methods' do
+  context '.type_instance.to_s' do
+    specify { expect(type_instance.to_s).to eq(type_to_s) }
+  end
+
+  context '#to_s' do
+    specify { expect(instance.to_s).to eq(instance_to_s) }
+  end
+end

data/spec/unit/rip/parser/grammar_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Grammar do
+  describe '.parse' do
+    context 'syntax error' do
+    end
+  end
+end

data/spec/unit/rip/parser/location_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Location do
+  subject { location }
+  let(:location) { Rip::Parser::Location.new(:rspec, 0, 1, 0) }
+
+  describe '#==' do
+    it 'glosses over superficial differences' do
+      expect(location).to eq(Rip::Parser::Location.new(:rspec, 0, 1, 0))
+    end
+
+    it 'notices important difference in source' do
+      expect(location).not_to eq(location_for(:origin => :cucumber))
+    end
+
+    it 'notices important differences in position' do
+      expect(location).not_to eq(location_for(:offset => 3))
+    end
+  end
+
+  describe '#to_s' do
+    specify { expect(subject.to_s).to eq('rspec:1:0(0)') }
+
+    context 'in another file' do
+      let(:location) { Rip::Parser::Location.new('lib/rip.rip', 47, 8, 3, 5) }
+
+      specify { expect(subject.to_s).to eq('lib/rip.rip:8:3(47..51)') }
+    end
+  end
+
+  describe '#add_character' do
+    let(:new_location) { Rip::Parser::Location.new(:rspec, 5, 1, 5) }
+
+    it 'returns a new location offset by specified characters' do
+      expect(location.add_character(5)).to eq(new_location)
+    end
+  end
+
+  describe '#add_line' do
+    let(:new_location) { Rip::Parser::Location.new(:rspec, 2, 3, 2) }
+
+    it 'returns a new location offset by specified lines' do
+      expect(location.add_line(2)).to eq(new_location)
+    end
+  end
+
+  describe '.from_slice' do
+    let(:location) { Rip::Parser::Location.from_slice(:rspec, slice) }
+
+    let(:parser) do
+      Class.new(Parslet::Parser) do
+        root :lines
+
+        rule(:lines) { line.repeat }
+        rule(:line) { (as | bs).as(:line) >> eol }
+
+        rule(:as) { a.repeat(3) }
+        rule(:bs) { b.repeat(3) }
+
+        rule(:a) { str('a').as(:a) }
+        rule(:b) { str('b').as(:b) }
+
+        rule(:eol) { str("\n") }
+      end.new
+    end
+
+    let(:slice) { slices[4] }
+    let(:slices) { tree.map(&:values).flatten.map(&:values).flatten }
+
+    let(:source) do
+      strip_heredoc(<<-SOURCE)
+        aaa
+        bbb
+      SOURCE
+    end
+
+    let(:tree) { parser.parse(source) }
+
+    specify { expect(location.origin).to eq(:rspec) }
+
+    specify { expect(location.offset).to eq(5) }
+
+    specify { expect(location.line).to eq(2) }
+
+    specify { expect(location.column).to eq(2) }
+
+    specify { expect(location.length).to eq(1) }
+  end
+end

data/spec/unit/rip/parser/node_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Node do
+  let(:location) { Rip::Parser::Location.new(:rspec, 0, 1, 0) }
+  let(:node) { Rip::Parser::Node.new(location: location, type: :test, answer: 42) }
+
+  describe '#==' do
+    specify { expect(node).to eq(Rip::Parser::Node.new(location: location, type: :test, answer: 42)) }
+    specify { expect(node).to eq(location: location, type: :test, answer: 42) }
+  end
+
+  describe '#[]' do
+    context 'responding to location' do
+      specify { expect(node[:location]).to eq(location) }
+    end
+
+    context 'symbol key' do
+      specify { expect(node[:answer]).to eq(42) }
+    end
+
+    context 'string key' do
+      specify { expect(node['answer']).to eq(42) }
+    end
+
+    context 'missing key' do
+      specify { expect(node[:other]).to be(nil) }
+    end
+  end
+
+  describe '#each' do
+    specify do
+      expect do |x|
+        node.each(&x)
+      end.to yield_successive_args([ :location, location ], [ :type, :test ], [ :answer, 42 ])
+    end
+  end
+
+  describe '#key?' do
+    specify { expect(node.key?(:answer)).to be(true) }
+    specify { expect(node.key?(:foo)).to be(false) }
+
+    specify { expect(node.key?('answer')).to be(true) }
+  end
+
+  describe '#keys' do
+    specify { expect(node.keys).to match_array([ :answer ]) }
+  end
+
+  describe '#length' do
+    specify { expect(node.length).to eq(node.location.length) }
+  end
+
+  describe '#merge' do
+    let(:other_location) { Rip::Parser::Location.new(:rspec, 1, 2, 1) }
+    let(:other) { Rip::Parser::Node.new(location: other_location, type: :other_test, foo: :bar) }
+
+    specify { expect(node.merge(foo: :bar)).to be_a(Rip::Parser::Node) }
+
+    specify { expect(node.merge(answer: :bar).to_h).to eq(location: location, type: :test, answer: :bar) }
+    specify { expect(node.merge(type: :baz, foo: :bar).to_h).to eq(location: location, type: :baz, answer: 42, foo: :bar) }
+
+    specify { expect(node.merge(other).to_h).to eq(location: location, type: :other_test, answer: 42, foo: :bar) }
+  end
+
+  describe '#s_expression' do
+    let(:tree) { Rip::Parser::Node.new(location: location, type: :root, children: [ node ]) }
+
+    let(:expected) do
+      {
+        type: :root,
+        children: [
+          {
+            type: :test,
+            answer: 42
+          }
+        ]
+      }
+    end
+
+    specify { expect(tree.s_expression).to eq(expected) }
+    specify { expect(tree.s_expression).to be_a(Hash) }
+
+    specify { expect(tree.s_expression.keys).to eq([ :type, :children ]) }
+
+    specify { expect(tree.s_expression[:children].first).to be_a(Hash) }
+  end
+
+  describe '#to_h' do
+    specify { expect(node.to_h.keys).to eq([ :location, :type, :answer ]) }
+
+    context 'nested tree' do
+      let(:tree) { Rip::Parser::Node.new(location: location, type: :root, other: node) }
+
+      let(:expected) do
+        {
+          location: location,
+          type: :root,
+          other: {
+            location: location,
+            type: :test,
+            answer: 42
+          }
+        }
+      end
+
+      specify { expect(tree.to_h).to eq(expected) }
+      specify { expect(tree.to_h[:other]).to be_a(Hash) }
+    end
+  end
+
+  describe '.new' do
+    let(:tree) { Rip::Parser::Node.new(location: location, type: :root, nested: { location: location, type: :nested, foo: :bar }) }
+
+    specify { expect(tree.nested).to be_a(Rip::Parser::Node) }
+    specify { expect(tree.nested.foo).to eq(:bar) }
+  end
+
+  context 'dynamic message lookup' do
+    specify { expect(node).to respond_to(:answer) }
+    specify { expect(node).to_not respond_to(:foo) }
+
+    specify { expect(node.answer).to eq(42) }
+    specify { expect { node.foo }.to raise_error(NoMethodError) }
+  end
+
+  context 'nesting' do
+    let(:root) { Rip::Parser::Node.new(location: location, type: :root, other: node) }
+
+    specify { expect(root.other).to eq(node) }
+    specify { expect(root.other.answer).to eq(42) }
+
+    specify { expect(root).to be_root }
+    specify { expect(root.type).to eq(:root) }
+
+    specify { expect(root).to respond_to(:root?) }
+    specify { expect(root).to respond_to(:test?) }
+
+    context 'nested collection' do
+      let(:nodes) do
+        [
+          Rip::Parser::Node.new(location: location, type: :nested, aaa: 111),
+          Rip::Parser::Node.new(location: location, type: :special, bbb: 222),
+          Rip::Parser::Node.new(location: location, type: :nested, ccc: 333)
+        ]
+      end
+
+      let(:root) { Rip::Parser::Node.new(location: location, type: :root, others: nodes) }
+
+      let(:filtered) { nodes.select(&:special?) }
+
+      specify { expect(root.others.sample).to be_a(Rip::Parser::Node) }
+
+      specify { expect(filtered.count).to eq(1) }
+      specify { expect(filtered.first.type).to eq(:special) }
+    end
+  end
+end

data/spec/unit/rip/parser/rules/assignment_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Assignment do
+  class AssignmentParser
+    include Rip::Parser::Rules::Assignment
+    include Rip::Parser::Rules::Module
+  end
+
+  let(:parser) { AssignmentParser.new }
+
+  describe '#reference_assignment' do
+    subject { parser.reference_assignment }
+
+    it { should_not parse('a.b = 42') }
+
+    it do
+      should parse('answer = 42').as(
+        lhs: { reference: 'answer' },
+        location: '=',
+        rhs: {
+          expression_chain: { integer: '42' }
+        }
+      )
+    end
+
+    it do
+      should parse('answer = foo.bar').as(
+        lhs: { reference: 'answer' },
+        location: '=',
+        rhs: {
+          expression_chain: [
+            { reference: 'foo' },
+            { location: '.', property_name: 'bar' }
+          ]
+        }
+      )
+    end
+  end
+
+  describe '#property_assignment' do
+    subject { parser.property_assignment }
+
+    it { should_not parse('a = 42') }
+
+    it do
+      should parse('a.b = 42').as(
+        lhs: {
+          object: { reference: 'a' },
+          location: '.',
+          property_name: 'b'
+        },
+        location: '=',
+        rhs: {
+          expression_chain: { integer: '42' }
+        }
+      )
+    end
+  end
+end

data/spec/unit/rip/parser/rules/binary_condition_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::BinaryCondition do
+  class BinaryConditionParser
+    include Rip::Parser::Rules::BinaryCondition
+    include Rip::Parser::Rules::Module
+  end
+
+  let(:parser) { BinaryConditionParser.new }
+
+  describe '#binary_condition' do
+    subject { parser.binary_condition }
+
+    it do
+      should parse('if (result) { :yes } else { :no }').as(
+        if: 'if',
+        condition: { expression_chain: { reference: 'result' } },
+        consequence: {
+          expression_chain: {
+            location: ':',
+            string: [
+              { character: 'y' },
+              { character: 'e' },
+              { character: 's' }
+            ]
+          }
+        },
+        else: 'else',
+        alternative: {
+          expression_chain: {
+            location: ':',
+            string: [
+              { character: 'n' },
+              { character: 'o' }
+            ]
+          }
+        }
+      )
+    end
+  end
+end

data/spec/unit/rip/parser/rules/character_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Character do
+  class CharacterParser
+    include Rip::Parser::Rules::Character
+  end
+
+  let(:parser) { CharacterParser.new }
+
+  describe '#character' do
+    subject { parser.character }
+
+    it { should parse('`c').as(location: '`', character: 'c') }
+    it { should parse('`\n').as(location: '`', escape_location: '\\', escape_special: 'n') }
+  end
+
+  describe '#escape_sequence' do
+    subject { parser.escape_sequence }
+
+    it { should parse('\u1234').as(escape_location: '\\', escape_unicode: '1234') }
+
+    described_class::SPECIAL_ESCAPES.each do |_, sequence|
+      it { should parse("\\#{sequence}").as(escape_location: '\\', escape_special: sequence) }
+    end
+
+    it { should parse('\w').as(escape_location: '\\', escape_any: 'w') }
+    it { should_not parse('\ ') }
+  end
+end