antelope 0.3.2 → 0.4.0

data/lib/antelope/grammar/loading.rb

@@ -1,84 +1,84 @@
-# encoding: utf-8
-
-module Antelope
-  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)
-          ext = File.extname(file_name)
-          case ext
-          when ".rb", ".ate"
-            from_dsl_file(file_name)
-          when ".ace"
-            from_ace_file(file_name)
-          else
-            raise ArgumentError, "Unexpected file extension #{ext},"\
-              " expected one of .rb, .ate, or .ace"
-          end
-        end
-
-        def from_dsl_file(file_name)
-          body   = File.read(file_name)
-          output = File.dirname(file_name)
-          from_dsl_string(file_name, output, body)
-        end
-
-        def from_ace_file(file_name)
-          body   = File.read(file_name)
-          output = File.dirname(file_name)
-          name   = File.basename(file_name)
-          from_ace_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 file [String] the path of the grammar.  This is
-        #   used for eval.
-        # @param output [String] the output directory.
-        # @param string [String] the grammar body.
-        # @return [Grammar]
-        # @see DSL::Compiler
-        def from_dsl_string(file, output, string)
-          eval(string, TOPLEVEL_BINDING, file, 0)
-          grammar = Antelope.grammar
-          compiler = DSL::Compiler.compile(grammar[1], &grammar[2])
-          new(File.basename(file), output, compiler)
-        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_ace_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
+# encoding: utf-8
+
+module Antelope
+  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)
+          ext = File.extname(file_name)
+          case ext
+          when ".rb", ".ate"
+            from_dsl_file(file_name)
+          when ".ace"
+            from_ace_file(file_name)
+          else
+            raise ArgumentError, "Unexpected file extension #{ext},"\
+              " expected one of .rb, .ate, or .ace"
+          end
+        end
+
+        def from_dsl_file(file_name)
+          body   = File.read(file_name)
+          output = File.dirname(file_name)
+          from_dsl_string(file_name, output, body)
+        end
+
+        def from_ace_file(file_name)
+          body   = File.read(file_name)
+          output = File.dirname(file_name)
+          name   = File.basename(file_name)
+          from_ace_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 file [String] the path of the grammar.  This is
+        #   used for eval.
+        # @param output [String] the output directory.
+        # @param string [String] the grammar body.
+        # @return [Grammar]
+        # @see DSL::Compiler
+        def from_dsl_string(file, output, string)
+          eval(string, TOPLEVEL_BINDING, file, 0)
+          grammar = Antelope.grammar
+          compiler = DSL::Compiler.compile(grammar[1], &grammar[2])
+          new(File.basename(file), output, compiler)
+        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_ace_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

data/lib/antelope/grammar/precedence.rb

@@ -1,59 +1,59 @@
-# encoding: utf-8
-
-module Antelope
-  class Grammar
-    # Defines a precedence.  A precedence has a type, tokens, and a
-    # level.
-    Precedence = Struct.new(:type, :tokens, :level) do
-      # @!attribute [rw] type
-      #   The type of precedence level.  This should be one of
-      #   `:left`, `:right`, or `:nonassoc`.
-      #
-      #   @return [Symbol] the type.
-      # @!attribute [rw] tokens
-      #   An set of tokens that are on this specific precedence
-      #   level.  The tokens are identified as symbols.  The special
-      #   symbol, `:_`, represents any token.
-      #
-      #   @return [Set<Symbol>] the tokens on this level.
-      # @!attribute [rw] level
-      #   The level we're on.  The higher the level, the higher the
-      #   precedence.
-
-      include Comparable
-
-      # Compares the other object to this object.  If the other object
-      # isn't a {Precedence}, it returns nil.  If the other
-      # precedence isn't on the same level as this one, then the
-      # levels are compared and the result of that is returned.  If
-      # it is, however, the type is checked; if this precedence is
-      # left associative, then it returns 1 (it is greater than the
-      # other); if this precedence is right associative, then it
-      # returns -1 (it is less than the other); if this precedence is
-      # nonassociative, it returns 0 (it is equal to the other).
-      #
-      # @param other [Object] the object to compare to this one.
-      # @return [Numeric?]
-      def <=>(other)
-        return nil unless other.is_a? Precedence
-        if level != other.level
-          level <=> other.level
-        elsif type == :left
-          1
-        elsif type == :right
-          -1
-        else
-          0
-        end
-      end
-
-      # Converts the precedence into a representative string, denoting
-      # the type and the level.
-      #
-      # @return [String]
-      def to_s
-        "#{type.to_s[0]}#{level}"
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  class Grammar
+    # Defines a precedence.  A precedence has a type, tokens, and a
+    # level.
+    Precedence = Struct.new(:type, :tokens, :level) do
+      # @!attribute [rw] type
+      #   The type of precedence level.  This should be one of
+      #   `:left`, `:right`, or `:nonassoc`.
+      #
+      #   @return [Symbol] the type.
+      # @!attribute [rw] tokens
+      #   An set of tokens that are on this specific precedence
+      #   level.  The tokens are identified as symbols.  The special
+      #   symbol, `:_`, represents any token.
+      #
+      #   @return [Set<Symbol>] the tokens on this level.
+      # @!attribute [rw] level
+      #   The level we're on.  The higher the level, the higher the
+      #   precedence.
+
+      include Comparable
+
+      # Compares the other object to this object.  If the other object
+      # isn't a {Precedence}, it returns nil.  If the other
+      # precedence isn't on the same level as this one, then the
+      # levels are compared and the result of that is returned.  If
+      # it is, however, the type is checked; if this precedence is
+      # left associative, then it returns 1 (it is greater than the
+      # other); if this precedence is right associative, then it
+      # returns -1 (it is less than the other); if this precedence is
+      # nonassociative, it returns 0 (it is equal to the other).
+      #
+      # @param other [Object] the object to compare to this one.
+      # @return [Numeric?]
+      def <=>(other)
+        return nil unless other.is_a? Precedence
+        if level != other.level
+          level <=> other.level
+        elsif type == :left
+          1
+        elsif type == :right
+          -1
+        else
+          0
+        end
+      end
+
+      # Converts the precedence into a representative string, denoting
+      # the type and the level.
+      #
+      # @return [String]
+      def to_s
+        "#{type.to_s[0]}#{level}"
+      end
+    end
+  end
+end

data/lib/antelope/grammar/precedences.rb

@@ -1,64 +1,64 @@
-# encoding: utf-8
-
-require "set"
-
-module Antelope
-  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 <<
-            Precedence.new(prec[0], prec[1..-1].to_set,
-            size - index)
-          index += 1
-        end
-
-        precedence <<
-          Precedence.new(:nonassoc, [:$end].to_set, 0) <<
-          Precedence.new(:nonassoc, [:_].to_set, 1)
-        precedence.sort_by(&:level).reverse
-      end
-
-    end
-  end
-end
+# encoding: utf-8
+
+require "set"
+
+module Antelope
+  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 <<
+            Precedence.new(prec[0], prec[1..-1].to_set,
+            size - index)
+          index += 1
+        end
+
+        precedence <<
+          Precedence.new(:nonassoc, [:$end].to_set, 0) <<
+          Precedence.new(:nonassoc, [:_].to_set, 1)
+        precedence.sort_by(&:level).reverse
+      end
+
+    end
+  end
+end

data/lib/antelope/grammar/production.rb

@@ -1,56 +1,56 @@
-# encoding: utf-8
-
-module Antelope
-  class Grammar
-    # Defines a production.
-    Production = Struct.new(:label, :items, :block, :prec, :id) do
-      # @!attribute [rw] label
-      #   The label (or left-hand side) of the production.  This
-      #   should be a nonterminal.
-      #
-      #   @return [Symbol]
-      # @!attribute [rw] items
-      #   The body (or right-hand side) of the production.  This can
-      #   be array of terminals and nonterminals.
-      #
-      #   @return [Array<Token>]
-      # @!attribute [rw] block
-      #   The block of code to be executed when the production's right
-      #   hand side is reduced.
-      #
-      #   @return [String]
-      # @!attribute [rw] prec
-      #   The precedence declaration for the production.
-      #
-      #   @return [Ace::Precedence]
-      # @!attribute [rw] id
-      #   The ID of the production.  The starting production always
-      #   has an ID of 0.
-      #
-      #   @return [Numeric]
-
-      # Creates a new production from a hash.  The hash's keys
-      # correspond to the attributes on this class.
-      #
-      # @param hash [Hash<(Symbol, Object)>]
-      def self.from_hash(hash)
-        new(hash[:label] || hash['label'],
-            hash[:items] || hash['items'],
-            hash[:block] || hash['block'],
-            hash[:prec]  || hash['prec'],
-            hash[:id]    || hash['id'])
-      end
-
-      # Create a new version of the production with duplicated values.
-      #
-      # @return [Production]
-      def clone
-        Production.new(label.dup,
-          items.map(&:dup),
-          block.dup,
-          prec.dup,
-          id)
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  class Grammar
+    # Defines a production.
+    Production = Struct.new(:label, :items, :block, :prec, :id) do
+      # @!attribute [rw] label
+      #   The label (or left-hand side) of the production.  This
+      #   should be a nonterminal.
+      #
+      #   @return [Symbol]
+      # @!attribute [rw] items
+      #   The body (or right-hand side) of the production.  This can
+      #   be array of terminals and nonterminals.
+      #
+      #   @return [Array<Token>]
+      # @!attribute [rw] block
+      #   The block of code to be executed when the production's right
+      #   hand side is reduced.
+      #
+      #   @return [String]
+      # @!attribute [rw] prec
+      #   The precedence declaration for the production.
+      #
+      #   @return [Ace::Precedence]
+      # @!attribute [rw] id
+      #   The ID of the production.  The starting production always
+      #   has an ID of 0.
+      #
+      #   @return [Numeric]
+
+      # Creates a new production from a hash.  The hash's keys
+      # correspond to the attributes on this class.
+      #
+      # @param hash [Hash<(Symbol, Object)>]
+      def self.from_hash(hash)
+        new(hash[:label] || hash['label'],
+            hash[:items] || hash['items'],
+            hash[:block] || hash['block'],
+            hash[:prec]  || hash['prec'],
+            hash[:id]    || hash['id'])
+      end
+
+      # Create a new version of the production with duplicated values.
+      #
+      # @return [Production]
+      def clone
+        Production.new(label.dup,
+          items.map(&:dup),
+          block.dup,
+          prec.dup,
+          id)
+      end
+    end
+  end
+end