wtf-tools 1.0.3 → 1.0.4

data/example/timing.rb

@@ -1,20 +1,20 @@
-require 'rubygems'
-require 'wtf-tools'
-require 'active_support/logger'
-
-# default: puts
-WTF.time {
-  sleep 1.01
-}
-
-# logging time with specified precision and options
-WTF.options = {
-  output: {
-    default: ActiveSupport::Logger.new('./example.log'),
-  }
-}
-result = WTF.time(4, :nl) {
-  sleep 3.12346
-  17
-}
-p result # => 17
+require 'rubygems'
+require 'wtf-tools'
+require 'active_support/logger'
+
+# default: puts
+WTF.time {
+  sleep 1.01
+}
+
+# logging time with specified precision and options
+WTF.options = {
+  output: {
+    default: ActiveSupport::Logger.new('./example.log'),
+  }
+}
+result = WTF.time(4, :nl) {
+  sleep 3.12346
+  17
+}
+p result # => 17

data/example/tracking.rb

@@ -1,32 +1,32 @@
-require 'rubygems'
-require 'wtf-tools'
-require 'fileutils'
-require 'csv'
-
-WTF.options = {
-  files: './wtf',
-}
-
-class Sample
-  def run
-    WTF.track(self)
-    action1
-    action2
-    action3
-    WTF.track_finish
-  end
-
-  def action1
-    sleep 1
-  end
-
-  def action2
-    sleep 2
-  end
-
-  def action3
-    sleep 3
-  end
-end
-
-Sample.new.run
+require 'rubygems'
+require 'wtf-tools'
+require 'fileutils'
+require 'csv'
+
+WTF.options = {
+  files: './wtf',
+}
+
+class Sample
+  def run
+    WTF.track(self)
+    action1
+    action2
+    action3
+    WTF.track_finish
+  end
+
+  def action1
+    sleep 1
+  end
+
+  def action2
+    sleep 2
+  end
+
+  def action3
+    sleep 3
+  end
+end
+
+Sample.new.run

data/lib/wtf-tools.rb

@@ -1,69 +1,69 @@
-require 'wtf/dumper'
-require 'wtf/method_tracker'
-require 'wtf/query_tracker'
-
-module WTF
-  class << self
-    def options=(value)
-      @options = value
-    end
-
-    def options
-      @options ||= {}
-    end
-
-    def files_path
-      if options[:files]
-        dirs = FileUtils.mkdir_p(options[:files])
-        dirs.first
-      else
-        Dir.getwd
-      end
-    end
-
-    def output_options
-      Hash(options[:output])
-    end
-
-    # TODO: separately track ActiveRecord finders usage in the related methods
-    def track(*objects)
-      WTF::MethodTracker.start_tracking(*objects)
-      if block_given?
-        yield
-        track_finish
-      end
-    end
-
-    def track_finish
-      WTF::MethodTracker.finish
-    end
-
-    def sql(*args)
-      WTF::QueryTracker.start_tracking(*args)
-    end
-
-    def time(*args)
-      require 'absolute_time'
-
-      precision = args.shift if args.first.is_a?(Fixnum)
-      precision ||= 3
-      before = AbsoluteTime.now
-      result = yield
-      duration = AbsoluteTime.now - before
-      WTF::Dumper.new(duration.round(precision), *args).call
-      result
-    end
-  end
-end
-
-Object.class_eval do
-  def WTF?(*args)
-    WTF::Dumper.new(*args).call
-    nil
-  end
-
-  def wtf(*args)
-    WTF::Dumper.new(self, *args).call
-    self
-  end
-end
+require_relative 'wtf/dumper'
+require_relative 'wtf/method_tracker'
+require_relative 'wtf/query_tracker'
+
+module WTF
+  class << self
+    def options=(value)
+      @options = value
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def files_path
+      if options[:files]
+        dirs = FileUtils.mkdir_p(options[:files])
+        dirs.first
+      else
+        Dir.getwd
+      end
+    end
+
+    def output_options
+      Hash(options[:output])
+    end
+
+    # TODO: separately track ActiveRecord finders usage in the related methods
+    def track(*objects)
+      WTF::MethodTracker.start_tracking(*objects)
+      if block_given?
+        yield
+        track_finish
+      end
+    end
+
+    def track_finish
+      WTF::MethodTracker.finish
+    end
+
+    def sql(*args)
+      WTF::QueryTracker.start_tracking(*args)
+    end
+
+    def time(*args)
+      require 'absolute_time'
+
+      precision = args.shift if args.first.is_a?(Fixnum)
+      precision ||= 3
+      before = AbsoluteTime.now
+      result = yield
+      duration = AbsoluteTime.now - before
+      WTF::Dumper.new(duration.round(precision), *args).call
+      result
+    end
+  end
+end
+
+Object.class_eval do
+  def WTF?(*args)
+    WTF::Dumper.new(*args).call
+    nil
+  end
+
+  def wtf(*args)
+    WTF::Dumper.new(self, *args).call
+    self
+  end
+end

data/lib/wtf/dumper.rb

@@ -1,113 +1,144 @@
-module WTF
-  class Dumper
-    PREFIX_OPTIONS = [:time, :nl, :np].freeze
-    FORMAT_OPTIONS = [:pp, :yaml, :json, :text, :line, :csv].freeze
-    MODIFY_OPTIONS = [:bare].freeze
-    OUTPUT_OPTIONS = [:puts, :error, :file].freeze
-
-    OPTIONS = (PREFIX_OPTIONS + FORMAT_OPTIONS + MODIFY_OPTIONS + OUTPUT_OPTIONS).freeze
-
-    attr_reader :args, :options
-
-    def initialize(*args)
-      @args = args
-      @options = {}
-      while is_option?(args.last)
-        @options[args.pop] = true
-      end
-    end
-
-    def call
-      data = prefix(args) << format(args)
-      output(data)
-    end
-
-    private
-
-    def is_option?(sym)
-      OPTIONS.include?(sym) or WTF.output_options.key?(sym)
-    end
-
-    def prefix(args)
-      data = ''
-      data << "\n" if options[:nl]
-      data << "[%s] " % Time.now if options[:time]
-      return data if options[:np]
-      data << if args[0].is_a?(Symbol)
-        args.shift.to_s.upcase
-      else
-        pattern = %r{([^/]+?)(?:\.rb)?:(\d+):in `(.*)'$}  # '
-        "WTF (%s/%s:%s)" % caller[3].match(pattern).values_at(1,3,2)
-      end
-      data << ': '
-    end
-
-    def format(args)
-      case
-      when options[:pp]
-        cleanup(args.pretty_inspect, options[:bare])
-      when options[:yaml]
-        YAML.dump(args)
-      when options[:json]
-        JSON::pretty_generate(args)
-      when options[:text]
-        args.map(&:to_s).join("\n")
-      when options[:line]
-        args.map(&:inspect).join("\n  ")
-      when options[:csv]
-        args[0].map(&:to_csv).join
-      else
-        cleanup(args.inspect, options[:bare])
-      end
-    end
-
-    def cleanup(str, bare = false)
-      # remove array parentheses
-      str.gsub!(/^\[|\]$/,'')
-      # ActiveRecord no attributes
-      str.gsub!(/#<[A-Z]\w+ id: \d+\K.*?>/, '>') if bare
-      str
-    end
-
-    def output(data)
-      selected = (OUTPUT_OPTIONS + WTF.output_options.keys).select { |how| options[how] }
-      selected << :default if selected.empty?
-      selected.each do |how|
-        Output.new(data).call(how)
-      end
-    end
-
-    class Output
-      attr_reader :data
-
-      def initialize(data)
-        @data = data
-      end
-
-      def call(meth)
-        if block = WTF.output_options[meth]
-          block.call(meth)
-        else
-          send(meth)
-        end
-      end
-
-      private
-
-      def puts
-        STDOUT.puts(data)
-      end
-      alias_method :default, :puts
-
-      def file
-        time = Time.now.strftime('%m%d_%H%M%S')
-        file = File.join(WTF.files_path, "wtf_#{time}_#{rand(10000)}.txt")
-        File.write(file, data)
-      end
-
-      def error
-        raise StandardError, data
-      end
-    end
-  end
-end
+module WTF
+  class Dumper
+    PREFIX_OPTIONS = [:time, :nl, :np].freeze
+    FORMAT_OPTIONS = [:pp, :yaml, :json, :text, :line, :csv].freeze
+    MODIFY_OPTIONS = [:bare, :name].freeze
+    OUTPUT_OPTIONS = [:puts, :error, :file].freeze
+
+    OPTIONS = (PREFIX_OPTIONS + FORMAT_OPTIONS + MODIFY_OPTIONS + OUTPUT_OPTIONS).freeze
+
+    attr_reader :args, :options
+
+    def initialize(*args)
+      @args = args
+      @options = {}
+      while is_option?(args.last)
+        @options[args.pop] = true
+      end
+    end
+
+    def call
+      where, names = parse_source(caller[1])
+      data = prefix(where) << format(names)
+      output(data)
+    end
+
+    private
+
+    def is_option?(sym)
+      OPTIONS.include?(sym) or WTF.output_options.key?(sym)
+    end
+
+    def prefix(where)
+      data = ''
+      data << "\n" if options[:nl]
+      data << "[%s] " % Time.now if options[:time]
+      return data if options[:np]
+      data << if args.first.is_a?(Symbol)
+        args.shift.to_s.upcase
+      else
+        "WTF (#{where})"
+      end
+      data << ': '
+    end
+
+    def parse_source(item)
+      md = item.match(%r{^(.*?([^/]+?)(?:\.rb)?):(\d+):in `(.*)'$})
+      where = '%s/%s:%s' % md.values_at(2, 4, 3)
+      names = parse_names(read_source(md[1], md[3].to_i)) if options[:name]
+      [where, names]
+    end
+
+    def read_source(file, line)
+      File.open(file).each_line.lazy.take(line).to_a[line-1]
+    end
+
+    def parse_names(source)
+      return nil unless source
+      md = source.match(/(\.wtf\(|WTF\?\(?)(.*?)\s*(?:if |unless |$)/)
+      return nil unless md
+      names = md[2].split(',').map(&:strip) # naive
+      names.unshift('self') if md[1] == '.wtf('
+      names
+    end
+
+    def format(names)
+      return format_with_names(names) if names
+
+      case
+      when options[:pp]
+        cleanup(args.pretty_inspect, options[:bare])
+      when options[:yaml]
+        YAML.dump(args)
+      when options[:json]
+        JSON::pretty_generate(args)
+      when options[:text]
+        args.map(&:to_s).join("\n")
+      when options[:line]
+        args.map(&:inspect).join("\n  ")
+      when options[:csv]
+        args.first.map(&:to_csv).join
+      else
+        cleanup(args.inspect, options[:bare])
+      end
+    end
+
+    def format_with_names(names)
+      len = names.map(&:length).max
+      args.each_with_object('').with_index do |(arg, data), i|
+        name = names[i] || '?'
+        data << "\n" << "  %-#{len}s => %s" % [name, arg.inspect]
+      end
+    end
+
+    def cleanup(str, bare = false)
+      # remove array parentheses
+      str.gsub!(/^\[|\]$/,'')
+      # ActiveRecord no attributes
+      str.gsub!(/#<[A-Z]\w+ id: \d+\K.*?>/, '>') if bare
+      str
+    end
+
+    def output(data)
+      selected = (OUTPUT_OPTIONS + WTF.output_options.keys).select { |how| options[how] }
+      selected << :default if selected.empty?
+      proxy = Output.new(data)
+      selected.each do |how|
+        proxy.call(how)
+      end
+    end
+
+    class Output
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def call(meth)
+        if block = WTF.output_options[meth]
+          block.call(data)
+        else
+          send(meth)
+        end
+      end
+
+      private
+
+      def puts
+        STDOUT.puts(data)
+      end
+      alias_method :default, :puts
+
+      def file
+        time = Time.now.strftime('%m%d_%H%M%S')
+        file = File.join(WTF.files_path, "wtf_#{time}_#{rand(10000)}.txt")
+        File.write(file, data)
+      end
+
+      def error
+        raise StandardError, data
+      end
+    end
+  end
+end