markdown_logging_proxy 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ede32c7a00afa640bd44e6ec610034cc8a968e369a214d80bc3071c5b902516
-  data.tar.gz: c2032172bb4e05c3ebf6ac0ba30984c08623d4948b371f1afb77199ed4effae3
+  metadata.gz: 338dd4aa3a43c7cda534f2b694a44b1347e1ad7434f417aa479dc8bb4daf7f95
+  data.tar.gz: 0bcd6c0fd97df22c18495e5f68a9181a45cd4dc2997c3d2754ba99e4b9678104
 SHA512:
-  metadata.gz: a60b3241307b03bd0ef86b4cec3ca1fc149e3cb552dfea7eecffadf9e831f014f367cd714b4e3a3897d3f08b6258ece8e22111500989707e216f909726e45ab1
-  data.tar.gz: 2dadcbef2a63e99aa6187751ee8cbf2c1318add028e0d6443f6f2331895dbadc27c4a20cdf740468df83937183a94f88bd28e6a8d46dee6fe21b5a3572f18bbe
+  metadata.gz: 689b425d69ab942947a53913d1ea6b2405d334d76e31bdb25050ed89fe3eb1bc5250f95801a6da1dd7b290b700c6ae62914f3d01d17d7f21ea782135920b6f8e
+  data.tar.gz: 3c67856e0afc5c95b08a1606e0d6d1338e96ee41542e6608deca25c77fe1ea1e758f8ce479c075de5f1de769277716285c56cb0f527c4d1fc2139c2fc8115611

data/CHANGELOG.md

@@ -3,3 +3,14 @@
 ## [0.1.0] - 2022-08-22
 
 - Initial release
+
+## [1.0.0]
+
+- Release of gem to rubygems
+- Proxy now defines zero methods besides `method_missing`
+- Addition of `bin/example` script
+
+## [1.0.1]
+
+- Add missing CHANGELOG updates
+- Commit updates to compiled `dist/` version of library

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    markdown_logging_proxy (0.1.0)
+    markdown_logging_proxy (1.0.1)
 
 GEM
   remote: https://rubygems.org/

data/dist/markdown_logging_proxy.rb

@@ -1,3 +1,78 @@
+module MarkdownLoggingProxy
+  class MarkdownLogger
+    def self.inspect_object(object)
+      ['```ruby', object.pretty_inspect.chomp, '```'].join("\n")
+    end
+
+    def self.id_object(object)
+      # #<Object:0x00007f5a0919e140>
+      "##{object.class}:0x#{object.object_id.to_s(16)}>"
+    end
+
+    def self.build(location, **options)
+      return location if location.is_a?(MarkdownLogger)
+      new(location, **options)
+    end
+
+    attr_reader :std_logger, :backtrace, :heading_level
+
+    def initialize(location, backtrace: true)
+      @std_logger = create_logger(location)
+      @heading_level = 1
+      @backtrace = backtrace
+    end
+
+    def log(level, heading = 3, msg)
+      @heading_level = heading
+      std_logger.send(level, msg)
+    end
+
+    def inspect_backtrace(ignore = 4)
+      return unless backtrace
+      lines =
+        case backtrace
+        when true then caller(ignore)
+        when Regexp then caller(ignore).grep(backtrace)
+        else
+          []
+        end
+      <<~MSG.chomp
+
+        Backtrace:
+
+        #{lines.map { |l| "* #{l.chop}`" }.join("\n")}
+      MSG
+    end
+
+    private
+
+    def logger_instance(location)
+      case location
+      when Logger then location
+      else
+        Logger.new(location)
+      end
+    end
+
+    def create_logger(location)
+      logger_instance(location).tap do |logger|
+        logger.formatter = markdown_formatter
+      end
+    end
+
+    def markdown_formatter
+      proc do |severity, time, __exec, msg|
+        "#{'#' * heading_level} #{severity} in #{Process.pid} at #{time.iso8601} -- #{msg}\n\n"
+      end
+    end
+  end
+end
+module MarkdownLoggingProxy
+  # just a shortcut for Proxy.new
+  def self.new(*args, **options)
+    Proxy.new(*args, **options)
+  end
+end
 module MarkdownLoggingProxy
   # frozen_string_literal: true
 
@@ -9,141 +84,151 @@ module MarkdownLoggingProxy
   class Proxy
 
     def initialize(
-        target:,
-        logger: nil,
+        to_proxy = nil,
+        target: nil,
         location: STDOUT,
-        backtrace: /projects/, # regex/true/false backtrace control
-        ignore: [], # methods we shouldn't proxy
+        backtrace: true, # regex/true/false backtrace control
+        ignore: [], # methods we shouldn't log/proxy
         proxy_response: [], # methods we should return a proxy for
         overwrite: [] # methods defined on Object we should overwrite
       )
-      @ignore = (ignore + proxy_response).uniq
-      @proxy_response = proxy_response
-      @target = target
-      @logger =
-        if logger
-          Utils.format_logger(logger)
-        else
-          Utils.create_logger(location)
-        end
-      @backtrace = backtrace
+      @target = to_proxy || target
+      raise ArgumentError, "Missing required proxy target" unless @target
+      @logger = MarkdownLogger.build(location, backtrace: backtrace)
+      @tracer = Tracer.new(
+        target: @target,
+        proxy: self,
+        logger: @logger,
+        ignore: ignore,
+        proxy_response: proxy_response,
+        proxy_options: {
+          overwrite: overwrite,
+          backtrace: backtrace,
+        }
+      )
       overwrite.each do |meth|
         define_method(meth) do |*args, &blk|
-          __trace_method(meth, args, &blk)
+          @traceer.trace(meth, args, &blk)
         end
       end
     end
 
     def method_missing(meth, *args, &blk)
-      __trace_method(meth, args, &blk)
+      @tracer.trace(meth, args, &blk)
+    end
+  end
+end
+module MarkdownLoggingProxy
+  class Tracer
+    attr_reader :target, :logger, :ignore, :proxy
+    
+    def initialize(
+        target:,
+        proxy:,
+        logger: nil,
+        ignore: [],
+        proxy_response: [],
+        proxy_options: {}
+      )
+      @target = target
+      @logger = logger
+      @ignore = (ignore + proxy_response)
+      @proxy_response = proxy_response
+      @proxy_options = proxy_options
     end
 
-    private
-
-    def __trace_method(meth, args, &blk)
-      __log :info, meth, 2, <<~MSG
-        Calling `#{meth}`
+    def trace(meth, args, &blk)
+      log_call_signature(meth, args, &blk) unless ignore?(meth)
+      log_and_proxy_response(meth, args, &blk)
+    rescue StandardError => e
+      log_and_reraise_error(meth, e)
+    end
 
-        Arguments:
+    def proxy_response?(meth)
+      case @proxy_response
+      when true, false then @proxy_response
+      else
+        @proxy_response.member?(meth)
+      end
+    end
 
-        #{__inspect_object(args)}
+    def ignore?(meth)
+      @ignore.member?(meth)
+    end
 
-        Block? #{block_given? ? 'Yes' : 'No'}
-        #{__display_backtrace}
-      MSG
+    private
 
-      __proxy_response(meth, @target.public_send(meth, *args, &__proxy_block(meth, blk))).tap do |response|
-        __log :info, meth, <<~MSG
-          `#{meth}` Response
+    def log_call_signature(meth, args, &blk)
+      return if ignore.member?(meth)
+      logger.log :info, 1, <<~MSG.chomp
+        Calling `#{meth}` on #{MarkdownLogger.id_object(target)}
 
-          #{__inspect_object(response)}
-        MSG
-      end
-    rescue StandardError => e
-      __log :error, meth, <<~MSG
-        Error in `#{meth}`
+        Arguments:
 
-        Type: #{e.class}
+        #{MarkdownLogger.inspect_object(args)}
 
-        #{__inspect_object(e)}
+        Block? #{block_given? ? 'Yes' : 'No'}
+        #{logger.inspect_backtrace}
       MSG
-      raise e
-    end
-
-    def __display_backtrace(ignore = 3)
-      displayed_trace =
-        case @backtrace
-        when true then caller(ignore)
-        when Regexp then caller(ignore).grep(@backtrace)
-        end
-      displayed_trace.map { |l| "* #{l.chop}`" }.join("\n") if displayed_trace
     end
 
-    def __log(level, meth, heading = 3, msg)
-      return if @ignore.member?(meth)
-      @heading_level = heading
-      @logger.send(level, msg)
-    end
-
-    def __proxy_response(meth, response)
-      return response unless @proxy_response.member?(meth)
-      __log :info, nil, <<~MSG
-        Using proxied response for `#{meth}`
-
-        Object to proxy:
-
-        #{__inspect_object(response)}
+    def log_and_proxy_response(meth, args, &blk)
+      response = target.public_send(meth, *args, &log_and_proxy_block(meth, blk))
+      log_response(meth, response) unless ignore?(meth)
+      return response unless proxy_response?(meth)
+      logger.log :info, 3, <<~MSG
+        Returning proxied response to `#{meth}`
+        
+        Proxy from `#{meth}` on #{MarkdownLogger.id_object(target)}
+        
+        Proxy for: #{MarkdownLogger.id_object(response)}
       MSG
-      self.class.new(target: response, logger: @logger)
+      Proxy.new(**@proxy_options.merge(
+        target: response,
+        location: logger,
+        proxy_response: @proxy_response,
+        ignore: @ignore,
+      ))
     end
 
-    def __proxy_block(meth, block)
-      return if block.nil?
-      logger = @logger
+    def log_and_proxy_block(meth, blk)
+      return if blk.nil?
       proc do |*args|
-        logger.info <<~MSG
-          Yield to block in `#{meth}`
+        logger.log :info, 3, <<~MSG
+          Yield to block in `#{meth}` on #{MarkdownLogger.id_object(target)}
 
           Arguments:
 
-          #{__inspect_object(args)}
+          #{MarkdownLogger.inspect_object(args)}
         MSG
-        block.call(*args).tap do |response|
-          logger.info <<~MSG
+        blk.call(*args).tap do |response|
+          logger.log :info, 4, <<~MSG
             Response from block in `#{meth}`
 
-            #{__inspect_object(response)}
+            #{MarkdownLogger.inspect_object(response)}
           MSG
         end
       end
     end
 
-    def __inspect_object(obj)
-      ['```ruby', obj.pretty_inspect.chomp, '```'].join("\n")
-    end
-  end
+    def log_and_reraise_error(meth, error)
+      logger.log :error, 2, <<~MSG
+        Error in `#{meth}`
 
-end
-module MarkdownLoggingProxy
-  module Utils
-    def self.heading_level
-      @heading_level || 1
-    end
+        Type: #{error.class}
 
-    def self.heading_level=(level)
-      @heading_level = level
+        #{MarkdownLogger.inspect_object(error)}
+      MSG
+      raise error
     end
 
-    def self.create_logger(location)
-      logger = location.kind_of?(Logger) ? location : Logger.new(location)
-      format_logger logger
-    end
+    def log_response(meth, response)
+      return if ignore?(meth)
+      logger.log :info, 2, <<~MSG.chomp
+        `#{meth}` response
 
-    def self.format_logger(logger)
-      logger.formatter = proc do |severity, time, _, msg|
-        "#{'#' * heading_level} #{severity} in #{Process.pid} at #{time.iso8601} -- #{msg}\n\n"
-      end
-      logger
+        #{MarkdownLogger.inspect_object(response)}
+      MSG
     end
   end
-end
+end

data/markdown_logging_proxy.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |spec|
+  spec.name = "markdown_logging_proxy"
+  spec.version = "1.0.1"
+  spec.authors = ["Carl Zulauf"]
+  spec.email = ["carl@linkleaf.com"]
+
+  spec.summary = "Proxy object for debugging"
+  spec.description = "Wrap your ruby objects in a proxy to find out what happens to them"
+  spec.homepage = "https://github.com/carlzulauf/markdown_logging_proxy"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/carlzulauf/markdown_logging_proxy"
+  spec.metadata["changelog_uri"] = "https://github.com/carlzulauf/markdown_logging_proxy/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown_logging_proxy
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Carl Zulauf
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-28 00:00:00.000000000 Z
+date: 2022-08-29 00:00:00.000000000 Z
 dependencies: []
 description: Wrap your ruby objects in a proxy to find out what happens to them
 email:
@@ -31,6 +31,7 @@ files:
 - lib/markdown_logging_proxy/module_methods.rb
 - lib/markdown_logging_proxy/proxy.rb
 - lib/markdown_logging_proxy/tracer.rb
+- markdown_logging_proxy.gemspec
 homepage: https://github.com/carlzulauf/markdown_logging_proxy
 licenses:
 - MIT