rails-idle 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f58b55e40ca14d9ba36db82d076cc50dc3ccba46
+  data.tar.gz: 8bde64f72b2e5dbd54d034132abe534ba2553d1f
+SHA512:
+  metadata.gz: ddffde060b6413844c73918b96440a479096c8e53212c2e93f8a7b3d1233148b8c341673ad5d80e9a56793b0b462c091095435d38848f4b975697cb275fb3f84
+  data.tar.gz: c5aae1b3eb90f11b0fbf95f8409a3d8efd6ad11529c2123ccdfba2f0a25d47ff71bcfbb16f043d8cb7da08bac3d77bdb422537bd7a74bb00c1d7a4066f3ee9ba

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+tmp

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Vitalik Danchenko
+
+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/lib/rails-idle.rb

@@ -0,0 +1,68 @@
+require 'pathname'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/string'
+
+module RailsIdle
+  autoload :Storage,      'rails-idle/storage'
+  autoload :Collector,    'rails-idle/collector'
+  autoload :TreeBuilder,  'rails-idle/tree_builder'
+  autoload :Report,       'rails-idle/report'
+  autoload :Web,          'rails-idle/web'
+  
+  DEFAULTS = {
+    collectors: RailsIdle::Collector.list,
+    reset: false,
+    cache: {
+      :views => Pathname.new('/tmp/cache/rails-idle/views.cache'),
+    },
+  }
+  
+  class << self
+    
+    def options
+      @options ||= DEFAULTS.dup
+    end
+
+    def options=(opts)
+      @options = opts
+    end
+    
+    def configure
+      yield self
+    end
+    
+    def collectors
+      options[:collectors]
+    end
+    
+    def collectors=(list)
+      options[:collectors] = list.map(&:to_sym).select{|c| DEFAULTS[:collectors].include? c}
+    end
+    
+    def cache=(hash)
+      hash.select{|key, _| DEFAULTS[:collectors].include? key}
+      _cache = hash.symbolize_keys.select{|c, _| DEFAULTS[:collectors].include? c}
+      options[:cache].merge!(_cache)
+    end
+    
+    def reset?
+      options[:reset]
+    end
+    
+    def reset=(value)
+      options[:reset] = value
+    end
+
+    def stylesheets
+      @stylesheets ||= []
+    end
+    
+    def stylesheets=(sheets = [])
+      @stylesheets = sheets
+    end
+    
+  end
+  
+end
+
+require 'rails-idle/railtie' if defined?(::Rails)

data/lib/rails-idle/collector.rb

@@ -0,0 +1,21 @@
+module RailsIdle
+  module Collector
+    autoload :Base,         'rails-idle/collector/base'
+    #autoload :Actions,     'rails-idle/collector/actions'
+    autoload :Views,        'rails-idle/collector/views'
+#    autoload :Stylesheets,  'rails-idle/collector/stylesheets'
+    
+    class << self
+    
+      def list
+        [:views]
+      end
+    
+      def instance(key)
+        return RailsIdle::Collector::Views.instance if key == :views
+#        return RailsIdle::Collector::Stylesheets.instance if key == :stylesheets
+      end
+    end
+    
+  end
+end

data/lib/rails-idle/collector/base.rb

@@ -0,0 +1,39 @@
+require 'singleton'
+
+module RailsIdle
+  module Collector
+    class Base
+      include Singleton
+      
+      def collect
+        raise NotImplementedError
+      end
+      
+      def subscribe
+        raise NotImplementedError
+      end
+      
+      def push(item, execution_time = 1)
+        storage.add(item, execution_time)
+      end
+      
+      def storage
+        @starage ||= RailsIdle::Storage::RailsCache.new
+      end
+      
+      protected
+      
+      def collector_key
+        self.class.to_s.demodulize.downcase.to_sym
+      end
+      
+      private
+      
+      def _collect(path)
+        storage.reset(path) if RailsIdle.reset?
+        storage.add(path)
+      end
+      
+    end
+  end
+end

data/lib/rails-idle/collector/views.rb

@@ -0,0 +1,92 @@
+module RailsIdle
+  module Collector
+    class Views < Base
+      def collect
+        view_paths.each do |path|
+          views = Dir[path + '/**/*.*']
+          views.each do |view|
+            view = modify_prefix(view)
+            next unless view
+            if view =~ extensions_regexp
+              _collect view
+            end
+          end
+        end
+      end
+      
+      def subscribe
+        %w{render_template render_partial render_collection}.each do |event|
+          ActiveSupport::Notifications.subscribe("#{event}.action_view") do |name, started, finished, unique_id, payload|
+            orig_prefix = ''
+            view = modify_prefix payload[:identifier], orig_prefix
+            next unless view
+            execution_time = finished.to_f - started.to_f 
+            push(view, execution_time)
+            if payload[:layout] && view =~ /\.\w+\.\w+$/
+              # just_view = extract_view  payload[:identifier], view
+              # prefix = payload[:identifier].gsub(just_view, '')
+              extension = view.match(/\.\w+\.\w+$/)[0]
+              layout = orig_prefix + '/' + payload[:layout] + extension
+              layout = modify_prefix layout
+              push(layout, execution_time) if layout
+            end
+          end
+        end
+      end
+      
+      private
+      
+      def view_paths
+        ActionController::Base.new.view_paths.map(&:to_path)
+      end
+      
+      def extensions_regexp
+        @extensions_regexp ||= build_extensions_regexp
+      end
+      
+      def build_extensions_regexp
+        formats = %w(html text)
+        handlers = ActionView::Template.template_handler_extensions
+        exts = view_extentions.join('|').gsub(/\./, '\.')
+        Regexp.new "(#{exts})$"
+      end
+      
+      def view_extentions
+        @view_extentions ||= build_view_extentions
+      end
+      
+      def build_view_extentions
+        extentions = []
+        format_extensions = %w(html text)
+        handler_extensions = ActionView::Template.template_handler_extensions
+        handler_extensions.each do |handler_ext|
+          extentions << ".#{handler_ext}"
+          format_extensions.each do |format_ext|
+            extentions << ".#{format_ext}.#{handler_ext}"
+          end
+        end
+        extentions
+      end
+      
+      def modify_prefix(identifier, orig_prefix = '')
+        view_paths.each do |path|
+          orig_prefix.replace path
+          return identifier.gsub(path, path.gsub('/', '&#47;')) if identifier.start_with?(path)
+        end
+        orig_prefix.replace ''
+        nil
+      end
+      
+      # def extract_view(orig_prefix, modified_prefix)
+      #   idx = 1
+      #   view = ''
+      #   while (idx <= orig_prefix.size && idx <= modified_prefix.size && orig_prefix[-idx] == modified_prefix[-idx])
+      #     view = modified_prefix[-idx] + view
+      #     idx += 1
+      #   end
+      #   view
+      # end
+      
+    end
+  end
+end

data/lib/rails-idle/init.rb

@@ -0,0 +1,22 @@
+module RailsIdle
+  class << self
+    def init!
+      collect
+      subscribe
+    end
+  
+    private
+    
+    def _collectors
+      Hash[*(RailsIdle::Collector.list.map{|c| [c, RailsIdle::Collector.instance(c)]}.flatten)]
+    end
+  
+    def collect
+      _collectors.select{|k, _| options[:collectors].include? k}.each_value(&:collect)
+    end
+    
+    def subscribe
+      _collectors.select{|k, _| options[:collectors].include? k}.each_value(&:subscribe)
+    end
+  end
+end

data/lib/rails-idle/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails-idle/init'
+
+module RailsIdle
+  class Railtie < ::Rails::Railtie    
+    config.to_prepare do
+      RailsIdle.init!
+    end    
+  end
+end

data/lib/rails-idle/report.rb

@@ -0,0 +1,42 @@
+module RailsIdle
+  class Report
+    CALCULATED_KEY = :calculated
+    COUNTER_KEY    = RailsIdle::Storage::COUNTER_KEY
+    
+    def initialize(collector)
+      @tree = TreeBuilder.new(collector).tree
+    end
+    
+    def prepare
+      calc_counter!(@tree)
+      #sort!(@obj)
+      @tree
+    end
+    
+    private
+    
+    def calc_counter!(obj)
+      return obj[COUNTER_KEY] if obj[COUNTER_KEY].is_a?(Fixnum)
+      return obj[CALCULATED_KEY] if obj[CALCULATED_KEY].is_a?(Fixnum)
+      obj[CALCULATED_KEY] = obj.inject(0) do |sum, (key, nested_obj)|
+        sum + (key.is_a?(Symbol) ? 0 : calc_counter!(nested_obj))
+      end
+      obj[CALCULATED_KEY]
+    end
+    
+    def sort!(obj)
+      obj.each do |k, v|        
+        obj[k] = sort!(v) if v.is_a?(Hash)
+      end
+      obj.sort_by do |k, v|
+        if v.is_a?(Hash)
+          v[CALCULATED_KEY] || v[COUNTER_KEY] || 0 
+        else
+          Float::INFINITY
+        end
+      end.to_h
+    end
+      
+    
+  end
+end

data/lib/rails-idle/storage.rb

@@ -0,0 +1,9 @@
+module RailsIdle
+  module Storage
+    COUNTER_KEY   = :counter
+    EXECUTION_KEY = :execution
+    
+    autoload :Base,           'rails-idle/storage/base'
+    autoload :RailsCache,     'rails-idle/storage/rails_cache'
+  end
+end

data/lib/rails-idle/storage/base.rb

@@ -0,0 +1,33 @@
+module RailsIdle
+  module Storage
+    class Base
+      
+      def add(path, execution_time = nil)
+        add_to_list path
+      end
+      
+      def get(path, key)
+        raise NotImplementedError
+      end
+      
+      def reset(path)
+        raise NotImplementedError
+      end
+      
+      def objects_list
+        @objects_list ||= empty_list
+      end
+    
+      private
+      
+      def empty_list
+        []
+      end
+      
+      def add_to_list(path)
+        objects_list << path
+      end
+
+    end
+  end
+end

data/lib/rails-idle/storage/rails_cache.rb

@@ -0,0 +1,39 @@
+module RailsIdle
+  module Storage
+    class RailsCache < Base
+      
+      def add(path, execution_time = nil)
+        super
+        if execution_time
+          increment(path, COUNTER_KEY)
+          increment(path, EXECUTION_KEY, (execution_time * 1000).round)
+        end
+      end
+      
+      def get(path, key)
+        begin
+          Rails.cache.read build_name(path, key)
+        rescue Exception => e # Redis workaround
+          (Rails.cache.read build_name(path, key), raw: true).to_i
+        end
+      end
+      
+      def reset(path)
+        [COUNTER_KEY, EXECUTION_KEY].each do |key|
+           Rails.cache.delete build_name(path, key)
+        end
+      end
+      
+      private
+      
+      def increment(path, key, amount = 1)
+        Rails.cache.increment build_name(path, key), amount
+      end
+      
+      def build_name(path, key)
+        "#{RailsIdle}.#{path}.#{key}"
+      end
+      
+    end
+  end
+end

data/lib/rails-idle/tree_builder.rb

@@ -0,0 +1,33 @@
+module RailsIdle
+  class TreeBuilder
+    def initialize(collector)
+      @storage = collector.storage
+    end
+    
+    def tree
+      @tree ||= build_tree
+    end
+    
+    private
+    
+    def build_tree
+      root = {}
+      @storage.objects_list.each do |path|
+        items = parse_path(path)
+        tree = root
+        items.each do |item|
+          tree[item] = {} unless tree[item]
+          tree = tree[item]
+        end
+        tree[RailsIdle::Storage::COUNTER_KEY]   = @storage.get(path, RailsIdle::Storage::COUNTER_KEY)
+        tree[RailsIdle::Storage::EXECUTION_KEY] = @storage.get(path, RailsIdle::Storage::EXECUTION_KEY)
+      end
+      root
+    end
+    
+    def parse_path(path)
+      path.split(/,|\/|::/)
+    end
+    
+  end
+end