depager 0.3.0.b20160729 → 0.3.0.b20250423

data/lib/depager.rb

@@ -1,17 +1,16 @@
-# -*- coding: utf-8 -*-
-require 'erb'
-require "depager/parser.rb"
-require "depager/grammar.rb"
-require "depager/utils.rb"
+require "erb"
+require "depager/parser"
+require "depager/grammar"
+require "depager/utils"
 
 module Depager
   def self.configuration
-    @flags ||= {}
+    @configuration ||= {}
   end
 
-  def self.debug_mode? flag = ''
+  def self.debug_mode?(flag = "")
     value = configuration[:debug] or return false
-    !! value.match(/#{flag.to_s}/)
+    !!value.match(/#{flag}/)
   end
 
   def self.verbose_mode?
@@ -28,21 +27,21 @@ module Depager
       @g_parser = GrammarPartParser.new(self)
 
       until file.eof?
-        case line = file.gets
+        case file.gets
         when /^\s*(#.*)?$/
-          #skip space and comment.
+          # skip space and comment.
         when /^%class\s+(\S+)(\s+based_on\s+(\S+)(\s+\(\s*'(.+)'\s*\))?)?\s*$/
           @target_name = $1
           if $2
             require $5 if $5
-            nesting = $3.split(/::/).tap{|it| it[-1] = "#{it[-1]}Generator"}
-            generator_class = nesting.inject(Object){|c,name| c.const_get(name) }
+            nesting = $3.split("::").tap { |it| it[-1] = "#{it[-1]}Generator" }
+            generator_class = nesting.inject(Object) { |c, name| c.const_get(name) }
           else
-            require 'depager/lr.rb'
+            require "depager/lr"
             generator_class = LALR::ParserGenerator
           end
 
-          if @target_name.match('(.+)::([^:]+)')
+          if @target_name =~ /(.+)::([^:]+)/
             @target_namespace = $1
             @target_name = $2
           else
@@ -52,10 +51,10 @@ module Depager
           @generator = generator_class.new(self)
           break
         when /^%defext\s+(\S+)\s*$/
-          require 'depager/lr.rb'
+          require "depager/lr"
 
           @target_namespace = $1
-          @target_name = 'Master'
+          @target_name = "Master"
 
           @generator = LALR::ExtensionGenerator.new(self)
           break
@@ -76,36 +75,34 @@ module Depager
 
     Token = Struct.new(:tag, :value, :name, :lineno)
 
-    HOOK_KEYS = [
-      :pre_rule_list, :post_rule_list,
-      :pre_rule,      :post_rule,
-      :post_lhs,
-      :post_rhs_list, :pre_rhs_list,
-      :pre_rhs,       :post_rhs,
-                      :post_symbol
-    ] #:nodoc:
-
-    attr_accessor :rules, :terms, :nonterms, :precs, :table
-    attr_accessor :lhs, :rhs, :nrhs, :rhs_names, :nrules
-    attr_accessor :line, :original_line, :old_line, :token
-    attr_accessor :outer_code, :inner_code, :mixins
+    HOOK_KEYS = %i[
+      pre_rule_list post_rule_list
+      pre_rule post_rule
+      post_lhs
+      post_rhs_list pre_rhs_list
+      pre_rhs post_rhs
+      post_symbol
+    ].freeze # :nodoc:
+
+    attr_accessor :rules, :terms, :nonterms, :precs, :table, :lhs, :rhs, :nrhs, :rhs_names, :nrules, :line,
+                  :original_line, :old_line, :token, :outer_code, :inner_code, :mixins
     attr_reader   :d_parser, :target_namespace, :target_name, :hooks
 
-    def initialize d_parser
+    def initialize(d_parser)
       @d_parser = d_parser
     end
 
     # parse and make LALR(1) table
     def parse(full_target_name, precs = [], extensions = [], options = {})
-      @original_line = @old_line = @line = ''
-      @inner_code    = ''
-      @outer_code    = ''
+      @original_line = @old_line = @line = ""
+      @inner_code    = ""
+      @outer_code    = ""
 
       full_target_name.match(/::([^:]+)$/) or raise
       @target_namespace = $`
       @target_name = $1
 
-      extend_paser(extensions, options)
+      extend_parser(extensions, options)
       init_grammar
       parse_grammar
       check_grammar
@@ -114,20 +111,20 @@ module Depager
       grammar = d_parser.parsing_method::Grammar.new(@rules, @terms, @nonterms, @precs)
       @table  = d_parser.parsing_method::Table.new(grammar)
       @table.check_table d_parser
-      @extensions.each{|o| o.send :term_extension }
+      @extensions.each { |o| o.send :term_extension }
       @table
     end
 
-    def hook_name? s
+    def hook_name?(s)
       HOOK_KEYS.include? s.to_sym
     end
 
-    def update_context line
+    def update_context(line)
       @line = line
-      get_token
+      scan_token
     end
 
-    def int_to_sym n
+    def int_to_sym(n)
       @int_to_sym[n]
     end
 
@@ -135,116 +132,114 @@ module Depager
       int_to_sym(lhs)
     end
 
-    def add_nonterm sym
+    def add_nonterm(sym)
       sym = sym.to_s.intern
       isym = @nonterms[sym] = @nonterms.size
       @int_to_sym[isym] = sym
-      return isym
+      isym
     end
 
-    def add_rule lhs, rhs, prec = nil, rhs_names = nil
+    def add_rule(lhs, rhs, prec = nil, rhs_names = nil)
       @lhs_syms[lhs] = true
-      rule = @parsing_method::Rule[lhs, rhs, prec, rhs_names]
+      rule = d_parser.parsing_method::Rule[lhs, rhs, prec, rhs_names]
       @rules.push rule
-      return rule
+      rule
     end
 
-    def name_to_rhs_index name
+    def name_to_rhs_index(name)
       @rhs_names.index(name)
     end
 
-    def insert_sym_to_rhs pos, token_value, token_name
+    def insert_sym_to_rhs(pos, token_value, token_name)
       if pos < 0
         @rhs.push token_value
         @rhs_names[@rhs.size - 1] = token_name
-        @rhs_syms[token_value] = true
       else
         @rhs.insert(pos, token_value)
         @rhs_names.insert(pos, token_name)
-        @rhs_syms[token_value] = true
       end
+      @rhs_syms[token_value] = true
     end
 
     private
+
     def parse_grammar
-      get_token
+      scan_token
       do_hook :pre_rule_list
       parse_rulelist
       do_hook :post_rule_list
-      unless @token.tag == nil
-        error_exit "syntax error(grammar). unexpected '#{@token.tag}' expect '%%'"
-      end
+      return if @token.tag.nil?
+
+      error_exit "syntax error(grammar). unexpected '#{@token.tag}' expect '%%'"
     end
 
     def parse_rulelist
       do_hook :pre_rule
       parse_rule
       do_hook :post_rule
-      if @token.tag == :NT
-        parse_rulelist
-      end
+      return unless @token.tag == :NT
+
+      parse_rulelist
     end
 
     def parse_rule
-      if @token[0] == :NT
-        @lhs = @token.value
+      return unless @token[0] == :NT
 
-        get_token
-        do_hook :post_lhs
+      @lhs = @token.value
 
-        unless  @token.tag == ':'
-          error_exit "syntax error(grammar). unexpected '#{@token.tag}' expecting ':'"
-        end
-        get_token
+      scan_token
+      do_hook :post_lhs
 
-        @nrhs = 0
-        do_hook :pre_rhs_list
-        parse_rhslist
-        do_hook :post_rhs_list
+      error_exit "syntax error(grammar). unexpected '#{@token.tag}' expecting ':'" unless @token.tag == ":"
+      scan_token
 
-        unless @token.tag == ';'
-          error_exit "syntax error(grammar). unexpected '#{@token.tag}' expecting ';'"
-        end
-        get_token
-      end
+      @nrhs = 0
+      do_hook :pre_rhs_list
+      parse_rhslist
+      do_hook :post_rhs_list
+
+      error_exit "syntax error(grammar). unexpected '#{@token.tag}' expecting ';'" unless @token.tag == ";"
+      scan_token
     end
 
     def parse_rhslist
-      @rhs = []; @rhs_names = []; @prec = nil
+      @rhs = []
+      @rhs_names = []
+      @prec = nil
       do_hook :pre_rhs
       parse_syms
       add_rule(@lhs, @rhs, @prec, @rhs_names)
       do_hook :post_rhs
       @nrhs += 1
 
-      if @token.tag == '|'
-        get_token
-        parse_rhslist
-      end
+      return unless @token.tag == "|"
+
+      scan_token
+      parse_rhslist
     end
 
     def parse_syms
-      if @token.tag == :NT || @token.tag == :T
-        insert_sym_to_rhs(-1, @token.value, @token.name)
-        get_token
+      return unless @token.tag == :NT || @token.tag == :T
 
-        do_hook :post_symbol
-        parse_syms
-      end
+      insert_sym_to_rhs(-1, @token.value, @token.name)
+      scan_token
+
+      do_hook :post_symbol
+      parse_syms
     end
 
-    def make_token tag, value, name = nil
+    def make_token(tag, value, name = nil)
       @token = Token.new(tag, value, name, file.lineno)
     end
 
-    def get_token
+    def scan_token
       while !@line.empty? || !file.eof?
         @original_line = @old_line = @line = file.gets if @line.empty?
 
         tag = s = name = val = nil
-        until @line.empty? do
+        until @line.empty?
           case @line
-          when /^\s+/, /^\#.*/ ;
+          when /^\s+/, /^\#.*/
             # skip
           when /^=([a-zA-Z]+)/
             @prec = s = $1.intern
@@ -252,17 +247,17 @@ module Depager
           when /^([a-z][a-z0-9_]*)(-([a-z][_a-z0-9]*))?/
             tag = :NT
             s = $1.intern
-            name = $3 ? $3 : $1
+            name = $3 || $1
             val = @nonterms[s] ||= @nonterms.size
           when /^([A-Z][A-Z0-9_]*)(-([a-z][_a-z0-9]*))?/
             tag = :T
             s = $1.intern
-            name = $3 ? $3 : $1
-            val = @terms[s] ||=  - (@terms.size + 1)
+            name = $3 || $1
+            val = @terms[s] ||= - (@terms.size + 1)
           when /^'(.+?)'/
             tag = :T
             name = s = $1
-            val = @terms[s] ||=  - (@terms.size + 1)
+            val = @terms[s] ||= - (@terms.size + 1)
           when /^%%/
             return make_token(nil, nil)
           when /^([:;|])/
@@ -271,32 +266,31 @@ module Depager
           else
             return make_token(:UNKNOWN, @line[0].chr)
           end
-          @old_line, @line = @line, $'
+          @old_line = @line
+          @line = $'
           @int_to_sym[val] ||= s if val && s
           return make_token(tag, val, name) if tag
         end
       end
-      return make_token(nil, nil)
+      make_token(nil, nil)
     end
 
-    def extend_paser extensions, options
+    def extend_parser(extensions, options)
       init_hook
       @extensions = []
       extensions.each do |f, m|
-        if f && f.match(%r!^\./!)
+        if f&.match(%r{^\./})
           require File.expand_path(f, File.dirname(file.path))
         elsif f
           require f
         end
 
-        nesting   = m.split(/::/).tap{|it| it[-1] = "#{it[-1]}Extension"}
-        extension = nesting.inject(Object){|c,name| c.const_get(name) }.new
-        options[m] and options[m].each do |k, v|
-          begin
-            e.send("#{k}=", v)
-          rescue NoMethodError
-            warning "no such a option '#{m}.#{k}'."
-          end
+        nesting   = m.split("::").tap { |it| it[-1] = "#{it[-1]}Extension" }
+        extension = nesting.inject(Object) { |c, name| c.const_get(name) }.new
+        options[m]&.each do |k, v|
+          extension.send(:"#{k}=", v)
+        rescue NoMethodError
+          warning "no such a option '#{m}.#{k}'."
         end
         @extensions << extension
         extension.extension_registered self
@@ -305,17 +299,17 @@ module Depager
     end
 
     def init_grammar
-      @rules      = [ d_parser.parsing_method::Rule[0 , [1]]]
+      @rules      = [d_parser.parsing_method::Rule[0, [1]]]
       @terms      = { nil => -1, false => -2 }
-      @nonterms   = { '$start' => 0 }
+      @nonterms   = { "$start" => 0 }
       @int_to_sym = {}
       @rhs_syms   = {}
       @lhs_syms   = {}
     end
 
-    def make_grammar precs
+    def make_grammar(precs)
       ts = @nonterms.size - 1
-      @terms.each{|k,v| @terms[k] = ts - v}
+      @terms.each { |k, v| @terms[k] = ts - v }
 
       @precs = {}
       precs.each_with_index do |p, x|
@@ -328,19 +322,19 @@ module Depager
         end
       end
       @rules.each do |rule|
-        rule.rhs.each_with_index{|i, x| rule.rhs[x] = ts - i if i < 0}
+        rule.rhs.each_with_index { |i, x| rule.rhs[x] = ts - i if i < 0 }
         rule.prec &&= @precs[@terms[rule.prec]]
       end
     end
 
     def check_grammar
       lhs_warns = []
-      @lhs_syms.each do |s, _|
-        lhs_warns << s if s != 1 and !@rhs_syms[s]
+      @lhs_syms.each_key do |s|
+        lhs_warns << s if (s != 1) && !@rhs_syms[s]
       end
       rhs_warns = []
-      @rhs_syms.each do |s, _|
-        rhs_warns << s if s > 0 and !@lhs_syms[s]
+      @rhs_syms.each_key do |s|
+        rhs_warns << s if (s > 0) && !@lhs_syms[s]
       end
       lhs_warns.uniq.each do |s|
         warning "the lhs '#{@int_to_sym[s]}' is not used"
@@ -351,24 +345,25 @@ module Depager
     end
 
     def init_hook
-      @hooks = HOOK_KEYS.inject({}){|r, i| r[i] = []; r }
+      @hooks = HOOK_KEYS.each_with_object({}) do |i, r|
+        r[i] = []
+      end
     end
 
-    def do_hook hook
-      @hooks[hook].each{|o, m| o.send m}
+    def do_hook(hook)
+      @hooks[hook].each { |o, m| o.send m }
     end
   end
 
   class Generator
     include Depager::Utils::CommonMethods
 
-    TEMPLATES_DIR = File.expand_path('../depager/ruby/templates', __FILE__)
+    TEMPLATES_DIR = File.expand_path("depager/ruby/templates", __dir__)
 
     attr_reader   :d_parser, :g_parser, :parsing_method
-    attr_accessor :outer_code, :inner_code
-    attr_accessor :decorators, :requirements, :options
+    attr_accessor :outer_code, :inner_code, :setup_code, :decorators, :requirements, :options
 
-    def initialize d_parser
+    def initialize(d_parser)
       @d_parser = d_parser
       @g_parser = d_parser.g_parser
       @parsing_method = nil
@@ -377,14 +372,15 @@ module Depager
       @decorators   = []
       @requirements = []
       @extensions   = []
-      @inner_code   = ''
-      @outer_code   = ''
+      @inner_code   = ""
+      @outer_code   = ""
+      @setup_code   = ""
       @precs        = []
       @mixins       = []
     end
 
-    def generate_code template
-      ERB.new(template || '', nil, '-').result(binding)
+    def generate_code(template)
+      ERB.new(template || "", trim_mode: "-").result(binding)
     end
 
     def parse_prec
@@ -395,7 +391,7 @@ module Depager
           # skip
         when /^\s*(left|right|nonassoc)\s+(.*)$/
           dir = $1.upcase.intern
-          syms = $2.split.map{|i| (i =~ /'(.+?)'/) ? $1 : i.intern}
+          syms = $2.split.map { |i| i =~ /'(.+?)'/ ? $1 : i.intern }
           precs.push [dir, syms]
         when /^%\}\s*$/
           break
@@ -403,38 +399,41 @@ module Depager
           error_exit "syntax error(prec).\n> #{line}"
         end
       end
-      return precs
+      precs
     end
 
-    def parse_block raw = false
-      lineno, val = self.file.lineno, ''
+    def parse_block(raw: false)
+      lineno = file.lineno
+      val = ""
       until file.eof?
         line = file.gets
-        break if line =~ /^%\}/
+        break if /^%\}/.match?(line)
+
         val.concat line
       end
       return val if raw
 
-      delimiter = Depager.configuration[:expanded_code_delimiter] ||
-        ".,.,#{Time.now.to_i}#{rand(0xffff)}.,.,"
-      return "module_eval <<'#{delimiter}', '#{file.path}', #{lineno + 1}\n" <<
-        "#{val.gsub('\\', '\\\\')}\n" <<
-        "#{delimiter}\n"
+      delimiter = expanded_code_delimiter
+      <<~EXPANDED_CODE
+        module_eval <<'#{delimiter}', '#{file.path}', #{lineno + 1}
+        #{val}
+        #{delimiter}
+      EXPANDED_CODE
     end
 
-    def parse_common line
+    def parse_common(line)
       case line
       when /^\s*(#.*)?$/
-        #skip space and comment.
+        # skip space and comment.
       when /^%decorate\s+(.*?)\s*\((.*)\)\s*$/
         @decorators.push $1
         @requirements.push $2
       when /^%decorate\s+(.*?)\s*$/
         @decorators.push $1
       when /^%extend\s+(.*?)\s*\(\s*'(.*)'\s*\)\s*$/
-        @extensions.push [$2.strip, $1] unless @extensions.find{|i| i[1] == $1}
-      when /^%option\s+(\w+).(\w+)\s+(.*)\s*$/
-        if $1 == 'Generator'
+        @extensions.push [$2.strip, $1] unless @extensions.find { |i| i[1] == $1 }
+      when /^%option\s+([\w:]+).(\w+)\s+(.*)\s*$/
+        if $1 == "Generator"
           Depager.configuration[$2.to_sym] = $3
         else
           @options[$1] ||= []
@@ -451,6 +450,9 @@ module Depager
         @precs = parse_prec
       when /^%expanded_code_delimiter\s+(\S+)\s*$/
         Depager.configuration[:expanded_code_delimiter] = $1
+      when /^%abort_behavior\s+(pending\s+)?(.*)$/
+        @inner_code << "    def do_abort_driver; end\n" if $1
+        @inner_code << "    def abort_driver; #{$2}; end\n" unless $2.strip.empty?
       else
         warning "syntax error(declaration).\n> #{line}"
       end
@@ -458,63 +460,62 @@ module Depager
   end
 
   class ParserGenerator < Generator
-    def initialize d_parser
-      super
-    end
-
     def parse
       until file.eof?
         line = file.gets
         case line
         when /^%%\s*$/
           g_parser.parse(@d_parser.full_target_name, @precs, @extensions, @options)
-          @outer_code << parse_block(true)
+          @outer_code << parse_block(raw: true)
           return generate_code parser_code_template
+        when /^%setup((\s*{\s*)|(\s.*))$/
+          @setup_code << ($2 ? parse_block : $3.lstrip)
         else
           parse_common(line)
         end
       end
-      return nil
+      nil
     end
 
-    def parser_code_template
-    end
+    def parser_code_template; end
   end
 
   class ExtensionGenerator < Generator
     attr_accessor :slaves
-    def initialize d_parser
+
+    def initialize(d_parser)
       super
-      @slaves = { }
+      @slaves = {}
     end
 
     def parse
       until file.eof?
         line = file.gets
         case line
-        when /^%hook\s+([\w \t]+?)(\/((?:[^\/\\]+|\\.)+)\/(\s+skip)?)?\s*$/
-          hooks = $1.split(' ')
-          @banner = hooks.join(',')
+        when %r{^%hook\s+([\w \t]+?)(/((?:[^/\\]+|\\.)+)/(\s+skip)?)?\s*$}
+          hooks = $1.split
+          @banner = hooks.join(",")
           @do_parse_re   = $3
           @do_parse_skip = $4
 
-          target_name = "#{d_parser.target_namespace}::Slave_#{ hooks.join('__') }::Parser"
-          hooks.each do |i| i = i.to_sym
+          parts = hooks.map do |i|
             error_exit "Unknown hook: #{i}" unless g_parser.hook_name? i
-            @slaves[i] = target_name
+            i.split("_").map(&:capitalize).join
           end
+          target_name = "#{d_parser.target_namespace}::#{parts.join}#{slaves.size}::Parser"
+          @slaves[target_name] = hooks
           @outer_code << parse_hook(target_name)
         when /^%%\s*$/
-          @outer_code << parse_block(true)
+          @outer_code << parse_block(raw: true)
         else
           parse_common(line)
         end
       end
-      return generate_code master_code_template
+      generate_code master_code_template
     end
 
-    def parse_hook target_name
-      inner = ''
+    def parse_hook(target_name)
+      inner = ""
       precs = []
       @slave_mixins = @mixins.dup
       until file.eof?
@@ -539,11 +540,9 @@ module Depager
       end
     end
 
-    def slave_code_template
-    end
+    def slave_code_template; end
 
-    def master_code_template
-    end
+    def master_code_template; end
   end
 
   class Extension
@@ -552,31 +551,22 @@ module Depager
 
     attr_reader :d_parser, :g_parser
 
-    def init_extension
-    end
+    def init_extension; end
 
-    def term_extension
-    end
+    def term_extension; end
 
-    def extension_registered g_parser
+    def extension_registered(g_parser)
       @g_parser = g_parser
       @d_parser = g_parser.d_parser
 
-      self.methods.sort.each do |m|
+      methods.sort.each do |m|
         m = m.to_sym
         g_parser.hooks[m].push [self, m] if g_parser.hook_name? m
       end
     end
 
     def decorator_name
-      self.class.name.split('::').last.sub(/Extension$/, '')
+      self.class.name.split("::").last.sub(/Extension$/, "")
     end
   end
 end
-
-class String
-  def unindent
-    indent = match(/\n(\s+)/) ? $1 : ''
-    gsub(/^#{indent}/m, '')
-  end
-end