antelope 0.3.2 → 0.4.0

data/lib/antelope/generator/templates/info.ant

@@ -1,53 +0,0 @@
-Productions:
-%len = grammar.all_productions.size.to_s.size
-%productions = recognizer.states.map(&:rules).inject(:merge).
-%  select(&:final?).map { |x| [x.to_s(false), x.production.block] }
-%body = productions.map { |_| _[0].size }.max
-%productions.each do |prod|
-  {{= sprintf("%-#{body}s", prod[0]) }} %{prod[1]}
-%end
-
-%if unused_symbols.any?
-Symbols unused in grammar:
-%  unused_symbols.each do |sym|
-  %{sym}
-%  end
-%end
-
-Precedence:
-  --- highest
-% grammar.precedence.each do |pr|
-  %{"%-8s" % pr.type} %{pr.level}:
-    {{= "{" << pr.tokens.to_a.join(", ") << "}" }}
-% end
-  --- lowest
-
-%states = grammar.states.to_a
-%table.each_with_index do |v, i|
-%  state = states[i]
-  State %{i}:
-%  state.rules.each do |rule|
-    %{rule}
-      {%{rule.lookahead.to_a.join(", ")}}
-%  end
-%  transitions = v.each.select { |_, a| a && a[0] == :state }
-%  reductions  = v.each.select { |_, a| a && a[0] == :reduce}
-%  accepting   = v.each.select { |_, a| a && a[0] == :accept}
-%  thing = [:transitions, :reductions, :accepting]
-%  num_type = {
-%    transitions: "State",
-%    reductions: "Rule",
-%    accepting: "Rule"
-%  }
-%  h = Hash[thing.zip([transitions, reductions, accepting])]
-%  h.each do |key, value|
-%    next unless value.any?
-    %{key}:
-%    value.each do |token, (_, name)|
-%       token_value = grammar.terminals.
-%          find { |_| _.name == token } || token
-      %{token_value}: %{num_type[key]} %{name}
-%     end
-%   end
-
-%end

data/lib/antelope/template/compiler.rb

@@ -1,78 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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,64 +0,0 @@
-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)
-      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/spec/antelope/template_spec.rb

@@ -1,50 +0,0 @@
-describe Template do
-
-  let(:content) { "hello {{ world }} test" }
-
-  subject { Template.new(content) }
-
-  it "generates ruby code" do
-    expect(subject.parse).to eq %Q(# encoding: utf-8\n_out ||= ""\n_out << "hello "\n world\n_out << " test"\n_out\n)
-  end
-
-  context "when the tag is on its own line" do
-
-    let :content do
-<<-TEST
-hello
-{{= something }}
-world
-
-{{ thing }}
-a
-
-TEST
-    end
-
-    it "removes surrounding whitespace" do
-      expect(subject.parse).to eq <<-TEST
-# encoding: utf-8
-_out ||= ""
-_out << "hello"
-_out << begin
-  something
-end.to_s
-_out << "\\nworld\\n"
- thing
-_out << "\\na\\n\\n"
-_out
-TEST
-    end
-
-    it "runs in ruby" do
-      object = Object.new
-      result = nil
-      def object.something; "-" end
-      def object.thing; end
-
-      expect { result = object.instance_eval(subject.parse) }.to_not raise_error
-      expect(result).to eq "hello-\nworld\n\na\n\n"
-    end
-  end
-end