ariadne 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c5b693660af05c17570b71a98e6ed6899932f9b2571fd6f8e4fd7d66d61e4fc
-  data.tar.gz: 8a3697425b580d3f40568b8b5a33d80e6d149197b0ede9fa2d35042b5ad90c8a
+  metadata.gz: 5d15963f0e72fcd20333f6227ced3e4dba5e3d5a7c2cc295440dcc98c9bb863a
+  data.tar.gz: bd90b66bad183442d7661fd72566ef11223d45f705817bcae2b2026efc928a3a
 SHA512:
-  metadata.gz: 9d41649519721ea428249d049823a82ecaf4530dc436b27b4bd643e815e12f70eec38895e752b46ca57154ed7e9b5c9133bc799903b69479876c6d9c3577732f
-  data.tar.gz: 70555aa75a6656cf16e199abb1b3b29ce960f806b3b68846edbf378072d7a4129c3268cfd2d8e06d44dde667f2682b9cee8766d63f9e98138df6f190b8a1ea7f
+  metadata.gz: 42c4370c8b426696d7b336fc42e40c60509569f60e1260a37aa952c1ee013b8a0ef94784032907574d256eb53071e5d8563ec5a9539b555e5abb08d4165b4bff
+  data.tar.gz: 30d1d3b263dee8c331d9f8d23b8bf8b9e422fd66b7f24a9488f2b4c3b8dc464a461201a0820475231628904a9a071d3ee496e8cd5cb27b0803818ecf2fce4bab

data/lib/ariadne/helpers/text.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ariadne
+  module Helpers
+    module Text
+      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
+
+      def Text(str) # rubocop:disable Naming/MethodName
+        Text.new(str)
+      end
+    end
+  end
+end

data/lib/ariadne/helpers/value_format.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Ariadne
+  module Helpers
+    module ValueFormat
+      RUBY_LITERALS = [
+        NilClass,
+        String,
+        Integer,
+        Float,
+        Proc,
+        TrueClass,
+        FalseClass,
+        Symbol,
+        Array,
+        Range,
+        Regexp,
+        Hash
+      ].freeze
+
+      def type(value)
+        return if value.is_a?(Class) || RUBY_LITERALS.include?(value.class)
+
+        value.class.name
+      end
+
+      def cast(value)
+        case value
+        when NilClass
+          "nil"
+        when Proc
+          "#<Proc>"
+        when Class
+          value.name
+        when String
+          "\"#{value}\""
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ariadne/log.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
 require "open3"
-require "ariadne/text"
+require "ariadne/helpers/text"
+require "ariadne/helpers/value_format"
 
 module Ariadne
   class Log
+    include Helpers::Text
+    include Helpers::ValueFormat
+
     def initialize(seam)
       @seam = seam
     end
@@ -22,50 +26,54 @@ module Ariadne
 
     def text
       @text ||=
-        Text.new(
-          [rank, " ", offset, " ", offset_dashes, class_name, prefix, method_name]
-            .tap { add_parameters(_1) }
-            .join
-        ).truncate(200)
+        Text(
+          [
+            rank,
+            " ",
+            depth_dashes,
+            class_name,
+            prefix,
+            method_name,
+            parameters,
+            return_value
+          ].join
+        )
     end
 
     def rank
-      Text.new(@seam.rank.to_s.rjust(4)).gray
-    end
-
-    def offset
-      Text.new("(#{@seam.offset})").gray
+      Text(@seam.rank.to_s.rjust(4)).gray
     end
 
-    def offset_dashes
-      Text.new("-" * @seam.offset).gray.tap { _1 << " " if @seam.offset.positive? }
+    def depth_dashes
+      Text("-" * @seam.depth).gray.tap { _1 << " " if @seam.depth.positive? }
     end
 
     def class_name
-      Text.new(@seam.class_name).green
+      Text(@seam.klass.name).green
     end
 
     def prefix
-      Text.new(@seam.prefix).gray
+      Text(@seam.prefix).gray
     end
 
     def method_name
-      Text.new(@seam.method_name).cyan
+      Text(@seam.method_name).cyan
     end
 
-    def add_parameters(str)
-      return if parameters == ""
-
-      str << Text.new("(#{parameters})").magenta
+    def return_value
+      value = Text(cast(@seam.return_value)).truncate(50)
+      value = type(@seam.return_value) ? "<#{type(@seam.return_value)}> #{value}" : value
+      Text(" -> #{value}").yellow
     end
 
     def parameters
-      @parameters ||=
+      str =
         @seam.parameters.map do |parameter|
-          arg = Text.new(parameter.stringified_arg).truncate(50)
-          arg = parameter.type ? "<#{parameter.type}> #{arg}" : arg
+          arg = Text(cast(parameter.arg)).truncate(50)
+          arg = type(parameter.arg) ? "<#{type(parameter.arg)}> #{arg}" : arg
           "#{parameter.param}: #{arg}"
         end.join(", ")
+      Text(str.empty? ? "" : "(#{str})").magenta
     end
   end
 end

data/lib/ariadne/parameter.rb

@@ -1,25 +1,9 @@
 # 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
@@ -34,26 +18,5 @@ module Ariadne
     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/seam.rb

@@ -4,37 +4,63 @@ 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
+    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 method_name(tracepoint)
+        tracepoint.method_id
+      end
 
-    def parameters
-      method = __getobj__.self.method(method_name)
-      method.parameters.map do |parameter|
-        Parameter.new(parameter, binding: binding)
+      def prefix(tracepoint)
+        tracepoint.self.is_a?(Module) ? "." : "#"
       end
+
+      def parameters(tracepoint)
+        method = tracepoint.self.method(tracepoint.method_id)
+        method.parameters.map do |parameter|
+          Parameter.new(parameter, binding: tracepoint.binding)
+        end
+      rescue NoMethodError
+        []
+      end
+
+      def path(tracepoint)
+        tracepoint.path
+      end
+    end
+
+    private
+
+    def initialize(rank:, depth:)
+      @rank = rank
+      @depth = depth
     end
   end
 end

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.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ariadne
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Edouard Piron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-23 00:00:00.000000000 Z
+date: 2023-02-24 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
@@ -116,10 +102,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/ariadne.rb
+- lib/ariadne/helpers/text.rb
+- lib/ariadne/helpers/value_format.rb
 - lib/ariadne/log.rb
 - lib/ariadne/parameter.rb
 - lib/ariadne/seam.rb
-- lib/ariadne/text.rb
 - lib/ariadne/thread.rb
 - lib/ariadne/version.rb
 homepage: https://github.com/BigBigDoudou/ariadne

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