DEV Community: Shuichi Tamayose

Get a ruby method block source

Shuichi Tamayose — Tue, 22 Jan 2019 19:49:10 +0000

Overview

I try it.

block_source.rb (require RUBY_VERSION >= '2.6.0'

def inspector(ast:, &block)
  ast.children.each do |child|
    next unless child.instance_of?(RubyVM::AbstractSyntaxTree::Node)
    yield child
    inspector(ast: child, &block)
  end
end

def find_node(ast:, type:, lineno:)
  inspector(ast: ast) do |node|
    return node if node.type == type && node.first_lineno == lineno
  end

  nil
end

def extract_source(node:, source:)
  first_lineno = node.first_lineno - 1
  first_column = node.first_column
  last_lineno = node.last_lineno - 1
  last_column = node.last_column - 1

  if first_lineno == last_lineno
    source[first_lineno][first_column..last_column]
  else
    src = ' ' * first_column + source[first_lineno][first_column..]
    ((first_lineno + 1)...last_lineno).each do |lineno|
      src << source[lineno]
    end
    src << source[last_lineno][0..last_column]
  end
end

module Kernel
  # RUBY_VERSION >= '2.6.0'
  def block_source
    @file_specs ||= {}
    bl = caller_locations.last
    source = @file_specs.dig(bl.path, :source) || File.readlines(bl.path)
    @file_specs[bl.path] ||= { source: source, ast: RubyVM::AbstractSyntaxTree.parse(source.join) }
    node = find_node(
      ast: @file_specs.dig(bl.path, :ast),
      type: :ITER,
      lineno: bl.lineno
    )
    extract_source(node: node.children[1], source: source) if node
  end
end

Usage

require_relative 'block_source'

def foo
  pp block_source
end

foo { 'hello' }   #=> " { 'hello' }"
foo { |i| i * 3 } #=> " { |i| i * 3 }"
foo               #=> nil

Detail

First, get a caller information by bl = caller_locations.last.

bl = caller_locations.last

Second, find ITER node. (ITER node is method call with block.)

node = find_node(
  ast: @file_specs.dig(bl.path, :ast),
  type: :ITER,
  lineno: bl.lineno
)

find_node implement is simple. call inspector and find node which match conditions.

def find_node(ast:, type:, lineno:)
  inspector(ast: ast) do |node|
    return node if node.type == type && node.first_lineno == lineno
  end

  nil
end

Finarlly, extract block source from ITER. (ITER node has block body in a second children element.

extract_source(node: node.children[1], source: source) if node

TODO

Currently, it isn't possible to get a column number from the information of the caller_locations. so, this case not working.

foo { 'hello' }; bar { 'world' }

" { 'hello' }"
" { 'hello' }"

Use `coverage` gem to check method call count in Ruby.

Shuichi Tamayose — Thu, 28 Dec 2017 00:55:00 +0000

coverage gem of ruby 2.5 can get method coverage. so, I wrote a code to check the count of the method call.

sample code. (fizzbuzz.rb)

def fizz
  "Fizz"
end

def buzz
  "Buzz"
end

def fizzbuzz
  "FizzBuzz"
end

1.upto(100) do |n|
  if n % 15 == 0
    puts fizzbuzz
  elsif n % 3 == 0
    puts fizz
  elsif n % 5 == 0
    puts buzz
  else
    puts n
  end
end

check code (RUBY_VERSION >= "2.5.0")
It use termianl-table to make the results easy to see.

require "coverage"
require "terminal-table"

Coverage.start(methods: true)
require_relative "fizzbuzz"
result = Coverage.result

rows = []

result.each do |filepath, coverage_data|
  filename = File.basename(filepath)
  methods = coverage_data[:methods]

  methods.each do |method_data, count|
    next if count.zero?

    defined_class, method_id, _from_row, _from_col, _to_row, _to_col = *method_data
    rows << [filename, defined_class, method_id, count]
  end
end

header = %w(filename defined_class method_id count)
rows.sort_by! { |e| -e.last }
table = Terminal::Table.new headings: header, rows: rows
puts table

Result

.
.
# display fizzbuzz.rb result
.
.
+-------------+---------------+-----------+-------+
| filename    | defined_class | method_id | count |
+-------------+---------------+-----------+-------+
| fizzbuzz.rb | Object        | fizz      | 27    |
| fizzbuzz.rb | Object        | buzz      | 14    |
| fizzbuzz.rb | Object        | fizzbuzz  | 6     |
+-------------+---------------+-----------+-------+

looks to good.

Get the longest method name in Ruby

Shuichi Tamayose — Tue, 26 Dec 2017 00:53:34 +0000

It can get the longest method name.

p ObjectSpace.each_object(Module).flat_map { |m| m.instance_methods + m.private_instance_methods }.uniq.max_by(&:size)

I tried it in local machine. (ruby 2.4.3p205)

:fix_syck_default_key_in_requirements

Check values of method arguments in Ruby

Shuichi Tamayose — Mon, 25 Dec 2017 01:15:40 +0000

I try it.

method(__method__).parameters.map { |t, v| [v, eval(v.to_s)] }.to_h

Example

def foo(a = 3, b = 'hello', *test)
  p method(__method__).parameters.map { |t, v| [v, eval(v.to_s)] }.to_h
end

foo #=> {:a=>3, :b=>"hello", :test=>[]}