antelope 0.3.2 → 0.4.0

data/lib/antelope/ace/scanner.rb

@@ -1,144 +1,144 @@
-# encoding: utf-8
-
-require "strscan"
-require "antelope/ace/scanner/argument"
-require "antelope/ace/scanner/first"
-require "antelope/ace/scanner/second"
-require "antelope/ace/scanner/third"
-
-module Antelope
-  module Ace
-
-    # Scans a given input.  The input should be a properly formatted
-    # ACE file; see the Ace module for more information.  This scanner
-    # uses the StringScanner class internally; see the ruby
-    # documentation for more on that.  This scanner seperates scanning
-    # into three seperate stages: First, Second, and Third, for each
-    # section of the file, respectively.
-    #
-    # @see Ace
-    # @see http://ruby-doc.org/stdlib-2.1.2/libdoc/strscan/rdoc/StringScanner.html
-    class Scanner
-
-      IDENTIFIER = "[a-zA-Z_.][a-zA-Z0-9_.-]*"
-
-      include First
-      include Second
-      include Third
-
-      # The string scanner that we're using to scan the string with.
-      #
-      # @return [StringScanner]
-      attr_reader :scanner
-
-      # An array of the tokens that the scanner scanned.
-      #
-      # @return [Array<Array<(Symbol, Object, ...)>>]
-      attr_reader :tokens
-
-      # The boundry between each section.  Placed here to be easily.
-      # modifiable. **MUST** be a regular expression.
-      #
-      # @return [RegExp]
-      CONTENT_BOUNDRY = /%%/
-
-      # The value regular expression.  It should match values; for
-      # example, things quoted in strings or word letters without
-      # quotes.  Must respond to #to_s, since it is embedded within
-      # other regular expressions.  The regular expression should
-      # place the contents of the value in the groups 2 or 3.
-      #
-      # @return [#to_s]
-      VALUE = %q{(?:
-                    (?:("|')((?:\\\\|\\"|\\'|.)+?)\\1)
-                  | ([A-Za-z0-9_.<>*-]+)
-                )}
-
-      # Scans a file.  It returns the tokens resulting from scanning.
-      #
-      # @param source [String] the source to scan.  This should be
-      #   compatible with StringScanner.
-      # @param name [String] the name of the source file.  This is
-      #   primarilyused in backtrace information.
-      # @return [Array<Array<(Symbol, Object, ...)>>]
-      # @see #tokens
-      def self.scan(source, name = "(ace file)")
-        new(source, name).scan_file
-      end
-
-      # Initialize the scanner with the input.
-      #
-      # @param input [String] The source to scan.
-      # @param source [String] the source file.  This is primarily
-      #   used in backtrace information.
-      def initialize(input, source = "(ace file)")
-        @source  = source
-        @scanner = StringScanner.new(input)
-        @tokens  = []
-      end
-
-      # Scans the file in parts.
-      #
-      # @raise [SyntaxError] if the source is malformed in some way.
-      # @return [Array<Array<(Symbol, Object, ...)>>] the tokens that
-      #   were scanned in this file.
-      # @see #scan_first_part
-      # @see #scan_second_part
-      # @see #scan_third_part
-      # @see #tokens
-      def scan_file
-        @line = 1
-        scan_first_part
-        scan_second_part
-        scan_third_part
-        tokens
-      rescue SyntaxError => e
-        start = [@scanner.pos - 8, 0].max
-        stop  = [@scanner.pos + 8, @scanner.string.length].min
-        snip  = @scanner.string[start..stop].strip.inspect
-        char  = @scanner.string[@scanner.pos]
-        char = if char
-          char.inspect
-        else
-          "EOF"
-        end
-
-        new_line = "#{@source}:#{@line}: unexpected #{char} " \
-          "(near #{snip})"
-
-        raise e, e.message, [new_line, *e.backtrace]
-      end
-
-      # Scans for whitespace.  If the next character is whitespace, it
-      # will consume all whitespace until the next non-whitespace
-      # character.
-      #
-      # @return [Boolean] if any whitespace was matched.
-      def scan_whitespace
-        if @scanner.scan(/(\s+)/)
-          @line += @scanner[1].count("\n")
-        end
-      end
-
-      # Scans for a comment.  If the next token is a number sign (#),
-      # it will consume all characters until the next newline.
-      #
-      # @return [Boolean] if a comment was matched.
-      def scan_comment
-        if @scanner.scan(/\#(.*)\n/)
-          @line += 1
-        end
-      end
-
-      private
-
-      # Raises an error.
-      #
-      # @raise [SyntaxError] always.
-      # @return [void]
-      def error!
-        raise SyntaxError, "invalid syntax"
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+require "strscan"
+require "antelope/ace/scanner/argument"
+require "antelope/ace/scanner/first"
+require "antelope/ace/scanner/second"
+require "antelope/ace/scanner/third"
+
+module Antelope
+  module Ace
+
+    # Scans a given input.  The input should be a properly formatted
+    # ACE file; see the Ace module for more information.  This scanner
+    # uses the StringScanner class internally; see the ruby
+    # documentation for more on that.  This scanner seperates scanning
+    # into three seperate stages: First, Second, and Third, for each
+    # section of the file, respectively.
+    #
+    # @see Ace
+    # @see http://ruby-doc.org/stdlib-2.1.2/libdoc/strscan/rdoc/StringScanner.html
+    class Scanner
+
+      IDENTIFIER = "[a-zA-Z_.][a-zA-Z0-9_.-]*"
+
+      include First
+      include Second
+      include Third
+
+      # The string scanner that we're using to scan the string with.
+      #
+      # @return [StringScanner]
+      attr_reader :scanner
+
+      # An array of the tokens that the scanner scanned.
+      #
+      # @return [Array<Array<(Symbol, Object, ...)>>]
+      attr_reader :tokens
+
+      # The boundry between each section.  Placed here to be easily.
+      # modifiable. **MUST** be a regular expression.
+      #
+      # @return [RegExp]
+      CONTENT_BOUNDRY = /%%/
+
+      # The value regular expression.  It should match values; for
+      # example, things quoted in strings or word letters without
+      # quotes.  Must respond to #to_s, since it is embedded within
+      # other regular expressions.  The regular expression should
+      # place the contents of the value in the groups 2 or 3.
+      #
+      # @return [#to_s]
+      VALUE = %q{(?:
+                    (?:("|')((?:\\\\|\\"|\\'|.)+?)\\1)
+                  | ([A-Za-z0-9_.<>*-]+)
+                )}
+
+      # Scans a file.  It returns the tokens resulting from scanning.
+      #
+      # @param source [String] the source to scan.  This should be
+      #   compatible with StringScanner.
+      # @param name [String] the name of the source file.  This is
+      #   primarilyused in backtrace information.
+      # @return [Array<Array<(Symbol, Object, ...)>>]
+      # @see #tokens
+      def self.scan(source, name = "(ace file)")
+        new(source, name).scan_file
+      end
+
+      # Initialize the scanner with the input.
+      #
+      # @param input [String] The source to scan.
+      # @param source [String] the source file.  This is primarily
+      #   used in backtrace information.
+      def initialize(input, source = "(ace file)")
+        @source  = source
+        @scanner = StringScanner.new(input)
+        @tokens  = []
+      end
+
+      # Scans the file in parts.
+      #
+      # @raise [SyntaxError] if the source is malformed in some way.
+      # @return [Array<Array<(Symbol, Object, ...)>>] the tokens that
+      #   were scanned in this file.
+      # @see #scan_first_part
+      # @see #scan_second_part
+      # @see #scan_third_part
+      # @see #tokens
+      def scan_file
+        @line = 1
+        scan_first_part
+        scan_second_part
+        scan_third_part
+        tokens
+      rescue SyntaxError => e
+        start = [@scanner.pos - 8, 0].max
+        stop  = [@scanner.pos + 8, @scanner.string.length].min
+        snip  = @scanner.string[start..stop].strip.inspect
+        char  = @scanner.string[@scanner.pos]
+        char = if char
+          char.inspect
+        else
+          "EOF"
+        end
+
+        new_line = "#{@source}:#{@line}: unexpected #{char} " \
+          "(near #{snip})"
+
+        raise e, e.message, [new_line, *e.backtrace]
+      end
+
+      # Scans for whitespace.  If the next character is whitespace, it
+      # will consume all whitespace until the next non-whitespace
+      # character.
+      #
+      # @return [Boolean] if any whitespace was matched.
+      def scan_whitespace
+        if @scanner.scan(/(\s+)/)
+          @line += @scanner[1].count("\n")
+        end
+      end
+
+      # Scans for a comment.  If the next token is a number sign (#),
+      # it will consume all characters until the next newline.
+      #
+      # @return [Boolean] if a comment was matched.
+      def scan_comment
+        if @scanner.scan(/\#(.*)\n/)
+          @line += 1
+        end
+      end
+
+      private
+
+      # Raises an error.
+      #
+      # @raise [SyntaxError] always.
+      # @return [void]
+      def error!
+        raise SyntaxError, "invalid syntax"
+      end
+    end
+  end
+end

data/lib/antelope/ace.rb

@@ -1,47 +1,47 @@
-# encoding: utf-8
-
-require 'antelope/ace/errors'
-require 'antelope/ace/scanner'
-require 'antelope/ace/compiler'
-
-module Antelope
-  # Defines the Ace file.  The Ace file format works similarly to
-  # bison's y file format.  The Ace file is seperated into three
-  # parts:
-  #
-  #      <first>
-  #      %%
-  #      <second>
-  #      %%
-  #      <third>
-  #
-  # All parts may be empty; thus, the minimal file that Ace will
-  # accept would be
-  #
-  #     %%
-  #     %%
-  #
-  # The first part consists of _directives_ and _blocks_; directives
-  # look something like `'%' <directive>[ <argument>]*\n`, with
-  # `<directive>` being any alphanumerical character, including
-  # underscores and dashes, and `<argument>` being any word character
-  # or a quote-delimited string.  Blocks consist of
-  # `'%{" <content> "\n" "\s"* "%}'`, with `<content>` being any
-  # characters.  The content is copied directly into the body of the
-  # output.
-  #
-  # The second part consists of rules.  Rules look something like
-  # this:
-  #
-  #     <nonterminal>: (<nonterminal> | <terminal>)* ['{" <content> "}"] ["|" (<nonterminal> | <terminal>)* ["{" <content> "}']]* [;]
-  #
-  # Where `<nonterminal>` is any lowercase alphabetical cahracter,
-  # `<terminal>` is any uppercase alphabetical character, and
-  # `<content>` is code to be used in the output file upon matching
-  # the specific rule.
-  #
-  # The third part consists of a body, which is copied directly into
-  # the output.
-  module Ace
-  end
-end
+# encoding: utf-8
+
+require 'antelope/ace/errors'
+require 'antelope/ace/scanner'
+require 'antelope/ace/compiler'
+
+module Antelope
+  # Defines the Ace file.  The Ace file format works similarly to
+  # bison's y file format.  The Ace file is seperated into three
+  # parts:
+  #
+  #      <first>
+  #      %%
+  #      <second>
+  #      %%
+  #      <third>
+  #
+  # All parts may be empty; thus, the minimal file that Ace will
+  # accept would be
+  #
+  #     %%
+  #     %%
+  #
+  # The first part consists of _directives_ and _blocks_; directives
+  # look something like `'%' <directive>[ <argument>]*\n`, with
+  # `<directive>` being any alphanumerical character, including
+  # underscores and dashes, and `<argument>` being any word character
+  # or a quote-delimited string.  Blocks consist of
+  # `'%{" <content> "\n" "\s"* "%}'`, with `<content>` being any
+  # characters.  The content is copied directly into the body of the
+  # output.
+  #
+  # The second part consists of rules.  Rules look something like
+  # this:
+  #
+  #     <nonterminal>: (<nonterminal> | <terminal>)* ['{" <content> "}"] ["|" (<nonterminal> | <terminal>)* ["{" <content> "}']]* [;]
+  #
+  # Where `<nonterminal>` is any lowercase alphabetical cahracter,
+  # `<terminal>` is any uppercase alphabetical character, and
+  # `<content>` is code to be used in the output file upon matching
+  # the specific rule.
+  #
+  # The third part consists of a body, which is copied directly into
+  # the output.
+  module Ace
+  end
+end

data/lib/antelope/cli.rb

@@ -1,60 +1,60 @@
-# encoding: utf-8
-
-require "thor"
-
-module Antelope
-
-  # Handles the command line interface.
-  class CLI < Thor
-
-    class_option :verbose, default: false, type: :boolean
-
-    option :type, default: nil, type: :string,
-      desc: "The type of generator to use"
-    desc "compile FILE [FILE]*", "compile the given files"
-
-    # Compile.
-    def compile(*files)
-      files.each do |file|
-        compile_file(file)
-      end
-    end
-
-    desc "check FILE [FILE]*", "check the syntax of the given files"
-
-    # Check.
-    def check(*files)
-      files.each do |file|
-        compile_file(file, [Generator::Null])
-      end
-    end
-
-    desc "version", "Displays the running version of antelope"
-    def version
-      puts "Antelope version #{Antelope::VERSION}"
-    end
-
-    private
-
-    # Compiles the given file, and then generates.  If an error
-    # occurs, it prints it out to stderr, along with a backtrace if
-    # the verbose flag was set.
-    #
-    # @param file [String] the file to compile.
-    # @param gen [Array, Symbol] the generator to use.
-    # @return [void]
-    def compile_file(file, gen = :guess)
-      puts "Compiling #{file}... "
-
-      grammar = Grammar.from_file(file)
-      grammar.generate(options, gen)
-
-    rescue => e
-      $stderr.puts "Error while compiling: #{e.class}: #{e.message}"
-
-      if options[:verbose]
-        $stderr.puts e.backtrace[0..10].map { |_| "\t#{_}" }
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+require "thor"
+
+module Antelope
+
+  # Handles the command line interface.
+  class CLI < Thor
+
+    class_option :verbose, default: false, type: :boolean
+
+    option :type, default: nil, type: :string,
+      desc: "The type of generator to use"
+    desc "compile FILE [FILE]*", "compile the given files"
+
+    # Compile.
+    def compile(*files)
+      files.each do |file|
+        compile_file(file)
+      end
+    end
+
+    desc "check FILE [FILE]*", "check the syntax of the given files"
+
+    # Check.
+    def check(*files)
+      files.each do |file|
+        compile_file(file, [Generator::Null])
+      end
+    end
+
+    desc "version", "Displays the running version of antelope"
+    def version
+      puts "Antelope version #{Antelope::VERSION}"
+    end
+
+    private
+
+    # Compiles the given file, and then generates.  If an error
+    # occurs, it prints it out to stderr, along with a backtrace if
+    # the verbose flag was set.
+    #
+    # @param file [String] the file to compile.
+    # @param gen [Array, Symbol] the generator to use.
+    # @return [void]
+    def compile_file(file, gen = :guess)
+      puts "Compiling #{file}... "
+
+      grammar = Grammar.from_file(file)
+      grammar.generate(options, gen)
+
+    rescue => e
+      $stderr.puts "Error while compiling: #{e.class}: #{e.message}"
+
+      if options[:verbose]
+        $stderr.puts e.backtrace[0..10].map { |_| "\t#{_}" }
+      end
+    end
+  end
+end

data/lib/antelope/errors.rb

@@ -1,25 +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
+# 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