antelope 0.2.0 → 0.2.2

data/lib/antelope/ace/errors.rb

@@ -1,48 +1,48 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-
-    # Defines an error that can occur within the Ace module.  All
-    # errors that are raised within the Ace module are subclasses of
-    # this.
-    class Error < Antelope::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
-
-    # Used primarily in the {Scanner}, this is raised when an input
-    # is malformed.  The message should contain a snippet of the input
-    # which caused the error.
-    class SyntaxError < Error
-    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
-
-    # Primarily used in the {Compiler}, if a scanner token appears
-    # that should not be in the current state, this is raised.
-    class InvalidStateError < 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
-
-    # Primarily used in the {Compiler}, it is raised if it encounters
-    # a directive it cannot handle.  This is more to warn the
-    # developer that a directive they wrote may not be accepted by any
-    # generator.
-    class NoDirectiveError < Error
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Ace
+
+    # Defines an error that can occur within the Ace module.  All
+    # errors that are raised within the Ace module are subclasses of
+    # this.
+    class Error < Antelope::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
+
+    # Used primarily in the {Scanner}, this is raised when an input
+    # is malformed.  The message should contain a snippet of the input
+    # which caused the error.
+    class SyntaxError < Error
+    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
+
+    # Primarily used in the {Compiler}, if a scanner token appears
+    # that should not be in the current state, this is raised.
+    class InvalidStateError < 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
+
+    # Primarily used in the {Compiler}, it is raised if it encounters
+    # a directive it cannot handle.  This is more to warn the
+    # developer that a directive they wrote may not be accepted by any
+    # generator.
+    class NoDirectiveError < Error
+    end
+  end
+end

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

@@ -1,80 +1,80 @@
-# 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
+# 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 +1,53 @@
-# 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
+# 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,65 +1,68 @@
-# 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.
-            select { |pr| pr.tokens.include?(token) }.first
-
-          unless prec
-            prec = precedence.
-              select { |pr| pr.tokens.include?(:_) }.first
-          end
-
-          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
-          precedence = @compiler.options[:prec].
-            each_with_index.map do |prec, i|
-            Ace::Precedence.new(prec[0], prec[1..-1].to_set, size - i)
-          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
+# 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