looksee 4.4.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 600194bca92f1417cef56f15fb778bf97169424c779269d16dc87afde159013b
-  data.tar.gz: a9548afb11a7e6ebbe7fa43d7155d6258871530d135197f93ed79573d899432a
+  metadata.gz: e79d312ff99899463a1ae1c3ef7c223bd2761cd51d03fdb4349cb3620c06f624
+  data.tar.gz: 2c5e23a018a88ef8c7bed8c3e9ea230ed81fb58dcd6f2479b3752cbe5e44cac3
 SHA512:
-  metadata.gz: '08f3978dbed48efa7daaba8fe778b9dfdf3032748dc2cdfd9ac5d36667bfd2ea7eff4b3662d660f97784d99459d082c0228c188bd2b3261e3ed5935d06a45460'
-  data.tar.gz: ec4dbddc1ca894b843d0ad187ea4ce35a4a1c6890a920790479d01e35ccb81f19bf321dff7001060d5f3280dd312d27b7c74494a756fad02613ad30b96dcae86
+  metadata.gz: ef17ec0b836a791aac8b814b9f825aceff66ea346f1ba3f2a6e9504e686d439013583b2c362b2e2c5626d32ca9ec58fd2f1dfecf95f9b503ccb2fd2ee08ceca5
+  data.tar.gz: 5e0d129f6977c2b32b8671168b9fd1ab5e5bc26a1efc0e07e88176ac80c8675d459210c639ef54ad51b088971acb75964886571a8aac81e04a7cc241ac736d51

data/CHANGELOG

@@ -1,3 +1,19 @@
+== 5.1.0 2025-03-28
+
+ * Support for MRI 3.3.
+ * Fix color escaping in Looksee.help.
+
+== 5.0.0 2022-11-08
+
+ * Rename #ls to #look. Sorry! irb now defines an ls built-in, though, and the
+   old name emits a warning on startup.
+ * Support for MRI 3.2.0 preview2. From 3.2 onwards, we once again display
+   undef'd methods.
+ * Remove support for MRI < 2.7. (2.6 is EOL anyway.)
+ * Remove support for Rubinius.
+ * Fix showing modules included in singleton classes with no direct methods.
+ * Fix ANSI color escaping in ruby >= 3.0.
+
 == 4.4.0 2021-01-17
 
  * Support for MRI 3.0. [Mathieu Jobin]

data/README.markdown

@@ -13,73 +13,97 @@ Pop this in your `.irbrc`:
 
     require 'looksee'
 
-Now each object has a method `ls`, which shows you all its methods.
-
-    irb> [].ls
-    => BasicObject
-      !   __id__    initialize     method_missing            singleton_method_undefined
-      !=  __send__  instance_eval  singleton_method_added
-      ==  equal?    instance_exec  singleton_method_removed
+Now each object has a method `look`, which shows you all its methods.
+
+    irb> [].look
+    =>
+    BasicObject
+      !       __send__       instance_exec             singleton_method_undefined
+      !=      equal?         method_missing
+      ==      initialize     singleton_method_added
+      __id__  instance_eval  singleton_method_removed
     Kernel
-      !~                       enum_for                    kind_of?                  respond_to_missing?
-      <=>                      eql?                        lambda                    select
-      ===                      eval                        load                      send
-      =~                       exec                        local_variables           set_trace_func
-      Array                    exit                        loop                      singleton_class
-      Complex                  exit!                       method                    singleton_method
-      Float                    extend                      methods                   singleton_methods
-      Hash                     fail                        nil?                      sleep
-      Integer                  fork                        object_id                 spawn
-      Rational                 format                      open                      sprintf
-      String                   freeze                      p                         srand
-      __callee__               frozen?                     print                     syscall
-      __dir__                  gem                         printf                    system
-      __method__               gem_original_require        private_methods           taint
-      `                        gets                        proc                      tainted?
-      abort                    global_variables            protected_methods         tap
-      at_exit                  hash                        public_method             test
-      autoload                 initialize_clone            public_methods            throw
-      autoload?                initialize_copy             public_send               to_enum
-      binding                  initialize_dup              putc                      to_s
-      block_given?             inspect                     puts                      trace_var
-      caller                   instance_of?                raise                     trap
-      caller_locations         instance_variable_defined?  rand                      trust
-      catch                    instance_variable_get       readline                  untaint
-      class                    instance_variable_set       readlines                 untrace_var
-      clone                    instance_variables          remove_instance_variable  untrust
-      define_singleton_method  is_a?                       require                   untrusted?
-      display                  iterator?                   require_relative          warn
-      dup                      itself                      respond_to?
+      !~                       format                      public_method
+      <=>                      freeze                      public_methods
+      ===                      frozen?                     public_send
+      Array                    gem                         putc
+      Complex                  gem_original_require        puts
+      Float                    gets                        raise
+      Hash                     global_variables            rand
+      Integer                  hash                        readline
+      Pathname                 initialize_clone            readlines
+      Rational                 initialize_copy             remove_instance_variable
+      String                   initialize_dup              require
+      __callee__               inspect                     require_relative
+      __dir__                  instance_of?                respond_to?
+      __method__               instance_variable_defined?  respond_to_missing?
+      `                        instance_variable_get       select
+      abort                    instance_variable_set       send
+      at_exit                  instance_variables          set_trace_func
+      autoload                 is_a?                       singleton_class
+      autoload?                iterator?                   singleton_method
+      binding                  itself                      singleton_methods
+      block_given?             kind_of?                    sleep
+      caller                   lambda                      spawn
+      caller_locations         load                        sprintf
+      catch                    local_variables             srand
+      class                    loop                        syscall
+      clone                    method                      system
+      define_singleton_method  methods                     tap
+      display                  nil?                        test
+      dup                      object_id                   then
+      enum_for                 open                        throw
+      eql?                     p                           to_enum
+      eval                     pp                          to_s
+      exec                     pretty_inspect              trace_var
+      exit                     print                       trap
+      exit!                    printf                      untrace_var
+      extend                   private_methods             warn
+      fail                     proc                        yield_self
+      fork                     protected_methods
     Looksee::ObjectMixin
-      ls
+      look
+    PP::ObjectMixin
+      pretty_print        pretty_print_inspect
+      pretty_print_cycle  pretty_print_instance_variables
     Object
-      DelegateClass  default_src_encoding  irb_binding
+      DelegateClass
     Enumerable
-      all?            detect            entries     group_by  min        reject        take
-      any?            drop              find        include?  min_by     reverse_each  take_while
-      chunk           drop_while        find_all    inject    minmax     select        to_a
-      chunk_while     each_cons         find_index  lazy      minmax_by  slice_after   to_h
-      collect         each_entry        first       map       none?      slice_before  to_set
-      collect_concat  each_slice        flat_map    max       one?       slice_when    zip
-      count           each_with_index   grep        max_by    partition  sort
-      cycle           each_with_object  grep_v      member?   reduce     sort_by
+      all?            drop              find_all    max        reject        tally
+      any?            drop_while        find_index  max_by     reverse_each  to_a
+      chain           each_cons         first       member?    select        to_h
+      chunk           each_entry        flat_map    min        slice_after   to_set
+      chunk_while     each_slice        grep        min_by     slice_before  uniq
+      collect         each_with_index   grep_v      minmax     slice_when    zip
+      collect_concat  each_with_object  group_by    minmax_by  sort
+      compact         entries           include?    none?      sort_by
+      count           filter            inject      one?       sum
+      cycle           filter_map        lazy        partition  take
+      detect          find              map         reduce     take_while
     Array
-      &              collect!     eql?             keep_if               reverse       sort!
-      *              combination  fetch            last                  reverse!      sort_by!
-      +              compact      fill             length                reverse_each  take
-      -              compact!     find_index       map                   rindex        take_while
-      <<             concat       first            map!                  rotate        to_a
-      <=>            count        flatten          pack                  rotate!       to_ary
-      ==             cycle        flatten!         permutation           sample        to_h
-      []             delete       frozen?          pop                   select        to_s
-      []=            delete_at    hash             product               select!       transpose
-      any?           delete_if    include?         push                  shift         uniq
-      assoc          dig          index            rassoc                shuffle       uniq!
-      at             drop         initialize       reject                shuffle!      unshift
-      bsearch        drop_while   initialize_copy  reject!               size          values_at
-      bsearch_index  each         insert           repeated_combination  slice         zip
-      clear          each_index   inspect          repeated_permutation  slice!        |
-      collect        empty?       join             replace               sort
+      &              count        include?         pretty_print          size
+      *              cycle        index            pretty_print_cycle    slice
+      +              deconstruct  initialize       product               slice!
+      -              delete       initialize_copy  push                  sort
+      <<             delete_at    insert           rassoc                sort!
+      <=>            delete_if    inspect          reject                sort_by!
+      ==             difference   intersect?       reject!               sum
+      []             dig          intersection     repeated_combination  take
+      []=            drop         join             repeated_permutation  take_while
+      all?           drop_while   keep_if          replace               to_a
+      any?           each         last             reverse               to_ary
+      append         each_index   length           reverse!              to_h
+      assoc          empty?       map              reverse_each          to_s
+      at             eql?         map!             rindex                transpose
+      bsearch        fetch        max              rotate                union
+      bsearch_index  fill         min              rotate!               uniq
+      clear          filter       minmax           sample                uniq!
+      collect        filter!      none?            select                unshift
+      collect!       find_index   one?             select!               values_at
+      combination    first        pack             shelljoin             zip
+      compact        flatten      permutation      shift                 |
+      compact!       flatten!     pop              shuffle
+      concat         hash         prepend          shuffle!
 
 Methods are colored according to whether they're public, protected,
 private, undefined (using Module#undef_method), or overridden.
@@ -88,11 +112,11 @@ private, undefined (using Module#undef_method), or overridden.
 
 You can hide, say, private methods like this:
 
-    irb> [].ls :noprivate
+    irb> [].look :noprivate
 
 Or filter the list by Regexp:
 
-    irb> [].ls /^to_/
+    irb> [].look /^to_/
      => BasicObject
     Kernel
       to_enum  to_s
@@ -107,32 +131,32 @@ Or filter the list by Regexp:
 ## Proxy objects
 
 Objects that delegate everything via `method_missing` to some other object can
-be tricky, because they will delegate `ls` itself. To view such objects, you can
-always do:
+be tricky, because they will delegate `look` itself. To view such objects, you
+can always do:
 
     Looksee[object]
 
-This will also work for `BasicObject` instances that don't have an `ls` method.
-`Object#ls` is simply a wrapper around `Looksee.[]`.
+This will also work for `BasicObject` instances that don't have an `look`
+method.  `Object#look` is simply a wrapper around `Looksee.[]`.
 
 ## To the source!
 
 If you want to know more about any of those methods, Looksee can
 take you straight to the source in your editor:
 
-    [].ls.edit :to_set
+    [].look.edit :to_set
 
 By default, this uses `vi`; customize it like this:
 
     # %f = file, %l = line number
     Looksee.editor = "mate -l%l %f"
 
-## `ls` in your way?
+## `look` in your way?
 
-If you have a library that for some reason can't handle an `ls` method existing
-on `Object`, you may rename it like this:
+If you have a library that for some reason can't handle an `look` method
+existing on `Object`, you may rename it like this:
 
-    Looksee.rename :_ls
+    Looksee.rename :_look
 
 ## Quick Reference
 

data/Rakefile

@@ -11,3 +11,30 @@ end
 task :default => [:clobber, :ext] do
   sh 'bundle exec rspec -I. spec'
 end
+
+task :test_all do
+  docker_configs.each do |config|
+    docker_run(config, 'rspec')
+  end
+end
+
+task :console, :config do |task, args|
+  docker_run(args[:config], nil)
+end
+
+task :test, :config do |task, args|
+  docker_run(args[:config], 'rspec')
+end
+
+task :shell, :config do |task, args|
+  docker_run(args[:config], '/bin/bash')
+end
+
+def docker_configs
+  Dir['Dockerfile.*'].map { |path| path[/(?<=\.).*?\z/] }
+end
+
+def docker_run(config, command)
+  sh "docker build -f Dockerfile.#{config} -t looksee:#{config} ."
+  sh "docker run -it looksee:#{config} #{command}"
+end

data/ext/extconf.rb

@@ -4,16 +4,13 @@ extension = ruby_engine == 'ruby' ? 'mri' : ruby_engine
 require 'mkmf'
 $CPPFLAGS << " -DRUBY_VERSION=#{RUBY_VERSION.tr('.', '')}"
 if extension == 'mri'
-  if RUBY_VERSION >= '3.0.0'
+  if RUBY_VERSION >= '3.2.0'
+    $CPPFLAGS << " -Imri/3.2.0"
+  elsif RUBY_VERSION >= '3.0.0'
     $CPPFLAGS << " -Imri/3.0.0"
-  elsif RUBY_VERSION >= '2.7.0'
+  else
     $CPPFLAGS << " -Imri/2.7.0"
-  elsif RUBY_VERSION >= '2.3.0'
-    $CPPFLAGS << " -Imri/2.3.0"
-  elsif RUBY_VERSION >= '2.2.0'
-    $CPPFLAGS << " -Imri/2.2.0"
-  elsif RUBY_VERSION >= '2.1.0'
-    $CPPFLAGS << " -Imri/2.1.0"
   end
 end
+
 create_makefile "looksee/#{extension}", extension

data/ext/mri/3.2.0/id_table.h

@@ -0,0 +1,36 @@
+#ifndef RUBY_ID_TABLE_H
+#define RUBY_ID_TABLE_H 1
+#include "ruby/internal/config.h"
+#include <stddef.h>
+#include "ruby/ruby.h"
+
+struct rb_id_table;
+
+/* compatible with ST_* */
+enum rb_id_table_iterator_result {
+    ID_TABLE_CONTINUE = ST_CONTINUE,
+    ID_TABLE_STOP     = ST_STOP,
+    ID_TABLE_DELETE   = ST_DELETE,
+    ID_TABLE_REPLACE  = ST_REPLACE,
+    ID_TABLE_ITERATOR_RESULT_END
+};
+
+struct rb_id_table *rb_id_table_create(size_t size);
+void rb_id_table_free(struct rb_id_table *tbl);
+void rb_id_table_clear(struct rb_id_table *tbl);
+
+size_t rb_id_table_size(const struct rb_id_table *tbl);
+size_t rb_id_table_memsize(const struct rb_id_table *tbl);
+
+int rb_id_table_insert(struct rb_id_table *tbl, ID id, VALUE val);
+int rb_id_table_lookup(struct rb_id_table *tbl, ID id, VALUE *valp);
+int rb_id_table_delete(struct rb_id_table *tbl, ID id);
+
+typedef enum rb_id_table_iterator_result rb_id_table_update_value_callback_func_t(VALUE *val, void *data, int existing);
+typedef enum rb_id_table_iterator_result rb_id_table_foreach_func_t(ID id, VALUE val, void *data);
+typedef enum rb_id_table_iterator_result rb_id_table_foreach_values_func_t(VALUE val, void *data);
+void rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, void *data);
+void rb_id_table_foreach_values(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, void *data);
+void rb_id_table_foreach_values_with_replace(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, rb_id_table_update_value_callback_func_t *replace, void *data);
+
+#endif	/* RUBY_ID_TABLE_H */

data/ext/mri/3.2.0/internal/array.h

@@ -0,0 +1,162 @@
+#ifndef INTERNAL_ARRAY_H                                 /*-*-C-*-vi:se ft=c:*/
+#define INTERNAL_ARRAY_H
+/**
+ * @author     Ruby developers <ruby-core@ruby-lang.org>
+ * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
+ *             Permission  is hereby  granted,  to  either redistribute  and/or
+ *             modify this file, provided that  the conditions mentioned in the
+ *             file COPYING are met.  Consult the file for details.
+ * @brief      Internal header for Array.
+ */
+#include "ruby/internal/config.h"
+#include <stddef.h>                 /* for size_t */
+#include "internal/static_assert.h" /* for STATIC_ASSERT */
+#include "ruby/internal/stdbool.h"         /* for bool */
+#include "ruby/ruby.h"              /* for RARRAY_LEN */
+
+#ifndef ARRAY_DEBUG
+# define ARRAY_DEBUG (0+RUBY_DEBUG)
+#endif
+
+#define RARRAY_SHARED_FLAG      ELTS_SHARED
+#define RARRAY_SHARED_ROOT_FLAG FL_USER12
+#define RARRAY_PTR_IN_USE_FLAG  FL_USER14
+
+/* array.c */
+VALUE rb_ary_last(int, const VALUE *, VALUE);
+void rb_ary_set_len(VALUE, long);
+void rb_ary_delete_same(VALUE, VALUE);
+VALUE rb_ary_hidden_new_fill(long capa);
+VALUE rb_ary_at(VALUE, VALUE);
+size_t rb_ary_memsize(VALUE);
+VALUE rb_to_array_type(VALUE obj);
+VALUE rb_to_array(VALUE obj);
+void rb_ary_cancel_sharing(VALUE ary);
+size_t rb_ary_size_as_embedded(VALUE ary);
+void rb_ary_make_embedded(VALUE ary);
+bool rb_ary_embeddable_p(VALUE ary);
+
+static inline VALUE rb_ary_entry_internal(VALUE ary, long offset);
+static inline bool ARY_PTR_USING_P(VALUE ary);
+static inline void RARY_TRANSIENT_SET(VALUE ary);
+static inline void RARY_TRANSIENT_UNSET(VALUE ary);
+
+MJIT_SYMBOL_EXPORT_BEGIN
+VALUE rb_ary_tmp_new_from_values(VALUE, long, const VALUE *);
+VALUE rb_check_to_array(VALUE ary);
+VALUE rb_ary_behead(VALUE, long);
+VALUE rb_ary_aref1(VALUE ary, VALUE i);
+
+struct rb_execution_context_struct;
+VALUE rb_ec_ary_new_from_values(struct rb_execution_context_struct *ec, long n, const VALUE *elts);
+MJIT_SYMBOL_EXPORT_END
+
+// YJIT needs this function to never allocate and never raise
+static inline VALUE
+rb_ary_entry_internal(VALUE ary, long offset)
+{
+    long len = RARRAY_LEN(ary);
+    const VALUE *ptr = RARRAY_CONST_PTR_TRANSIENT(ary);
+    if (len == 0) return Qnil;
+    if (offset < 0) {
+        offset += len;
+        if (offset < 0) return Qnil;
+    }
+    else if (len <= offset) {
+        return Qnil;
+    }
+    return ptr[offset];
+}
+
+static inline bool
+ARY_PTR_USING_P(VALUE ary)
+{
+    return FL_TEST_RAW(ary, RARRAY_PTR_IN_USE_FLAG);
+}
+
+RBIMPL_ATTR_MAYBE_UNUSED()
+static inline int
+ary_should_not_be_shared_and_embedded(VALUE ary)
+{
+    return !FL_ALL_RAW(ary, RARRAY_SHARED_FLAG|RARRAY_EMBED_FLAG);
+}
+
+static inline bool
+ARY_SHARED_P(VALUE ary)
+{
+    assert(RB_TYPE_P(ary, T_ARRAY));
+    assert(ary_should_not_be_shared_and_embedded(ary));
+    return FL_TEST_RAW(ary, RARRAY_SHARED_FLAG);
+}
+
+static inline bool
+ARY_EMBED_P(VALUE ary)
+{
+    assert(RB_TYPE_P(ary, T_ARRAY));
+    assert(ary_should_not_be_shared_and_embedded(ary));
+    return FL_TEST_RAW(ary, RARRAY_EMBED_FLAG);
+}
+
+static inline VALUE
+ARY_SHARED_ROOT(VALUE ary)
+{
+    assert(ARY_SHARED_P(ary));
+    return RARRAY(ary)->as.heap.aux.shared_root;
+}
+
+static inline bool
+ARY_SHARED_ROOT_P(VALUE ary)
+{
+    assert(RB_TYPE_P(ary, T_ARRAY));
+    return FL_TEST_RAW(ary, RARRAY_SHARED_ROOT_FLAG);
+}
+
+static inline long
+ARY_SHARED_ROOT_REFCNT(VALUE ary)
+{
+    assert(ARY_SHARED_ROOT_P(ary));
+    return RARRAY(ary)->as.heap.aux.capa;
+}
+
+static inline void
+RARY_TRANSIENT_SET(VALUE ary)
+{
+#if USE_TRANSIENT_HEAP
+    FL_SET_RAW(ary, RARRAY_TRANSIENT_FLAG);
+#endif
+}
+
+static inline void
+RARY_TRANSIENT_UNSET(VALUE ary)
+{
+#if USE_TRANSIENT_HEAP
+    FL_UNSET_RAW(ary, RARRAY_TRANSIENT_FLAG);
+#endif
+}
+
+#undef rb_ary_new_from_args
+#if RBIMPL_HAS_WARNING("-Wgnu-zero-variadic-macro-arguments")
+# /* Skip it; clang -pedantic doesn't like the following */
+#elif defined(__GNUC__) && defined(HAVE_VA_ARGS_MACRO)
+#define rb_ary_new_from_args(n, ...) \
+    __extension__ ({ \
+        const VALUE args_to_new_ary[] = {__VA_ARGS__}; \
+        if (__builtin_constant_p(n)) { \
+            STATIC_ASSERT(rb_ary_new_from_args, numberof(args_to_new_ary) == (n)); \
+        } \
+        rb_ary_new_from_values(numberof(args_to_new_ary), args_to_new_ary); \
+    })
+#endif
+
+#undef RARRAY_AREF
+RBIMPL_ATTR_PURE_UNLESS_DEBUG()
+RBIMPL_ATTR_ARTIFICIAL()
+static inline VALUE
+RARRAY_AREF(VALUE ary, long i)
+{
+    RBIMPL_ASSERT_TYPE(ary, RUBY_T_ARRAY);
+
+    return RARRAY_CONST_PTR_TRANSIENT(ary)[i];
+}
+
+#endif /* INTERNAL_ARRAY_H */