antelope 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bded4fc112838ad4b250647b7b15fbecac25ab32
-  data.tar.gz: 25e8b92170861126767829c19a85b1407a31fcb8
+  metadata.gz: a92fce8aab3e6c5107252ea4a33c51f7da399473
+  data.tar.gz: 6833313957e6ae84009644b24ce78093bf049285
 SHA512:
-  metadata.gz: bd091e4348fadd6caa15865e87ad60d849959c2d76baae2e3aa6bed62111a76169310ed0b3ea842e746f566d097ae87fc29580379f1ebe0a732afbaeea348ada
-  data.tar.gz: ba5288283b0e6c46ae9671c92f19d5776bacfe6c232ca565d93f17d8056a96859c2e231e8a095a14eb583e87c25fbf295ebfe56394ae5bd7370d3270e8068639
+  metadata.gz: 0904f4b66bbb6468462420b81bdcd3d711291137f9ca54232bf3856dc8f1fafe6d208186c4db6d2aeb74af7b83e3fd74b2877a159c80767eac55325fdee5333b
+  data.tar.gz: c75fa1bc293beb80a2e45fe971c2db0330064919954393121a72fae89872c5a8e1d93f99eebfc247e7f879b25c2dcf86d3ad01d4ba92982f9eed9ffdfbb5a411

data/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing to _Antelope_
+
+First and foremost, **thank you**! Contributing to _Antelope_ is great!  There are a few guidelines, however...
+
+## Contribution Process
+
+1. Fork the repository ([medcat/antelope])
+2. Create a new branch for your feature (something like `my-feature`)
+3. Make yo' changes
+4. Commit yo' changes
+5. if(notDone) goto 3;
+6. Push yo' changes
+7. Make yo' pull request
+
+Creating a new branch is a _really, really_ good idea; it keeps things neat in the world of git.  When you make the pull request, any commits you make to the merging branch are added to the pull request.  Also, _please_ make sure you describe the pull request, and what it does, and why it's needed.
+
+## Commit Message Style
+
+I have to admit, I'm absolutely terrible at commits.  But, in case of a commit, commit messages should be imperative - it's what the commit _does_, not what it _will do_ or what it _has done_; for example, "Create Generator for C Output".  Messages should have a subject, and optionally a body; the subject should have no more than 50 characters, and should be concise, as well as in Title Case.  If you can't fit information in the subject, put it in the body.
+
+## Issues
+
+When opening issues, there are a few requirements:
+
+- Describe the problem
+- Show how to reproduce it, if applicable
+- Explain what you think is causing it, if applicable
+- Give a plausible solution, if applicable
+
+Give (us|me) as much information as needed so (we|I) can decide how to handle the issue.
+
+## Closing Words
+
+And, most of all, the last requirement: have fun!
+
+
+
+[medcat/antelope]: https://github.com/medcat/antelope

data/GENERATORS.md

@@ -0,0 +1,82 @@
+# Generators
+
+_Antelope_ comes with an assortment of generators; however, if you wish to create a custom generator, here's how.
+
+First, you'll want to make your generator a subclass of `Antelope::Generator::Base`.  This sets up a basic framework for you to build upon.
+
+```Ruby
+class MyGenerator < Antelope::Generator::Base
+
+end
+```
+
+Next, you'll want to define a `generate` method on your generator that takes no arguments.  This is used internally by _Antelope_ to actually have your generator perform its generation.  In the case of this generator, we'll have it copy over a template (after running ERb over it).
+
+```Ruby
+class MyGenerator < Antelope::Generator::Base
+    
+  def generate
+    template "my_template", "#{file}.my_file"
+  end
+end
+```
+
+`Base` provides a few convienince methods for you, one of them being [`template`](http://rubydoc.info/github/medcat/antelope/master/Antelope/Generator/Base#template-instance_method); `file` is also provided, and it contains the base part of the file name of the parser ace file that this is being generated for.  The template, by default, should rest in `<lib path>/lib/antelope/generator/templates` (with `<lib path>` being the place that _Antelope_ was installed); however, if it should be changed, you can overwrite the `source_root` method on the class:
+
+```Ruby
+class MyGenerator < Antelope::Generator::Base
+  
+  def self.source_root
+    Pathname.new("/path/to/source")
+  end
+
+  def generate
+    template "my_template", "#{file}.my_file"
+  end
+end
+```
+
+In the template, the code is run in the context of the instance of the class, so you have access to instance variables and methods as if you were defining a method on the class:
+
+```
+% table.each_with_index do |hash, i|
+  state <%= i %>:
+%   hash.each do |token, action|
+    for <%= token %>, I'll <%= action[0] %> <%= action[1] %>
+%   end
+% end
+```
+
+_Note: in templates, the ERb syntax allows lines starting with `%` to be interpreted as ruby; this helps remove unwanted line space._
+
+`table` here is defined on the base class, and we're iterating over all of the values of it.
+
+The last thing to do is to register the generator with _Antelope_.  This is as simple as adding a line `register_as "my_generator"` to the class definition.  Then, if any grammar file has the type `"my_generator"`, your generator will be run (assuming it's been required by _Antelope_).
+
+The finialized product:
+
+```Ruby
+# my_generator.rb
+class MyGenerator < Antelope::Generator::Base
+
+  register_as "my_generator"
+  
+  def self.source_root
+    Pathname.new("/path/to/source")
+  end
+
+  def generate
+    template "my_template", "#{file}.my_file"
+  end
+end
+```
+
+```
+# my_template.erb
+% table.each_with_index do |hash, i|
+  state <%= i %>:
+%   hash.each do |token, action|
+    for <%= token %>, I'll <%= action[0] %> <%= action[1] %>
+%   end
+% end
+```

data/examples/deterministic.output

@@ -1,10 +1,10 @@
 Productions:
-  s → e 
-  e → t ";" 
-  e → t "+" e 
-  t → NUMBER 
-  t → "(" e ")" 
-  $start → s $ 
+  0 $start: s $  
+  1 s: e         
+  2 e: t ";"     
+  3 e: t "+" e   
+  4 t: NUMBER    
+  5 t: "(" e ")" 
 
 Precedence:
   --- highest

data/examples/example.output

@@ -1,12 +1,12 @@
 Productions:
-  expression → NUMBER { |a| a[1]        }
-  expression → expression "+" expression { |a, _, b| a + b }
-  expression → expression "-" expression { |a, _, b| a - b }
-  expression → expression "*" expression { |a, _, b| a * b }
-  expression → expression "/" expression { |a, _, b| a / b }
-  expression → "(" expression ")" { |_, a, _| a     }
-  expression → "(" $error ")" 
-  $start → expression $ 
+  0 $start: expression $                  
+  1 expression: NUMBER                    { |a| a[1]        }
+  2 expression: expression "+" expression { |a, _, b| a + b }
+  3 expression: expression "-" expression { |a, _, b| a - b }
+  4 expression: expression "*" expression { |a, _, b| a * b }
+  5 expression: expression "/" expression { |a, _, b| a / b }
+  6 expression: "(" expression ")"        { |_, a, _| a     }
+  7 expression: "(" $error ")"            
 
 Precedence:
   --- highest

data/examples/simple.output

@@ -1,10 +1,10 @@
 Productions:
-  e → l "=" r 
-  e → r 
-  l → IDENT 
-  l → "*" r 
-  r → l 
-  $start → e $ 
+  0 $start: e $ 
+  1 e: l "=" r  
+  2 e: r        
+  3 l: IDENT    
+  4 l: "*" r    
+  5 r: l        
 
 Precedence:
   --- highest

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

@@ -13,10 +13,6 @@ module Antelope
         [:tableizer,   Generation::Tableizer  ]
       ].freeze
 
-      DEFAULT_GENERATORS = {
-        "ruby" => [Generator::Ruby]
-      }
-
       # Handles the generation of output for the grammar.
       module Generation
 
@@ -44,6 +40,7 @@ module Antelope
           # This is when we'd generate
 
           find_generators(generators, options).each do |gen|
+            puts "Running generator #{gen}..."
             gen.new(self, hash).generate
           end
         end
@@ -70,7 +67,7 @@ module Antelope
           type = options[:type] || options["type"] ||
             compiler.options.fetch(:type)
 
-          generators += DEFAULT_GENERATORS.fetch(type)
+          generators << Generator.generators.fetch(type)
 
           generators
 

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

@@ -34,7 +34,7 @@ module Antelope
           # @see Ace::Scanner
           # @see Ace::Compiler
           def from_string(name, output, string)
-            scanner  = Ace::Scanner.scan(string)
+            scanner  = Ace::Scanner.scan(string, name)
             compiler = Ace::Compiler.compile(scanner)
             new(name, output, compiler)
           end

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

@@ -22,6 +22,33 @@ module Antelope
           productions.values.flatten.sort_by(&:id)
         end
 
+        # Finds a token based on its corresponding symbol.  First
+        # checks the productions, to see if it's a nonterminal; then,
+        # tries to find it in the terminals; otherwise, if the symbol
+        # is `error`, it returns a {Token::Error}; if the symbol is
+        # `nothing` or `ε`, it returns a {Token::Epsilon}; if it's
+        # none of those, it raises an {UndefinedTokenError}.
+        #
+        # @raise [UndefinedTokenError] if the token doesn't exist.
+        # @param value [String, Symbol, #intern] the token's symbol to
+        #   check.
+        # @return [Token]
+        def find_token(value)
+          value = value.intern
+          if productions.key?(value)
+            Token::Nonterminal.new(value)
+          elsif terminal = terminals.
+              find { |term| term.name == value }
+            terminal
+          elsif value == :error
+            Token::Error.new
+          elsif [:nothing, :ε].include?(value)
+            Token::Epsilon.new
+          else
+            raise UndefinedTokenError, "Could not find a token named #{value.inspect}"
+          end
+        end
+
         private
 
         # Actually generates the productions.  Uses the rules from the
@@ -92,33 +119,6 @@ module Antelope
               Token::Terminal.new(:"$")
             ], "", precedence.last, 0)
         end
-
-        # Finds a token based on its corresponding symbol.  First
-        # checks the productions, to see if it's a nonterminal; then,
-        # tries to find it in the terminals; otherwise, if the symbol
-        # is `error`, it returns a {Token::Error}; if the symbol is
-        # `nothing` or `ε`, it returns a {Token::Epsilon}; if it's
-        # none of those, it raises an {UndefinedTokenError}.
-        #
-        # @raise [UndefinedTokenError] if the token doesn't exist.
-        # @param value [String, Symbol, #intern] the token's symbol to
-        #   check.
-        # @return [Token]
-        def find_token(value)
-          value = value.intern
-          if productions.key?(value)
-            Token::Nonterminal.new(value)
-          elsif terminal = terminals.
-              find { |term| term.name == value }
-            terminal
-          elsif value == :error
-            Token::Error.new
-          elsif [:nothing, :ε].include?(value)
-            Token::Epsilon.new
-          else
-            raise UndefinedTokenError, "Could not find a token named #{value.inspect}"
-          end
-        end
       end
     end
   end

data/lib/antelope/ace/precedence.rb

@@ -48,6 +48,10 @@ module Antelope
           0
         end
       end
+
+      def to_s
+        "#{type.to_s[0]}#{level}"
+      end
     end
   end
 end

data/lib/antelope/ace/scanner.rb

@@ -54,16 +54,21 @@ module Antelope
       #
       # @param source [String] the source to scan.  This should be compatible
       #   with StringScanner.
+      # @param name [String] the name of the source file.  This is primarily
+      #   used in backtrace information.
       # @return [Array<Array<(Symbol, Object, ...)>>]
       # @see #tokens
-      def self.scan(source)
-        new(source).scan_file
+      def self.scan(source, name = "(ace file)")
+        new(source, name).scan_file
       end
 
       # Initialize the scanner with the input.
       #
       # @param input [String] The source to scan.
-      def initialize(input)
+      # @param source [String] the source file.  This is primarily
+      #   used in backtrace information.
+      def initialize(input, source = "(ace file)")
+        @source  = source
         @scanner = StringScanner.new(input)
         @tokens  = []
       end
@@ -78,10 +83,19 @@ module Antelope
       # @see #scan_third_part
       # @see #tokens
       def scan_file
+        @line = 1
         scan_first_part
         scan_second_part
         scan_third_part
         tokens
+      rescue SyntaxError => e
+        start = [@scanner.pos - 8, 0].max
+        stop  = [@scanner.pos + 8, @scanner.string.length].min
+        snip  = @scanner.string[start..stop].strip.inspect
+        char  = @scanner.string[@scanner.pos].inspect
+        new_line = "#{@source}:#{@line}:unexpected #{char} (near #{snip})"
+
+        raise e, e.message, [new_line, *e.backtrace]
       end
 
       # Scans for whitespace.  If the next character is whitespace, it
@@ -90,7 +104,9 @@ module Antelope
       #
       # @return [Boolean] if any whitespace was matched.
       def scan_whitespace
-        @scanner.scan(/\s+/)
+        if @scanner.scan(/(\s+)/)
+          @line += @scanner[1].count("\n")
+        end
       end
 
       private
@@ -105,7 +121,7 @@ module Antelope
         stop  = [@scanner.pos + 8, @scanner.string.length].min
         snip  = @scanner.string[start..stop].strip
         char  = @scanner.string[@scanner.pos]
-        raise SyntaxError, "invalid syntax near `#{snip.inspect}' (#{char.inspect})"
+        raise SyntaxError, "invalid syntax"# near `#{snip.inspect}' (#{char.inspect})"
       end
     end
   end

data/lib/antelope/generation/tableizer.rb

@@ -21,6 +21,8 @@ module Antelope
       # @return [Hash<(Numeric, Recognizer::Rule)>]
       attr_accessor :rules
 
+      attr_reader :conflicts
+
       # Initialize.
       #
       # @param grammar [Ace::Grammar]
@@ -82,6 +84,7 @@ module Antelope
       #   resolved using precedence rules.
       # @return [void]
       def conflictize
+        @conflicts = Hash.new { |h, k| h[k] = {} }
         @table.each_with_index do |v, state|
           v.each do |on, data|
             if data.size == 1
@@ -104,6 +107,9 @@ module Antelope
 
             case result
             when 0
+              conflicts[state][on] = [
+                rule_part, other_part, terminal, @rules[rule_part[1]].prec
+              ]
               $stderr.puts \
                 "Could not determine move for #{on} in state " \
                 "#{state} (shift/reduce conflict)"

data/lib/antelope/generator/base.rb

@@ -0,0 +1,127 @@
+module Antelope
+  module Generator
+
+    # Generates a parser.  This is normally the parent class, and the
+    # specific implementations inherit from this.  The generated
+    # parser should, ideally, be completely independent (not requiring
+    # any external source code), as well as be under a permissive
+    # license.
+    #
+    # @abstract Subclass and redefine {#generate} to create a
+    #   generator.
+    class Base
+      # The modifiers that were applied to the grammar.
+      #
+      # @return [Hash<(Symbol, Object)>]
+      attr_reader :mods
+
+      # The file name (not including the extension) that the grammar
+      # should output to.
+      #
+      # @return [String]
+      attr_reader :file
+
+      # The grammar that the generator is for.
+      #
+      # @return [Ace::Grammar]
+      attr_reader :grammar
+
+      # The source root directory for templates.  Overwrite to change.
+      #
+      # @return [Pathname]
+      def self.source_root
+        Pathname.new("../templates").expand_path(__FILE__)
+      end
+
+      def self.register_as(*names)
+        Generator.register_generator(self, *names)
+      end
+
+      # Initialize the generator.
+      #
+      # @param grammar [Grammar]
+      # @param mods [Hash<(Symbol, Object)>]
+      def initialize(grammar, mods)
+        @file    = grammar.name
+        @grammar = grammar
+        @mods    = mods
+      end
+
+      # Actually does the generation.  A subclass should implement this.
+      #
+      # @raise [NotImplementedError]
+      # @return [void]
+      def generate
+        raise NotImplementedError
+      end
+
+      protected
+
+      # Copies a template from the source, runs it through erb (in the
+      # context of this class), and then outputs it at the destination.
+      # If given a block, it will call the block after the template is
+      # run through erb with the content from erb; the result of the
+      # block is then used as the content instead.
+      #
+      # @param source [String] the source file.  This should be in
+      #   {.source_root}.
+      # @param destination [String] the destination file.  This will be
+      #   in {Ace::Grammar#output}.
+      # @yieldparam [String] content The content that ERB created.
+      # @yieldreturn [String] The new content to write to the output.
+      # @return [void]
+      def template(source, destination)
+        src_file  = Pathname.new(source)
+          .expand_path(self.class.source_root)
+        src       = src_file.open("r")
+        context   = instance_eval('binding')
+        erb       = ERB.new(src.read, nil, "%")
+        erb.filename = source
+        content   = erb.result(context)
+        content   = yield content if block_given?
+        dest_file = Pathname.new(destination)
+          .expand_path(grammar.output)
+        dest_file.open("w") do |f|
+          f.write(content)
+        end
+      end
+
+      # The actual table that is used for parsing.  This returns an
+      # array of hashes; the array index corresponds to the state
+      # number, and the hash keys correspond to the lookahead tokens.
+      # The hash values are an array; the first element of that array
+      # is the action to be taken, and the second element of the
+      # array is the argument for that action.  Possible actions
+      # include `:accept`, `:reduce`, and `:state`; `:accept` means
+      # to accept the string; `:reduce` means to perform the given
+      # reduction; and `:state` means to transition to the given
+      # state.
+      #
+      # @return [Array<Hash<Symbol => Array<(Symbol, Numeric)>>>]
+      def table
+        mods[:tableizer].table
+      end
+
+      # Returns an array of the production information of each
+      # production needed by the parser.  The first element of any
+      # element in the array is an {Ace::Token::Nonterminal} that
+      # that specific production reduces to; the second element
+      # is a number describing the number of items in the right hand
+      # side of the production; the string represents the action
+      # that should be taken on reduction.
+      #
+      # This information is used for `:reduce` actions in the parser;
+      # the value of the `:reduce` action corresponds to the array
+      # index of the production in this array.
+      #
+      # @return [Array<Array<(Ace::Token::Nonterminal, Numeric, String)>]
+      def productions
+        grammar.all_productions.map do |production|
+          [production[:label],
+           production[:items].size,
+           production[:block]]
+        end
+      end
+    end
+  end
+end

data/lib/antelope/generator/group.rb

@@ -0,0 +1,57 @@
+module Antelope
+  module Generator
+
+    # For use to use multiple generators as a bundle.  Works exactly
+    # like a normal generator, i.e. responds to both {.register_as}
+    # and {#generate}, but also responds to {.register_generator},
+    # like {Generator}.  Any generators registered to the group are
+    # used to generate the files.
+    #
+    # @abtract Subclass and use {.register_generator} to create a
+    #   group generator.
+    class Group < Base
+
+      extend Generator
+
+      # Initialize the group generator.  Calls {Base#initialize}, and
+      # then instantizes all of the generators in the group.
+      def initialize(*_)
+        super
+
+        generators.map! do |gen|
+          gen.new(*_)
+        end
+      end
+
+      # Generates files using the generators contained within this
+      # group.  If it encounters an error in one of the generators, it
+      # will continue to try to generate the rest of the generators.
+      # It will then raise the last error given at the end.
+      #
+      # @return [void]
+      def generate
+        error = nil
+        generators.map do |gen|
+          begin
+            gen.generate
+          rescue => e
+            $stderr.puts "Error running #{gen.class}: #{e.message}"
+            error = e
+          end
+        end
+
+        raise error if error
+      end
+
+      private
+
+      # Retrieve a list of all of the generators that are contained
+      # within this group.
+      #
+      # @return [Array<Generator::Base>]
+      def generators
+        @_generators ||= self.class.generators.values
+      end
+    end
+  end
+end

data/lib/antelope/generator/null.rb

@@ -0,0 +1,13 @@
+module Antelope
+  module Generator
+
+    # Represents a generator that does not generate anything.
+    class Null < Base
+
+      # Does nothing.
+      #
+      # @return [void]
+      def generate; end
+    end
+  end
+end

data/lib/antelope/generator/output.rb

@@ -3,11 +3,13 @@
 require "pp"
 
 module Antelope
-  class Generator
+  module Generator
 
     # Generates an output file, mainly for debugging.  Included always
     # as a generator for a grammar.
-    class Output < Generator
+    class Output < Base
+
+      register_as "output"
 
       # Defines singleton method for every mod that the grammar passed
       # to the generator.
@@ -20,6 +22,21 @@ module Antelope
         end
       end
 
+      def unused_symbols
+        @_unused_symbols ||= begin
+          used = grammar.all_productions.map(&:items).flatten.uniq
+          all  = grammar.symbols.map do |s|
+            if Symbol === s
+              grammar.find_token(s)
+            else
+              s
+            end
+          end
+
+          all - used - [grammar.find_token(:"$start")]
+        end
+      end
+
       # Actually performs the generation.  Uses the template in
       # output.erb, and generates the file `<file>.output`.
       #

data/lib/antelope/generator/ruby.rb

@@ -3,17 +3,19 @@
 require "pp"
 
 module Antelope
-  class Generator
+  module Generator
 
     # Generates a ruby parser.
-    class Ruby < Generator
+    class Ruby < Base
+
+      register_as "ruby"
 
       # Creates an action table for the parser.
       #
       # @return [String]
       def generate_action_table
         out = ""
-        PP.pp(mods[:tableizer].table, out)
+        PP.pp(table, out)
         out
       end
 
@@ -23,15 +25,15 @@ module Antelope
       def generate_productions_list
         out = "["
 
-        grammar.all_productions.each do |production|
-          out                              <<
-            "["                            <<
-            production.label.name.inspect  <<
-            ", "                           <<
-            production.items.size.inspect  <<
+        productions.each do |(label, size, block)|
+          out                   <<
+            "["                 <<
+            label.name.inspect  <<
+            ", "                <<
+            size.inspect        <<
             ", "
 
-          block = if production.block.empty?
+          block = if block.empty?
             "proc { |_| _ }"
           else
             "proc #{production.block}"

data/lib/antelope/generator/templates/output.erb

@@ -3,11 +3,17 @@ Productions:
 % productions = grammar.all_productions.
 %   map { |x| ["#{x.label}: #{x.items.join(' ')}", x.block] }
 % body = productions.map { |_| _.first.size }.max
-<%= body %>
 % productions.each_with_index do |prod, i|
   <%= "%#{len}s" % i %> <%= "%-#{body}s" % prod[0] %> <%= prod[1] %>
 % end
 
+% if unused_symbols.any?
+Symbols unused in grammar:
+%   unused_symbols.each do |sym|
+  <%= sym %>
+%   end
+% end
+
 Precedence:
   --- highest
 % grammar.precedence.each do |pr|
@@ -28,7 +34,7 @@ Precedence:
 %   transitions = v.each.select { |_, a| a && a[0] == :state }
 %   reductions  = v.each.select { |_, a| a && a[0] == :reduce}
 %   accepting   = v.each.select { |_, a| a && a[0] == :accept}
-%   conflicts   = v.each.select { |_, (a, b)| a.is_a?(Array) }
+%   conflicts   = tableizer.conflicts[i].each
 %   thing = [:transitions, :reductions, :accepting]
 %   num_type = {transitions: "State", reductions: "Rule", accepting: "Rule"}
 %   h = Hash[thing.zip([transitions, reductions, accepting])]
@@ -42,8 +48,8 @@ Precedence:
 %   end
 %   if conflicts.any?
     conflicts:
-%     conflicts.each do |token, (first, second)|
-      <%= token %>: <%= first.join(" ") %>/<%= second.join(" ") %>
+%     conflicts.each do |token, (first, second, rule, terminal)|
+      <%= token %>: <%= first.join(" ") %>/<%= second.join(" ") %> (<%= rule %> vs <%= terminal %>)
 %     end
 %   end
 

data/lib/antelope/generator/templates/ruby.erb

@@ -1,3 +1,4 @@
+
 # This file assumes that the output of the generator will be placed
 # within a module or a class.  However, the module/class requires a
 # `type` method, which takes a terminal and gives its type, as a

data/lib/antelope/generator.rb

@@ -1,88 +1,50 @@
 # encoding: utf-8
-
-require "antelope/generator/output"
-require "antelope/generator/ruby"
 require "erb"
 require "pathname"
 
 module Antelope
 
-  # Generates a parser.  This is normally the parent class, and the
-  # specific implementations inherit from this.  The generated
-  # parser should, ideally, be completely independent (not requiring
-  # any external source code), as well as be under a permissive
-  # license.
-  class Generator
-
-    # The modifiers that were applied to the grammar.
-    #
-    # @return [Hash<(Symbol, Object)>]
-    attr_reader :mods
-
-    # The file name (not including the extension) that the grammar
-    # should output to.
-    #
-    # @return [String]
-    attr_reader :file
-
-    # The grammar that the generator is for.
-    #
-    # @return [Ace::Grammar]
-    attr_reader :grammar
-
-    # The source root directory for templates.  Overwrite to change.
-    #
-    # @return [Pathname]
-    def self.source_root
-      Pathname.new("../generator/templates").expand_path(__FILE__)
-    end
-
-    # Initialize the generator.
-    #
-    # @param grammar [Grammar]
-    # @param mods [Hash<(Symbol, Object)>]
-    def initialize(grammar, mods)
-      @file    = grammar.name
-      @grammar = grammar
-      @mods    = mods
-    end
+  # Contains the classes that generate parsers.  This contains a
+  # registery of all of the generators available to antelope.
+  module Generator
 
-    # Actually does the generation.  A subclass should implement this.
+    # Returns a hash of all of the generators registered within this
+    # module.  If a generator is accessed that does not exist on the
+    # hash, it by default returns the {Generator::Null} class.
     #
-    # @raise [NotImplementedError]
-    # @return [void]
-    def generate
-      raise NotImplementedError
+    # @return [Hash<(Symbol, String) => Generator::Base>]
+    def generators
+      @_generators ||= Hash.new { |h, k| h[k] = Generator::Null }
     end
 
-    protected
-
-    # Copies a template from the source, runs it through erb (in the
-    # context of this class), and then outputs it at the destination.
-    # If given a block, it will call the block after the template is
-    # run through erb with the content from erb; the result of the
-    # block is then used as the content instead.
+    # Registers a generator with the given names.  If multiple names
+    # are given, they are assigned the generator as a value in the
+    # {#generators} hash; otherwise, the one name is assigned the
+    # generator as a value.
     #
-    # @param source [String] the source file.  This should be in
-    #   {.source_root}.
-    # @param destination [String] the destination file.  This will be
-    #   in {Ace::Grammar#output}.
-    # @yieldparam [String] content The content that ERB created.
-    # @yieldreturn [String] The new content to write to the output.
-    # @return [void]
-    def template(source, destination)
-      src_file  = self.class.source_root + source
-      src       = src_file.open("r")
-      context   = instance_eval('binding')
-      erb       = ERB.new(src.read, nil, "%")
-      erb.filename = source
-      content   = erb.result(context)
-      content   = yield content if block_given?
-      dest_file = grammar.output + destination
-      dest_file.open("w") do |f|
-        f.write(content)
+    # @param generator [Generator::Base] the generator class to
+    #   associate the key with.
+    # @param name [String, Symbol] a name to associate the generator
+    #   with.
+    def register_generator(generator, *names)
+      names = [names].flatten
+      raise ArgumentError,
+        "Requires at least one name" unless names.any?
+      raise ArgumentError,
+        "All name values must be a Symbol or string" unless names.
+        all? {|_| [Symbol, String].include?(_.class) }
+
+      names.each do |name|
+        generators[name] = generator
       end
     end
 
+    extend self
+
   end
 end
+
+require "antelope/generator/base"
+require "antelope/generator/group"
+require "antelope/generator/output"
+require "antelope/generator/ruby"

data/lib/antelope/version.rb

@@ -2,5 +2,5 @@
 
 module Antelope
   # The current running version of antelope.
-  VERSION = "0.1.7".freeze
+  VERSION = "0.1.8".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: antelope
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-29 00:00:00.000000000 Z
+date: 2014-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -106,6 +106,8 @@ files:
 - ".rspec"
 - ".travis.yml"
 - ".yardopts"
+- CONTRIBUTING.md
+- GENERATORS.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -152,6 +154,9 @@ files:
 - lib/antelope/generation/recognizer/state.rb
 - lib/antelope/generation/tableizer.rb
 - lib/antelope/generator.rb
+- lib/antelope/generator/base.rb
+- lib/antelope/generator/group.rb
+- lib/antelope/generator/null.rb
 - lib/antelope/generator/output.rb
 - lib/antelope/generator/ruby.rb
 - lib/antelope/generator/templates/output.erb