antelope 0.2.4 → 0.3.0

data/lib/antelope.rb

@@ -1,13 +1,19 @@
 # encoding: utf-8
 
-require "antelope/errors"
-require "antelope/generation"
-require "antelope/generator"
-require "antelope/version"
-require "antelope/ace"
-require "antelope/template"
+require 'antelope/errors'
+require 'antelope/generation'
+require 'antelope/generator'
+require 'antelope/version'
+require 'antelope/grammar'
+require 'antelope/ace'
+require 'antelope/dsl'
+require 'antelope/template'
 
 # Antelope, the compiler compiler.
 module Antelope
+  def self.define(name, options = {}, &block)
+    @grammar = [name, options, block]
+  end
 
+  class << self; attr_reader :grammar; end
 end

data/spec/antelope/ace/compiler_spec.rb

@@ -43,18 +43,18 @@ describe Ace::Compiler do
   its(:body) { should =~ /hello/ }
   its(:options) { should have_key :type }
 
-  it "should have the proper terminals" do
+  it 'has the proper terminals' do
     expect(subject.options[:terminals].map(&:first)).to eq [:NUMBER,
       :SEMICOLON, :ADD, :LPAREN, :RPAREN]
   end
 
-  context "with an unmatched version" do
-    let :file do "%require \"0.0.0\"\n%%\n%%\n" end
+  context 'with an unmatched version' do
+    let(:file) { "%require \"0.0.0\"\n%%\n%%\n" }
 
-    it "should raise an error" do
-      expect {
+    it 'raises an error' do
+      expect do
         subject
-      }.to raise_error(Ace::IncompatibleVersionError)
+      end.to raise_error(IncompatibleVersionError)
     end
   end
 end

data/spec/antelope/ace/scanner_spec.rb

@@ -1,20 +1,20 @@
 describe Ace::Scanner do
 
-  it "properly scans" do
+  it 'properly scans' do
     expect(scan("%test \"a\" hi\n%%\nt: d { { } }\n%%\nhi\n")).to eq [
-      [:directive, "test", ["a", "hi"]],
+      [:directive, 'test', %w(a hi)],
       [:second],
-      [:label, "t", nil],
-      [:part, "d", nil],
-      [:block, "{ { } }"],
+      [:label, 't', nil],
+      [:part, 'd', nil],
+      [:block, '{ { } }'],
       [:third],
       [:copy, "\nhi\n"]
     ]
   end
 
-  it "throws an error" do
+  it 'throws an error' do
     expect {
-      scan("% %% %% ")
+      scan('% %% %% ')
     }.to raise_error(Ace::SyntaxError)
   end
 

data/spec/antelope/generation/constructor_spec.rb

@@ -0,0 +1,131 @@
+describe Generation::Constructor do
+  let(:grammar)  { double('grammar') }
+  let(:terminal) { token(:TERMINAL)  }
+  let(:epsilon)  { token(:epsilon) }
+
+  subject { described_class.new(grammar) }
+
+  context '#nullable?' do
+    context 'when given an epsilon token' do
+      it 'returns true' do
+        expect(subject.nullable?(epsilon)).to be true
+      end
+    end
+
+    context 'when given a terminal' do
+      it 'returns false' do
+        expect(subject.nullable?(terminal)).to be false
+      end
+    end
+
+    context 'when given an array' do
+      context 'with one of the elements not nullable' do
+        it 'returns false' do
+          expect(subject.nullable?([terminal, epsilon])).to be false
+        end
+      end
+
+      context 'with all of the elements nullable' do
+        it 'returns true' do
+          expect(subject.nullable?([epsilon, epsilon])).to be true
+        end
+      end
+    end
+
+    context 'when given a nonterminal' do
+      let(:grammar) { with_recognizer }
+
+      context 'with no nullable productions' do
+        let(:nonterminal) { Grammar::Token::Nonterminal.new(:l) }
+
+        it 'returns false' do
+          expect(subject.nullable?(nonterminal)).to be false
+        end
+      end
+
+      context 'with a nullable production' do
+        let(:nonterminal) { Grammar::Token::Nonterminal.new(:e) }
+
+        it 'returns true' do
+          expect(subject.nullable?(nonterminal)).to be true
+        end
+      end
+    end
+
+    context 'when given a bad argument' do
+      it 'raises an error' do
+        expect { subject.nullable?(nil) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context '#first' do
+    context 'when given an epsilon token' do
+      it 'generates an empty set' do
+        expect(subject.first(epsilon)).to eq Set.new
+      end
+    end
+
+    context 'when given a terminal' do
+      it 'generates a set' do
+        expect(subject.first(terminal)).to eq [terminal].to_set
+      end
+    end
+
+    context 'when given an array' do
+      let(:terminal2) { token(:terminal, :TERMINAL2) }
+
+      it 'generates a set' do
+        expect(subject.first([epsilon, terminal]))
+          .to eq [terminal].to_set
+        expect(subject.first([terminal, terminal2]))
+          .to eq [terminal].to_set
+      end
+    end
+
+    context 'when given a nonterminal' do
+      let(:grammar) { with_recognizer }
+      let(:nonterminal) { token(:nonterminal, :e) }
+
+      it 'generates a set' do
+        expect(subject.first(nonterminal))
+          .to eq [token(:terminal, :IDENT), token(:terminal, :STAR, '*')].to_set
+      end
+    end
+
+    context 'when given a bad argument' do
+      it 'raises an error' do
+        expect { subject.first(nil) }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context '#follow' do
+    context 'when given a bad argument' do
+      it 'raises an error' do
+        expect { subject.follow(nil) }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when given a nonterminal' do
+      let(:grammar) { with_recognizer }
+      let(:nonterminal) { token(:nonterminal, :l) }
+
+      before do
+        subject.productions.merge grammar.productions.values.flatten
+      end
+
+      it 'generates a set' do
+        expect(subject.follow(nonterminal)).to eq [
+          token(:terminal, :EQUALS, '='),
+          token(:terminal, :'$end')
+        ].to_set
+      end
+    end
+  end
+
+  def token(type, name = nil, value = nil, ttype = nil, id = nil)
+    type = Grammar::Token.const_get(type.to_s.capitalize)
+    type.new(name, ttype, id, value)
+  end
+end

data/spec/support/grammar_helper.rb

@@ -1,13 +1,12 @@
 module GrammarHelper
-
   def grammar_for(grammar_file = "simple")
     source_path = Pathname.new("../../fixtures").expand_path(__FILE__)
-    Ace::Grammar.from_file(source_path.children.select(&:file?)
+    Grammar.from_file(source_path.children.select(&:file?)
       .find { |x| x.to_s =~ /#{Regexp.escape(grammar_file)}\..*\z/ }.to_s)
   end
 
   def with_recognizer(grammar = simple_grammar)
-    recognizer = Generation::Recognizer.new(grammar).call
+    Generation::Recognizer.new(grammar).call
     grammar
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: antelope
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-22 00:00:00.000000000 Z
+date: 2015-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -104,6 +104,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - ".yardopts"
 - CONTRIBUTING.md
@@ -117,33 +118,32 @@ files:
 - bin/antelope
 - examples/deterministic.ace
 - examples/example.ace
-- examples/example.err
-- examples/example.inf
+- examples/example.ace.err
+- examples/example.ace.inf
+- examples/example.ate
+- examples/example.ate.err
+- examples/example.ate.inf
 - examples/liquidscript.ace
 - examples/simple.ace
 - lib/antelope.rb
 - lib/antelope/ace.rb
 - lib/antelope/ace/compiler.rb
 - lib/antelope/ace/errors.rb
-- lib/antelope/ace/grammar.rb
-- lib/antelope/ace/grammar/generation.rb
-- lib/antelope/ace/grammar/loading.rb
-- lib/antelope/ace/grammar/precedences.rb
-- lib/antelope/ace/grammar/productions.rb
-- lib/antelope/ace/grammar/symbols.rb
-- lib/antelope/ace/precedence.rb
-- lib/antelope/ace/production.rb
 - lib/antelope/ace/scanner.rb
 - lib/antelope/ace/scanner/argument.rb
 - lib/antelope/ace/scanner/first.rb
 - lib/antelope/ace/scanner/second.rb
 - lib/antelope/ace/scanner/third.rb
-- lib/antelope/ace/token.rb
-- lib/antelope/ace/token/epsilon.rb
-- lib/antelope/ace/token/error.rb
-- lib/antelope/ace/token/nonterminal.rb
-- lib/antelope/ace/token/terminal.rb
 - lib/antelope/cli.rb
+- lib/antelope/dsl.rb
+- lib/antelope/dsl/compiler.rb
+- lib/antelope/dsl/contexts.rb
+- lib/antelope/dsl/contexts/base.rb
+- lib/antelope/dsl/contexts/main.rb
+- lib/antelope/dsl/contexts/match.rb
+- lib/antelope/dsl/contexts/precedence.rb
+- lib/antelope/dsl/contexts/production.rb
+- lib/antelope/dsl/contexts/terminal.rb
 - lib/antelope/errors.rb
 - lib/antelope/generation.rb
 - lib/antelope/generation/constructor.rb
@@ -179,6 +179,19 @@ files:
 - lib/antelope/generator/templates/html/js.ant
 - lib/antelope/generator/templates/info.ant
 - lib/antelope/generator/templates/ruby.ant
+- lib/antelope/grammar.rb
+- lib/antelope/grammar/generation.rb
+- lib/antelope/grammar/loading.rb
+- lib/antelope/grammar/precedence.rb
+- lib/antelope/grammar/precedences.rb
+- lib/antelope/grammar/production.rb
+- lib/antelope/grammar/productions.rb
+- lib/antelope/grammar/symbols.rb
+- lib/antelope/grammar/token.rb
+- lib/antelope/grammar/token/epsilon.rb
+- lib/antelope/grammar/token/error.rb
+- lib/antelope/grammar/token/nonterminal.rb
+- lib/antelope/grammar/token/terminal.rb
 - lib/antelope/template.rb
 - lib/antelope/template/compiler.rb
 - lib/antelope/template/errors.rb
@@ -187,7 +200,7 @@ files:
 - optimizations.txt
 - spec/antelope/ace/compiler_spec.rb
 - spec/antelope/ace/scanner_spec.rb
-- spec/antelope/constructor_spec.rb
+- spec/antelope/generation/constructor_spec.rb
 - spec/antelope/template_spec.rb
 - spec/fixtures/simple.ace
 - spec/spec_helper.rb
@@ -222,7 +235,7 @@ summary: A compiler compiler, written in ruby.
 test_files:
 - spec/antelope/ace/compiler_spec.rb
 - spec/antelope/ace/scanner_spec.rb
-- spec/antelope/constructor_spec.rb
+- spec/antelope/generation/constructor_spec.rb
 - spec/antelope/template_spec.rb
 - spec/fixtures/simple.ace
 - spec/spec_helper.rb

data/lib/antelope/ace/grammar/generation.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-    class Grammar
-
-      # The default modifiers for generation.  It's not really
-      # recommended to (heh) modify this; however, adding your own
-      # modifier is always acceptable.
-      DEFAULT_MODIFIERS = [
-        [:recognizer,  Generation::Recognizer ],
-        [:constructor, Generation::Constructor],
-        [:tableizer,   Generation::Tableizer  ]
-      ].freeze
-
-      # Handles the generation of output for the grammar.
-      module Generation
-
-        # Generates the output.  First, it runs through every given
-        # modifier, and instintates it.  It then calls every modifier,
-        # turns it into a hash, and passes that hash to each of the
-        # given generators.
-        #
-        # @param options [Hash] options.
-        # @param generators [Array<Generator>] a list of generators
-        #   to use in generation.
-        # @param modifiers [Array<Array<(Symbol, #call)>>] a list of
-        #   modifiers to apply to the grammar.
-        # @return [void]
-        def generate(options    = {},
-                     generators = :guess,
-                     modifiers  = DEFAULT_MODIFIERS)
-          mods = modifiers.map(&:last).
-            map  { |x| x.new(self) }
-          mods.each do |mod|
-            puts "Running mod #{mod.class}..." if options[:verbose]
-            mod.call
-          end
-          hash = Hash[modifiers.map(&:first).zip(mods)]
-          # This is when we'd generate
-
-          find_generators(generators, options).each do |gen|
-            puts "Running generator #{gen}..." if options[:verbose]
-            gen.new(self, hash).generate
-          end
-        end
-
-        private
-
-        # Find the corresponding generators.  If the first argument
-        # isn't `:guess`, it returns the first argument.  Otherwise,
-        # it tries to "intelligently guess" by checking the type from
-        # the options _or_ the compiler.  If it is unable to find the
-        # type, it will raise a {NoTypeError}.
-        #
-        # @raise [NoTypeError] if it could not determine the type of
-        #   the generator.
-        # @param generators [Symbol, Array<Generator>]
-        # @param options [Hash]
-        # @return [Array<Generator>]
-        def find_generators(generators, options)
-          return generators unless generators == :guess
-
-          generators = [Generator::Output]
-
-          # command line precedence...
-          type = options[:type] || options["type"] ||
-            compiler.options.fetch(:type)
-
-          generators << Generator.generators.fetch(type)
-
-          generators
-
-        rescue KeyError
-          raise NoTypeError, "Undefined type #{type}"
-        end
-      end
-    end
-  end
-end

data/lib/antelope/ace/grammar/loading.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-    class Grammar
-
-      # Handles loading to and from files and strings.
-      module Loading
-
-        # Defines class methods on the grammar.
-        module ClassMethods
-
-          # Loads a grammar from a file.  Assumes the output
-          # directory and name from the file name.
-          #
-          # @param file_name [String] the file name.
-          # @return [Grammar]
-          # @see #from_string
-          def from_file(file_name)
-            body     = File.read(file_name)
-            output   = File.dirname(file_name)
-            name     = File.basename(file_name).gsub(/\.[A-Za-z]+/, "")
-            from_string(name, output, body)
-          end
-
-          # Loads a grammar from a string.  First runs the scanner and
-          # compiler over the string, and then instantiates a new
-          # Grammar from the resultant.
-          #
-          # @param name [String] the name of the grammar.
-          # @param output [String] the output directory.
-          # @param string [String] the grammar body.
-          # @return [Grammar]
-          # @see Ace::Scanner
-          # @see Ace::Compiler
-          def from_string(name, output, string)
-            scanner  = Ace::Scanner.scan(string, name)
-            compiler = Ace::Compiler.compile(scanner)
-            new(name, output, compiler)
-          end
-        end
-
-        # Extends the grammar with the class methods.
-        #
-        # @param receiver [Grammar]
-        # @see ClassMethods
-        def self.included(receiver)
-          receiver.extend ClassMethods
-        end
-      end
-    end
-  end
-end

data/lib/antelope/ace/grammar/precedences.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-require "set"
-
-module Antelope
-  module Ace
-    class Grammar
-
-      # Manages precedence for tokens.
-      module Precedences
-
-        # Accesses the generated precedence list.  Lazily generates
-        # the precedence rules on the go, and then caches it.
-        #
-        # @return [Array<Ace::Precedence>]
-        def precedence
-          @_precedence ||= generate_precedence
-        end
-
-        # Finds a precedence rule for a given token.  If no direct
-        # rule is defined for that token, it will check for a rule
-        # defined for the special symbol, `:_`.  By default, there
-        # is always a rule defined for `:_`.
-        #
-        # @param token [Ace::Token, Symbol]
-        # @return [Ace::Precedence]
-        def precedence_for(token)
-          token = token.name if token.is_a?(Token)
-
-          prec = precedence.
-            detect { |pr| pr.tokens.include?(token) } ||
-          precedence.
-            detect { |pr| pr.tokens.include?(:_) }
-
-          prec
-        end
-
-        private
-
-        # Generates the precedence rules.  Loops through the compiler
-        # given precedence settings, and then adds two default
-        # precedence rules; one for `:$` (level 0, nonassoc), and one
-        # for `:_` (level 1, nonassoc).
-        #
-        # @return [Array<Ace::Precedence>]
-        def generate_precedence
-          size = @compiler.options[:prec].size + 1
-          index = 0
-          precedence = []
-
-          while index < size - 1
-            prec = @compiler.options[:prec][index]
-            precedence <<
-              Ace::Precedence.new(prec[0], prec[1..-1].to_set,
-              size - index)
-            index += 1
-          end
-
-          precedence <<
-            Ace::Precedence.new(:nonassoc, [:$end].to_set, 0) <<
-            Ace::Precedence.new(:nonassoc, [:_].to_set, 1)
-          precedence.sort_by(&:level).reverse
-        end
-
-      end
-    end
-  end
-end