turbo_test_constant_tracer 0.1.11

data/lib/turbo_test_constant_tracer/delegate_class.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+def TurboTestDelegateClass(superclass)
+  klass = Class.new(Delegator)
+  ignores = [*::Delegator.public_api, :to_s, :inspect, :=~, :!~, :===]
+  protected_instance_methods = superclass.protected_instance_methods
+  protected_instance_methods -= ignores
+  public_instance_methods = superclass.public_instance_methods
+  public_instance_methods -= ignores
+
+  klass.module_eval do
+    def __getobj__ # :nodoc:
+      unless defined?(@delegate_dc_obj)
+        return yield if block_given?
+
+        __raise__ ::ArgumentError, "not delegated"
+      end
+      @delegate_dc_obj
+    end
+
+    def __setobj__(obj) # :nodoc:
+      # Not needed since we are controlling which classes are delegated
+      # __raise__ ::ArgumentError, "cannot delegate to self" if self.equal?(obj)
+      @delegate_dc_obj = obj
+    end
+
+    protected_instance_methods.each do |method|
+      klass.send(:define_method, method, Delegator.delegating_block(method))
+      protected method
+    end
+
+    public_instance_methods.each do |method|
+      if (superclass == String && TurboTest::ConstantTracer::Klass::STRING_METHODS[method]) ||
+         (superclass.ancestors.include?(Enumerable) &&
+           TurboTest::ConstantTracer::Klass::ENUMERABLE_METHODS[method])
+        klass.send(
+          :define_method,
+          method,
+          Delegator.delegating_block_with_binding_for_ruby(method)
+        )
+      else
+        klass.send(:define_method, method, Delegator.delegating_block(method))
+      end
+    end
+
+    if superclass == String || superclass.ancestors.include?(::String)
+      method_name = "=~".to_sym
+      klass.send(
+        :define_method,
+        method_name,
+        Delegator.delegating_block_with_binding_for_ruby(method_name)
+      )
+    end
+
+    if superclass == Regexp || superclass.ancestors.include?(::Regexp)
+      TurboTest::ConstantTracer::Klass::REGEXP_METHODS.each_key do |key|
+        klass.send(:remove_method, key) if klass.method_defined?(key)
+        klass.send(:define_method, key, Delegator.delegating_block_with_binding_for_ruby(key))
+      end
+    end
+  end
+
+  klass.define_singleton_method :public_instance_methods do |all = true|
+    super(all) | superclass.public_instance_methods
+  end
+  klass.define_singleton_method :protected_instance_methods do |all = true|
+    super(all) | superclass.protected_instance_methods
+  end
+  klass
+end

data/lib/turbo_test_constant_tracer/delegator.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "binding_of_caller"
+require "English"
+
+# :nocov:
+def Delegator.delegating_block_with_binding_for_ruby(mid)
+  if RUBY_VERSION >= "2.7"
+    Delegator.delegating_block_with_binding_ruby_27(mid)
+  else
+    Delegator.delegating_block_with_binding(mid)
+  end
+end
+
+# rubocop:disable Metrics/MethodLength
+def Delegator.delegating_block_with_binding(mid) # :nodoc:
+  lambda do |*args, &block|
+    target = __getobj__
+    send_block = if block
+                   proc do |match|
+                     block_binding = block.binding
+                     block_binding.local_variable_set(:_turbotest_tilde, $LAST_MATCH_INFO)
+                     block_binding.eval("$~=_turbotest_tilde")
+                     block.call(match)
+                   end
+                 else
+                   block
+                 end
+    result = target.__send__(mid, *args, &send_block)
+    caller_binding = binding.of_caller(1)
+    caller_binding.local_variable_set(:_turbotest_tilde, $LAST_MATCH_INFO)
+    caller_binding.eval("$~=_turbotest_tilde")
+    result
+  end
+end
+# :nocov:
+
+def Delegator.delegating_block_with_binding_ruby_27(mid) # :nodoc:
+  lambda do |*args, &block|
+    target = __getobj__
+    send_block = if block
+                   proc do |match|
+                     block_binding = block.binding
+                     block_binding.local_variable_set(:_turbotest_tilde, $LAST_MATCH_INFO)
+                     block_binding.eval("$~=_turbotest_tilde")
+                     block.call(match)
+                   end
+                 else
+                   block
+                 end
+    result = target.__send__(mid, *args, &send_block)
+    caller_binding = binding.of_caller(1)
+    caller_binding.local_variable_set(:_turbotest_tilde, $LAST_MATCH_INFO)
+    caller_binding.eval("$~=_turbotest_tilde")
+    result
+  end.ruby2_keywords
+end
+# rubocop:enable Metrics/MethodLength

data/lib/turbo_test_constant_tracer/event_publisher.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module TurboTest
+  module ConstantTracer
+    class EventPublisher
+      include Singleton
+
+      EVENT = "proxy_object_method_call"
+
+      attr_reader :enabled
+
+      class << self
+        extend Forwardable
+        def_delegators :instance,
+                       :reset_call_log,
+                       :publish_all_events!,
+                       :publish_events_once!,
+                       :publish
+
+        private
+
+        def instance
+          @instance || Mutex.new.synchronize { @instance ||= new }
+        end
+      end
+
+      def initialize
+        @call_log = {}
+        @log_all_events = false
+      end
+
+      def reset_call_log
+        @call_log = {}
+      end
+
+      def publish_all_events!
+        @log_all_events = true
+      end
+
+      def publish_events_once!
+        @log_all_events = false
+      end
+
+      def publish(name, location)
+        return unless @call_log[name].nil? || @log_all_events == true
+
+        TurboTest::EventRegistry[EVENT].publish(name, location)
+        @call_log[name] = true
+      end
+    end
+  end
+end

data/lib/turbo_test_constant_tracer/hash_lookup_with_proxy.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "./../hash_lookup_with_proxy_ext"
+
+module TurboTest
+  module ConstantTracer
+    module HashLookupWithProxy
+      class << self
+        attr_reader :enabled
+      end
+
+      def self.enable
+        return if enabled
+
+        Hash.prepend(Methods)
+        Methods.enable
+        @enabled = true
+      end
+
+      def self.disable
+        return unless enabled
+
+        Methods.disable
+        @enabled = false
+      end
+
+      module Methods
+        class << self
+          def enable
+            add_assign_method
+          end
+
+          def disable
+            class_eval do
+              remove_method :[]=
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_constant_tracer/klass.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "binding_of_caller"
+require_relative "delegator"
+require_relative "delegate_class"
+module TurboTest
+  module ConstantTracer
+    class Klass
+      STRING_METHODS = {
+        scan: true, gsub: true, gsub!: true, sub: true, sub!: true, "=~": 1
+      }.freeze
+
+      ENUMERABLE_METHODS = {
+        all?: true, any?: true, grep: true, grep_v: true,
+        none?: true, one?: true, slice_before: true, slice_after: true
+      }.freeze
+
+      REGEXP_METHODS = {
+        match: 1, "=~": 1, "===": 1
+      }.freeze
+
+      def self.define(original_class, name)
+        return ::TurboTest::ConstantTracer::Regexp if original_class == ::Regexp
+
+        klass = Class.new(TurboTestDelegateClass(original_class)) do
+          include InstanceMethods
+          extend  ClassMethods
+        end
+        klass.turbo_test_proxied_class = original_class
+        ProxyKlass.const_set name, klass
+        klass
+      end
+
+      module ClassMethods
+        attr_accessor :turbo_test_proxied_class
+
+        def ==(other)
+          turbo_test_proxied_class == other
+        end
+      end
+
+      module InstanceMethods
+        attr_accessor :turbo_test_name, :turbo_test_path
+
+        def initialize(object)
+          super
+          check_object_type!(object)
+        end
+
+        def __getobj__
+          result = super
+          TurboTest::ConstantTracer::EventPublisher.publish(
+            turbo_test_name, turbo_test_path
+          )
+          result
+        end
+
+        def turbo_test_proxied_class
+          __getobj__
+        end
+        alias __turbo_test_proxy_object turbo_test_proxied_class
+
+        private
+
+        def check_object_type!(object)
+          return if object.class == self.class.turbo_test_proxied_class
+
+          msg = "Object class is not #{self.class.turbo_test_proxied_class}"
+          raise(TypeError, msg)
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_constant_tracer/proxy_klass.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module ConstantTracer
+    module ProxyKlass
+      def self.proxied_objects
+        @proxied_objects ||= {}
+      end
+    end
+  end
+end

data/lib/turbo_test_constant_tracer/regexp/tilde.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "binding_of_caller"
+require "English"
+
+module TurboTest
+  module ConstantTracer
+    class Regexp < TurboTestDelegateClass(::Regexp)
+      include ::TurboTest::ConstantTracer::Klass::InstanceMethods
+      extend  ::TurboTest::ConstantTracer::Klass::ClassMethods
+
+      def ~
+        caller_binding = binding.of_caller(1)
+        res = (self =~ caller_binding.eval("$_"))
+        caller_binding.local_variable_set(:_turbotest_tilde, $LAST_MATCH_INFO)
+        caller_binding.eval("$~=_turbotest_tilde")
+        res
+      end
+    end
+  end
+end
+
+TurboTest::ConstantTracer::Regexp.turbo_test_proxied_class = ::Regexp

data/lib/turbo_test_constant_tracer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TurboTestConstantTracer
+  VERSION = "0.1.11"
+end

data/turbo_test_constant_tracer.gemspec

@@ -0,0 +1,34 @@
+require_relative 'lib/turbo_test_constant_tracer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "turbo_test_constant_tracer"
+  spec.version       = TurboTestConstantTracer::VERSION
+  spec.authors       = ["Marcos Essindi"]
+  spec.email         = ["marcessindi@icloud.com"]
+
+  spec.summary       = "Summary"
+  spec.homepage      = "https://github.com/dunkelbraun/turbo_test_constant_tracer"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # 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(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "minitest", "~> 5.14.1"
+  spec.add_development_dependency "rake-compiler"
+
+  spec.add_dependency "binding_of_caller"
+  spec.add_dependency "turbo_test_events"
+
+  spec.extensions = %w[ext/hash_lookup_with_proxy_ext/extconf.rb]
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: turbo_test_constant_tracer
+version: !ruby/object:Gem::Version
+  version: 0.1.11
+platform: ruby
+authors:
+- Marcos Essindi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.14.1
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  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: binding_of_caller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turbo_test_events
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- marcessindi@icloud.com
+executables: []
+extensions:
+- ext/hash_lookup_with_proxy_ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ".github/workflows/tests.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.common
+- Gemfile.lock
+- GemfileCI
+- GemfileCI.lock
+- LICENSE.txt
+- Makefile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/hash_lookup_with_proxy_ext/extconf.h
+- ext/hash_lookup_with_proxy_ext/extconf.rb
+- ext/hash_lookup_with_proxy_ext/hash_lookup_with_proxy_ext.c
+- lib/turbo_test_constant_tracer.rb
+- lib/turbo_test_constant_tracer/constructor.rb
+- lib/turbo_test_constant_tracer/definition.rb
+- lib/turbo_test_constant_tracer/definition/templates.rb
+- lib/turbo_test_constant_tracer/delegate_class.rb
+- lib/turbo_test_constant_tracer/delegator.rb
+- lib/turbo_test_constant_tracer/event_publisher.rb
+- lib/turbo_test_constant_tracer/hash_lookup_with_proxy.rb
+- lib/turbo_test_constant_tracer/klass.rb
+- lib/turbo_test_constant_tracer/proxy_klass.rb
+- lib/turbo_test_constant_tracer/regexp/tilde.rb
+- lib/turbo_test_constant_tracer/version.rb
+- turbo_test_constant_tracer.gemspec
+homepage: https://github.com/dunkelbraun/turbo_test_constant_tracer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dunkelbraun/turbo_test_constant_tracer
+  source_code_uri: https://github.com/dunkelbraun/turbo_test_constant_tracer
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Summary
+test_files: []