rip-parser 0.1.0

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

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Lambda do
+  class LambdaParser
+    include Rip::Parser::Rules::Lambda
+    include Rip::Parser::Rules::Module
+  end
+
+  let(:parser) { LambdaParser.new }
+
+  describe '#lambda_block' do
+    subject { parser.lambda_block }
+
+    it do
+      should parse('=> { -> { 42 } }').as(
+        fat_rocket: '=>',
+        overloads: [
+          {
+            dash_rocket: '->',
+            body: { expression_chain: { integer: '42' } }
+          }
+        ]
+      )
+    end
+
+    it do
+      should parse('=> { -> { 42 } (foo) -> { foo } }').as(
+        fat_rocket: '=>',
+        overloads: [
+          {
+            dash_rocket: '->',
+            body: { expression_chain: { integer: '42' } }
+          },
+          {
+            dash_rocket: '->',
+            parameters: [ { parameter: 'foo' } ],
+            body: { expression_chain: { reference: 'foo' } }
+          }
+        ]
+      )
+    end
+
+    it { should_not parse('=> { }') }
+  end
+
+  describe '#overload_block' do
+    subject { parser.overload_block }
+
+    it do
+      should parse('-> { 42 }').as(
+        dash_rocket: '->',
+        body: { expression_chain: { integer: '42' } }
+      )
+    end
+
+    it do
+      should parse('() -> { 42 }').as(
+        dash_rocket: '->',
+        parameters: [],
+        body: { expression_chain: { integer: '42' } }
+      )
+    end
+
+    it { should_not parse('-> {}') }
+  end
+
+  describe '#parameters' do
+    subject { parser.parameters }
+
+    it { should parse('()').as(parameters: []) }
+
+    it do
+      should parse('(foo)').as(
+        parameters: [
+          { parameter: 'foo' }
+        ]
+      )
+    end
+
+    it do
+      should parse('(foo<integer>, bar)').as(
+       parameters: [
+          { parameter: 'foo', type_argument: { reference: 'integer' } },
+          { parameter: 'bar' }
+        ]
+      )
+    end
+
+    it do
+      should parse('(foo<integer> = 42)').as(
+       parameters: [
+          { parameter: 'foo', default: { expression_chain: { integer: '42' } }, type_argument: { reference: 'integer' } }
+        ]
+      )
+    end
+
+    it do
+      should parse('(foo, bar<integer>, baz = 42)').as(
+        parameters: [
+          { parameter: 'foo' },
+          { parameter: 'bar', type_argument: { reference: 'integer' } },
+          { parameter: 'baz', default: { expression_chain: { integer: '42' } } }
+        ]
+      )
+    end
+  end
+
+  describe '#required_parameter' do
+    subject { parser.required_parameter }
+
+    it { should parse('foo').as(parameter: 'foo') }
+
+    it do
+      should parse('foo<bar>').as(
+        parameter: 'foo',
+        type_argument: { reference: 'bar' }
+      )
+    end
+  end
+
+  describe '#optional_parameter' do
+    subject { parser.optional_parameter }
+
+    it do
+      should parse('foo = 42').as(
+        parameter: 'foo',
+        default: { expression_chain: { integer: '42' } }
+      )
+    end
+
+    it do
+      should parse('foo<bar> = 42').as(
+        parameter: 'foo',
+        default: { expression_chain: { integer: '42' } },
+        type_argument: { reference: 'bar' }
+      )
+    end
+  end
+
+  describe '#parameter_type_argument' do
+    subject { parser.parameter_type_argument }
+
+    it { should parse('<foo>').as(type_argument: { reference: 'foo' }) }
+  end
+
+  describe '#block_body' do
+    subject { parser.block_body }
+
+    it do
+      should parse('{ :one }').as(
+        body: { expression_chain: { location: ':', string: [
+          { character: 'o' },
+          { character: 'n' },
+          { character: 'e' }
+        ] } }
+      )
+    end
+
+    it do
+      should parse('{ 42; :cat }').as(
+        body: [
+          { expression_chain: { integer: '42' } },
+          { expression_chain: { location: ':', string: [
+            { character: 'c' },
+            { character: 'a' },
+            { character: 't' }
+          ] } }
+        ]
+      )
+    end
+
+    it { should_not parse('{}') }
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::List do
+  class ListParser
+    include Parslet
+
+    include Rip::Parser::Rules::List
+    include Rip::Parser::Rules::Number
+    include Rip::Parser::Rules::String
+
+    rule(:expression) { number | string | list }
+  end
+
+  let(:parser) { ListParser.new }
+
+  describe '#list' do
+    subject { parser.list }
+
+    it { should parse('[]').as(location: '[', list: []) }
+
+    it do
+      should parse('[ 1, 2, 3.14 ]').as(location: '[', list: [
+        { integer: '1' },
+        { integer: '2' },
+        { integer: '3', decimal: '14' }
+      ])
+    end
+
+    it do
+      should parse('[ "nested", [] ]').as(location: '[', list: [
+        {
+          location: '"', string: [
+            { character: 'n' },
+            { character: 'e' },
+            { character: 's' },
+            { character: 't' },
+            { character: 'e' },
+            { character: 'd' }
+          ]
+        },
+        { location: '[', list: [] }
+      ])
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Map do
+  class MapParser
+    include Parslet
+
+    include Rip::Parser::Rules::Map
+    include Rip::Parser::Rules::Reference
+    include Rip::Parser::Rules::String
+
+    rule(:expression) { reference | string | map }
+  end
+
+  let(:parser) { MapParser.new }
+
+  describe '#map' do
+    subject { parser.map }
+
+    it { should parse('{}').as(location: '{', map: []) }
+
+    it do
+      should parse('{ a, b, c }').as(location: '{', map: [
+        { reference: 'a' },
+        { reference: 'b' },
+        { reference: 'c' }
+      ])
+    end
+
+    it do
+      should parse('{ nested, {} }').as(location: '{', map: [
+        { reference: 'nested' },
+        { location: '{', map: [] }
+      ])
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Module do
+  class ModuleParser
+    include Parslet
+
+    include Rip::Parser::Rules::Module
+    include Rip::Parser::Rules::Number
+    include Rip::Parser::Rules::String
+
+    rule(:expression) { number | string | list }
+  end
+
+  let(:parser) { ModuleParser.new }
+
+  describe '#module' do
+    subject { parser.module }
+
+    it do
+      should parse('42;3.14').as(module: [
+        { integer: '42' },
+        { integer: '3', decimal: '14' }
+      ])
+    end
+
+    it do
+      should parse(":foo\n:bar\n:baz").as(module: [
+        {
+          location: ':',
+          string: [
+            { character: 'f' },
+            { character: 'o' },
+            { character: 'o' }
+          ]
+        },
+        {
+          location: ':',
+          string: [
+            { character: 'b' },
+            { character: 'a' },
+            { character: 'r' }
+          ]
+        },
+        {
+          location: ':',
+          string: [
+            { character: 'b' },
+            { character: 'a' },
+            { character: 'z' }
+          ]
+        }
+      ])
+    end
+
+    it { should_not parse('') }
+
+    it { should_not parse('# comment') }
+
+    it { should_not parse('42 3.14') }
+
+    it { should_not parse(':aaa :bbb') }
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Number do
+  class NumberParser
+    include Rip::Parser::Rules::Number
+  end
+
+  let(:parser) { NumberParser.new }
+
+  describe '#integer' do
+    subject { parser.integer }
+
+    it { should parse('42').as(integer: '42') }
+  end
+
+  describe '#decimal' do
+    subject { parser.decimal }
+
+    it { should parse('3.14').as(integer: '3', decimal: '14') }
+  end
+
+  describe '#number' do
+    subject { parser.number }
+
+    it { should parse('42').as(integer: '42') }
+    it { should parse('+42').as(integer: '42', sign: '+') }
+    it { should parse('-3.14').as(integer: '3', decimal: '14', sign: '-') }
+  end
+
+  describe '#digits' do
+    subject { parser.digits }
+
+    it { should parse('0') }
+    it { should parse('1_234_567_890') }
+
+    it { should_not parse('_1') }
+    it { should_not parse('2_') }
+    it { should_not parse('3__4') }
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Pair do
+  class PairParser
+    include ::Parslet
+
+    include Rip::Parser::Rules::Module
+    include Rip::Parser::Rules::Pair
+  end
+
+  let(:parser) { PairParser.new }
+
+  describe '#pair_value' do
+    subject { parser.pair_value }
+
+    it do
+      should parse(': value').as(
+        location: ':',
+        value: {
+          expression_chain: { reference: 'value' }
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Property do
+  class PropertyParser
+    include Rip::Parser::Rules::Property
+  end
+
+  let(:parser) { PropertyParser.new }
+
+  describe '#property' do
+    subject { parser.property }
+
+    it { should parse('.code').as(location: '.', property_name: 'code') }
+    it { should parse("\n.code").as(location: '.', property_name: 'code') }
+    it { should parse(".\ncode").as(location: '.', property_name: 'code') }
+  end
+
+  describe '#property_name' do
+    subject { parser.property_name }
+
+    Rip::Parser::Rules::Property::SPECIAL_NAMES.each do |name|
+      it { should parse(name) }
+    end
+
+    it { should_not parse('>~<') }
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Range do
+  class RangeParser
+    include ::Parslet
+
+    include Rip::Parser::Rules::Module
+    include Rip::Parser::Rules::Range
+  end
+
+  let(:parser) { RangeParser.new }
+
+  describe '#range_end' do
+    subject { parser.range_end }
+
+    it do
+      should parse('..`z').as(
+        location: '..',
+        end: {
+          expression_chain: { character: 'z', location: '`' }
+        }
+      )
+    end
+
+    it do
+      should parse('..5.to_float').as(
+        location: '..',
+        end: {
+          expression_chain: [
+            { integer: '5' },
+            { property_name: 'to_float', location: '.' }
+          ]
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Reference do
+  class ReferenceParser
+    include Rip::Parser::Rules::Reference
+  end
+
+  let(:parser) { ReferenceParser.new }
+
+  describe '#reference' do
+    subject { parser.reference }
+
+    [
+      'name',
+      'Person',
+      '==',
+      'save!',
+      'valid?',
+      'long_ref-name',
+      '*-+&$~%',
+      'one_9',
+      'ɹÇʇɹoÔ€uÉl∀™',
+      'nilly',
+      'nil',
+      'true',
+      'false',
+      'System',
+      'returner'
+    ].each do |word|
+      it { should parse(word).as(reference: word) }
+    end
+
+    [
+      'one.two',
+      '999',
+      '6teen',
+      'rip rocks',
+      'key:value'
+    ].each do |word|
+      it { should_not parse(word) }
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::String do
+  class StringParser
+    include ::Parslet
+
+    include Rip::Parser::Rules::Reference
+    include Rip::Parser::Rules::String
+
+    rule(:expression) { reference }
+  end
+
+  let(:parser) { StringParser.new }
+
+  describe '#string' do
+    subject { parser.string }
+
+    it { should parse(':rip') }
+    it { should parse('""') }
+    it { should parse('"foo-bar-baz"') }
+
+    it do
+      should parse(strip_heredoc(<<-RIP))
+        <<DOC
+          foo
+          bar
+          baz
+        DOC
+      RIP
+    end
+  end
+
+  describe '#string_symbol' do
+    subject { parser.string_symbol }
+
+    it do
+      should parse(':cat').as(location: ':', string: [
+        { character: 'c' },
+        { character: 'a' },
+        { character: 't' }
+      ])
+    end
+
+    it do
+      should parse(':7').as(location: ':', string: [
+        { character: '7' }
+      ])
+    end
+
+    it { should_not parse(':foo#{bar}baz') }
+  end
+
+  describe '#string_double' do
+    subject { parser.string_double }
+
+    it do
+      should parse('"dog"').as(location: '"', string: [
+        { character: 'd' },
+        { character: 'o' },
+        { character: 'g' }
+      ])
+    end
+
+    it do
+      should parse('"a\nb"').as(location: '"', string: [
+        { character: 'a' },
+        { escape_location: '\\', escape_special: 'n' },
+        { character: 'b' }
+      ])
+    end
+
+    it do
+      should parse('"foo#{bar}baz"').as(location: '"', string: [
+        { character: 'f' },
+        { character: 'o' },
+        { character: 'o' },
+        { location: '#{', interpolation: { reference: 'bar' } },
+        { character: 'b' },
+        { character: 'a' },
+        { character: 'z' }
+      ])
+    end
+  end
+
+  describe '#regular_expression' do
+    subject { parser.regular_expression }
+
+    it do
+      should parse('/r\.p/').as(location: '/', regular_expression: [
+        { character: 'r' },
+        { escape_location: '\\', escape_any: '.' },
+        { character: 'p' }
+      ])
+    end
+
+    it do
+      should parse('/f#{bar}b/').as(location: '/', regular_expression: [
+        { character: 'f' },
+        { location: '#{', interpolation: { reference: 'bar' } },
+        { character: 'b' }
+      ])
+    end
+  end
+
+  describe '#heredoc' do
+    subject { parser.heredoc }
+
+    context 'normal' do
+      let(:rip) do
+        strip_heredoc(<<-RIP)
+          <<BLOCK
+          multi-line
+          string
+          BLOCK
+        RIP
+      end
+
+      it do
+        should parse(rip).as(location: '<<', label: 'BLOCK', string: [
+          { character: 'm' }, { character: 'u' }, { character: 'l' }, { character: 't' },
+          { character: 'i' }, { character: '-' }, { character: 'l' }, { character: 'i' },
+          { character: 'n' }, { character: 'e' }, { character: "\n" }, { character: 's' },
+          { character: 't' }, { character: 'r' }, { character: 'i' }, { character: 'n' },
+          { character: 'g' }, { character: "\n" }
+        ])
+      end
+    end
+
+    context 'interpolation' do
+      let(:rip) do
+        strip_heredoc(<<-RIP)
+          <<BLOCK
+          \#{answer}
+          BLOCK
+        RIP
+      end
+
+      it do
+        should parse(rip).as(location: '<<', label: 'BLOCK', string: [
+          { location: '#{', interpolation: { reference: 'answer' } },
+          { character: "\n" }
+        ])
+      end
+    end
+
+    context 'pathelogical' do
+      let(:rip) do
+        strip_heredoc(<<-RIP)
+          <<BLOCK
+
+          \\tfoo
+
+          BLOCK
+        RIP
+      end
+
+      it do
+        should parse(rip).as(location: '<<', label: 'BLOCK', string: [
+          { character: "\n" },
+          { escape_location: '\\', escape_special: 't' }, { character: 'f' }, { character: 'o' }, { character: 'o' }, { character: "\n" },
+          { character: "\n" }
+        ])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Rip::Parser::Rules::Unit do
+  class UnitParser
+    include Rip::Parser::Rules::Unit
+  end
+
+  let(:parser) { UnitParser.new }
+
+  describe '#unit' do
+    subject { parser.unit }
+
+    it { should parse('-42°').as(magnitude: { sign: '-', integer: '42' }, label: '°') }
+
+    it { should parse('6.28circle').as(magnitude: { integer: '6', decimal: '28' }, label: 'circle') }
+  end
+end