antelope 0.3.2 → 0.4.0

data/lib/antelope/ace/errors.rb

@@ -1,30 +1,30 @@
-# 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 {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
-
-    # 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 {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 {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
+
+    # 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 {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/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 || scan_comment || 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 || scan_comment || 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