1117

pending completion

Build # 1117

Build Type

Pull #1296

travis-ci

Committed by

web-flow

Commit Message

Support Ruby 2.7.0

Follow up of https://github.com/lsegal/yard/pull/1290#issuecomment-558204534.

This is a workaround path for Ruby 2.7.0.

`irb/slex` internal API has been removed in the following commits.
https://github.com/ruby/ruby/commit/45bb6f28d

This PR copies the above file to lib/yard/parser/ruby/legacy/irb/slex.rb.

Hopefully this workaround patch will be dropped along with legacy Ruby code
in the future.

And E2MM (e2mmap gem) is no longer bundled gems.
https://www.ruby-lang.org/en/news/2019/12/25/ruby-2-7-0-released/

```console
% cd path/to/repo/yard
% ruby -v
ruby 2.7.0p0 (2019-12-25 revision 647ee6f091) [x86_64-darwin17]
% bundle exec rake

(snip)

LoadError:
  cannot load such file -- e2mmap
  # ./lib/yard/parser/ruby/legacy/ruby_lex.rb:1:in `require'
  # ./lib/yard/parser/ruby/legacy/ruby_lex.rb:1:in `<top (required)>'
```

This dependency on `e2mmap` could be removed when `irb/slex` is removed
in the future.

Pull Request Pull Request #1296: Support Ruby 2.7.0

Run Details

155 of 155 new or added lines in 2 files covered. (100.0%)

29079 of 31442 relevant lines covered (92.48%)

27352.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.55

/lib/yard/parser/ruby/legacy/irb/slex.rb

# frozen_string_literal: false
#
#   irb/slex.rb - simple lex analyzer
#           $Release Version: 0.9.6$
#           $Revision$
#           by Keiju ISHITSUKA(keiju@ruby-lang.org)
#
# --
#
#
#

require "e2mmap"
require "irb/notifier"

# :stopdoc:
module IRB
  class SLex

    extend Exception2MessageMapper
    def_exception :ErrNodeNothing, "node nothing"
    def_exception :ErrNodeAlreadyExists, "node already exists"

    DOUT = Notifier::def_notifier("SLex::")
    D_WARN = DOUT::def_notifier(1, "Warn: ")
    D_DEBUG = DOUT::def_notifier(2, "Debug: ")
    D_DETAIL = DOUT::def_notifier(4, "Detail: ")

    DOUT.level = Notifier::D_NOMSG

    def initialize
      @head = Node.new("")
    end

    def def_rule(token, preproc = nil, postproc = nil, &block)
      D_DETAIL.pp token

      postproc = block if block_given?
      create(token, preproc, postproc)
    end

    def def_rules(*tokens, &block)
      if block_given?
        p = block
      end
      for token in tokens
        def_rule(token, nil, p)
      end
    end

    def preproc(token, proc)
      node = search(token)
      node.preproc=proc
    end

    # need a check?
    def postproc(token)
      node = search(token, proc)
      node.postproc=proc
    end

    def search(token)
      @head.search(token.split(//))
    end

    def create(token, preproc = nil, postproc = nil)
      @head.create_subnode(token.split(//), preproc, postproc)
    end

    def match(token)
      case token
      when Array
      when String
        return match(token.split(//))
      else
        return @head.match_io(token)
      end
      ret = @head.match(token)
      D_DETAIL.exec_if{D_DETAIL.printf "match end: %s:%s\n", ret, token.inspect}
      ret
    end

    def inspect
      format("<SLex: @head = %s>", @head.inspect)
    end

    #----------------------------------------------------------------------
    #
    #   class Node -
    #
    #----------------------------------------------------------------------
    class Node
      # if postproc is nil, this node is an abstract node.
      # if postproc is non-nil, this node is a real node.
      def initialize(preproc = nil, postproc = nil)
        @Tree = {}
        @preproc = preproc
        @postproc = postproc
      end

      attr_accessor :preproc
      attr_accessor :postproc

      def search(chrs, opt = nil)
        return self if chrs.empty?
        ch = chrs.shift
        if node = @Tree[ch]
          node.search(chrs, opt)
        else
          if opt
            chrs.unshift ch
            self.create_subnode(chrs)
          else
            SLex.fail ErrNodeNothing
          end
        end
      end

      def create_subnode(chrs, preproc = nil, postproc = nil)
        if chrs.empty?
          if @postproc
            D_DETAIL.pp node
            SLex.fail ErrNodeAlreadyExists
          else
            D_DEBUG.puts "change abstract node to real node."
            @preproc = preproc
            @postproc = postproc
          end
          return self
        end

        ch = chrs.shift
        if node = @Tree[ch]
          if chrs.empty?
            if node.postproc
              DebugLogger.pp node
              DebugLogger.pp self
              DebugLogger.pp ch
              DebugLogger.pp chrs
              SLex.fail ErrNodeAlreadyExists
            else
              D_WARN.puts "change abstract node to real node"
              node.preproc = preproc
              node.postproc = postproc
            end
          else
            node.create_subnode(chrs, preproc, postproc)
          end
        else
          if chrs.empty?
            node = Node.new(preproc, postproc)
          else
            node = Node.new
            node.create_subnode(chrs, preproc, postproc)
          end
          @Tree[ch] = node
        end
        node
      end

      #
      # chrs: String
      #       character array
      #       io must have getc()/ungetc(); and ungetc() must be
      #       able to be called arbitrary number of times.
      #
      def match(chrs, op = "")
        D_DETAIL.print "match>: ", chrs, "op:", op, "\n"
        if chrs.empty?
          if @preproc.nil? || @preproc.call(op, chrs)
            DOUT.printf(D_DETAIL, "op1: %s\n", op)
            @postproc.call(op, chrs)
          else
            nil
          end
        else
          ch = chrs.shift
          if node = @Tree[ch]
            if ret = node.match(chrs, op+ch)
              return ret
            else
              chrs.unshift ch
              if @postproc and @preproc.nil? || @preproc.call(op, chrs)
                DOUT.printf(D_DETAIL, "op2: %s\n", op.inspect)
                ret = @postproc.call(op, chrs)
                return ret
              else
                return nil
              end
            end
          else
            chrs.unshift ch
            if @postproc and @preproc.nil? || @preproc.call(op, chrs)
              DOUT.printf(D_DETAIL, "op3: %s\n", op)
              @postproc.call(op, chrs)
              return ""
            else
              return nil
            end
          end
        end
      end

      def match_io(io, op = "")
        if op == ""
          ch = io.getc
          if ch == nil
            return nil
          end
        else
          ch = io.getc_of_rests
        end
        if ch.nil?
          if @preproc.nil? || @preproc.call(op, io)
            D_DETAIL.printf("op1: %s\n", op)
            @postproc.call(op, io)
          else
            nil
          end
        else
          if node = @Tree[ch]
            if ret = node.match_io(io, op+ch)
              ret
            else
              io.ungetc ch
              if @postproc and @preproc.nil? || @preproc.call(op, io)
                DOUT.exec_if{D_DETAIL.printf "op2: %s\n", op.inspect}
                @postproc.call(op, io)
              else
                nil
              end
            end
          else
            io.ungetc ch
            if @postproc and @preproc.nil? || @preproc.call(op, io)
              D_DETAIL.printf("op3: %s\n", op)
              @postproc.call(op, io)
            else
              nil
            end
          end
        end
      end
    end
  end
end
# :startdoc:

if $0 == __FILE__
  case $1
  when "1"
    tr = SLex.new
    print "0: ", tr.inspect, "\n"
    tr.def_rule("=") {print "=\n"}
    print "1: ", tr.inspect, "\n"
    tr.def_rule("==") {print "==\n"}
    print "2: ", tr.inspect, "\n"

    print "case 1:\n"
    print tr.match("="), "\n"
    print "case 2:\n"
    print tr.match("=="), "\n"
    print "case 3:\n"
    print tr.match("=>"), "\n"

  when "2"
    tr = SLex.new
    print "0: ", tr.inspect, "\n"
    tr.def_rule("=") {print "=\n"}
    print "1: ", tr.inspect, "\n"
    tr.def_rule("==", proc{false}) {print "==\n"}
    print "2: ", tr.inspect, "\n"

    print "case 1:\n"
    print tr.match("="), "\n"
    print "case 2:\n"
    print tr.match("=="), "\n"
    print "case 3:\n"
    print tr.match("=>"), "\n"
  end
  exit
end

1	# frozen_string_literal: false
2	#
3	# irb/slex.rb - simple lex analyzer
4	# $Release Version: 0.9.6$
5	# $Revision$
6	# by Keiju ISHITSUKA(keiju@ruby-lang.org)
7	#
8	# --
9	#
10	#
11	#
12
13	require "e2mmap"	8✔
14	require "irb/notifier"	8✔
15
16	# :stopdoc:
17	module IRB	8✔
18	class SLex	8✔
19
20	extend Exception2MessageMapper	8✔
21	def_exception :ErrNodeNothing, "node nothing"	8✔
22	def_exception :ErrNodeAlreadyExists, "node already exists"	8✔
23
24	DOUT = Notifier::def_notifier("SLex::")	8✔
25	D_WARN = DOUT::def_notifier(1, "Warn: ")	8✔
26	D_DEBUG = DOUT::def_notifier(2, "Debug: ")	8✔
27	D_DETAIL = DOUT::def_notifier(4, "Detail: ")	8✔
28
29	DOUT.level = Notifier::D_NOMSG	8✔
30
31	def initialize	8✔
32	@head = Node.new("")	1,942✔
33	end
34
35	def def_rule(token, preproc = nil, postproc = nil, &block)	8✔
36	D_DETAIL.pp token	145,650✔
37
38	postproc = block if block_given?	145,650✔
39	create(token, preproc, postproc)	145,650✔
40	end
41
42	def def_rules(*tokens, &block)	8✔
43	if block_given?	27,188✔
44	p = block	27,188✔
45	end
46	for token in tokens	27,188✔
47	def_rule(token, nil, p)	102,926✔
48	end
49	end
50
51	def preproc(token, proc)	8✔
52	node = search(token)	×
53	node.preproc=proc	×
54	end
55
56	# need a check?
57	def postproc(token)	8✔
58	node = search(token, proc)	×
59	node.postproc=proc	×
60	end
61
62	def search(token)	8✔
63	@head.search(token.split(//))	×
64	end
65
66	def create(token, preproc = nil, postproc = nil)	8✔
67	@head.create_subnode(token.split(//), preproc, postproc)	145,650✔
68	end
69
70	def match(token)	8✔
71	case token	16,350✔
72	when Array
73	when String
74	return match(token.split(//))	×
75	else
76	return @head.match_io(token)	16,350✔
77	end
78	ret = @head.match(token)	×
79	D_DETAIL.exec_if{D_DETAIL.printf "match end: %s:%s\n", ret, token.inspect}	×
80	ret	×
81	end
82
83	def inspect	8✔
84	format("<SLex: @head = %s>", @head.inspect)	×
85	end
86
87	#----------------------------------------------------------------------
88	#
89	# class Node -
90	#
91	#----------------------------------------------------------------------
92	class Node	8✔
93	# if postproc is nil, this node is an abstract node.
94	# if postproc is non-nil, this node is a real node.
95	def initialize(preproc = nil, postproc = nil)	8✔
96	@Tree = {}	165,070✔
97	@preproc = preproc	165,070✔
98	@postproc = postproc	165,070✔
99	end
100
101	attr_accessor :preproc	8✔
102	attr_accessor :postproc	8✔
103
104	def search(chrs, opt = nil)	8✔
105	return self if chrs.empty?	×
106	ch = chrs.shift	×
107	if node = @Tree[ch]	×
108	node.search(chrs, opt)	×
109	else
110	if opt	×
111	chrs.unshift ch	×
112	self.create_subnode(chrs)	×
113	else
114	SLex.fail ErrNodeNothing	×
115	end
116	end
117	end
118
119	def create_subnode(chrs, preproc = nil, postproc = nil)	8✔
120	if chrs.empty?	246,634✔
121	if @postproc	1,942✔
122	D_DETAIL.pp node	×
123	SLex.fail ErrNodeAlreadyExists	×
124	else
125	D_DEBUG.puts "change abstract node to real node."	1,942✔
126	@preproc = preproc	1,942✔
127	@postproc = postproc	1,942✔
128	end
129	return self	1,942✔
130	end
131
132	ch = chrs.shift	244,692✔
133	if node = @Tree[ch]	244,692✔
134	if chrs.empty?	81,564✔
135	if node.postproc	13,594✔
136	DebugLogger.pp node	×
137	DebugLogger.pp self	×
138	DebugLogger.pp ch	×
139	DebugLogger.pp chrs	×
140	SLex.fail ErrNodeAlreadyExists	×
141	else
142	D_WARN.puts "change abstract node to real node"	13,594✔
143	node.preproc = preproc	13,594✔
144	node.postproc = postproc	13,594✔
145	end
146	else
147	node.create_subnode(chrs, preproc, postproc)	67,970✔
148	end
149	else
150	if chrs.empty?	163,128✔
151	node = Node.new(preproc, postproc)	130,114✔
152	else
153	node = Node.new	33,014✔
154	node.create_subnode(chrs, preproc, postproc)	33,014✔
155	end
156	@Tree[ch] = node	163,128✔
157	end
158	node	244,692✔
159	end
160
161	#
162	# chrs: String
163	# character array
164	# io must have getc()/ungetc(); and ungetc() must be
165	# able to be called arbitrary number of times.
166	#
167	def match(chrs, op = "")	8✔
168	D_DETAIL.print "match>: ", chrs, "op:", op, "\n"	×
169	if chrs.empty?	×
170	if @preproc.nil? \|\| @preproc.call(op, chrs)	×
171	DOUT.printf(D_DETAIL, "op1: %s\n", op)	×
172	@postproc.call(op, chrs)	×
173	else
174	nil
175	end
176	else
177	ch = chrs.shift	×
178	if node = @Tree[ch]	×
179	if ret = node.match(chrs, op+ch)	×
180	return ret	×
181	else
182	chrs.unshift ch	×
183	if @postproc and @preproc.nil? \|\| @preproc.call(op, chrs)	×
184	DOUT.printf(D_DETAIL, "op2: %s\n", op.inspect)	×
185	ret = @postproc.call(op, chrs)	×
186	return ret	×
187	else
188	return nil
189	end
190	end
191	else
192	chrs.unshift ch	×
193	if @postproc and @preproc.nil? \|\| @preproc.call(op, chrs)	×
194	DOUT.printf(D_DETAIL, "op3: %s\n", op)	×
195	@postproc.call(op, chrs)	×
196	return ""	×
197	else
198	return nil
199	end
200	end
201	end
202	end
203
204	def match_io(io, op = "")	8✔
205	if op == ""	26,560✔
206	ch = io.getc	16,350✔
207	if ch == nil	16,350✔
208	return nil	1,942✔
209	end
210	else
211	ch = io.getc_of_rests	10,210✔
212	end
213	if ch.nil?	24,618✔
214	if @preproc.nil? \|\| @preproc.call(op, io)	1,942✔
215	D_DETAIL.printf("op1: %s\n", op)	1,942✔
216	@postproc.call(op, io)	1,942✔
217	else
218	nil
219	end
220	else
221	if node = @Tree[ch]	22,676✔
222	if ret = node.match_io(io, op+ch)	10,210✔
223	ret	10,204✔
224	else
225	io.ungetc ch	6✔
226	if @postproc and @preproc.nil? \|\| @preproc.call(op, io)	6✔
227	DOUT.exec_if{D_DETAIL.printf "op2: %s\n", op.inspect}	12✔
228	@postproc.call(op, io)	6✔
229	else
230	nil
231	end
232	end
233	else
234	io.ungetc ch	12,466✔
235	if @postproc and @preproc.nil? \|\| @preproc.call(op, io)	12,466✔
236	D_DETAIL.printf("op3: %s\n", op)	12,460✔
237	@postproc.call(op, io)	12,460✔
238	else
239	nil
240	end
241	end
242	end
243	end
244	end
245	end
246	end
247	# :startdoc:
248
249	if $0 == __FILE__	8✔
250	case $1	×
251	when "1"
252	tr = SLex.new	×
253	print "0: ", tr.inspect, "\n"	×
254	tr.def_rule("=") {print "=\n"}	×
255	print "1: ", tr.inspect, "\n"	×
256	tr.def_rule("==") {print "==\n"}	×
257	print "2: ", tr.inspect, "\n"	×
258
259	print "case 1:\n"	×
260	print tr.match("="), "\n"	×
261	print "case 2:\n"	×
262	print tr.match("=="), "\n"	×
263	print "case 3:\n"	×
264	print tr.match("=>"), "\n"	×
265
266	when "2"
267	tr = SLex.new	×
268	print "0: ", tr.inspect, "\n"	×
269	tr.def_rule("=") {print "=\n"}	×
270	print "1: ", tr.inspect, "\n"	×
271	tr.def_rule("==", proc{false}) {print "==\n"}	×
272	print "2: ", tr.inspect, "\n"	×
273
274	print "case 1:\n"	×
275	print tr.match("="), "\n"	×
276	print "case 2:\n"	×
277	print tr.match("=="), "\n"	×
278	print "case 3:\n"	×
279	print tr.match("=>"), "\n"	×
280	end
281	exit	×
282	end

lsegal / yard / 1117

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous