generation.rb in antelope-0.4.0

- old
+ new
@@ -1,76 +1,76 @@
-# encoding: utf-8
-
-module Antelope
-  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.to_s)
-
-        generators
-
-      rescue KeyError
-        raise NoTypeError, "Undefined type #{type}"
-      end
-    end
-  end
-end
+# encoding: utf-8
+
+module Antelope
+  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.to_s)
+
+        generators
+
+      rescue KeyError
+        raise NoTypeError, "Undefined type #{type}"
+      end
+    end
+  end
+end