ariadne 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c5b693660af05c17570b71a98e6ed6899932f9b2571fd6f8e4fd7d66d61e4fc
-  data.tar.gz: 8a3697425b580d3f40568b8b5a33d80e6d149197b0ede9fa2d35042b5ad90c8a
+  metadata.gz: a71929c19a3e8fff0abc484843c1762edf12ecf6f45d90a6e0394cb4743aa243
+  data.tar.gz: e5959ac737aaf0392957164769dcb56e72ca73362da8431fcbb4a9d47fcc835b
 SHA512:
-  metadata.gz: 9d41649519721ea428249d049823a82ecaf4530dc436b27b4bd643e815e12f70eec38895e752b46ca57154ed7e9b5c9133bc799903b69479876c6d9c3577732f
-  data.tar.gz: 70555aa75a6656cf16e199abb1b3b29ce960f806b3b68846edbf378072d7a4129c3268cfd2d8e06d44dde667f2682b9cee8766d63f9e98138df6f190b8a1ea7f
+  metadata.gz: 1bec945c8243605fb555b88e817c9cfe84268e06b4ae110ef2c5b472f86360deb5c91d4cfa3a8e3cf9220f90259bddcfe902fcd829fbe53d2090722bb6f454d9
+  data.tar.gz: fbb773617d74362a76c461c0c01283239175fea01d8915e3b810299b13b7849863cdefb1f8875592c3421da5a19945236736c7ec2df296a0d4fc72f8d666082c

data/lib/ariadne/log.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "open3"
-require "ariadne/text"
+require "ariadne/string/color"
 
 module Ariadne
   class Log
@@ -22,50 +22,68 @@ module Ariadne
 
     def text
       @text ||=
-        Text.new(
-          [rank, " ", offset, " ", offset_dashes, class_name, prefix, method_name]
-            .tap { add_parameters(_1) }
-            .join
-        ).truncate(200)
+        [
+          rank,
+          " ",
+          depth_dashes,
+          class_name,
+          prefix,
+          method_name,
+          parameters,
+          return_value_type
+        ].join
     end
 
     def rank
-      Text.new(@seam.rank.to_s.rjust(4)).gray
+      @seam.rank.to_s.rjust(4).gray
     end
 
-    def offset
-      Text.new("(#{@seam.offset})").gray
-    end
-
-    def offset_dashes
-      Text.new("-" * @seam.offset).gray.tap { _1 << " " if @seam.offset.positive? }
+    def depth_dashes
+      ("-" * @seam.depth).gray.tap { _1 << " " if @seam.depth.positive? }
     end
 
     def class_name
-      Text.new(@seam.class_name).green
+      @seam.klass.name.green
     end
 
     def prefix
-      Text.new(@seam.prefix).gray
+      @seam.prefix.gray
     end
 
     def method_name
-      Text.new(@seam.method_name).cyan
+      @seam.method_name.to_s.cyan
     end
 
-    def add_parameters(str)
-      return if parameters == ""
-
-      str << Text.new("(#{parameters})").magenta
+    def return_value_type
+      value = type(@seam.return_value)
+      " -> #{value}".yellow
     end
 
     def parameters
-      @parameters ||=
-        @seam.parameters.map do |parameter|
-          arg = Text.new(parameter.stringified_arg).truncate(50)
-          arg = parameter.type ? "<#{parameter.type}> #{arg}" : arg
-          "#{parameter.param}: #{arg}"
-        end.join(", ")
+      return if @seam.parameters.empty?
+
+      [
+        "(",
+        @seam.parameters.flat_map { "#{_1.param}:  #{arg(_1)}" }.join(", "),
+        ")"
+      ].join.magenta
+    end
+
+    def arg(parameter)
+      if parameter.type == :rest || %i[* ** &].include?(parameter.param)
+        parameter.arg.map { type(_1) }.join(", ")
+      else
+        type(parameter.arg)
+      end
+    end
+
+    def type(arg)
+      case arg
+      when "<?>" then "<?>"
+      when TrueClass, FalseClass then "Boolean"
+      when NilClass then "nil"
+      else arg.class.to_s
+      end
     end
   end
 end

data/lib/ariadne/seam.rb

@@ -1,40 +1,79 @@
 # frozen_string_literal: true
 
 require "open3"
-require "ariadne/parameter"
 
 module Ariadne
-  class Seam < SimpleDelegator
-    attr_reader :rank, :offset
+  class Seam
+    attr_reader :rank, :depth, :klass, :method_name, :prefix, :parameters, :return_value, :binding, :path
 
-    def initialize(tracepoint, rank:, offset:)
-      super(tracepoint)
-      @rank = rank
-      @offset = offset
-    end
+    Parameter = Struct.new(:type, :param, :arg)
+
+    class << self
+      # We cannot make public methods because accessing the TracePoint
+      # after it has been disabled would raise a RunTimeError
+      # with message "access from outside".
+      # We need to set the values while the TracePoint is enabled.
+      def build(tracepoint, rank:, depth:)
+        raise "tracepoint is disabled" unless tracepoint.enabled?
 
-    # Seam.new(@rank, class_name(tp), prefix(tp), tp.method_id, parameters, @seams.size)
-    def class_name
-      if __getobj__.self.is_a?(Module)
-        __getobj__.self.name
-      else
-        __getobj__.self.class.name
+        new(rank: rank, depth: depth).tap do |seam|
+          seam.instance_variable_set(:@klass, klass(tracepoint))
+          seam.instance_variable_set(:@prefix, prefix(tracepoint))
+          seam.instance_variable_set(:@method_name, method_name(tracepoint))
+          seam.instance_variable_set(:@parameters, parameters(tracepoint))
+          seam.instance_variable_set(:@path, path(tracepoint))
+        end
       end
-    end
 
-    def method_name
-      method_id
-    end
+      private
 
-    def prefix
-      __getobj__.self.is_a?(Module) ? "." : "#"
-    end
+      def klass(tracepoint)
+        if tracepoint.self.is_a?(Module)
+          tracepoint.self
+        else
+          tracepoint.self.class
+        end
+      end
 
-    def parameters
-      method = __getobj__.self.method(method_name)
-      method.parameters.map do |parameter|
-        Parameter.new(parameter, binding: binding)
+      def method_name(tracepoint)
+        tracepoint.method_id
       end
+
+      def prefix(tracepoint)
+        tracepoint.self.is_a?(Module) ? "." : "#"
+      end
+
+      def parameters(tracepoint)
+        method = tracepoint.self.method(tracepoint.method_id)
+        if forwarded_parameters?(method)
+          [Parameter.new(:rest, "...", ["<?>"])]
+        else
+          method.parameters.flat_map do |parameter|
+            type = parameter.first
+            param = parameter.last
+            arg = %i[* ** &].include?(param) ? ["<?>"] : tracepoint.binding.local_variable_get(param)
+            Parameter.new(type, param, arg)
+          rescue NameError
+            Parameter.new(type, param, type == :rest ? ["<?>"] : "<?>")
+          end
+        end
+      end
+
+      # return true if method's signature is like `def my_method(...)`
+      def forwarded_parameters?(method)
+        method.parameters == [%i[rest *], %i[block &]]
+      end
+
+      def path(tracepoint)
+        tracepoint.path
+      end
+    end
+
+    private
+
+    def initialize(rank:, depth:)
+      @rank = rank
+      @depth = depth
     end
   end
 end

data/lib/ariadne/string/color.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Ariadne
+  module String
+    module Color
+      COLORS = %w[
+        black
+        red
+        green
+        yellow
+        blue
+        magenta
+        cyan
+        gray
+      ].freeze
+
+      COLORS.each.with_index do |color, index|
+        code = index + 30
+        define_method(color) do
+          "\e[#{code}m#{bleach}\e[0m"
+        end
+        bg_code = index + 40
+        define_method("bg_#{color}") do
+          "\e[#{bg_code}m#{bleach}\e[0m"
+        end
+      end
+
+      def bleach
+        gsub(/\e\[\d{1,2}m/, "")
+      end
+    end
+  end
+end
+
+String.include Ariadne::String::Color

data/lib/ariadne/thread.rb

@@ -6,44 +6,86 @@ require "ariadne/log"
 
 module Ariadne
   class Thread
+    attr_reader :seams
+
     LOG_FILE = "thread.log"
     DEFAULT_INCLUDE_PATHS = Open3.capture3("pwd").first.strip
     DEFAULT_EXCLUDE_PATHS = [].freeze
 
     def initialize(include_paths: nil, exclude_paths: nil)
-      @include_paths = include_paths || DEFAULT_INCLUDE_PATHS
-      @exclude_paths = exclude_paths || DEFAULT_EXCLUDE_PATHS
+      @include_paths = Array(include_paths) || DEFAULT_INCLUDE_PATHS
+      @exclude_paths = Array(exclude_paths) || DEFAULT_EXCLUDE_PATHS
+      @seams = []
     end
 
     def call
-      @rank = 0
-      @seams = []
-      file = File.open(LOG_FILE, "w")
-      trace = build_trace
+      prepare
+      open_file
       trace.enable
       yield
     ensure
       trace.disable
-      file.close
+      log
+      close_file
     end
 
     private
 
-    def build_trace
-      TracePoint.new(:call, :return) do |tp|
-        next if @include_paths.none? { tp.path.include?(_1) }
-        next if @exclude_paths.any? { tp.path.include?(_1) }
-
-        case tp.event
-        when :call
-          seam = Seam.new(tp, rank: @rank, offset: @seams.size)
-          @seams << seam
-          @rank += 1
-          Log.new(seam).call
-        when :return
-          @seams.pop
+    def prepare
+      @rank = 0
+      @depth = 0
+      @seams = []
+    end
+
+    def open_file
+      @file = File.open(LOG_FILE, "w")
+    end
+
+    def close_file
+      @file.close
+    end
+
+    def trace
+      @trace ||=
+        TracePoint.new(:call, :return) do |tracepoint|
+          next if tracepoint.self.is_a?(TracePoint)
+
+          case tracepoint.event
+          when :call
+            on_call(tracepoint)
+          when :return
+            on_return(tracepoint)
+          end
         end
-      end
+    end
+
+    def on_call(tracepoint)
+      return unless selected?(tracepoint)
+
+      seam = Seam.build(tracepoint, rank: @rank, depth: @depth)
+      @seams << seam
+
+      @rank += 1
+      @depth += 1
+    end
+
+    def on_return(tracepoint)
+      return unless selected?(tracepoint)
+
+      @depth -= 1
+
+      seam = @seams.reverse.find { _1.depth == @depth }
+      seam&.instance_variable_set(:@return_value, tracepoint.return_value)
+      seam&.instance_variable_set(:@binding, tracepoint.binding)
+    end
+
+    def selected?(tracepoint)
+      @include_paths.any? { tracepoint.path.include?(_1) } &&
+        @exclude_paths.none? { tracepoint.path.include?(_1) }
+    end
+
+    def log
+      @seams.each { Log.new(_1).call }
     end
   end
 end

data/lib/ariadne/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ariadne
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ariadne
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Edouard Piron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-23 00:00:00.000000000 Z
+date: 2023-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,20 +80,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -117,9 +103,8 @@ extra_rdoc_files: []
 files:
 - lib/ariadne.rb
 - lib/ariadne/log.rb
-- lib/ariadne/parameter.rb
 - lib/ariadne/seam.rb
-- lib/ariadne/text.rb
+- lib/ariadne/string/color.rb
 - lib/ariadne/thread.rb
 - lib/ariadne/version.rb
 homepage: https://github.com/BigBigDoudou/ariadne

data/lib/ariadne/parameter.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "open3"
-require "ariadne/text"
-
-module Ariadne
-  class Parameter < SimpleDelegator
-    RUBY_LITERALS = [
-      NilClass,
-      String,
-      Integer,
-      Float,
-      Proc,
-      TrueClass,
-      FalseClass,
-      Symbol,
-      Array,
-      Range,
-      Regexp,
-      Hash
-    ].freeze
-
-    def initialize(parameter, binding:)
-      super(parameter)
-      @binding = binding
-    end
-
-    def param
-      last
-    end
-
-    def arg
-      @binding.local_variable_get(last)
-    rescue NameError
-      "?"
-    end
-
-    def type
-      return if arg.is_a?(Class) || RUBY_LITERALS.include?(arg.class)
-
-      arg.class.name
-    end
-
-    def stringified_arg
-      case arg
-      when NilClass
-        "nil"
-      when Proc
-        "#<Proc>"
-      when Class
-        arg.name
-      when String
-        "\"#{arg}\""
-      else
-        arg.to_s
-      end
-    end
-  end
-end

data/lib/ariadne/text.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Ariadne
-  class Text < String
-    COLORS = %w[
-      black
-      red
-      green
-      yellow
-      blue
-      magenta
-      cyan
-      gray
-    ].freeze
-
-    COLORS.each.with_index do |color, index|
-      code = index + 30
-      define_method(color) do
-        "\e[#{code}m#{bleach}\e[0m"
-      end
-      bg_code = index + 40
-      define_method("bg_#{color}") do
-        "\e[#{bg_code}m#{bleach}\e[0m"
-      end
-    end
-
-    def initialize(str)
-      super(str.to_s)
-    end
-
-    def truncate(size)
-      if self.size > size
-        Text.new("#{self[..size]}...")
-      else
-        self
-      end
-    end
-
-    def bleach
-      gsub(/\e\[\d{1,2}m/, "")
-    end
-  end
-end