hyper-trace 0.99.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c1b9434cfff5cca792bbe2339fca20449e7c69fce8fd01ec4d2319049275552a
+  data.tar.gz: 81be044684fe171674624b7f61551c5a1de74feb9b03463d0d83839259a66450
+SHA512:
+  metadata.gz: b85b57a316236f09432e8c387465711f462b166bdddb503fe36d48ebf30bd0f441224eec4d8757ef57be96e688e736ddabab5fb78ced9ef2c3f01a785d25539a
+  data.tar.gz: f4a5688c1a0649e94afd89557e563a4879b4487b411950904b2311f36430fa488082663190e6deb0c3948f718b69877265f2a6fb675e6b687e7e3a37105ade80

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at mitch@catprint.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/DOCS.md

@@ -0,0 +1,145 @@
+# HyperTrace
+
+Method tracing and conditional break points for [Opal](http://opalrb.org/) and [Hyperloop](http://ruby-hyperloop.io) debug.
+
+Typically you are going to use this in Capybara or Opal-RSpec examples that you are debugging.
+
+HyperTrace adds a `hypertrace` method to all classes that you will use to switch on tracing and break points.
+
+For example:
+
+```ruby
+SomeClass.hypertrace instrument: :all
+```
+
+Will instrument all methods in `SomeClass` and you will get a trace like this:
+
+<img width="952" alt="screen shot 2016-10-22 at 11 08 56 pm" src="https://cloud.githubusercontent.com/assets/63146/19624133/48098fce-98b6-11e6-9198-cc5eae836ccf.png">
+
+The trace log uses the javascript console grouping mechanism, so you can explore in detail the args, return values and state of the instance as each method executes.
+
+instead of `:all` you can specify a single method, or an array of methods.  Use the array notation if you happen to want to trace just the method `:all`.
+
+#### Breakpoints
+
+```ruby
+SomeClass.hypertrace break_on_enter: :foo
+```
+
+Will break on entry to `SomeClass#foo` and `self` will be set the instance. The equivalent `break_on_exit` method will also store the result in a javascript variable called `RESULT`.
+
+#### Conditional Breakpoints
+
+```ruby
+SomeClass.hypertrace break_on_enter?: {foo: ->(arg1, arg2 ...) { ... }}
+```
+
+The proc will be called before each call to `SomeClass#foo`, and any args passed to foo will be matched to the args, and the proc's instance will be set the foo's instance.  If the proc returns a falsy value the breakpoint will be skipped.
+
+#### Instrumenting Class methods
+
+If the first argument is `:class` hypertrace will instrument the class methods.
+
+```ruby
+SomeClass.hypertrace :class instrument: :some_class_method
+```
+
+#### DSL
+
+You can also use a simple DSL:
+
+```ruby
+SomeClass.hypertrace do
+  instrument      [:foo, :bar]
+  break_on_exit   :baz
+  break_on_enter? :ralph do |p1, p2|
+    # executes with self set the instance, p1, p2 will be the
+    # first two args passed to ralph
+    p1 == p2 # break if p1 == p2
+  end
+end
+```
+
+#### Switching it off
+
+```ruby
+SomeClass.hypertrace instrument: :none
+```
+
+#### Inside of classes
+
+Of course you can switch hypertrace on inside of your classes for quick debugging.  Just remember that hypertrace applies
+only to currently defined methods.
+
+```ruby
+SomeClass
+  ...
+  hypertrace instrument: :all
+end
+```
+
+#### Works with Hyper-React (Reactrb)
+
+If you hypertrace a React Component class you will get information on the component lifecycle, and the component state will include react state variables, and params (props) as well as normal instance variables.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hyper-trace'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install hyper-trace
+
+Once installed add `require 'hyper-trace'` to your application or component manifest file.  This gem works best if you are using Capybara or opal rspec, in which case you can reference the gem in the test application's manifest.
+
+
+## Custom Class Definitions
+
+If class instance responds to `hypertrace_format_instance` then that method will be called to format the state information.
+
+The method will be passed a hypertrace context object that will respond to the following methods:
+
++ `format_instance(instance_vars = nil, &block)`  
+log the default instance header information.  If instance_vars is nil then all instance vars will be printed.  Otherwise instance_vars should be an array of the instance vars to display.  The block will be executed to provide other details following the instance vars.
++ `safe_i(object)`:  
+call inspect on an object will work even if the object is a native js object.
++ `safe_s(object)`:  
+call to_s on an object safely
++ `log(s)`  
+print a s to the log, nested at the current grouping level
++ `group(header, collapsed: false, &block)`  
+create a new nesting group.  If collapsed is true then the group will be initially closed.  If block is present it will provide the contents of the group.
+
+If the method `hypertrace_exclusions` is defined, it can return an array of methods names that will be not
+be shown unless explicitly named.
+
+For more details see the react_trace.rb module in this gem.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+This is a very simple work in progress.  Any and all help is requested.  Things to do:
+
+2. Conditional tracing
+2. Add ability to specify `to_s` and `inspect` methods for use during tracing
+3. Add ability to specify `HyperTrace` delegator classes
+5. Add some tests
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/hyper-trace. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gem 'hyperloop-config', path: '../hyperloop-config'
+# Specify your gem's dependencies in hyper-trace.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    hyper-trace (0.3.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12)
+  hyper-trace!
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 catmando
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+<div class="githubhyperloopheader">
+
+<p align="center">
+
+<a href="http://ruby-hyperloop.org/" alt="Hyperloop" title="Hyperloop">
+<img width="350px" src="http://ruby-hyperloop.org/images/hyperloop-github-logo.png">
+</a>
+
+</p>
+
+<h2 align="center">The Complete Isomorphic Ruby Framework</h2>
+
+<br>
+
+<a href="http://ruby-hyperloop.org/" alt="Hyperloop" title="Hyperloop">
+<img src="http://ruby-hyperloop.org/images/githubhyperloopbadge.png">
+</a>
+
+<a href="https://gitter.im/ruby-hyperloop/chat" alt="Gitter chat" title="Gitter chat">
+<img src="http://ruby-hyperloop.org/images/githubgitterbadge.png">
+</a>
+
+[![Gem Version](https://badge.fury.io/rb/hyper-trace.svg)](https://badge.fury.io/rb/hyper-trace)
+
+<p align="center">
+<img src="http://ruby-hyperloop.org/images/HyperTracer.png" width="100" alt="Hyper-trace">
+</p>
+
+</div>
+
+## Hyper-Trace GEM is part of Hyperloop GEMS family
+
+Build interactive Web applications quickly. Hyperloop encourages rapid development with clean, pragmatic design. With developer productivity as our highest goal, Hyperloop takes care of much of the hassle of Web development, so you can focus on innovation and delivering end-user value.
+
+One language. One model. One set of tests. The same business logic and domain models running on the clients and the server. Hyperloop is fully integrated with Rails and also gives you unfettered access to the complete universe of JavaScript libraries (including React) from within your Ruby code. Hyperloop lets you build beautiful interactive user interfaces in Ruby.
+
+Everything has a place in our architecture. Components deliver interactive user experiences, Operations encapsulate business logic, Models magically synchronize data between clients and servers, Policies govern authorization and Stores hold local state. 
+
+**Hyper-Trace** brings a method tracing and conditional break points for [Opal](http://opalrb.org/) and [Hyperloop](http://ruby-hyperloop.org) debug.
+
+Typically you are going to use this in Capybara or Opal-RSpec examples that you are debugging.
+
+HyperTrace adds a `hypertrace` method to all classes that you will use to switch on tracing and break points.
+
+## Getting Started
+
+1. Update your Gemfile:
+        
+```ruby
+#Gemfile
+
+gem 'hyper-trace'
+```
+
+2. At the command prompt, update your bundle :
+
+        $ bundle update
+
+3. Run the gem install generator:
+
+        $ gem install hyper-trace
+        
+4. Add `require 'hyper-trace'` to your application or component manifest file.
+
+5. Follow the Hyper-trace documentation:
+
+    * [Hyper-trace documentation](http://ruby-hyperloop.org/tools/hypertrace/)
+    * [Hyperloop Guides](http://ruby-hyperloop.org/docs/architecture)
+    * [Hyperloop Tutorial](http://ruby-hyperloop.org/tutorials)
+
+## Community
+
+#### Getting Help
+Please **do not post** usage questions to GitHub Issues. For these types of questions use our [Gitter chatroom](https://gitter.im/ruby-hyperloop/chat) or [StackOverflow](http://stackoverflow.com/questions/tagged/hyperloop).
+
+#### Submitting Bugs and Enhancements
+[GitHub Issues](https://github.com/ruby-hyperloop/hyperloop/issues) is for suggesting enhancements and reporting bugs. Before submiting a bug make sure you do the following:
+* Check out our [contributing guide](https://github.com/ruby-hyperloop/hyperloop/blob/master/CONTRIBUTING.md) for info on our release cycle.
+
+## License
+
+Hyperloop is released under the [MIT License](http://www.opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+task :default do
+end
+
+namespace :spec do
+  task :prepare do
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hyper/trace"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/hyper-trace.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hyper_trace/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hyper-trace"
+  spec.version       = HyperTrace::VERSION
+  spec.authors       = ["catmando"]
+  spec.email         = ["mitch@catprint.com"]
+
+  spec.summary       = %q{Method tracing and conditional breakpoints for Opal Ruby}
+  spec.homepage      = "https://github.com/reactrb/hyper-trace"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'hyperloop-config', HyperTrace::VERSION
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency 'chromedriver-helper'
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/hyper-trace.rb

@@ -0,0 +1,8 @@
+Hyperloop.import 'hyper-trace'
+if RUBY_ENGINE=='opal'
+  require 'hyper_trace/hyper_trace.rb'
+  require 'hyper_trace/react_trace.rb'
+else
+  require 'opal'
+  Opal.append_path File.expand_path('../', __FILE__).untaint
+end

data/lib/hyper_trace/hyper_trace.rb

@@ -0,0 +1,354 @@
+class Class
+  def hyper_trace(*args, &block)
+    return unless React::IsomorphicHelpers.on_opal_client?
+    HyperTrace.hyper_trace(self, *args, &block)
+  end
+  alias hypertrace hyper_trace
+end
+
+class Method
+  def parameters
+    /.*function[^(]*\(([^)]*)\)/
+      .match(`#{@method}.toString()`)[1]
+      .split(',')
+      .collect { |param| [:req, param.strip.to_sym] }
+  end
+end
+
+module HyperTrace
+
+  class Config
+    def initialize(klass, instrument_class, opts, &block)
+      @klass = klass
+      @opts = {}
+      @instrument_class = instrument_class
+      [:break_on_enter?, :break_on_entry?, :break_on_exit?, :break_on_enter, :break_on_entry, :break_on_exit, :instrument].each do |method|
+        send(method, opts[method]) if opts[method]
+      end unless opts[:instrument] == :none
+      instance_eval(&block) if block
+    end
+    def instrument_class?
+      @instrument_class
+    end
+    attr_reader :klass
+    def instrument(opt)
+      return if @opts[:instrument] == :all
+      if opt == :all
+        @opts[:instrument] = :all
+      else
+        @opts[:instrument] = [*opt, *@opts[:instrument]]
+      end
+    end
+    def break_on_exit(methods)
+      [*methods].each { |method| break_on_exit?(method) { true } }
+    end
+    def break_on_enter(methods)
+      [*methods].each { |method| break_on_enter?(method) { true } }
+    end
+    alias break_on_entry break_on_enter
+    def break_on_exit?(method, &block)
+      @opts[:break_on_exit?] ||= {}
+      @opts[:break_on_exit?][method] = block
+      instrument(method)
+    end
+    def break_on_enter?(method, &block)
+      @opts[:break_on_enter?] ||= {}
+      @opts[:break_on_enter?][method] = block
+      instrument(method)
+    end
+    alias break_on_entry? break_on_enter
+    def [](opt)
+      @opts[opt]
+    end
+    def hypertrace_class_exclusions
+      if klass.respond_to? :hypertrace_class_exclusions
+        klass.hypertrace_class_exclusions
+      else
+        []
+      end
+    end
+    def hypertrace_exclusions
+      if klass.respond_to? :hypertrace_exclusions
+        klass.hypertrace_exclusions
+      else
+        []
+      end
+    end
+  end
+
+
+  class << self
+    def hyper_trace(klass, *args, &block)
+      if args.count == 0
+        opts = { instrument: :all }
+        instrument_class = false
+      elsif args.first == :class
+        opts = args[1] || {}
+        instrument_class = true
+      else
+        opts = args.last || {}
+        instrument_class = false
+      end
+      begin
+        opts.is_a? Hash
+      rescue Exception
+        opts = Hash.new(opts)
+      end
+      config = Config.new(klass, instrument_class, opts, &block)
+      if config[:exclude]
+        exclusions[:instrumentation][klass] << opts[:exclude]
+      else
+        instrumentation_off(config)
+        selected_methods = if config[:instrument] == :all
+          all_methods(config)
+        else
+          Set.new config[:instrument]
+        end
+        selected_methods.each { |method| instrument_method(method, config) }
+      end
+    end
+
+    def exclusions
+      @exclusions ||= Hash.new { |h, k| h[k] = Hash.new { |h, k| h[k] = Set.new } }
+    end
+
+    def instrumentation_off(config)
+      if config.instrument_class?
+        config.klass.methods.grep(/^__hyper_trace_pre_.+$/).each do |method|
+          config.klass.class_eval do
+            class << self
+              alias_method method.gsub(/^__hyper_trace_pre_/, ''), method
+            end
+          end
+        end
+      else
+        config.klass.instance_methods.grep(/^__hyper_trace_pre_.+$/).each do |method|
+          config.klass.class_eval { alias_method method.gsub(/^__hyper_trace_pre_/, ''), method }
+        end
+      end
+    end
+
+    def all_methods(config)
+      if config.instrument_class?
+        Set.new(config.klass.methods.grep(/^(?!__hyper_trace_)/)) -
+        Set.new(Class.methods + Object.methods) -
+        config.hypertrace_class_exclusions -
+        [:hypertrace_format_instance]
+      else
+        Set.new(config.klass.instance_methods.grep(/^(?!__hyper_trace_)/)) -
+        Set.new(Class.methods + Object.methods) -
+        config.hypertrace_exclusions -
+        [:hypertrace_format_instance]
+      end
+    end
+
+    def instrument_method(method, config)
+      if config.instrument_class?
+        config.klass.class_eval do
+          class << self
+            alias_method "__hyper_trace_pre_#{method}", method unless method_defined? "__pre_hyper_trace_#{method}"
+          end
+        end
+        add_hyper_trace_method(method, config)
+      else
+        unless config.klass.method_defined? "__pre_hyper_trace_#{method}"
+          config.klass.class_eval do
+            alias_method "__hyper_trace_pre_#{method}", method
+          end
+        end
+      end
+      add_hyper_trace_method(method, config)
+    end
+
+    def formatting?
+      @formatting
+    end
+
+    def safe_s(obj)
+      obj.to_s
+    rescue Exception
+      "native object"
+    end
+
+    def safe_i(obj)
+      "#{obj.inspect}"
+    rescue Exception
+      begin
+        "native: #{`JSON.stringify(obj)`}"
+      rescue Exception
+        safe_s(obj)
+      end
+    end
+
+    def show_js_object(obj)
+      return true
+      safe(obj) != obj
+    rescue Exception
+      nil
+    end
+
+    def instance_tag(instance, prefix = ' - ')
+      if instance.instance_variables.any?
+        "#{prefix}#<#{instance.class}:0x#{instance.object_id.to_s(16)}>"
+      end
+    end
+
+    def format_head(instance, name, args, &block)
+      @formatting = true
+      method = instance.method("__hyper_trace_pre_#{name}")
+      if args.any?
+        group(" #{name}(...)#{instance_tag(instance)}") do
+          params = method.parameters
+          group("args:", collapsed: true) do
+            params.each_with_index do |param_spec, i|
+              arg_name = param_spec[1]
+              if arg_name == '$a_rest'
+                arg_name = '*'
+                arg = args[i..-1]
+              else
+                arg = args[i]
+              end
+              if safe_i(arg).length > 30 || show_js_object(arg)
+                group "#{arg_name}: #{safe_s(arg)}"[0..29], collapsed: true do
+                  puts safe_i(arg)
+                  log arg if show_js_object(arg)
+                end
+              else
+                group "#{arg_name}: #{safe_i(arg)}"
+              end
+            end
+          end
+          yield
+        end
+      else
+        group " #{name}()#{instance_tag(instance)}", &block
+      end
+    ensure
+      @formatting = false
+    end
+
+    def log(s)
+      `console.log(#{s})`
+    end
+
+    def group(s, collapsed: false, &block)
+      if collapsed
+        `console.groupCollapsed(#{s})`
+      else
+        `console.group(#{s})`
+      end
+      yield if block
+    ensure
+      `console.groupEnd()`
+    end
+
+    def format_instance_internal(instance)
+      if instance.respond_to? :hypertrace_format_instance
+        instance.hypertrace_format_instance(self)
+      else
+        format_instance(instance, instance.instance_variables)
+      end
+    end
+
+    def format_instance(instance, filter = nil, &block)
+      filtered_instance_variables = if filter
+          filter
+        else
+          instance.instance_variables
+        end
+      return if filtered_instance_variables.empty? && block.nil?
+      group "self:#{instance_tag(instance,' ')}", collapsed: true do
+        puts safe_i(instance) unless safe_i(instance).length < 40
+        filtered_instance_variables.each do |iv|
+          val = safe_i(instance.instance_variable_get(iv))
+          group "#{iv}: #{val[0..10]}", collapsed: true do
+            puts val
+            log instance.instance_variable_get(iv)
+          end
+        end
+        yield if block
+      end
+    end
+
+    def format_result(result)
+      if safe_i(result).length > 40 || show_js_object(result)
+        group "returns: #{safe_s(result)}"[0..40], collapsed: true do
+          puts safe_i(result)
+          log result if show_js_object(result)
+        end
+      else
+        group "returns: #{safe_i(result)}"
+      end
+    end
+
+    def format_exception(result)
+      @formatting = true
+      if safe_i(result).length > 40
+        group "raised: #{safe_s(result)}"[0..40], collapsed: true do
+          puts safe_i(result)
+        end
+      else
+        group "raised: #{safe_i(result)}"
+      end
+    ensure
+      @formatting = false
+    end
+
+    def should_break?(location, config, name, args, instance, result)
+      breaker = config["break_on_#{location}?"]
+      breaker &&= breaker[name] || breaker[:all]
+      return unless breaker
+      args = [result, *args] if location == 'exit'
+      instance.instance_exec(*args, &breaker)
+    end
+
+    def breakpoint(location, config, name, args, instance, result = nil)
+      if should_break? location, config, name, args, instance, result
+        method = instance.method("__hyper_trace_pre_#{name}")
+        fn_def = ['RESULT']
+        fn_def += method.parameters.collect { |p| p[1] }
+        fn_def += ["//break on #{location} of #{name}\nvar self = this;\ndebugger;\n;"]
+        puts "break on #{location} of #{name}"
+        fn = `Function.apply(#{self}, #{fn_def}).bind(#{instance})`
+        fn.call(result, *args)
+      end
+    end
+
+    def call_original(instance, method, *args, &block)
+      @formatting = false
+      instance.send "__hyper_trace_pre_#{method}", *args, &block
+    ensure
+      @formatting = true
+    end
+
+
+    def add_hyper_trace_method(method, config)
+      def_method = config.instrument_class? ? :define_singleton_method : :define_method
+      config.klass.send(def_method, method) do |*args, &block|
+        block_string = ' { ... }' if block
+        if HyperTrace.formatting?
+          begin
+            send "__hyper_trace_pre_#{method}", *args, &block
+          rescue Exception
+            "???"
+          end
+        else
+          begin
+            HyperTrace.format_head(self, method, args) do
+              HyperTrace.format_instance_internal(self)
+              HyperTrace.breakpoint(:enter, config, method, args, self)
+              result = HyperTrace.call_original self, method, *args, &block
+              HyperTrace.format_result(result)
+              HyperTrace.breakpoint(:exit, config, method, args, self, result)
+              result
+            end
+          rescue Exception => e
+            HyperTrace.format_exception(e)
+            debugger unless HyperTrace.exclusions[self.class][:rescue].include? :method
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyper_trace/react_trace.rb

@@ -0,0 +1,47 @@
+
+module React
+  module Component
+    module ClassMethods
+      def hypertrace_exclusions
+        @@hypertrace_exclusions ||=
+          Tags::HTML_TAGS +
+          Tags::HTML_TAGS.collect { |t| t.upcase } +
+          [
+            :_render_wrapper, :params, :find_component, :lookup_const,
+            :update_react_js_state, :props_changed?,
+            :update_react_js_state2, :set_state, :original_component_did_mount,
+            :props, :reactive_record_link_to_enclosing_while_loading_container,
+            :reactive_record_link_set_while_loading_container_class,
+            :dom_node, :state, :run_callback, :initial_state, :set_state!,
+            :set_or_replace_state_or_prop, :original_component_did_update
+          ]
+      end
+    end
+    module DslInstanceMethods
+      def hypertrace_format_instance(h)
+        filtered_vars =
+          instance_variables -
+          ['@native', '@props_wrapper', '@state_wrapper', '@waiting_on_resources']
+        h.format_instance(self, filtered_vars) do
+          @props_wrapper.props.each do |param, value|
+            val = h.safe_i value
+            h.group("params.#{param}: #{val[0..10]}", collapsed: true) do
+              puts val
+              h.log value
+            end
+          end if @props_wrapper
+          hash = Hash.new(`#{@native}.state`)
+          updated_at = hash.delete('***_state_updated_at-***')
+          h.group("state last updated at: #{Time.at(updated_at)}") if updated_at
+          hash.each do |state, value|
+            val = h.safe_i(value)
+            h.group("state.#{state}: #{val[0..10]}", collapsed: true) do
+              puts val
+              h.log value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyper_trace/version.rb

@@ -0,0 +1,3 @@
+module HyperTrace
+  VERSION = "0.99.0"
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: hyper-trace
+version: !ruby/object:Gem::Version
+  version: 0.99.0
+platform: ruby
+authors:
+- catmando
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hyperloop-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.99.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.99.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: chromedriver-helper
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- mitch@catprint.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- DOCS.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- hyper-trace.gemspec
+- lib/hyper-trace.rb
+- lib/hyper_trace/hyper_trace.rb
+- lib/hyper_trace/react_trace.rb
+- lib/hyper_trace/version.rb
+homepage: https://github.com/reactrb/hyper-trace
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Method tracing and conditional breakpoints for Opal Ruby
+test_files: []