rip-parser 0.1.0

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

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Class do
+  class ClassParser
+    include Rip::Parser::Rules::Class
+    include Rip::Parser::Rules::Module
+  end
+
+  let(:parser) { ClassParser.new }
+
+  describe '#class_block' do
+    subject { parser.class_block }
+
+    it do
+      should parse('class {}').as(
+        class: 'class',
+        body: nil
+      )
+    end
+
+    it do
+      should parse('class (Collection) { self.foo = 42 }').as(
+        class: 'class',
+        ancestors: [
+          { reference: 'Collection' }
+        ],
+        body: {
+          property: {
+            class_self: 'self',
+            location: '.',
+            property_name: 'foo'
+          },
+          location: '=',
+          property_value: { expression_chain: { integer: '42' } }
+        }
+      )
+    end
+
+    it do
+      should parse('class () { foo = 42; @.initialize = ~> { @.bar = `F } }').as(
+        class: 'class',
+        ancestors: [],
+        body: [
+          {
+            property: {
+              property_name: 'foo'
+            },
+            location: '=',
+            property_value: { expression_chain: { integer: '42' } }
+          },
+          {
+            property: {
+              class_prototype: '@',
+              location: '.',
+              property_name: 'initialize'
+            },
+            location: '=',
+            property_value: {
+              swerve_rocket: '~>',
+              body: {
+                lhs: {
+                  object: { reference: '@' },
+                  location: '.',
+                  property_name: 'bar'
+                },
+                location: '=',
+                rhs: { expression_chain: { location: '`', character: 'F' } }
+              }
+            }
+          }
+        ]
+      )
+    end
+  end
+
+  describe '#class_ancestors' do
+    subject { parser.class_ancestors }
+
+    it { should parse('()').as(ancestors: []) }
+
+    it do
+      should parse('(Queryable)').as(
+        ancestors: [
+          { reference: 'Queryable' }
+        ]
+      )
+    end
+
+    it do
+      should parse('(Collection, Queryable)').as(
+        ancestors: [
+          { reference: 'Collection' },
+          { reference: 'Queryable' }
+        ]
+      )
+    end
+  end
+
+  describe '#class_property_assignment' do
+    subject { parser.class_property_assignment }
+
+    it do
+      should parse('foo = 42').as(
+        {
+          property: {
+            property_name: 'foo'
+          },
+          location: '=',
+          property_value: { expression_chain: { integer: '42' } }
+        }
+      )
+    end
+
+    it do
+      should parse('foo = ~> { 42 }').as(
+        {
+          property: {
+            property_name: 'foo'
+          },
+          location: '=',
+          property_value: {
+            swerve_rocket: '~>',
+            body: { expression_chain: { integer: '42' } }
+          }
+        }
+      )
+    end
+
+    it do
+      should parse('self.[] = -> { 42 }').as(
+        {
+          property: {
+            class_self: 'self',
+            location: '.',
+            property_name: '[]'
+          },
+          location: '=',
+          property_value: {
+            dash_rocket: '->',
+            body: { expression_chain: { integer: '42' } }
+          }
+        }
+      )
+    end
+
+    it do
+      should parse('@.[] = => { -> { 42 } }').as(
+        {
+          property: {
+            class_prototype: '@',
+            location: '.',
+            property_name: '[]'
+          },
+          location: '=',
+          property_value: {
+            fat_rocket: '=>',
+            overloads: [
+              {
+                dash_rocket: '->',
+                body: { expression_chain: { integer: '42' } }
+              }
+            ]
+          }
+        }
+      )
+    end
+  end
+
+  describe '#property_block' do
+    subject { parser.property_block }
+
+    it do
+      should parse('~> { 42 }').as(
+        swerve_rocket: '~>',
+        body: { expression_chain: { integer: '42' } }
+      )
+    end
+
+    it { should_not parse('~> {}') }
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Common do
+  class CommonParser
+    include Rip::Parser::Rules::Common
+  end
+
+  let(:parser) { CommonParser.new }
+
+  describe '#comment' do
+    subject { parser.comment }
+
+    it { should parse('#') }
+    it { should parse('# comment') }
+  end
+
+  describe '#space' do
+    subject { parser.space }
+
+    it { should parse(' ') }
+    it { should parse("\t") }
+  end
+
+  describe '#spaces' do
+    subject { parser.spaces }
+
+    it { should parse(' ') }
+    it { should parse("\t\t") }
+    it { should parse("  \t  \t  ") }
+  end
+
+  describe '#spaces?' do
+    subject { parser.spaces? }
+
+    it { should parse('') }
+    it { should parse(' ') }
+    it { should parse("  \t  \t  ") }
+  end
+
+  describe '#line_break' do
+    subject { parser.line_break }
+
+    it { should parse("\n") }
+    it { should parse("\r") }
+    it { should parse("\r\n") }
+  end
+
+  describe '#line_breaks' do
+    subject { parser.line_breaks }
+
+    it { should parse("\r\n\r\n") }
+    it { should parse("\n\n") }
+    it { should parse("\r\r") }
+  end
+
+  describe '#line_breaks?' do
+    subject { parser.line_breaks? }
+
+    it { should parse('') }
+    it { should parse("\r\n\r\n") }
+    it { should parse("\n\n") }
+  end
+
+  describe '#whitespace' do
+    subject { parser.whitespace }
+
+    it { should parse(' ') }
+    it { should parse("\t") }
+    it { should parse("\n") }
+    it { should parse("\r") }
+    it { should parse("\r\n") }
+  end
+
+  describe '#whitespaces' do
+    subject { parser.whitespaces }
+
+    it { should parse(' ') }
+    it { should parse("\t\t") }
+  end
+
+  describe '#whitespaces?' do
+    subject { parser.whitespaces? }
+
+    it { should parse('') }
+    it { should parse("\n") }
+    it { should parse("\t\r") }
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::DateTime do
+  class DateTimeParser
+    include Rip::Parser::Rules::DateTime
+  end
+
+  let(:parser) { DateTimeParser.new }
+
+  describe '#date_time' do
+    subject { parser.date_time }
+
+    it do
+      should parse('2012-02-12T21:51:50').as(
+        date: { year: '2012', month: '02', day: '12' },
+        time: { hour: '21', minute: '51', second: '50' }
+      )
+    end
+  end
+
+  describe '#date' do
+    subject { parser.date }
+
+    it { should parse('2012-02-12').as(year: '2012', month: '02', day: '12') }
+  end
+
+  describe '#time' do
+    subject { parser.time }
+
+    it { should parse('21:51:50').as(hour: '21', minute: '51', second: '50') }
+
+    it { should parse('12:34:45.678').as(hour: '12', minute: '34', second: '45', sub_second: '678') }
+
+    it do
+      should parse('12:34:45-0500').as(
+        hour: '12',
+        minute: '34',
+        second: '45',
+        offset: {
+          sign: '-',
+          hour: '05',
+          minute: '00'
+        }
+      )
+    end
+
+    it do
+      should parse('12:34:45.678+1230').as(
+        hour: '12',
+        minute: '34',
+        second: '45',
+        sub_second: '678',
+        offset: {
+          sign: '+',
+          hour: '12',
+          minute: '30'
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Expression do
+  class ExpressionParser
+    include Rip::Parser::Rules::Expression
+    include Rip::Parser::Rules::Module
+  end
+
+  let(:parser) { ExpressionParser.new }
+
+  describe '#expression' do
+    subject { parser.expression }
+
+    it { should parse('42') }
+    it { should parse('-39.7') }
+
+    it { should parse('`r') }
+
+    it { should parse(':rip') }
+
+    it { should parse('[ "nested", [] ]') }
+
+    it { should parse('foo') }
+
+    it { should parse('import :bar') }
+
+    context 'with nested parenthesis' do
+      it { should parse('(( ((`z))) )') }
+      it { should parse('(import :bar)') }
+    end
+
+    context 'map literals' do
+      it do
+        should parse('{ nested: {} }').as(
+          expression_chain: {
+            location: '{',
+            map: [
+              {
+                expression_chain: [
+                  { reference: 'nested' },
+                  {
+                    location: ':',
+                    value: {
+                      expression_chain: { location: '{', map: [] }
+                    }
+                  }
+                ]
+              }
+            ]
+          }
+        )
+      end
+    end
+
+    context 'chaining' do
+      it do
+        should parse('foo.bar').as(expression_chain: [
+          { reference: 'foo' },
+          { location: '.', property_name: 'bar' }
+        ])
+      end
+
+      it do
+        should parse('a.b.c').as(expression_chain: [
+          { reference: 'a' },
+          { location: '.', property_name: 'b' },
+          { location: '.', property_name: 'c' }
+        ])
+      end
+
+      it do
+        should parse('(((((foo).bar()).baz)))').as(
+          expression_chain: {
+            expression_chain: {
+              expression_chain: {
+                expression_chain: [
+                  {
+                    expression_chain: [
+                      {
+                        expression_chain: { reference: 'foo' }
+                      },
+                      { location: '.', property_name: 'bar' },
+                      { location: '(', arguments: [] }
+                    ]
+                  },
+                  { location: '.', property_name: 'baz' }
+                ]
+              }
+            }
+          }
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Import do
+  class ImportParser
+    include ::Parslet
+
+    include Rip::Parser::Rules::Import
+    include Rip::Parser::Rules::Reference
+
+    rule(:expression) { reference }
+  end
+
+  let(:parser) { ImportParser.new }
+
+  describe '#import' do
+    subject { parser.import }
+
+    it do
+      should parse('import :foo').as(import: 'import', module_name: {
+        location: ':',
+        string: [
+          { character: 'f' },
+          { character: 'o' },
+          { character: 'o' }
+        ]
+      })
+    end
+
+    it do
+      should parse('import(:bar)').as(import: 'import', module_name: {
+        location: ':',
+        string: [
+          { character: 'b' },
+          { character: 'a' },
+          { character: 'r' }
+        ]
+      })
+    end
+
+    it do
+      should parse('import "bar"').as(import: 'import', module_name: {
+        location: '"',
+        string: [
+          { character: 'b' },
+          { character: 'a' },
+          { character: 'r' }
+        ]
+      })
+    end
+
+    it do
+      should parse('import "./a/b"').as(import: 'import', module_name: {
+        location: '"',
+        string: [
+          { character: '.' },
+          { character: '/' },
+          { character: 'a' },
+          { character: '/' },
+          { character: 'b' }
+        ]
+      })
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::InvocationIndex do
+  class InvocationIndexParser
+    include ::Parslet
+
+    include Rip::Parser::Rules::InvocationIndex
+    include Rip::Parser::Rules::Module
+  end
+
+  let(:parser) { InvocationIndexParser.new }
+
+  describe '#invocation_index' do
+    subject { parser.invocation_index }
+
+    it { should parse('[]').as(location: '[', index_arguments: []) }
+
+    it do
+      should parse('[`3]').as(
+        location: '[',
+        index_arguments: [
+          {
+            expression_chain: { character: '3', location: '`' }
+          }
+        ]
+      )
+    end
+
+    it do
+      should parse('[1, 2, 3]').as(
+        location: '[',
+        index_arguments: [
+          {
+            expression_chain: { integer: '1' }
+          },
+          {
+            expression_chain: { integer: '2' }
+          },
+          {
+            expression_chain: { integer: '3' }
+          }
+        ]
+      )
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Invocation do
+  class InvocationParser
+    include ::Parslet
+
+    include Rip::Parser::Rules::Invocation
+    include Rip::Parser::Rules::Module
+  end
+
+  let(:parser) { InvocationParser.new }
+
+  describe '#invocation' do
+    subject { parser.invocation }
+
+    it { should parse('()').as(location: '(', arguments: []) }
+
+    it do
+      should parse('(`3)').as(
+        location: '(',
+        arguments: [
+          {
+            expression_chain: { character: '3', location: '`' }
+          }
+        ]
+      )
+    end
+
+    it do
+      should parse('(1, 2, 3)').as(
+        location: '(',
+        arguments: [
+          {
+            expression_chain: { integer: '1' }
+          },
+          {
+            expression_chain: { integer: '2' }
+          },
+          {
+            expression_chain: { integer: '3' }
+          }
+        ]
+      )
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Keyword do
+  class KeywordParser
+    include Rip::Parser::Rules::Keyword
+  end
+
+  let(:parser) { KeywordParser.new }
+
+  describe '#keyword' do
+    subject { parser.keyword(:import) }
+
+    it { should parse('import').as(import: 'import') }
+
+    it { should_not parse('importer') }
+  end
+end