backbone-deep-rails 0.0.2 → 0.0.3

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/testing/performance/jruby.rb

@@ -1,115 +0,0 @@
-require 'jruby/profiler'
-require 'java'
-java_import java.lang.management.ManagementFactory
-
-module ActiveSupport
-  module Testing
-    module Performance
-      DEFAULTS.merge!(
-        if ARGV.include?('--benchmark')
-          {:metrics => [:wall_time, :user_time, :memory, :gc_runs, :gc_time]}
-        else
-          { :metrics => [:wall_time],
-            :formats => [:flat, :graph] }
-        end).freeze
-
-      protected
-        def run_gc
-          ManagementFactory.memory_mx_bean.gc
-        end
-
-      class Profiler < Performer
-        def initialize(*args)
-          super
-          @supported = @metric.is_a?(Metrics::WallTime)
-        end
-
-        def run
-          return unless @supported
-
-          @total = time_with_block do
-            @data = JRuby::Profiler.profile do
-              full_profile_options[:runs].to_i.times { run_test(@metric, :profile) }
-            end
-          end
-        end
-
-        def record
-          return unless @supported
-
-          klasses = full_profile_options[:formats].map { |f| JRuby::Profiler.const_get("#{f.to_s.camelize}ProfilePrinter") }.compact
-
-          klasses.each do |klass|
-            fname = output_filename(klass)
-            FileUtils.mkdir_p(File.dirname(fname))
-            file = File.open(fname, 'wb') do |file|
-              klass.new(@data).printProfile(file)
-            end
-          end
-        end
-
-        protected
-          def output_filename(printer_class)
-            suffix =
-              case printer_class.name.demodulize
-                when 'FlatProfilePrinter';  'flat.txt'
-                when 'GraphProfilePrinter'; 'graph.txt'
-                else printer_class.name.sub(/ProfilePrinter$/, '').underscore
-              end
-
-            "#{super()}_#{suffix}"
-          end
-      end
-
-      module Metrics
-        class Base
-          def profile
-            yield
-          end
-
-          protected
-            def with_gc_stats
-              ManagementFactory.memory_mx_bean.gc
-              yield
-            end
-        end
-
-        class WallTime < Time
-          def measure
-            super
-          end
-        end
-
-        class CpuTime < Time
-          def measure
-            ManagementFactory.thread_mx_bean.get_current_thread_cpu_time / 1000 / 1000 / 1000.0 # seconds
-          end
-        end
-
-        class UserTime < Time
-          def measure
-            ManagementFactory.thread_mx_bean.get_current_thread_user_time / 1000 / 1000 / 1000.0 # seconds
-          end
-        end
-
-        class Memory < DigitalInformationUnit
-          def measure
-            ManagementFactory.memory_mx_bean.non_heap_memory_usage.used + ManagementFactory.memory_mx_bean.heap_memory_usage.used
-          end
-        end
-
-        class GcRuns < Amount
-          def measure
-            ManagementFactory.garbage_collector_mx_beans.inject(0) { |total_runs, current_gc| total_runs += current_gc.collection_count }
-          end
-        end
-
-        class GcTime < Time
-          def measure
-            ManagementFactory.garbage_collector_mx_beans.inject(0) { |total_time, current_gc| total_time += current_gc.collection_time } / 1000.0 # seconds
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/testing/performance/rubinius.rb

@@ -1,113 +0,0 @@
-require 'rubinius/agent'
-
-module ActiveSupport
-  module Testing
-    module Performance
-      DEFAULTS.merge!(
-        if ARGV.include?('--benchmark')
-          {:metrics => [:wall_time, :memory, :objects, :gc_runs, :gc_time]}
-        else
-          { :metrics => [:wall_time],
-            :formats => [:flat, :graph] }
-        end).freeze
-
-      protected
-        def run_gc
-          GC.run(true)
-        end
-
-      class Performer; end
-
-      class Profiler < Performer
-        def initialize(*args)
-          super
-          @supported = @metric.is_a?(Metrics::WallTime)
-        end
-
-        def run
-          return unless @supported
-
-          @profiler = Rubinius::Profiler::Instrumenter.new
-
-          @total = time_with_block do
-            @profiler.profile(false) do
-              full_profile_options[:runs].to_i.times { run_test(@metric, :profile) }
-            end
-          end
-        end
-
-        def record
-          return unless @supported
-
-          if(full_profile_options[:formats].include?(:flat))
-            create_path_and_open_file(:flat) do |file|
-              @profiler.show(file)
-            end
-          end
-
-          if(full_profile_options[:formats].include?(:graph))
-            create_path_and_open_file(:graph) do |file|
-              @profiler.show(file)
-            end
-          end
-        end
-
-        protected
-          def create_path_and_open_file(printer_name)
-            fname = "#{output_filename}_#{printer_name}.txt"
-            FileUtils.mkdir_p(File.dirname(fname))
-            File.open(fname, 'wb') do |file|
-              yield(file)
-            end
-          end
-      end
-
-      module Metrics
-        class Base
-          attr_reader :loopback
-
-          def profile
-            yield
-          end
-
-          protected
-            def with_gc_stats
-              @loopback = Rubinius::Agent.loopback
-              GC.run(true)
-              yield
-            end
-        end
-
-        class WallTime < Time
-          def measure
-            super
-          end
-        end
-
-        class Memory < DigitalInformationUnit
-          def measure
-            loopback.get("system.memory.counter.bytes").last
-          end
-        end
-
-        class Objects < Amount
-          def measure
-            loopback.get("system.memory.counter.objects").last
-          end
-        end
-
-        class GcRuns < Amount
-          def measure
-            loopback.get("system.gc.full.count").last + loopback.get("system.gc.young.count").last
-          end
-        end
-
-        class GcTime < Time
-          def measure
-            (loopback.get("system.gc.full.wallclock").last + loopback.get("system.gc.young.wallclock").last) / 1000.0
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/testing/performance/ruby.rb

@@ -1,152 +0,0 @@
-begin
-  require 'ruby-prof'
-rescue LoadError
-  $stderr.puts 'Specify ruby-prof as application\'s dependency in Gemfile to run benchmarks.'
-  exit
-end
-
-module ActiveSupport
-  module Testing
-    module Performance
-      DEFAULTS.merge!(
-        if ARGV.include?('--benchmark')
-          { :metrics => [:wall_time, :memory, :objects, :gc_runs, :gc_time] }
-        else
-          { :min_percent => 0.01,
-            :metrics => [:process_time, :memory, :objects],
-            :formats => [:flat, :graph_html, :call_tree, :call_stack] }
-        end).freeze
-
-      protected
-        def run_gc
-          GC.start
-        end
-
-      class Profiler < Performer
-        def initialize(*args)
-          super
-          @supported = @metric.measure_mode rescue false
-        end
-
-        def run
-          return unless @supported
-
-          RubyProf.measure_mode = @metric.measure_mode
-          RubyProf.start
-          RubyProf.pause
-          full_profile_options[:runs].to_i.times { run_test(@metric, :profile) }
-          @data = RubyProf.stop
-          @total = @data.threads.sum(0) { |thread| thread.methods.max.total_time }
-        end
-
-        def record
-          return unless @supported
-
-          klasses = full_profile_options[:formats].map { |f| RubyProf.const_get("#{f.to_s.camelize}Printer") }.compact
-
-          klasses.each do |klass|
-            fname = output_filename(klass)
-            FileUtils.mkdir_p(File.dirname(fname))
-            File.open(fname, 'wb') do |file|
-              klass.new(@data).print(file, full_profile_options.slice(:min_percent))
-            end
-          end
-        end
-
-        protected
-          def output_filename(printer_class)
-            suffix =
-              case printer_class.name.demodulize
-                when 'FlatPrinter';                 'flat.txt'
-                when 'FlatPrinterWithLineNumbers';  'flat_line_numbers.txt'
-                when 'GraphPrinter';                'graph.txt'
-                when 'GraphHtmlPrinter';            'graph.html'
-                when 'GraphYamlPrinter';            'graph.yml'
-                when 'CallTreePrinter';             'tree.txt'
-                when 'CallStackPrinter';            'stack.html'
-                when 'DotPrinter';                  'graph.dot'
-                else printer_class.name.sub(/Printer$/, '').underscore
-              end
-
-            "#{super()}_#{suffix}"
-          end
-      end
-
-      module Metrics
-        class Base
-          def measure_mode
-            self.class::Mode
-          end
-
-          def profile
-            RubyProf.resume
-            yield
-          ensure
-            RubyProf.pause
-          end
-
-          protected
-            # overridden by each implementation
-            def with_gc_stats
-              yield
-            end
-        end
-
-        class ProcessTime < Time
-          Mode = RubyProf::PROCESS_TIME if RubyProf.const_defined?(:PROCESS_TIME)
-
-          def measure
-            RubyProf.measure_process_time
-          end
-        end
-
-        class WallTime < Time
-          Mode = RubyProf::WALL_TIME if RubyProf.const_defined?(:WALL_TIME)
-
-          def measure
-            RubyProf.measure_wall_time
-          end
-        end
-
-        class CpuTime < Time
-          Mode = RubyProf::CPU_TIME if RubyProf.const_defined?(:CPU_TIME)
-
-          def initialize(*args)
-            # FIXME: yeah my CPU is 2.33 GHz
-            RubyProf.cpu_frequency = 2.33e9 unless RubyProf.cpu_frequency > 0
-            super
-          end
-
-          def measure
-            RubyProf.measure_cpu_time
-          end
-        end
-
-        class Memory < DigitalInformationUnit
-          Mode = RubyProf::MEMORY if RubyProf.const_defined?(:MEMORY)
-        end
-
-        class Objects < Amount
-          Mode = RubyProf::ALLOCATIONS if RubyProf.const_defined?(:ALLOCATIONS)
-        end
-
-        class GcRuns < Amount
-          Mode = RubyProf::GC_RUNS if RubyProf.const_defined?(:GC_RUNS)
-        end
-
-        class GcTime < Time
-          Mode = RubyProf::GC_TIME if RubyProf.const_defined?(:GC_TIME)
-        end
-      end
-    end
-  end
-end
-
-if RUBY_VERSION.between?('1.9.2', '2.0')
-  require 'active_support/testing/performance/ruby/yarv'
-elsif RUBY_VERSION.between?('1.8.6', '1.9')
-  require 'active_support/testing/performance/ruby/mri'
-else
-  $stderr.puts 'Update your ruby interpreter to be able to run benchmarks.'
-  exit
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/testing/performance/ruby/mri.rb

@@ -1,57 +0,0 @@
-module ActiveSupport
-  module Testing
-    module Performance
-      module Metrics
-        class Base
-          protected
-            # Ruby 1.8 + ruby-prof wrapper (enable/disable stats for Benchmarker)
-            if GC.respond_to?(:enable_stats)
-              def with_gc_stats
-                GC.enable_stats
-                GC.start
-                yield
-              ensure
-                GC.disable_stats
-              end
-            end
-        end
-
-        class Memory < DigitalInformationUnit
-          # Ruby 1.8 + ruby-prof wrapper
-          if RubyProf.respond_to?(:measure_memory)
-            def measure
-              RubyProf.measure_memory
-            end
-          end
-        end
-
-        class Objects < Amount
-          # Ruby 1.8 + ruby-prof wrapper
-          if RubyProf.respond_to?(:measure_allocations)
-            def measure
-              RubyProf.measure_allocations
-            end
-          end
-        end
-
-        class GcRuns < Amount
-          # Ruby 1.8 + ruby-prof wrapper
-          if RubyProf.respond_to?(:measure_gc_runs)
-            def measure
-              RubyProf.measure_gc_runs
-            end
-          end
-        end
-
-        class GcTime < Time
-          # Ruby 1.8 + ruby-prof wrapper
-          if RubyProf.respond_to?(:measure_gc_time)
-            def measure
-              RubyProf.measure_gc_time / 1000.0 / 1000.0
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/testing/performance/ruby/yarv.rb

@@ -1,57 +0,0 @@
-module ActiveSupport
-  module Testing
-    module Performance
-      module Metrics
-        class Base
-          protected
-            # Ruby 1.9 with GC::Profiler
-            if defined?(GC::Profiler)
-              def with_gc_stats
-                GC::Profiler.enable
-                GC.start
-                yield
-              ensure
-                GC::Profiler.disable
-              end
-            end
-        end
-
-        class Memory < DigitalInformationUnit
-          # Ruby 1.9 + GCdata patch
-          if GC.respond_to?(:malloc_allocated_size)
-            def measure
-              GC.malloc_allocated_size
-            end
-          end
-        end
-
-        class Objects < Amount
-          # Ruby 1.9 + GCdata patch
-          if GC.respond_to?(:malloc_allocations)
-            def measure
-              GC.malloc_allocations
-            end
-          end
-        end
-
-        class GcRuns < Amount
-          # Ruby 1.9
-          if GC.respond_to?(:count)
-            def measure
-              GC.count
-            end
-          end
-        end
-
-        class GcTime < Time
-          # Ruby 1.9 with GC::Profiler
-          if defined?(GC::Profiler) && GC::Profiler.respond_to?(:total_time)
-            def measure
-              GC::Profiler.total_time
-            end
-          end
-        end
-      end
-    end
-  end
-end