antelope 0.2.0 → 0.2.2

data/lib/antelope/template/compiler.rb

@@ -1,78 +1,78 @@
-module Antelope
-  class Template
-    class Compiler
-
-      attr_reader :buffer
-
-      attr_reader :tokens
-
-      def initialize(tokens, buffer_variable = "_out")
-        @tokens = tokens.dup
-        @buffer = ""
-        @buffer_variable = buffer_variable
-      end
-
-      def compile
-        merge_text_tokens
-
-        @buffer = "#{@buffer_variable} ||= \"\"\n"
-
-        until @tokens.empty?
-          token = @tokens.shift
-          parse_method = "parse_#{token[0]}".intern
-
-          send(parse_method, token[1])
-        end
-
-        @buffer << "#{@buffer_variable}\n"
-
-        @buffer
-
-      rescue NoMethodError => e
-
-        if e.name == parse_method
-          raise NoTokenError, "No token #{token[0]} exists"
-        else
-          raise
-        end
-      end
-
-      private
-
-      def parse_text(value)
-        buffer << "#{@buffer_variable} << #{value.to_s.inspect}\n"
-      end
-
-      def parse_tag(value)
-        value.gsub!(/\A\s*([\s\S]*?)\s*\Z/, "\\1")
-        buffer << "#{value}\n"
-      end
-
-      def parse_output_tag(value)
-        value.gsub!(/\A\s*([\s\S]*?)\s*\Z/, "\\1")
-        buffer << "#{@buffer_variable} << begin\n  " \
-          "#{value}\nend.to_s\n"
-      end
-
-      def parse_newline(_)
-        parse_text("\n")
-      end
-
-      def parse_comment_tag(_)
-      end
-
-      def merge_text_tokens
-        new_tokens = []
-        @tokens.chunk(&:first).each do |type, tokens|
-          if type == :text
-            new_tokens << [:text, tokens.map(&:last).join('')]
-          else
-            new_tokens.push(*tokens)
-          end
-        end
-
-        @tokens = new_tokens
-      end
-    end
-  end
-end
+module Antelope
+  class Template
+    class Compiler
+
+      attr_reader :buffer
+
+      attr_reader :tokens
+
+      def initialize(tokens, buffer_variable = "_out")
+        @tokens = tokens.dup
+        @buffer = ""
+        @buffer_variable = buffer_variable
+      end
+
+      def compile
+        merge_text_tokens
+
+        @buffer = "\# encoding: utf-8\n#{@buffer_variable} ||= \"\"\n"
+
+        until @tokens.empty?
+          token = @tokens.shift
+          parse_method = "parse_#{token[0]}".intern
+
+          send(parse_method, token[1])
+        end
+
+        @buffer << "#{@buffer_variable}\n"
+
+        @buffer
+
+      rescue NoMethodError => e
+
+        if e.name == parse_method
+          raise NoTokenError, "No token #{token[0]} exists"
+        else
+          raise
+        end
+      end
+
+      private
+
+      def parse_text(value)
+        buffer << "#{@buffer_variable} << #{value.to_s.inspect}\n"
+      end
+
+      def parse_tag(value)
+        value.gsub!(/\A([\s\S]*?)\s*\Z/, "\\1")
+        buffer << "#{value}\n"
+      end
+
+      def parse_output_tag(value)
+        value.gsub!(/\A\s*([\s\S]*?)\s*\Z/, "\\1")
+        buffer << "#{@buffer_variable} << begin\n  " \
+          "#{value}\nend.to_s\n"
+      end
+
+      def parse_newline(_)
+        parse_text("\n")
+      end
+
+      def parse_comment_tag(_)
+      end
+
+      def merge_text_tokens
+        new_tokens = []
+        @tokens.chunk(&:first).each do |type, tokens|
+          if type == :text
+            new_tokens << [:text, tokens.map(&:last).join('')]
+          else
+            new_tokens.push(*tokens)
+          end
+        end
+
+        @tokens = new_tokens
+      end
+    end
+  end
+end

data/lib/antelope/template/errors.rb

@@ -1,9 +1,9 @@
-module Antelope
-  class Template
-    class Error < Antelope::Error; end
-
-    class SyntaxError < Error; end
-
-    class NoTokenError < Error; end
-  end
-end
+module Antelope
+  class Template
+    class Error < Antelope::Error; end
+
+    class SyntaxError < Error; end
+
+    class NoTokenError < Error; end
+  end
+end

data/lib/antelope/template/scanner.rb

@@ -1,109 +1,109 @@
-require 'strscan'
-
-module Antelope
-  class Template
-    class Scanner
-      attr_reader :scanner
-
-      attr_reader :tokens
-
-      def initialize(input, source = "(template)")
-        @scanner = StringScanner.new(input)
-        @source  = source
-        @tokens  = nil
-        @line    = 1
-      end
-
-      def scan
-
-        @tokens ||= begin
-          @tokens = []
-          @line   = 1
-          @scanner.pos = 0
-          until @scanner.eos?
-            scan_tag || scan_until_tag || scan_until_end
-          end
-
-          @tokens
-        end
-
-      rescue SyntaxError => e
-        start = [@scanner.pos - 8, 0].max
-        stop  = [@scanner.pos + 8, @scanner.string.length].min
-        snip  = @scanner.string[start..stop].inspect
-        char  = @scanner.string[@scanner.pos]
-        char = if char
-          char.inspect
-        else
-          "EOF"
-        end
-
-        new_line = "#{@source}:#{@line}:#{@scanner.pos}: "\
-          "unexpected #{char} (near #{snip})"
-
-        raise e, e.message, [new_line, *e.backtrace]
-      end
-
-      private
-
-      def scan_until_tag
-        case
-        when value = @scanner.scan_until(/(\%|\{|\}|\\|\n)/)
-          @scanner.pos -= 1
-          tokens << [:text, value[0..-2]]
-        end
-      end
-
-      def scan_until_end
-        tokens << [:text, @scanner.scan(/.+/m)]
-      end
-
-      def scan_tag
-        case
-        when @scanner.scan(/\\(\{\{|\}\}|\%)/)
-          tokens << [:text, @scanner[1]]
-        when @scanner.scan(/\n?\%\{/)
-          update_line
-          scan_tag_start(:output_tag, :_, /\}/)
-        when @scanner.scan(/\n?\%/)
-          update_line
-          tokens << [:tag, value]
-        when @scanner.scan(/\n?\{\{=/)
-          update_line
-          scan_tag_start(:output_tag)
-        when @scanner.scan(/\n?\{\{!/)
-          update_line
-          scan_tag_start(:comment_tag)
-        when @scanner.scan(/\n?\{\{/)
-          update_line
-          scan_tag_start(:tag)
-        when @scanner.scan(/\}\}/)
-          @scanner.pos -= 2
-          error!
-        when @scanner.scan(/\{|\}|\%|\\|\n/)
-          tokens << [:text, @scanner[0]]
-        else
-          false
-        end
-      end
-
-      def scan_tag_start(type, online = :_, ending = /\}\}/)
-        if online == :_
-          online = @scanner[0][0] == "\n"
-        end
-
-        value = @scanner.scan_until(ending) or error!
-        tokens << [type, value[0..-(@scanner[0].length + 1)]]
-      end
-
-      def error!
-        raise SyntaxError, "invalid syntax"
-      end
-
-      def update_line
-        @line += @scanner[0].count("\n")
-      end
-
-    end
-  end
-end
+require 'strscan'
+
+module Antelope
+  class Template
+    class Scanner
+      attr_reader :scanner
+
+      attr_reader :tokens
+
+      def initialize(input, source = "(template)")
+        @scanner = StringScanner.new(input)
+        @source  = source
+        @tokens  = nil
+        @line    = 1
+      end
+
+      def scan
+
+        @tokens ||= begin
+          @tokens = []
+          @line   = 1
+          @scanner.pos = 0
+          until @scanner.eos?
+            scan_tag || scan_until_tag || scan_until_end
+          end
+
+          @tokens
+        end
+
+      rescue SyntaxError => e
+        start = [@scanner.pos - 8, 0].max
+        stop  = [@scanner.pos + 8, @scanner.string.length].min
+        snip  = @scanner.string[start..stop].inspect
+        char  = @scanner.string[@scanner.pos]
+        char = if char
+          char.inspect
+        else
+          "EOF"
+        end
+
+        new_line = "#{@source}:#{@line}:#{@scanner.pos}: "\
+          "unexpected #{char} (near #{snip})"
+
+        raise e, e.message, [new_line, *e.backtrace]
+      end
+
+      private
+
+      def scan_until_tag
+        case
+        when value = @scanner.scan_until(/(\%|\{|\}|\\|\n)/)
+          @scanner.pos -= 1
+          tokens << [:text, value[0..-2]]
+        end
+      end
+
+      def scan_until_end
+        tokens << [:text, @scanner.scan(/.+/m)]
+      end
+
+      def scan_tag
+        case
+        when @scanner.scan(/\\(\{\{|\}\}|\%)/)
+          tokens << [:text, @scanner[1]]
+        when @scanner.scan(/\%\%/)
+          tokens << [:text, "%"]
+        when @scanner.scan(/\n?\%\{/)
+          update_line
+          scan_tag_start(:output_tag, /\}/)
+        when @scanner.scan(/(\n|\A)\%/)
+          update_line
+          #tokens << [:tag]
+          scan_tag_start(:tag, /\n/)
+          @scanner.pos -= 1
+        when @scanner.scan(/\n?\{\{=/)
+          update_line
+          scan_tag_start(:output_tag)
+        when @scanner.scan(/\n?\{\{!/)
+          update_line
+          scan_tag_start(:comment_tag)
+        when @scanner.scan(/\n?\{\{/)
+          update_line
+          scan_tag_start(:tag)
+        when @scanner.scan(/\}\}/)
+          @scanner.pos -= 2
+          error!
+        when @scanner.scan(/\{|\}|\%|\\|\n/)
+          tokens << [:text, @scanner[0]]
+        else
+          false
+        end
+      end
+
+      def scan_tag_start(type, ending = /\}\}/)
+        value = @scanner.scan_until(ending) or error!
+        tokens << [type, value[0..-(@scanner[0].length + 1)]]
+      end
+
+      def error!
+        raise SyntaxError, "invalid syntax"
+      end
+
+      def update_line
+        @line += @scanner[0].count("\n")
+      end
+
+    end
+  end
+end

data/lib/antelope/template.rb

@@ -1,60 +1,65 @@
-require "antelope/template/errors"
-require "antelope/template/scanner"
-require "antelope/template/compiler"
-
-
-module Antelope
-  class Template
-
-    NO_SOURCE = Object.new
-
-
-    def initialize(input, source = NO_SOURCE)
-      @input  = normalize_input(input)
-      @source = determine_source(input, source)
-    end
-
-    def parse
-      @result ||= begin
-        scanner  = Scanner.new(@input, @source)
-        compiler = Compiler.new(scanner.scan)
-        compiler.compile
-      end
-    end
-
-    def result(binding = TOPLEVEL_BINDING.dup)
-      # sue me.
-      eval(parse, binding, "#{@source}.rb", 0)
-    end
-
-    alias_method :run, :result
-    alias_method :call, :result
-
-    private
-
-    def normalize_input(input)
-      case
-      when String === input
-        input
-      when input.respond_to?(:read)
-        input.read
-      when input.respond_to?(:open)
-        input.open("r") { |f| f.read }
-      else
-        raise ArgumentError, "Received #{input.class}, expected " \
-          "#{String}, #read"
-      end
-    end
-
-    def determine_source(input, source)
-      case
-      when source != NO_SOURCE
-        source
-      when input.respond_to?(:to_path)
-        input.to_path
-      else
-        "(template)"
-      end
-    end
-  end
-end
+require "antelope/template/errors"
+require "antelope/template/scanner"
+require "antelope/template/compiler"
+
+
+module Antelope
+  class Template
+
+    NO_SOURCE = Object.new
+
+
+    def initialize(input, source = NO_SOURCE)
+      @input  = normalize_input(input)
+      @source = determine_source(input, source)
+    end
+
+    def parse
+      @result ||= begin
+        scanner  = Scanner.new(@input, @source)
+        compiler = Compiler.new(scanner.scan)
+        compiler.compile
+      end
+    end
+
+    def result(binding = TOPLEVEL_BINDING.dup)
+      # sue me.
+      eval(parse, binding, fake_name, 0)
+    end
+
+    alias_method :run, :result
+    alias_method :call, :result
+
+    private
+
+    def normalize_input(input)
+      case
+      when String === input
+        input
+      when input.respond_to?(:read)
+        input.read
+      when input.respond_to?(:open)
+        input.open("r") { |f| f.read }
+      else
+        raise ArgumentError, "Received #{input.class}, expected " \
+          "#{String}, #read"
+      end
+    end
+
+    def determine_source(input, source)
+      case
+      when source != NO_SOURCE
+        source
+      when input.respond_to?(:to_path)
+        input.to_path
+      else
+        "(template)"
+      end
+    end
+
+    def fake_name
+      File.join(File.dirname(@source),
+        "_#{File.basename(@source, '.*')}.rb")
+    end
+  end
+end

data/lib/antelope/version.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
-
-module Antelope
-  # The current running version of antelope.
-  VERSION = "0.2.0".freeze
-end
+# encoding: utf-8
+
+module Antelope
+  # The current running version of antelope.
+  VERSION = "0.2.2".freeze
+end

data/lib/antelope.rb

@@ -1,13 +1,13 @@
-# encoding: utf-8
-
-require "antelope/errors"
-require "antelope/generation"
-require "antelope/generator"
-require "antelope/version"
-require "antelope/ace"
-require "antelope/template"
-
-# Antelope, the compiler compiler.
-module Antelope
-
-end
+# encoding: utf-8
+
+require "antelope/errors"
+require "antelope/generation"
+require "antelope/generator"
+require "antelope/version"
+require "antelope/ace"
+require "antelope/template"
+
+# Antelope, the compiler compiler.
+module Antelope
+
+end

data/optimizations.txt

@@ -0,0 +1,42 @@
+lib/antelope/ace/grammar/precedences.rb
+Array#select.first is slower than Array#detect. Occured at lines: 31, 35.
+Using each_with_index is slower than while loop. Occured at lines: 51.
+
+lib/antelope/ace/grammar/productions.rb
+Using each_with_index is slower than while loop. Occured at lines: 71, 106.
+
+lib/antelope/ace/grammar/symbols.rb
+Hash#fetch with second argument is slower than Hash#fetch with block. Occured at lines: 17.
+
+lib/antelope/generation/constructor/first.rb
+Using each_with_index is slower than while loop. Occured at lines: 63.
+
+lib/antelope/generation/constructor/follow.rb
+Using each_with_index is slower than while loop. Occured at lines: 78.
+
+lib/antelope/generation/constructor.rb
+Using each_with_index is slower than while loop. Occured at lines: 71.
+
+lib/antelope/generation/recognizer/rule.rb
+Parallel assignment is slower than sequential assignment. Occured at lines: 77.
+Using each_with_index is slower than while loop. Occured at lines: 178.
+
+lib/antelope/generation/recognizer/state.rb
+Using each_with_index is slower than while loop. Occured at lines: 123.
+
+lib/antelope/generation/recognizer.rb
+Using each_with_index is slower than while loop. Occured at lines: 138.
+
+lib/antelope/generation/tableizer.rb
+Using each_with_index is slower than while loop. Occured at lines: 90, 138.
+Parallel assignment is slower than sequential assignment. Occured at lines: 99.
+
+lib/antelope/generator/base.rb
+Using each_with_index is slower than while loop. Occured at lines: 124.
+
+lib/antelope/generator/c_header.rb
+Using each_with_index is slower than while loop. Occured at lines: 91.
+
+lib/antelope/template/compiler.rb
+Don't rescue NoMethodError, rather check with respond_to?. Occured at lines: 40.
+