[#97086] [Ruby master Bug#16612] Enumerator::ArithmeticSequence#last with float range produces incorrect value — muraken@...
Issue #16612 has been updated by mrkn (Kenta Murata).
4 messages
2020/02/07
[#97307] [Ruby master Feature#16663] Add block or filtered forms of Kernel#caller to allow early bail-out — headius@...
Issue #16663 has been reported by headius (Charles Nutter).
29 messages
2020/02/28
[ruby-core:97306] [Ruby master Feature#14145] Proposal: Better Method#inspect
From:
zverok.offline@...
Date:
2020-02-28 13:44:27 UTC
List:
ruby-core #97306
Issue #14145 has been updated by zverok (Victor Shepelev).
This can be closed now, I believe.
----------------------------------------
Feature #14145: Proposal: Better Method#inspect
https://bugs.ruby-lang.org/issues/14145#change-84434
* Author: zverok (Victor Shepelev)
* Status: Open
* Priority: Normal
----------------------------------------
The idea: When investigating (in example scripts, debugger or console) the library you are unfamiliar with, Ruby's reflection is very useful mechanism to understand "what it can": classes, modules, their constants, methods and so on.
I propose to expose a bit more information Ruby has internally in `Method#inspect`:
```ruby
# before:
some_interesting_object.method(:foo) # => #<Method Klass#foo>
# after:
some_interesting_object.method(:foo) # => #<Method Klass#foo(first_arg, *other_args, keyword_arg:)>
```
Dead-naive implementation:
```ruby
class Method
def signature
recv = case receiver
when Module
"#{receiver.name}."
else
"#{receiver.class}#"
end
parameters.map.with_index { |(type, name), i|
case type
when :req then "#{name || "param#{i+1}"}"
when :opt then "#{name || "param#{i+1}"} = <default>"
when :keyreq then "#{name || "kw#{i+1}"}:"
when :key then "#{name || "kwparam#{i+1}"}: <default>"
when :rest then "*#{name || "rest"}"
when :keyrest then "**#{name || "kwrest"}"
end
}.join(', ').prepend("#{recv}#{name}(") << ")"
end
def inspect
"#<#{self.class.name} #{signature}>"
end
end
```
This works "sub-optimal" for methods implemented in C, yet pretty decently for Ruby-implemented methods:
```ruby
# C method, default param names
[1,2,3].method(:at)
# => #<Method Array#at(param1)>
# Ruby method, proper param names
CGI.method(:escape)
# => #<Method CGI.escape(string)>
Addressable::URI.method(:parse)
# => #<Method Addressable::URI.parse(uri)>
Addressable::URI.method(:join)
=> #<Method Addressable::URI.join(*uris)>
# We can't extract default values, but at least we can say they are there
Addressable::URI.method(:heuristic_parse)
# => #<Method Addressable::URI.heuristic_parse(uri, hints = <default>)>
```
If the proposal is accepted, I am ready to implement it properly in C (for all callable objects: `Method`, `UnboundMethod`, `Proc`)
--
https://bugs.ruby-lang.org/
Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>