bumbler 0.1.2 → 0.1.3

data/bumbler.gemspec

@@ -1,20 +1,24 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path("../lib/bumbler.rb", __FILE__)
+
+# Bumbler may be already required due to the RUBYOPT=-rbumbler/go that we use to activate.  Clear it
+# if so to get rid of our warning, and then load it.  We just need the version number
+Bumbler.send(:remove_const, :VERSION) if Object.const_defined? :Bumbler
+load File.expand_path('../lib/bumbler.rb', __FILE__)
 
 Gem::Specification.new do |s|
-  s.name        = "bumbler"
+  s.name        = 'bumbler'
   s.version     = Bumbler::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Ian MacLeod"]
-  s.email       = ["ian@nevir.net"]
-  s.homepage    = "https://github.com/nevir/Bumbler"
+  s.authors     = ['Ian MacLeod']
+  s.email       = ['ian@nevir.net']
+  s.homepage    = 'https://github.com/nevir/Bumbler'
   s.summary     = %q{Track the load progress of your Bundler-based projects}
   s.description = %q{Why stare blankly at your terminal window when you can clutter it up with awesome progress bars?}
 
-  s.rubyforge_project = "bumbler"
+  s.rubyforge_project = 'bumbler'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.require_paths = ['lib']
 end

data/lib/bumbler.rb

@@ -1,8 +1,9 @@
 module Bumbler
   # We can be required twice due to the command line require
-  VERSION = '0.1.2' unless self.const_defined? :VERSION
+  VERSION = '0.1.3' unless self.const_defined? :VERSION
   
-  autoload :Hooks,    'bumbler/hooks'
   autoload :Bundler,  'bumbler/bundler'
+  autoload :Hooks,    'bumbler/hooks'
   autoload :Progress, 'bumbler/progress'
+  autoload :Stats,    'bumbler/stats'
 end

data/lib/bumbler/bundler.rb

@@ -1,51 +1,52 @@
 module Bumbler
   module Bundler
-    # Returns which gem a require maps to, or nil.
-    def self.gem_for_require(path)
-      self.read_bundler_environment if @require_map.nil?
-      
-      return @require_map[path]
-    end
-    
-    def self.require_started(path)
-      gem_name = self.gem_for_require(path)
-      return unless gem_name
-      
-      Bumbler::Progress.item_started(:bundler, gem_name)
-    end
-    
-    def self.require_finished(path, load_time)
-      self.read_bundler_environment if @gem_state.nil?
+    class << self
+      # Returns which gem a require maps to, or nil.
+      def gem_for_require(path)
+        self.read_bundler_environment if @require_map.nil?
+        
+        return @require_map[path]
+      end
       
-      # Tick it off for the gem.
-      gem_name = self.gem_for_require(path)
-      return unless gem_name
+      def require_started(path)
+        gem_name = self.gem_for_require(path)
+        return unless gem_name
+        
+        Bumbler::Progress.item_started(:bundler, gem_name)
+      end
       
-      @gem_state[gem_name][path] = true
+      def require_finished(path, load_time)
+        self.read_bundler_environment if @gem_state.nil?
+        
+        # Tick it off for the gem.
+        gem_name = self.gem_for_require(path)
+        return unless gem_name
+        
+        @gem_state[gem_name][path] = true
+        
+        if @gem_state[gem_name].values.all?
+          Bumbler::Progress.item_finished(:bundler, gem_name, load_time)
+        end
+      end
       
-      if @gem_state[gem_name].values.all?
-        Bumbler::Progress.item_finished(:bundler, gem_name, load_time)
+      def start!
+        self.read_bundler_environment
       end
-    end
-    
-    def self.start!
-      self.read_bundler_environment
-    end
-    
-  private
-    def self.read_bundler_environment
-      @require_map = {}
-      @gem_state = {}
       
-      ::Bundler.environment.current_dependencies.each do |spec|
-        @gem_state[spec.name] = {}
+      def read_bundler_environment
+        @require_map = {}
+        @gem_state = {}
         
-        Array(spec.autorequire || spec.name).each do |path|
-          @require_map[path] = spec.name
-          @gem_state[spec.name][path] = false
+        ::Bundler.environment.current_dependencies.each do |spec|
+          @gem_state[spec.name] = {}
+          
+          Array(spec.autorequire || spec.name).each do |path|
+            @require_map[path] = spec.name
+            @gem_state[spec.name][path] = false
+          end
+          
+          Bumbler::Progress.register_item(:bundler, spec.name)
         end
-        
-        Bumbler::Progress.register_item(:bundler, spec.name)
       end
     end
   end

data/lib/bumbler/hooks.rb

@@ -1,72 +1,83 @@
 module Bumbler
   module Hooks
-    # Inject our custom handling of require into the Kernel.
-    def self.hook_require!
-      @hooking_require = true
+    SLOW_REQUIRE_THRESHOLD = 100.0
+    @previous_gems = {}
+    @slow_requires = {}
+    
+    # Everything's a class method (we're a singleton)
+    class << self
+      def slow_requires
+        @slow_requires
+      end
       
-      # There are two independent require methods.  Joy!
-      ::Kernel.module_eval do
-        class << self
-          orig_public_require = Kernel.public_method(:require)
+      # Inject our custom handling of require into the Kernel.
+      def hook_require!
+        @hooking_require = true
+        
+        # There are two independent require methods.  Joy!
+        ::Kernel.module_eval do
+          class << self
+            orig_public_require = Kernel.public_method(:require)
+            define_method(:require) do |path, *args|
+              ::Bumbler::Hooks.handle_require(path) do
+                orig_public_require.call(path, *args)
+              end
+            end
+          end
+          
+          orig_instance_require = self.instance_method(:require)
           define_method(:require) do |path, *args|
             ::Bumbler::Hooks.handle_require(path) do
-              orig_public_require.call(path, *args)
+              orig_instance_require.bind(self).call(path, *args)
             end
           end
         end
         
-        orig_instance_require = self.instance_method(:require)
-        define_method(:require) do |path, *args|
-          ::Bumbler::Hooks.handle_require(path) do
-            orig_instance_require.bind(self).call(path, *args)
-          end
-        end
+        @hooking_require = nil
       end
       
-      @hooking_require = nil
-    end
-    
-    # Even better: Other gems hook require as well.  The instance method one at least.
-    def self.watch_require!
-      ::Kernel.module_eval do
-        # It isn't previously defined in Kernel.  This could be a bit dangerous, though.
-        def self.method_added(method_name, *args)
-          if method_name == :require && !::Bumbler::Hooks.hooking_require?
-            # Fix those hooks.
-            ::Bumbler::Hooks.hook_require!
+      # Even better: Other gems hook require as well.  The instance method one at least.
+      def watch_require!
+        ::Kernel.module_eval do
+          # It isn't previously defined in Kernel.  This could be a bit dangerous, though.
+          def self.method_added(method_name, *args)
+            if method_name == :require && !::Bumbler::Hooks.hooking_require?
+              # Fix those hooks.
+              ::Bumbler::Hooks.hook_require!
+            end
           end
         end
       end
-    end
-    
-  private
-    def self.hooking_require?
-      @hooking_require
-    end
-    
-    # Actually do something about a require here.
-    def self.handle_require(path)
-      # break out early if we're already handling this
-      return yield if path == @previous_require
-      @previous_require = path
-      
-      # Shortcut unless we're tracking the gem
-      gem_name = Bumbler::Bundler.gem_for_require(path)
-      return yield unless gem_name
-      
-      # Track load starts
-      @previous_gems ||= {}
-      Bumbler::Bundler.require_started(path) unless @previous_gems[gem_name]
-      @previous_gems[gem_name] = true
       
-      # Let's time them
-      start = Time.now.to_f
-      result = yield
-      require_time = (Time.now.to_f - start) * 1000 # ms
-      
-      Bumbler::Bundler.require_finished(path, require_time) if result
+      def hooking_require?
+        @hooking_require
+      end
       
-      return result
+      # Actually do something about a require here.
+      def handle_require(path)
+        # break out early if we're already handling this
+        return yield if path == @previous_require
+        @previous_require = path
+        
+        # Shortcut unless we're tracking the gem
+        gem_name = Bumbler::Bundler.gem_for_require(path)
+        return yield unless gem_name
+        
+        # Track load starts
+        Bumbler::Bundler.require_started(path) unless @previous_gems[gem_name]
+        @previous_gems[gem_name] = true
+        
+        # Let's time them
+        start = Time.now.to_f
+        result = yield
+        require_time = (Time.now.to_f - start) * 1000 # ms
+        
+        @slow_requires[path] = require_time if require_time > SLOW_REQUIRE_THRESHOLD
+        
+        Bumbler::Bundler.require_finished(path, require_time) if result
+        
+        return result
+      end
     end
   end
 end

data/lib/bumbler/progress.rb

@@ -1,94 +1,94 @@
 module Bumbler
-  # Singletons are fun, yay!
   module Progress
-    def self.register_item(type, name)
-      # Build a blank key for the item
-      unless self.registry[type][name]
-        @item_count ||= 0
-        @item_count  += 1
-      end
-      
-      self.registry[type][name] = {}
-    end
-    
-    def self.item_started(type, name)
-      @curr_item = {:type => type, :name => name}
-      
-      self.render_progress
-    end
-    
-    def self.item_finished(type, name, time)
-      self.registry[type][name] = {:time => time}
-      
-      @loaded_items ||= 0
-      @loaded_items  += 1
-      
-      @prev_item = {:type => type, :name => name, :time => time}
-      @curr_item = nil if @curr_item && @curr_item[:name] == @prev_item[:name] && @curr_item[:type] == @prev_item[:type]
-      
-      self.render_progress
-    end
-    
-    def self.start!
-      # No-op for now.
-    end
+    @item_count   = 0
+    @loaded_items = 0
     
-  private
     # registry[item_type][item_name] = {:time => 123.45}
-    def self.registry
-      @registry ||= Hash.new { |h,k| h[k] = {} }
-    end
-    
-    def self.tty_width
-      `tput cols`.to_i || 80
-    end
+    @registry = Hash.new { |h,k| h[k] = {} }
     
-    def self.bar(width)
-      inner_size = width - 2
-      
-      fill_size = ((@loaded_items.to_f / @item_count.to_f) * inner_size).to_i
-      fill  = '#' * fill_size
-      empty = ' ' * (inner_size - fill_size)
-      
-      return "[#{fill}#{empty}]"
-    end
-    
-    def self.render_progress
-      unless $stdout.tty?
-        puts '(%s/%d) %s' % [@loaded_items.to_s.rjust(@item_count.to_s.size), @item_count, message]
-        return
+    class << self
+      def registry
+        @registry
       end
       
-      # Do nothing if we don't have any items to load
-      return if @item_count == 0
-      
-      width = self.tty_width
-      
-      print "\r\e[A\r\e[A" if @outputted_once
-      @outputted_once = true
-      
-      @loaded_items ||= 0
-      @item_count   ||= 0
+      def register_item(type, name)
+        # Build a blank key for the item
+        unless @registry[type][name]
+          @item_count  += 1
+        end
+        
+        @registry[type][name] = {}
+      end
       
-      # Output components:
-      #   [#######################################]
-      #   (##/##) <current>...   <prev> (####.##ms)
-      # 
-      # Skip the current if there isn't enough room
-      count   = '(%s/%d) ' % [@loaded_items.to_s.rjust(@item_count.to_s.size), @item_count]
-      current = @curr_item ? "#{@curr_item[:name]}... " : ''
-      prev    = @prev_item ? '%s (%sms)' % [@prev_item[:name], ('%.2f' % @prev_item[:time]).rjust(7)] : ''
+      def item_started(type, name)
+        @curr_item = {:type => type, :name => name}
+        
+        self.render_progress
+      end
       
-      # Align the bottom row
-      space_for_current = width - (count.length + prev.length)
+      def item_finished(type, name, time)
+        @registry[type][name] = {:time => time}
+        
+        @loaded_items  += 1
+        
+        @prev_item = {:type => type, :name => name, :time => time}
+        @curr_item = nil if @curr_item && @curr_item[:name] == @prev_item[:name] && @curr_item[:type] == @prev_item[:type]
+        
+        self.render_progress
+      end
       
-      # Render the progress
-      puts self.bar(width)
+      def start!
+        # No-op for now.
+      end
       
-      if space_for_current >= current.length
-        puts count + current + prev.rjust(width - count.length - current.length)
-      else
-        puts count + prev.rjust(width - count.length)
+      def tty_width
+        `tput cols`.to_i || 80
+      end
+    
+      def bar(width)
+        inner_size = width - 2
+        
+        fill_size = ((@loaded_items.to_f / @item_count.to_f) * inner_size).to_i
+        fill  = '#' * fill_size
+        empty = ' ' * (inner_size - fill_size)
+        
+        return "[#{fill}#{empty}]"
+      end
+    
+      def render_progress
+        unless $stdout.tty?
+          puts '(%s/%d) %s' % [@loaded_items.to_s.rjust(@item_count.to_s.size), @item_count, message]
+          return
+        end
+        
+        # Do nothing if we don't have any items to load
+        return if @item_count == 0
+        
+        width = self.tty_width
+        
+        print "\r\e[A\r\e[A" if @outputted_once
+        @outputted_once = true
+        
+        # Output components:
+        #   [#######################################]
+        #   (##/##) <current>...   <prev> (####.##ms)
+        # 
+        # Skip the current if there isn't enough room
+        count   = '(%s/%d) ' % [@loaded_items.to_s.rjust(@item_count.to_s.size), @item_count]
+        current = @curr_item ? "#{@curr_item[:name]}... " : ''
+        prev    = @prev_item ? '%s (%sms)' % [@prev_item[:name], ('%.2f' % @prev_item[:time]).rjust(7)] : ''
+        
+        # Align the bottom row
+        space_for_current = width - (count.length + prev.length)
+        
+        # Render the progress
+        puts self.bar(width)
+        
+        if space_for_current >= current.length
+          puts count + current + prev.rjust(width - count.length - current.length)
+        else
+          puts count + prev.rjust(width - count.length)
+        end
       end
     end
   end

data/lib/bumbler/stats.rb

@@ -0,0 +1,30 @@
+module Bumbler
+  module Stats
+    class << self
+      def tracked_items
+        Bumbler::Progress.registry.each do |type, items|
+          puts "Stats for #{type} items:"
+          
+          items.to_a.sort_by! {|n,d| d[:time].to_f}.each do |name, info|
+            if info[:time]
+              puts '  %s  %s' % [('%.2f' % info[:time]).rjust(8), name]
+            else
+              puts "  pending:  #{name}"
+            end
+          end
+        end
+        
+        self
+      end
+      
+      def all_slow_items
+        puts "Slow requires:"
+        Bumbler::Hooks.slow_requires.to_a.sort_by! {|n,t| t}.each do |name, time|
+          puts '  %s  %s' % [('%.2f' % time).rjust(8), name]
+        end
+        
+        self
+      end
+    end
+  end
+end

metadata

@@ -2,7 +2,7 @@
 name: bumbler
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Ian MacLeod
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-22 00:00:00 -07:00
+date: 2011-04-23 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -34,6 +34,7 @@ files:
 - lib/bumbler/go.rb
 - lib/bumbler/hooks.rb
 - lib/bumbler/progress.rb
+- lib/bumbler/stats.rb
 has_rdoc: true
 homepage: https://github.com/nevir/Bumbler
 licenses: []