antelope 0.2.4 → 0.3.0

data/lib/antelope/dsl/contexts/main.rb

@@ -0,0 +1,63 @@
+module Antelope
+  module DSL
+    module Contexts
+      # The main context of the Antelope DSL.
+      class Main < Base
+        def define(pass)
+          pass.each do |key, value|
+            case value
+            when Array
+              @defines[key] = value
+            else
+              @defines[key] = [value]
+            end
+          end
+        end
+
+        def terminals(&block)
+          @terminals.merge! context(Terminal, &block)
+        end
+
+        def precedences(&block)
+          @precedences = context(Precedence, &block)
+        end
+
+        def productions(&block)
+          @productions = context(Production, &block)
+        end
+
+        def template(template)
+          case template
+          when Hash
+            @templates.merge(template)
+          when String
+            @templates[:default] = template
+          else
+            raise ArgumentError, "Unexpected #{template.class}, " \
+              "expected String or Hash"
+          end
+        end
+
+        private
+
+        def before_call
+          @defines     = {}
+          @templates   = {}
+          @terminals   = {}
+          @precedences = []
+          @productions = []
+        end
+
+        def data
+          {
+            defines:     @defines,
+            templates:   @templates,
+            terminals:   @terminals,
+            precedences: @precedences,
+            productions: @productions
+          }
+        end
+      end
+    end
+  end
+end

data/lib/antelope/dsl/contexts/match.rb

@@ -0,0 +1,24 @@
+module Antelope
+  module DSL
+    module Contexts
+      class Match < Base
+        def match(options)
+          body   = options.fetch(:body)
+          action = options.fetch(:action)
+          prec   = options.fetch(:prec, '')
+
+          @matches << { body: body, action: "{#{action}}", prec: prec }
+        end
+
+        private
+
+        attr_reader :matches
+        alias_method :data, :matches
+
+        def before_call
+          @matches = []
+        end
+      end
+    end
+  end
+end

data/lib/antelope/dsl/contexts/precedence.rb

@@ -0,0 +1,20 @@
+module Antelope
+  module DSL
+    module Contexts
+      class Precedence < Base
+        def precedence(type, contents)
+          @precedences << [type].concat(contents)
+        end
+
+        private
+
+        attr_reader :precedences
+        alias_method :data, :precedences
+
+        def before_call
+          @precedences = []
+        end
+      end
+    end
+  end
+end

data/lib/antelope/dsl/contexts/production.rb

@@ -0,0 +1,24 @@
+module Antelope
+  module DSL
+    module Contexts
+      class Production < Base
+        def production(name, &block)
+          @productions[name].concat(context(Match, &block))
+        end
+
+        private
+
+        attr_reader :productions
+        alias_method :data, :productions
+
+        def before_call
+          @productions = Hash.new { |h, k| h[k] = [] }
+        end
+
+        def data
+          @productions
+        end
+      end
+    end
+  end
+end

data/lib/antelope/dsl/contexts/terminal.rb

@@ -0,0 +1,28 @@
+module Antelope
+  module DSL
+    module Contexts
+      class Terminal < Base
+        def terminal(map, value = true)
+          case map
+          when Hash
+            @terminals.merge!(map)
+          when Symbol, String
+            @terminals[map] = value
+          else
+            raise ArgumentError, "Unexpected #{map.class}, expected " \
+              "Hash or Symbol"
+          end
+        end
+
+        private
+
+        attr_reader :terminals
+        alias_method :data, :terminals
+
+        def before_call
+          @terminals = {}
+        end
+      end
+    end
+  end
+end

data/lib/antelope/dsl/contexts.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'antelope/dsl/contexts/base'
+require 'antelope/dsl/contexts/main'
+require 'antelope/dsl/contexts/match'
+require 'antelope/dsl/contexts/precedence'
+require 'antelope/dsl/contexts/production'
+require 'antelope/dsl/contexts/terminal'
+
+module Antelope
+  module DSL
+    # The contexts implemented within a DSL.
+    module Contexts
+    end
+  end
+end

data/lib/antelope/dsl.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'antelope/dsl/compiler'
+require 'antelope/dsl/contexts'
+
+module Antelope
+  module DSL
+  end
+end

data/lib/antelope/errors.rb

@@ -1,8 +1,25 @@
 # encoding: utf-8
 
 module Antelope
-
   # Every error in antelope inherits this error class.
   class Error < StandardError
   end
+
+  # This is used primarily in the {Grammar}; if a rule references a
+  # token (a nonterminal or a terminal) that was not previously
+  # defined, this is raised.
+  class UndefinedTokenError < Error
+  end
+
+  # Used primarily in the {Compiler}, this is raised when the
+  # version requirement of the Ace file doesn't match the running
+  # version of Ace.
+  class IncompatibleVersionError < Error
+  end
+
+  # Primarily used in the {Grammar} (specifically
+  # {Grammar::Generation}), if the grammar could not determine the
+  # generator to use for the generation, it raises this.
+  class NoTypeError < Error
+  end
 end

data/lib/antelope/generation/constructor/first.rb

@@ -3,10 +3,8 @@
 module Antelope
   module Generation
     class Constructor
-
       # Contains the methods to construct first sets for tokens.
       module First
-
         # Initialize.
         def initialize
           @firstifying = []
@@ -27,12 +25,12 @@ module Antelope
         #       # if A is a nonterminal and a_1, a_2, ..., a_3 are all
         #       # of the right-hand sides of its productions.
         #
-        # @param token [Ace::Token, Array<Ace::Token>]
-        # @return [Set<Ace::Token::Terminal>]
+        # @param token [Grammar::Token, Array<Grammar::Token>]
+        # @return [Set<Grammar::Token::Terminal>]
         # @see #first_array
         def first(token)
           case token
-          when Ace::Token::Nonterminal
+          when Grammar::Token::Nonterminal
             firstifying(token) do
               productions = grammar.productions[token.name]
               productions.map { |prod|
@@ -40,12 +38,12 @@ module Antelope
             end
           when Array
             first_array(token)
-          when Ace::Token::Epsilon
+          when Grammar::Token::Epsilon
             Set.new
-          when Ace::Token::Terminal
+          when Grammar::Token::Terminal
             Set.new([token])
           else
-            incorrect_argument! token, Ace::Token, Array
+            incorrect_argument! token, Grammar::Token, Array
           end
         end
 
@@ -57,8 +55,8 @@ module Antelope
         # sets for (since some tokens may be nullable).  We then add
         # those sets to our set.
         #
-        # @param tokens [Array<Ace::Token>]
-        # @return [Set<Ace::Token>]
+        # @param tokens [Array<Grammar::Token>]
+        # @return [Set<Grammar::Token>]
         def first_array(tokens)
           tokens.dup.delete_if { |_| @firstifying.include?(_) }.
           each_with_index.take_while do |token, i|
@@ -73,9 +71,9 @@ module Antelope
         # Helps keep track of the nonterminals we're finding FIRST
         # sets for. This helps prevent recursion.
         #
-        # @param tok [Ace::Token::Nonterminal]
+        # @param tok [Grammar::Token::Nonterminal]
         # @yield once.
-        # @return [Set<Ace::Token>]
+        # @return [Set<Grammar::Token>]
         def firstifying(tok)
           @firstifying << tok
           out = yield

data/lib/antelope/generation/constructor/follow.rb

@@ -18,12 +18,12 @@ module Antelope
         # generates the FOLLOW set for the given token, and then
         # caches it.
         #
-        # @return [Set<Ace::Token>]
+        # @return [Set<Grammar::Token>]
         # @see Constructor#incorrect_argument!
         # @see #generate_follow_set
         def follow(token)
-          unless token.is_a? Ace::Token::Nonterminal
-            incorrect_argument! token, Ace::Token::Nonterminal
+          unless token.is_a? Grammar::Token::Nonterminal
+            incorrect_argument! token, Grammar::Token::Nonterminal
           end
 
           @follows.fetch(token) { generate_follow_set(token) }
@@ -62,8 +62,8 @@ module Antelope
         # cache the result of a FOLLOW set, the empty set will be
         # returned).
         #
-        # @param token [Ace::Token::Nonterminal]
-        # @return [Set<Ace::Token>]
+        # @param token [Grammar::Token::Nonterminal]
+        # @return [Set<Grammar::Token>]
         # @see First#first
         # @see Nullable#nullable?
         def generate_follow_set(token)
@@ -96,7 +96,7 @@ module Antelope
             end
           end
 
-          # Replace the cached empty set with our filled set.
+          # ReplGrammar the cached empty set with our filled set.
           @follows[token] = set
         end
       end

data/lib/antelope/generation/constructor/nullable.rb

@@ -22,12 +22,12 @@ module Antelope
         #       # if A is a nonterminal and a_1, a_2, ..., a_n are all
         #       # of the right-hand sides of its productions
         #
-        # @param token [Ace::Token, Array<Ace::Token>] the token to
+        # @param token [Grammar::Token, Array<Grammar::Token>] the token to
         #    check.
         # @return [Boolean] if the token can reduce to ϵ.
         def nullable?(token)
           case token
-          when Ace::Token::Nonterminal
+          when Grammar::Token::Nonterminal
             nullifying(token) do
               productions = grammar.productions[token.name]
               !!productions.any? { |prod| nullable?(prod[:items]) }
@@ -35,12 +35,12 @@ module Antelope
           when Array
             token.dup.delete_if { |tok|
               @nullifying.include?(tok) }.all? { |tok| nullable?(tok) }
-          when Ace::Token::Epsilon
+          when Grammar::Token::Epsilon
             true
-          when Ace::Token::Terminal
+          when Grammar::Token::Terminal
             false
           else
-            incorrect_argument! token, Ace::Token, Array
+            incorrect_argument! token, Grammar::Token, Array
           end
         end
 
@@ -49,7 +49,7 @@ module Antelope
         # Helps keep track of the nonterminals we're checking for
         # nullability.  This helps prevent recursion.
         #
-        # @param tok [Ace::Token::Nonterminal]
+        # @param tok [Grammar::Token::Nonterminal]
         # @yield once.
         # @return [Boolean]
         def nullifying(tok)

data/lib/antelope/generation/constructor.rb

@@ -18,17 +18,17 @@ module Antelope
 
       # The grammar.
       #
-      # @return [Ace::Grammar]
+      # @return [Grammar::Grammar]
       attr_reader :grammar
 
       # The augmented productions generated by the constructor.
       #
-      # @return [Set<Ace::Production>]
+      # @return [Set<Grammar::Production>]
       attr_reader :productions
 
       # Initialize.
       #
-      # @param grammar [Ace::Grammar] the grammar.
+      # @param grammar [Grammar::Grammar] the grammar.
       def initialize(grammar)
         @productions = Set.new
         @grammar = grammar
@@ -120,7 +120,7 @@ module Antelope
       private
 
       def incorrect_argument!(arg, *types)
-        raise ArgumentError, "Expected one of #{types.join(", ")}, got #{arg.class}"
+        raise ArgumentError, "Expected one of #{types.join(', ')}, got #{arg.class}"
       end
     end
   end

data/lib/antelope/generation/recognizer/rule.rb

@@ -13,12 +13,12 @@ module Antelope
 
         # The left-hand side of the rule.
         #
-        # @return [Ace::Token::Nonterminal]
+        # @return [Grammar::Token::Nonterminal]
         attr_reader :left
 
         # The right-hand side of the rule.
         #
-        # @return [Array<Ace::Token>]
+        # @return [Array<Grammar::Token>]
         attr_reader :right
 
         # The current position inside of the rule.
@@ -28,7 +28,7 @@ module Antelope
 
         # The block to be executed on production match.
         #
-        # @deprecated Use {Ace::Production#block} instead.
+        # @deprecated Use {Grammar::Production#block} instead.
         # @return [String]
         attr_reader :block
 
@@ -47,19 +47,19 @@ module Antelope
 
         # The precedence for this rule.
         #
-        # @return [Ace::Precedence]
+        # @return [Grammar::Precedence]
         attr_accessor :precedence
 
         # The associated production.
         #
-        # @return [Ace::Production]
+        # @return [Grammar::Production]
         attr_reader :production
 
         include Comparable
 
         # Initialize the rule.
         #
-        # @param production [Ace::Production] the production
+        # @param production [Grammar::Production] the production
         #   that this rule is based off of.
         # @param position [Numeric] the position that this rule is in
         #   the production.
@@ -71,7 +71,7 @@ module Antelope
           @precedence = production.prec
           @production = production
           @block      = production.block
-          @id         = "%10x" % object_id
+          @id         = format('%10x', object_id)
 
           if inherited
             @left, @right = inherited
@@ -85,7 +85,7 @@ module Antelope
         # @return [String]
         def inspect
           "#<#{self.class} id=#{id} left=#{left} " \
-            "right=[#{right.join(" ")}] position=#{position}>"
+            "right=[#{right.join(' ')}] position=#{position}>"
         end
 
         # Give a nicer representation of the rule as a string.  Shows
@@ -97,16 +97,16 @@ module Antelope
         # @return [String]
         def to_s(dot = true)
           "#{id}/#{precedence.type.to_s[0]}#{precedence.level}: " \
-            "#{left} → #{right[0, position].join(" ")}" \
-            "#{" • " if dot}#{right[position..-1].join(" ")}"
+            "#{left} → #{right[0, position].join(' ')}" \
+            "#{' • ' if dot}#{right[position..-1].join(' ')}"
         end
 
         # Returns the active token.  If there is no active token, it
-        # returns a blank {Ace::Token}.
+        # returns a blank {Grammar::Token}.
         #
-        # @return [Ace::Token]
+        # @return [Grammar::Token]
         def active
-          right[position] or Ace::Token.new(nil)
+          right[position] || Grammar::Token.new(nil)
         end
 
         # Creates the rule after this one by incrementing the position
@@ -174,9 +174,9 @@ module Antelope
         # @return [Numeric]
         def ===(other)
           if other.is_a? Rule
-            left === other.left and right.size == other.right.size and
-              right.each_with_index.
-                all? { |e, i| e === other.right[i] }
+            left === other.left && right.size == other.right.size &&
+              right.each_with_index
+                .all? { |e, i| e === other.right[i] }
           else
             super
           end
@@ -206,7 +206,7 @@ module Antelope
         # @note This is not intended for use.  It is only defined to
         #   make equality checking easier, and to create a hash.
         # @private
-        # @return [Array<(Ace::Token::Nonterminal, Array<Ace::Token>, Numeric)>]
+        # @return [Array<(Grammar::Token::Nonterminal, Array<Grammar::Token>, Numeric)>]
         def to_a
           @_array ||= [left, right, position]
         end

data/lib/antelope/generation/recognizer/state.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
-require "forwardable"
-require "securerandom"
+require 'forwardable'
+require 'securerandom'
 
 module Antelope
   module Generation
@@ -37,7 +37,7 @@ module Antelope
         def initialize
           @rules = Set.new
           @transitions = {}
-          @id = "%10x" % object_id
+          @id = format('%10x', object_id)
         end
 
         # Gives a nice string representation of the state.
@@ -45,8 +45,8 @@ module Antelope
         # @return [String]
         def inspect
           "#<#{self.class} id=#{id} " \
-            "transitions=[#{transitions.keys.join(", ")}] " \
-            "rules=[{#{rules.to_a.join("} {")}}]>"
+            "transitions=[#{transitions.keys.join(', ')}] " \
+            "rules=[{#{rules.to_a.join('} {')}}]>"
         end
 
         # Merges another state with this state.  It copies all of the
@@ -61,7 +61,7 @@ module Antelope
             "got #{other.class}" unless other.is_a? State
 
           self << other
-          self.transitions.merge! other.transitions
+          transitions.merge! other.transitions
 
           self
         end
@@ -90,7 +90,7 @@ module Antelope
           when State
             rule.rules.map(&:clone).each { |r| self << r }
           when Rule
-            rules << rule #unless rules.include? rule
+            rules << rule
           when Array, Set
             rule.each do |part|
               self << part
@@ -120,10 +120,9 @@ module Antelope
           other_rules = other.rules.to_a
           other.transitions == transitions &&
             rules.size == other_rules.size &&
-            rules.each_with_index.
-            all? { |rule, i| rule === other_rules[i] }
+            rules.each_with_index
+            .all? { |rule, i| rule === other_rules[i] }
         end
-
       end
     end
   end

data/lib/antelope/generation/recognizer.rb

@@ -1,16 +1,14 @@
 # encoding: utf-8
 
-require "antelope/generation/recognizer/rule"
-require "antelope/generation/recognizer/state"
+require 'antelope/generation/recognizer/rule'
+require 'antelope/generation/recognizer/state'
 
 module Antelope
   module Generation
-
     # Recognizes all of the states in the grammar.
     #
     # @see http://redjazz96.tumblr.com/post/88446352960
     class Recognizer
-
       # A list of all of the states in the grammar.
       #
       # @return [Set<State>]
@@ -24,12 +22,12 @@ module Antelope
 
       # The grammar that the recognizer is running off of.
       #
-      # @return [Ace::Grammar]
+      # @return [Grammar]
       attr_reader :grammar
 
       # Initialize the recognizer.
       #
-      # @param grammar [Ace::Grammar]
+      # @param grammar [Grammar]
       def initialize(grammar)
         @grammar = grammar
         @states = Set.new
@@ -102,7 +100,7 @@ module Antelope
       # @return [void]
       def compute_closure(state)
         fixed_point(state.rules) do
-          state.rules.select { |_| _.active.nonterminal? }.each do |rule|
+          state.rules.select { |r| r.active.nonterminal? }.each do |rule|
             grammar.productions[rule.active.name].each do |prod|
               state << Rule.new(prod, 0)
             end
@@ -115,9 +113,9 @@ module Antelope
 
         actives.each do |active|
           next if state.transitions[active.name]
-          rules = state.rules.
-            select { |r| r.active == active && r.succ? }.
-            map(&:succ).to_set
+          rules = state.rules
+                  .select { |r| r.active == active && r.succ? }
+                  .map(&:succ).to_set
           s = states.find { |st| rules.subset? st.rules } || begin
             s = State.new << rules
             compute_closure(s)
@@ -174,7 +172,6 @@ module Antelope
           added = enum.size - added
         end
       end
-
     end
   end
 end

data/lib/antelope/generation/tableizer.rb

@@ -8,7 +8,7 @@ module Antelope
 
       # The grammar that the table is based off of.
       #
-      # @return [Ace::Grammar]
+      # @return [Grammar]
       attr_accessor :grammar
 
       # The table itself.
@@ -25,7 +25,7 @@ module Antelope
 
       # Initialize.
       #
-      # @param grammar [Ace::Grammar]
+      # @param grammar [Grammar]
       def initialize(grammar)
         @grammar = grammar
       end

data/lib/antelope/generator/base.rb

@@ -118,15 +118,15 @@ module Antelope
       end
 
       def coerce_nested_hash(key, value)
-        parts = key.split('.').map { |p| p.gsub(/-/, "_") }
+        parts = key.split('.').map { |p| p.gsub(/-/, '_') }
         top   = {}
         hash  = top
-        parts.each_with_index do |part, i|
+        parts.each_with_index do |part, _|
           hash[part] = if parts.last == part
-            value
-          else
-            {}
-          end
+                         value
+                       else
+                         {}
+                       end
           hash = hash[part]
         end
 
@@ -162,7 +162,7 @@ module Antelope
           # otherwise, if the first argument isn't "false", return
           # true.
 
-          values[0].to_s != "false"
+          values[0].to_s != 'false'
         when Array
           values.zip(type).map do |value, t|
             coerce_directive_value(defined, [value], t)

data/lib/antelope/generator/ruby.rb

@@ -71,7 +71,7 @@ module Antelope
       # @return [void]
       def generate
         template "ruby", "#{file}.rb" do |body|
-          sprintf(grammar.compiler.body, :write => body)
+          sprintf(grammar.compiler.body, write: body)
         end
       end
     end