antelope 0.2.0 → 0.2.2

data/lib/antelope/ace/precedence.rb

@@ -1,61 +1,61 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-
-    # Defines a precedence.  A precedence has a type, tokens, and a
-    # level.
-    class Precedence < Struct.new(:type, :tokens, :level)
-
-      # @!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
+  module Ace
+
+    # Defines a precedence.  A precedence has a type, tokens, and a
+    # level.
+    class Precedence < Struct.new(:type, :tokens, :level)
+
+      # @!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/ace/production.rb

@@ -1,57 +1,57 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-
-    # Defines a production.
-    class Production < Struct.new(:label, :items, :block, :prec, :id)
-      # @!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
+  module Ace
+
+    # Defines a production.
+    class Production < Struct.new(:label, :items, :block, :prec, :id)
+      # @!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

data/lib/antelope/ace/scanner/argument.rb

@@ -1,57 +1,57 @@
-module Antelope
-  module Ace
-    class Scanner
-
-      # Represents an argument to a directive.  It encapsulates a
-      # string object, which is the value of the argument.
-      class Argument < String
-
-        # Initialize the argument.
-        #
-        # @param type [Symbol] the type of argument it is; it can be
-        #   a `:block`, `:text`, or `:caret`.  The type is defined by
-        #   the encapsulating characters.  If the encapsulating
-        #   characters are `{` and `}`, it's a `:block`; if they are
-        #   `<` and `>`, it's a `:caret`; otherwise, it's a `:text`.
-        # @param value [String] the value of the argument.
-        def initialize(type, value)
-          @type = type
-          super(value)
-        end
-
-        # If this argument is type `:block`.
-        #
-        # @return [Boolean]
-        # @see type?
-        def block?
-          type? :block
-        end
-
-        # If this argument is type `:text`.
-        #
-        # @return [Boolean]
-        # @see type?
-        def text?
-          type? :text
-        end
-
-        # If this argument is type `:caret`.
-        #
-        # @return [Boolean]
-        # @see type?
-        def caret?
-          type? :caret
-        end
-
-        # Checks to see if any of the given arguments match the type
-        # of this argument.
-        #
-        # @param inc [Array<Symbol>]
-        # @return [Boolean]
-        def type?(*inc)
-          inc.include?(@type)
-        end
-      end
-    end
-  end
-end
+module Antelope
+  module Ace
+    class Scanner
+
+      # Represents an argument to a directive.  It encapsulates a
+      # string object, which is the value of the argument.
+      class Argument < String
+
+        # Initialize the argument.
+        #
+        # @param type [Symbol] the type of argument it is; it can be
+        #   a `:block`, `:text`, or `:caret`.  The type is defined by
+        #   the encapsulating characters.  If the encapsulating
+        #   characters are `{` and `}`, it's a `:block`; if they are
+        #   `<` and `>`, it's a `:caret`; otherwise, it's a `:text`.
+        # @param value [String] the value of the argument.
+        def initialize(type, value)
+          @type = type
+          super(value)
+        end
+
+        # If this argument is type `:block`.
+        #
+        # @return [Boolean]
+        # @see type?
+        def block?
+          type? :block
+        end
+
+        # If this argument is type `:text`.
+        #
+        # @return [Boolean]
+        # @see type?
+        def text?
+          type? :text
+        end
+
+        # If this argument is type `:caret`.
+        #
+        # @return [Boolean]
+        # @see type?
+        def caret?
+          type? :caret
+        end
+
+        # Checks to see if any of the given arguments match the type
+        # of this argument.
+        #
+        # @param inc [Array<Symbol>]
+        # @return [Boolean]
+        def type?(*inc)
+          inc.include?(@type)
+        end
+      end
+    end
+  end
+end

data/lib/antelope/ace/scanner/first.rb

@@ -1,89 +1,89 @@
-# encoding: utf-8
-
-module Antelope
-  module Ace
-    class Scanner
-
-      # Scans the first section of the file.  This contains directives and
-      # small blocks that can be copied directly into the body of the output.
-      # The blocks are formatted as `%{ ... %}`; however, the ending tag _must_
-      # be on its own line.  The directive is formatted as `%<name> <value>`,
-      # with `<name>` being the key, and `<value>` being the value.  The value
-      # can be a piece of straight-up text (no quotes), or it can be quoted.
-      # There can be any number of values to a directive.
-      module First
-
-        # Scans until the first content boundry.  If it encounters anything but
-        # a block or a directive (or whitespace), it will raise an error.
-        #
-        # @raise [SyntaxError] if it encounters anything but whitespace, a
-        #   block, or a directive.
-        # @return [void]
-        def scan_first_part
-          until @scanner.check(CONTENT_BOUNDRY)
-            scan_first_copy || scan_first_directive ||
-            scan_whitespace || error!
-          end
-        end
-
-        # Scans for a block.  It is called `copy` instead of `block` because
-        # contents of the block is _copied_ directly into the body.
-        #
-        # @return [Boolean] if it matched.
-        def scan_first_copy
-          if @scanner.scan(/%{([\s\S]+?)\n\s*%}/)
-            tokens << [:copy, @scanner[1]]
-          end
-        end
-
-        # Scans a directive.  A directive has one _name_, and any number of
-        # arguments.  Every argument is a _value_.  The name can be any
-        # combinations of alphabetical characters, underscores, and dashes;
-        # the value can be word characters, or a quote-delimited string.
-        # It emits a `:directive` token with the directive (Sring) as an
-        # argument, and the passed arguments (Array<String>).
-        #
-        # @return [Boolean] if it matched.
-        def scan_first_directive
-          if @scanner.scan(/%(#{IDENTIFIER}) ?/)
-            directive = @scanner[1]
-            arguments = scan_first_directive_arguments
-
-            tokens << [:directive, directive, arguments]
-          end
-        end
-
-        # Scan the arguments for a directive.  It keeps attempting to
-        # scan arguments until the first newline that was not in a
-        # block.  Arguments can be blocks, carets, or text; blocks are
-        # encapsulated with `{` and `}`, carets are encapsulated with
-        # `<` and `>`, and text is encapsulated with quotes or
-        # nothing.
-        #
-        # @return [Array<Argument>]
-        def scan_first_directive_arguments
-          arguments = []
-          until @scanner.check(/\n/)
-            if @scanner.scan(/\{/)
-              argument =
-                Argument.new(:block, _scan_block[1..-2])
-            elsif @scanner.scan(/</)
-              @scanner.scan(/((?:\\>|[^>])*)\>/)
-              argument =
-                Argument.new(:caret, @scanner[1])
-            else
-              @scanner.scan(/#{VALUE}/x) or error!
-              argument = Argument.new(:text,
-                @scanner[2] || @scanner[3])
-            end
-
-            arguments.push(argument)
-            @scanner.scan(/ */)
-          end
-
-          arguments
-        end
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  module Ace
+    class Scanner
+
+      # Scans the first section of the file.  This contains directives and
+      # small blocks that can be copied directly into the body of the output.
+      # The blocks are formatted as `%{ ... %}`; however, the ending tag _must_
+      # be on its own line.  The directive is formatted as `%<name> <value>`,
+      # with `<name>` being the key, and `<value>` being the value.  The value
+      # can be a piece of straight-up text (no quotes), or it can be quoted.
+      # There can be any number of values to a directive.
+      module First
+
+        # Scans until the first content boundry.  If it encounters anything but
+        # a block or a directive (or whitespace), it will raise an error.
+        #
+        # @raise [SyntaxError] if it encounters anything but whitespace, a
+        #   block, or a directive.
+        # @return [void]
+        def scan_first_part
+          until @scanner.check(CONTENT_BOUNDRY)
+            scan_first_copy || scan_first_directive ||
+            scan_whitespace || error!
+          end
+        end
+
+        # Scans for a block.  It is called `copy` instead of `block` because
+        # contents of the block is _copied_ directly into the body.
+        #
+        # @return [Boolean] if it matched.
+        def scan_first_copy
+          if @scanner.scan(/%{([\s\S]+?)\n\s*%}/)
+            tokens << [:copy, @scanner[1]]
+          end
+        end
+
+        # Scans a directive.  A directive has one _name_, and any number of
+        # arguments.  Every argument is a _value_.  The name can be any
+        # combinations of alphabetical characters, underscores, and dashes;
+        # the value can be word characters, or a quote-delimited string.
+        # It emits a `:directive` token with the directive (Sring) as an
+        # argument, and the passed arguments (Array<String>).
+        #
+        # @return [Boolean] if it matched.
+        def scan_first_directive
+          if @scanner.scan(/%(#{IDENTIFIER}) ?/)
+            directive = @scanner[1]
+            arguments = scan_first_directive_arguments
+
+            tokens << [:directive, directive, arguments]
+          end
+        end
+
+        # Scan the arguments for a directive.  It keeps attempting to
+        # scan arguments until the first newline that was not in a
+        # block.  Arguments can be blocks, carets, or text; blocks are
+        # encapsulated with `{` and `}`, carets are encapsulated with
+        # `<` and `>`, and text is encapsulated with quotes or
+        # nothing.
+        #
+        # @return [Array<Argument>]
+        def scan_first_directive_arguments
+          arguments = []
+          until @scanner.check(/\n/)
+            if @scanner.scan(/\{/)
+              argument =
+                Argument.new(:block, _scan_block[1..-2])
+            elsif @scanner.scan(/</)
+              @scanner.scan(/((?:\\>|[^>])*)\>/)
+              argument =
+                Argument.new(:caret, @scanner[1])
+            else
+              @scanner.scan(/#{VALUE}/x) or error!
+              argument = Argument.new(:text,
+                @scanner[2] || @scanner[3])
+            end
+
+            arguments.push(argument)
+            @scanner.scan(/ */)
+          end
+
+          arguments
+        end
+      end
+    end
+  end
+end