refinerycms 0.9.6.19 → 0.9.6.21

data/vendor/plugins/refinery_settings/app/models/refinery_setting.rb

@@ -8,12 +8,16 @@ class RefinerySetting < ActiveRecord::Base
     cache_write(object.name, object.value)
   end
 
+  def self.cache_key(name)
+    "refinery_setting_#{name}"
+  end
+
   def self.cache_write(name, value)
-    Rails.cache.write("refinery_setting_#{name}", value)
+    Rails.cache.write(cache_key(name), value)
   end
 
   def self.cache_read(name)
-    Rails.cache.read("refinery_setting_#{name}")
+    Rails.cache.read(cache_key(name))
   end
 
   # Number of settings to show per page when using will_paginate
@@ -75,7 +79,7 @@ class RefinerySetting < ActiveRecord::Base
   def self.[]=(name, value)
     setting = find_or_create_by_name(name.to_s)
     setting.value = value
-    setting.save!
+    setting.save
   end
 
   # Below is not very nice, but seems to be required

data/vendor/plugins/slim_scrooge/README.textile

@@ -0,0 +1,112 @@
+h1. SlimScrooge - serious optimisation for activerecord
+
+h2. What is it?
+
+It's an optimization layer to ensure your application only fetches the database content needed to minimize wire traffic, excessive SQL queries and reduce conversion overheads to native Ruby types.
+
+SlimScrooge implements inline query optimisation, automatically restricting the columns fetched based on what was used during previous passes through the same part of your code.
+
+SlimScrooge is similar to (and is partly derived from) "Scrooge":http://github.com/methodmissing/scrooge but has many fewer lines of code and is faster.
+
+h2. Benchmark
+
+SlimScrooge performs best when the database is not on the same machine as your rails app.  In this case the overhead of fetching unnecessary data from the database can become more important.
+
+I ran a benchmark that consisted of fetching 400 real urls (culled from the log file) from our complex web app.  In this test I found a consistent *12% improvement* in performance over plain active record.  Not earth-shattering, but worthwhile.
+
+Note that this result was for comparing the time taken for running complete requests through rails - of which database accesses are only one part.  So the result is better than it at first sounds.
+
+In future releases I expect further gains.
+
+h2. Installation
+
+Requirements: Rails 2.2 or above, Ruby 1.8.6 or above.
+
+h3. Gem
+
+<pre>
+  # if you haven't already, add gemcutter to your gem sources
+  sudo gem install gemcutter
+  gem tumble
+  # install slim_scrooge
+  sudo gem install slim_scrooge
+</pre>
+
+Note that the C extension will only build in MRI Ruby 1.8 on non-windows at present, but do not worry, for other platforms the backup callsite mechanism is used.
+
+Next add this to your Rails::Initializer section in environment.rb:
+
+<pre>
+  config.gem 'slim_scrooge'
+</pre>
+
+h3. Plugin
+
+<pre>
+script/plugin install git://github.com/sdsykes/slim_scrooge.git
+</pre>
+
+h2. What it does
+
+<pre>
+  # 1st request, sql is unchanged but columns accesses are recorded
+  Brochure Load SlimScrooged 1st time (27.1ms)   SELECT * FROM `brochures` WHERE (expires_at IS NULL)
+  
+  # 2nd request, only fetch columns that were used the first time
+  Brochure Load SlimScrooged (4.5ms)   SELECT `brochures`.expires_at,`brochures`.operator_id,`brochures`.id FROM 
+  `brochures` WHERE (expires_at IS NULL)
+
+  # 2nd request, later in code we need another column which causes a reload of all remaining columns
+  Brochure Reload SlimScrooged (0.6ms) `brochures`.name,`brochures`.comment,`brochures`.image_height,`brochures`.id,
+  `brochures`.tel,`brochures`.long_comment,`brochures`.image_name,`brochures`.image_width FROM 
+  `brochures` WHERE `brochures`.id IN ('5646','5476','4562','3456','4567','7355')
+
+  # 3rd request
+  Brochure Load SlimScrooged (4.5ms)   SELECT `brochures`.expires_at,`brochures`.operator_id,`brochures`.name,
+  `brochures`.id FROM `brochures` WHERE (expires_at IS NULL)
+</pre>
+
+h2. Technical discussion
+
+SlimScrooge hooks in at just one particular place in ActiveRecord - and that place is the find_all_by_sql method.  All select queries pass through this method.
+
+SlimScrooge is able to record each call (and where it came from in your code), and to modify queries that do SELECT * FROM en-route to the database so that they only select the rows that are actually used by that piece of code.
+
+How does SlimScrooge know which columns are actually used?
+
+It tracks them using a monitored hash - the hash is a subclass of Hash that has is instantiated with a proc for its default value.  In this proc we handle any attributes that were not fetched from the DB - fetching the remaining columns as needed.
+
+In fact for efficiency, column accesses are only recorded when they are for newly accessed columns.  Columns we already know about are accessed completely normally, and there is no additional overhead.
+
+h2. Caveats
+
+* It is possible to delete an object and then to try to use its attributes to access another object that perhaps must be also deleted (like the option :dependent=>:destroy in Rails associations).
+
+This situation is likely to be found rarely because SlimScrooge particularly checks for columns used by :dependent=>:destroy, but if you are doing something similar manually in your code then you may run into problems.  Your attempt to access the key of the dependent object could cause a reload if the column is not already noted by SlimScrooge, and the reload will fail if you have already destroyed the parent object.
+
+* Some users have complained that running their test suite is slower when SlimScrooge is enabled.  This is expected - it's doing a little more work for each query, and most queries in tests are only executed once.
+
+If it proves to be a problem, you can try this in environment.rb:
+
+<pre>
+  config.gem 'slim_scrooge' unless Rails.env.test?
+</pre>
+
+I do recommend you test with SlimScrooge enabled at some point though, to make sure that everything is working as expected.
+
+h2. Tests
+
+SlimScrooge performs the full activerecord test suite without errors, except for a couple of tests that check the number of queries performed.
+
+To run the tests you need to set your database up with appropriate access for the rails user, and make activerecord_unittest and activerecord_unittest2 databases.  Then run:
+
+<pre>
+  rake test_with_active_record
+</pre>
+
+h2. References
+* "Scrooge":http://github.com/methodmissing/scrooge
+
+h2. Authors
+* Stephen Sykes (sdsykes)
+* Special thanks to Lourens Naudé (methodmissing) for the original idea, and the C implementation of callsite_hash as well as some other bits of code that I borrowed from the original project.

data/vendor/plugins/slim_scrooge/Rakefile

@@ -0,0 +1,29 @@
+require 'rake'
+require 'rake/testtask'
+require 'test/helper'
+
+Rake::TestTask.new(:test_with_active_record) do |t|
+  t.libs << SlimScrooge::ActiveRecordTest::AR_TEST_SUITE
+  t.libs << SlimScrooge::ActiveRecordTest.connection
+  t.test_files = SlimScrooge::ActiveRecordTest.test_files
+  t.ruby_opts = ["-r #{File.join(File.dirname(__FILE__), 'test', 'active_record_setup')}"]
+  t.verbose = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "slim_scrooge"
+    s.summary = "Slim_scrooge - serious optimisation for ActiveRecord"
+    s.email = "sdsykes@gmail.com"
+    s.homepage = "http://github.com/sdsykes/slim_scrooge"
+    s.description = "Slim scrooge boosts speed in Rails ActiveRecord Models by only querying the database for what is needed."
+    s.authors = ["Stephen Sykes"]
+    s.files = FileList["[A-Z]*", "{ext,lib,test}/**/*"]
+    s.extensions = "ext/Rakefile"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://
+gems.github.com"
+end

data/vendor/plugins/slim_scrooge/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:patch: 5
+:major: 1
+:build: 
+:minor: 0

data/vendor/plugins/slim_scrooge/ext/Rakefile

@@ -0,0 +1,42 @@
+task :default=>[:build]
+
+task :build do
+  # only try to install extension on non windows / MRI 1.8
+  unless /mswin/ =~ RUBY_PLATFORM || RUBY_VERSION >= "1.9" || defined?(RUBY_ENGINE) && RUBY_ENGINE != "ruby"
+    require 'rbconfig'
+
+    ruby = File.join(Config::CONFIG["bindir"],
+    Config::CONFIG["RUBY_INSTALL_NAME"])
+    ruby << Config::CONFIG["EXEEXT"]
+
+    # escape string in case path to ruby executable contain spaces.
+    ruby.sub!(/.*\s.*/m, '"\&"')
+
+    results = `#{ruby} extconf.rb`
+
+    unless File.exist? 'Makefile'
+      raise "Makefile not found:\n\n#{results.join "\n"}" 
+    end
+
+    dest_path = ENV["RUBYARCHDIR"] || File.join(File.dirname(__FILE__), "..", "lib")
+
+    mf = File.read('Makefile')
+    mf = mf.gsub(/^RUBYARCHDIR\s*=\s*\$[^$]*/, "RUBYARCHDIR = #{dest_path}")
+    mf = mf.gsub(/^RUBYLIBDIR\s*=\s*\$[^$]*/, "RUBYLIBDIR = #{dest_path}")
+
+    File.open('Makefile', 'wb') {|f| f.print mf}
+
+    make_program = ENV['make']
+    unless make_program
+      make_program = (/mswin/ =~ RUBY_PLATFORM) ? 'nmake' : 'make'
+    end
+
+    ['', ' install'].each do |target|
+      cmd = "#{make_program}#{target}"
+      results << cmd + "\n"
+      results << `#{cmd}`
+
+      raise "make#{target} failed:\n\n#{results}" unless $?.success?
+    end
+  end
+end

data/vendor/plugins/slim_scrooge/ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+dir_config('callsite_hash')
+
+create_makefile('callsite_hash')

data/vendor/plugins/slim_scrooge/lib/slim_scrooge.rb

@@ -0,0 +1,16 @@
+# Author: Stephen Sykes
+begin
+  unless File.exists?(File.join(File.dirname(__FILE__), "../", "ext", "Makefile"))
+    Dir.chdir(File.join(File.dirname(__FILE__), "../", "ext"))
+    `rake`
+  end
+rescue Exception
+end
+
+begin; require 'callsite_hash'; rescue LoadError; end
+require 'slim_scrooge/simple_set'
+require 'slim_scrooge/callsites'
+require 'slim_scrooge/callsite'
+require 'slim_scrooge/result_set'
+require 'slim_scrooge/monitored_hash'
+require 'slim_scrooge/slim_scrooge'

data/vendor/plugins/slim_scrooge/lib/slim_scrooge/callsite.rb

@@ -0,0 +1,96 @@
+# Author: Stephen Sykes
+
+module SlimScrooge
+  # A Callsite contains the list of columns that are accessed when an SQL
+  # query is made from a particular place in the app
+  #
+  class Callsite
+    ScroogeComma = ",".freeze
+    ScroogeRegexJoin = /(?:LEFT|INNER|OUTER|CROSS)*\s*(?:STRAIGHT_JOIN|JOIN)/i
+
+    attr_accessor :seen_columns
+    attr_reader :columns_hash, :primary_key, :model_class_name
+
+    class << self
+      # Make a callsite if the query is of the right type for us to optimise
+      #
+      def make_callsite(model_class, original_sql)
+        if use_scrooge?(model_class, original_sql)
+          new(model_class)
+        else
+          nil
+        end
+      end
+
+      # Check if query can be optimised
+      #
+      def use_scrooge?(model_class, original_sql)
+        original_sql =~ select_regexp(model_class.table_name) &&
+        model_class.columns_hash.has_key?(model_class.primary_key) &&
+        original_sql !~ ScroogeRegexJoin
+      end
+
+      # The regexp that enables us to replace the * from SELECT * with
+      # the list of columns we actually need
+      #
+      def select_regexp(table_name)
+        %r{SELECT (`?(?:#{table_name})?`?.?\\*) FROM}
+      end
+    end
+
+    def initialize(model_class)
+      @all_columns = SimpleSet.new(model_class.column_names)
+      @model_class_name = model_class.to_s
+      @quoted_table_name = model_class.quoted_table_name
+      @primary_key = model_class.primary_key
+      @quoted_primary_key = model_class.connection.quote_column_name(@primary_key)
+      @columns_hash = model_class.columns_hash
+      @select_regexp = self.class.select_regexp(model_class.table_name)
+      @seen_columns = SimpleSet.new(essential_columns(model_class))
+    end
+
+    # List of columns that should always be fetched no matter what
+    #
+    def essential_columns(model_class)
+      model_class.reflect_on_all_associations.inject([@primary_key]) do |arr, assoc|
+        if assoc.options[:dependent] && assoc.macro == :belongs_to
+          arr << assoc.association_foreign_key
+        end
+        arr
+      end
+    end
+
+    # Returns suitable sql given a list of columns and the original query
+    #
+    def scrooged_sql(seen_columns, sql)
+      sql.gsub(@select_regexp, "SELECT #{scrooge_select_sql(seen_columns)} FROM")
+    end
+
+    # List if columns what were not fetched
+    #
+    def missing_columns(fetched_columns)
+      (@all_columns - SimpleSet.new(fetched_columns)) << @primary_key
+    end
+
+    # Returns sql for fetching the unfetched columns for all the rows
+    # in the result set, specified by primary_keys
+    #
+    def reload_sql(primary_keys, fetched_columns)
+      sql_keys = primary_keys.collect{|pk| "'#{pk}'"}.join(ScroogeComma)
+      cols = scrooge_select_sql(missing_columns(fetched_columns))
+      "SELECT #{cols} FROM #{@quoted_table_name} WHERE #{@quoted_primary_key} IN (#{sql_keys})"
+    end
+
+    def connection
+      @model_class_name.constantize.connection
+    end
+
+    # Change a set of columns into a correctly quoted comma separated list
+    #
+    def scrooge_select_sql(set)
+      set.collect do |name|
+        "#{@quoted_table_name}.#{connection.quote_column_name(name)}"
+      end.join(ScroogeComma)
+    end
+  end
+end

data/vendor/plugins/slim_scrooge/lib/slim_scrooge/callsites.rb

@@ -0,0 +1,70 @@
+# Author: Stephen Sykes
+
+module SlimScrooge
+  # Contains the complete list of callsites
+  #
+  class Callsites
+    CallsitesMutex = Mutex.new
+    @@callsites = {}
+    ScroogeCallsiteSample = 1..16
+
+    class << self
+      # Whether we have encountered a callsite before
+      #
+      def has_key?(callsite_key)
+        @@callsites.has_key?(callsite_key)
+      end
+
+      # Return the callsite for this key
+      #
+      def [](callsite_key)
+        @@callsites[callsite_key]
+      end
+
+      # Fallback if you can't compile extension for some reason
+      #
+      begin
+        callsite_hash
+      rescue NameError
+        def callsite_hash
+          caller[ScroogeCallsiteSample].hash
+        end
+      end
+
+      # Generate a key string - uses the portion of the query before the WHERE
+      # together with the callsite_hash generated by callsite_hash.c
+      #
+      def callsite_key(sql)
+        callsite_hash + sql.gsub(/\sWHERE.*/i, "").hash
+      end
+
+      # Create a new callsite
+      #
+      def create(sql, callsite_key, name)
+        begin
+          model_class = name.split.first.constantize
+        rescue NameError, NoMethodError
+          add_callsite(callsite_key, nil)
+        else
+          add_callsite(callsite_key, Callsite.make_callsite(model_class, sql))
+        end
+      end
+
+      # Add a new callsite, wrap in a mutex for safety
+      #
+      def add_callsite(callsite_key, callsite)
+        CallsitesMutex.synchronize do
+          @@callsites[callsite_key] = callsite
+        end
+      end
+
+      # Record that a column was accessed, wrap in a mutex for safety
+      #
+      def add_seen_column(callsite, seen_column)
+        CallsitesMutex.synchronize do
+          callsite.seen_columns << seen_column
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/slim_scrooge/lib/slim_scrooge/monitored_hash.rb

@@ -0,0 +1,103 @@
+# Author: Stephen Sykes
+
+module SlimScrooge
+  # A MonitoredHash allows us to return only some columns into the @attributes
+  # of an ActiveRecord model object, but to notice when an attribute that
+  # wasn't fetched is accessed.
+  #
+  # Also, when a result is first fetched for a particular callsite, we monitor
+  # all the columns so that we can immediately learn which columns are needed.
+  #
+  class MonitoredHash < Hash
+    attr_accessor :callsite, :result_set, :monitored_columns
+
+    # Create a monitored hash.  The unmonitored_columns are accessed like a regular
+    # hash.  The monitored columns kept separately, and new_column_access is called
+    # before they are returned.
+    #
+    def self.[](monitored_columns, unmonitored_columns, callsite)
+      hash = MonitoredHash.new {|hash, key| hash.new_column_access(key)}
+      hash.monitored_columns = monitored_columns
+      hash.merge!(unmonitored_columns)
+      hash.callsite = callsite
+      hash
+    end
+
+    # Called when an unknown column is requested, through the default proc.
+    # If the column requested is valid, and the result set is not completely
+    # loaded, then we reload.  Otherwise just note the column with add_seen_column.
+    #
+    def new_column_access(name)
+      if @callsite.columns_hash.has_key?(name)
+        @result_set.reload! if @result_set && name != @callsite.primary_key
+        Callsites.add_seen_column(@callsite, name)
+      end
+      @monitored_columns[name]
+    end
+
+    # Reload if needed before allowing assignment
+    #
+    def []=(name, value)
+      if has_key?(name)
+        return super
+      elsif @result_set && @callsite.columns_hash.has_key?(name)
+        @result_set.reload!
+        Callsites.add_seen_column(@callsite, name)
+      end
+      @monitored_columns[name] = value
+    end
+
+    # Returns the column names
+    #
+    def keys
+      @result_set ? @callsite.columns_hash.keys : super | @monitored_columns.keys
+    end
+
+    # Check for a column name
+    #
+    def has_key?(name)
+      @result_set ? @callsite.columns_hash.has_key?(name) : super || @monitored_columns.has_key?(name)
+    end
+
+    alias_method :include?, :has_key?
+
+    # Called by Hash#update when reload is called on an ActiveRecord object
+    #
+    def to_hash
+      @result_set.reload! if @result_set
+      @monitored_columns.merge(self)
+    end
+
+    def freeze
+      @result_set.reload! if @result_set
+      @monitored_columns.freeze
+      super
+    end
+
+    # Marshal
+    # Dump a real hash - can't dump a monitored hash due to default proc
+    #
+    def _dump(depth)
+      Marshal.dump(to_hash)
+    end
+
+    def self._load(str)
+      Marshal.load(str)
+    end
+  end
+end
+
+# We need to change the update method of Hash so that it *always* calls
+# to_hash.  This is because it normally checks if other_hash is a kind of
+# Hash, and doesn't bother calling to_hash if so.  But we need it to call
+# to_hash, because otherwise update will not get the complete columns
+# from a MonitoredHash
+#
+# This is not harmful - to_hash in a regular Hash just returns self.
+#
+class Hash
+  alias_method :c_update, :update
+  def update(other_hash, &block)
+    c_update(other_hash.to_hash, &block)
+  end
+end