typo 4.0.3 → 4.1

data/themes/scribbish/views/articles/_comment_form.rhtml

@@ -1,6 +1,6 @@
-<%= form_remote_tag :url      => {:action => 'comment', :id => @article}, 
+<%= form_remote_tag :url      => {:action => 'comment', :id => @article},
                     :update   => 'comments_div',
-                    :loading  => 'commentLoading()', 
+                    :loading  => 'commentLoading()',
                     :complete => 'commentComplete()',
                     :html     => {:id => 'commentform', :class => 'comments' } %>
 
@@ -9,38 +9,41 @@
 <fieldset>
   <legend>Comments</legend>
   <p>
-    <label>Name:<br /> 
+    <label>Name:<br />
       <%= text_field "comment", "author" %>
-      <small>(<%= link_to_function("leave url/email &#187;", "new Effect.toggle('extra_fields', 'blind', {duration: .3})") %>)</small>
+      <small>(<%= link_to_function("leave url/email &#187;", "Effect.toggle('extra_fields', 'blind', {duration: .3})") %>)</small>
     </label>
   </p>
-  
-  <div id="extra_fields" style="display:none;">  
-	  <p>
-	    <label>Email: <%= content_tag('small', "(#{link_to('gravatar', 'http://gravatar.com')} enabled)") if config_value(:use_gravatar) %><br />
-	      <%= text_field "comment", "email" %>
-	    </label>
-	  </p>
-	  <p>
-	    <label>Url:<br />
-	      <%= text_field "comment", "url" %>
-	    </label>
-	  </p>
+
+  <div id="extra_fields" style="display:none;">
+      <p>
+        <label>Email: <%= content_tag('small', "(#{link_to('gravatar', 'http://gravatar.com')} enabled)") if this_blog.use_gravatar %><br />
+          <%= text_field "comment", "email" %>
+        </label>
+      </p>
+      <p>
+        <label>Url:<br />
+          <%= text_field "comment", "url" %>
+        </label>
+      </p>
   </div>
-    
+
   <p>
     <label>
       Comments:
-      <%= content_tag('small', link_to("Textile enabled", "http://hobix.com/textile/")) if config_value(:comment_text_filter).include? 'textile' %>
-      <%= content_tag('small', link_to("Markdown enabled", "http://daringfireball.net/projects/markdown/")) if config_value(:comment_text_filter).include? 'markdown' %>
+      <%= content_tag('small', link_to("Textile enabled", "http://hobix.com/textile/")) if this_blog.comment_text_filter.include? 'textile' %>
+      <%= content_tag('small', link_to("Markdown enabled", "http://daringfireball.net/projects/markdown/")) if this_blog.comment_text_filter.include? 'markdown' %>
       <br />
       <%= text_area 'comment', 'body' %>
     </label>
   </p>
-  
+
   <p>
-    <input type="button" value="Preview" onclick="new Ajax.Updater('preview','<%= url_for :action => 'comment_preview' %>',{asynchronous:true,evalScripts:true,parameters:Form.serialize('commentform'),onComplete:function(request){Element.show('preview')}});return false;" />      
-    <%= submit_tag 'Submit' %>
+    <%= submit_to_remote('preview', 'Preview!',
+                         :update => 'preview',
+                         :complete => "Element.show('preview')",
+                         :url    => { :action => 'comment_preview' }) %>
+    <%= submit_tag 'Submit', :onclick => "$('commentform').onsubmit();this.disabled=true;Element.hide('preview');return false;" %>
     <%= image_tag '/images/theme/spinner.gif', :id => 'spinner', :style => 'display:none' %>
   </p>
 </fieldset>

data/themes/scribbish/views/articles/_search.rhtml

@@ -1,15 +1,16 @@
 <div id="search" class="search">
-	<%= start_form_tag({ :controller => 'articles', :action => 'search' }, { :method => 'get', :id => 'sform' }) %>
-	  <p><input type="text" id="q" name="q" value="" /></p>
-	<%= end_form_tag %>
-	
-	<div id="loading" class="loading" style="display:none;">Searching...</div>
-	<div id="results" class="results"></div>
-  <%= observe_field 'q', 
-                  	:url        => { :controller => 'live', :action => 'search' }, 
-                  	:frequency  => 1, 
-                  	:loading    => "Element.show('loading')",
-                  	:complete   => "Element.hide('loading')",
-                  	:update     => 'results',
-                  	:with       => "'q=' + escape($F('q'))" %>
+    <% form_tag({ :controller => 'articles', :action => 'search' },
+                { :method => 'get', :id => 'sform' }) do -%>
+      <p><input type="text" id="q" name="q" value="" /></p>
+    <% end -%>
+
+    <div id="loading" class="loading" style="display:none;">Searching...</div>
+    <div id="results" class="results"></div>
+  <%= observe_field 'q',
+                    :url        => { :controller => 'live', :action => 'search' },
+                    :frequency  => 1,
+                    :loading    => "Element.show('loading')",
+                    :complete   => "Element.hide('loading')",
+                    :update     => 'results',
+                    :with       => "'q=' + escape($F('q'))" %>
 </div>

data/themes/scribbish/views/articles/comment_preview.rhtml

@@ -1,10 +1,10 @@
 <div class="comment preview">
   <div class="author">
-    <%= content_tag(:div, gravatar_tag(@comment.email)) if config_value(:use_gravatar) and @comment.email %>
+    <%= content_tag(:div, gravatar_tag(@comment.email)) if this_blog.use_gravatar and @comment.email %>
     <cite><%= (@comment.url.blank?) ? h(@comment.author) : link_to(h(@comment.author), @comment.url) %></cite>
     <abbr>is about to say</abbr>
   </div>
   <div class="content">
-    <%= comment_html(@comment) %>
+    <%= @comment.html %>
   </div>
-</div>
+</div>

data/themes/scribbish/views/articles/index.rhtml

@@ -1,5 +1,5 @@
 <%= render :partial => 'article', :collection => @articles %>
 
-<% unless @pages.item_count <= config_value(:limit_article_display) -%>
+<% unless @pages.item_count <= this_blog.limit_article_display -%>
 <p class="pagination">Older posts: <%= pagination_links @pages, :params => { :action => @controller.action_name } %></p>
 <% end -%>

data/themes/scribbish/views/articles/read.rhtml

@@ -5,32 +5,32 @@
   xmlns:dc="http://purl.org/dc/elements/1.1/">
 <rdf:Description
   rdf:about=""
-  trackback:ping="<%= server_url_for :controller=>"/articles", :action=>"trackback", :id=>@article %>"
+  trackback:ping="<%= @article.trackback_url %>"
   dc:title="<%=h @article.title.gsub(/-+/, '-') %>"
-  dc:identifier="<%= server_url_for :controller=>"/articles", :action=>"read", :id=>@article %>"
-  dc:description="<%=h strip_html(article_html(@article)[0..255]).gsub(/-+/, '-') %>"
+  dc:identifier="<%= @article.permalink_url %>"
+  dc:description="<%=h (@article.html.strip_html[0..255]).gsub(/-+/, '-') %>"
   dc:creator="<%= h @article.author %>"
   dc:date="<%= @article.updated_at.xmlschema %>" />
 </rdf:RDF>
 -->
 
-<%= render :partial => 'article' %>
+<%= render :partial => 'article', :object => @article %>
 
 <% if @article.allow_pings? -%>
   <h5><a name="trackbacks">Trackbacks</a></h5>
   <p>
     Use the following link to trackback from your own site:<br />
-    <%= server_url_for :controller => '/articles', :action => 'trackback', :id => @article %>
+    <%= @article.trackback_url %>
   </p>
 
-  <% unless @article.trackbacks.blank? -%>
+  <% unless @article.published_trackbacks.blank? -%>
   <ol id="trackbacks" class="trackbacks">
-    <%= render(:partial => "trackback", :collection => @article.trackbacks) %>
+    <%= render(:partial => "trackback", :collection => @article.published_trackbacks) %>
   </ol>
   <% end -%>
 <% end -%>
 
-<% if @article.allow_comments? or @article.comments.size > 0 -%>
+<% if @article.allow_comments? or @article.published_comments.size > 0 -%>
   <h5><a name="comments">Comments</a></h5>
   <p><a href="#commentform">Leave a response</a></p>
 

data/vendor/cached_model/History.txt

@@ -0,0 +1,30 @@
+= 1.3.1
+
+* Match behavior of ActiveRecord::Base#transaction
+
+= 1.3.0
+
+* Added support for transaction
+* Use ZenTest's assertions
+* Switched to Hoe
+
+= 1.2.1
+
+* Lost to time
+
+= 1.2.0
+
+* Support Rails 1.1.2+
+* Moved work into find_by_sql
+
+= 1.1.0
+
+* Lost to time
+
+= 1.0.1
+
+* Lost to time
+
+= 1.0.0
+
+* Birthday!

data/vendor/cached_model/LICENSE.txt

@@ -0,0 +1,30 @@
+All original code copyright 2005 Bob Cottrell and Eric Hodel, The Robot Co-op.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the names of the authors nor the names of their contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+4. Redistribution in Rails or any sub-projects of Rails is not allowed
+   until Rails runs without warnings with the ``-W2'' flag enabled.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
+OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/vendor/cached_model/Manifest.txt

@@ -0,0 +1,7 @@
+History.txt
+LICENSE.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/cached_model.rb
+test/test_cached_model.rb

data/vendor/cached_model/README.txt

@@ -0,0 +1,96 @@
+= CachedModel
+
+Rubyforge Project:
+
+http://rubyforge.org/projects/rctools/
+
+Documentation:
+
+http://dev.robotcoop.com/Libraries/cached_model/
+
+== About
+
+CachedModel stores Rails ActiveRecord objects in memcache allowing for very
+fast retrievals.  CachedModel uses the ActiveRecord::Locking to ensure that
+you don't perform multiple updates.
+
+== CachedModel Doesn't...
+
+CachedModel is not magic.
+
+CachedModel only accelerates simple finds for single rows.
+
+CachedModel won't cache every query you run.
+
+CachedModel isn't smart enough to determine the dependencies between your
+queries so that it can accelerate more complicated queries.  Without these
+smarts you'll only end up with a broken application.
+
+If you want to cache more complicated queries you need do it by hand.
+
+== Using CachedModel
+
+First, install the cached_model gem:
+
+  $ sudo gem install cached_model
+
+Then set up memcache-client for CachedModel by setting CACHE in your
+config/environment files:
+
+  CACHE = MemCache.new 'localhost:11211', :namespace => 'my_rails_app'
+
+You will need separate namespaces for production and development, if
+you are using memcache on the same machine.
+
+Note that using memcache with tests will cause test failures, so set your
+memcache to be readonly for the test environment.
+
+Then make Rails load the gem:
+
+  $ tail -n 4 config/environment.rb 
+  # Include your application configuration below
+  
+  require 'cached_model'
+
+Then edit your ActiveRecord model to inherit from CachedModel instead of
+ActiveRecord::Base:
+
+  $ head -n 8 app/models/photo.rb
+  ##
+  # A Photo from Flickr.
+  
+  class Photo < CachedModel
+  
+    belongs_to :point
+    belongs_to :route
+
+== Extra Features
+
+=== Local Cache
+
+CachedModel also incorporates an in-process cache, but it is disabled by
+default.  In order to enable the in-process cache enable it in your
+environment.rb:
+
+  CachedModel.use_local_cache = true
+
+And add a after_filter that flushes the local cache:
+
+  class ApplicationController < ActionController::Base
+  
+    after_filter { CachedModel.cache_reset }
+  
+  end
+
+IF YOU DO NOT ADD THE AFTER FILTER YOU WILL EXPERIENCE EXTREME PROCESS GROWTH.
+
+=== Memcache
+
+Memcache may be disabled and the TTL for objects stored in memcache may be
+changed:
+
+  CachedModel.use_memcache = false
+  CachedModel.ttl = 86400
+
+The default TTL for memcache objects is 900 seconds.
+

data/vendor/cached_model/Rakefile

@@ -0,0 +1,25 @@
+# vim: syntax=Ruby
+
+require 'hoe'
+
+DEV_DOC_PATH = 'Libraries/cached_model'
+
+hoe = Hoe.new 'cached_model', '1.3.1' do |p|
+  p.summary = 'An ActiveRecord abstract model that caches records in memcached'
+  p.description = 'CachedModel caches simple (by id) finds in memcached reducing the amount of work the database needs to perform for simple queries.'
+  p.author = ['Eric Hodel', 'Robert Cottrell']
+  p.email = 'eric@robotcoop.com'
+  p.url = "http://dev.robotcoop.com/#{DEV_DOC_PATH}"
+  p.rubyforge_name = 'rctools'
+
+  p.changes = File.read('History.txt').scan(/\A(=.*?)^=/m).first.first
+
+  p.extra_deps << ['memcache-client', '>= 1.1.0']
+  p.extra_deps << ['activerecord', '>= 1.14.4']
+  p.extra_deps << ['ZenTest', '>= 3.4.1']
+end
+
+SPEC = hoe.spec
+
+require '../tasks'
+

data/vendor/cached_model/lib/cached_model.rb

@@ -0,0 +1,287 @@
+$TESTING_CM = defined? $TESTING_CM
+
+require 'timeout'
+require 'memcache_util' unless $TESTING_CM
+
+##
+# An abstract ActiveRecord descendant that caches records in memcache and in
+# local memory.
+#
+# CachedModel can store into both a local in-memory cache and in memcached.
+# By default memcached is enabled and the local cache is disabled.
+#
+# Local cache use can be enabled or disabled with
+# CachedModel::use_local_cache=.  If you do enable the local cache be sure to
+# add a before filter that calls CachedModel::cache_reset for every request.
+#
+# memcached use can be enabled or disabled with CachedModel::use_memcache=.
+#
+# You can adjust the memcached TTL with CachedModel::ttl=
+
+class CachedModel < ActiveRecord::Base
+
+  @cache_delay_commit = {}
+  @cache_local = {}
+  @cache_transaction_level = 0
+  @use_local_cache = false
+  @use_memcache = true
+  @ttl = 60 * 15
+
+  class << self
+
+    # :stopdoc:
+
+    ##
+    # The transaction commit buffer.  You shouldn't touch me.
+
+    attr_accessor :cache_delay_commit
+
+    ##
+    # The local process cache.  You shouldn't touch me.
+
+    attr_reader :cache_local
+
+    ##
+    # The transaction nesting level.  You shouldn't touch me.
+
+    attr_accessor :cache_transaction_level
+
+    # :startdoc:
+
+    ##
+    # Enables or disables use of the local cache.
+    #
+    # NOTE if you enable this you must call #cache_reset or you will
+    # experience uncontrollable process growth!
+    #
+    # Defaults to false.
+
+    attr_writer :use_local_cache
+
+    ##
+    # Enables or disables the use of memcache.
+
+    attr_writer :use_memcache
+
+    ##
+    # Memcache record time-to-live for stored records.
+
+    attr_accessor :ttl
+
+  end
+
+  ##
+  # We only work on 1.1.2 + because Rails broke backwards compatibility
+  # despite a bug http://dev.rubyonrails.org/ticket/3704
+
+  if Rails::VERSION::MAJOR > 1 or
+     (Rails::VERSION::MAJOR == 1 and Rails::VERSION::MINOR > 1) or
+     (Rails::VERSION::MAJOR == 1 and Rails::VERSION::MINOR == 1 and
+      Rails::VERSION::TINY >= 2) then
+
+    ##
+    # Override the flawed assumption ActiveRecord::Base makes about
+    # inheritance.
+
+    self.abstract_class = true
+  else
+    raise NotImplementedError, 'upgrade to Rails 1.1.2+'
+  end
+
+  ##
+  # Invalidate the cache entry for a record.  The update method will
+  # automatically invalidate the cache when updates are made through
+  # ActiveRecord model record.  However, several methods update tables with
+  # direct sql queries for effeciency.  These methods should call this method
+  # to invalidate the cache after making those changes.
+  #
+  # NOTE - if a SQL query updates multiple rows with one query, there is
+  # currently no way to invalidate the affected entries unless the entire
+  # cache is dumped or until the TTL expires, so try not to do this.
+
+  def self.cache_delete(klass, id)
+    key = "#{klass}:#{id}"
+    CachedModel.cache_local.delete key if CachedModel.use_local_cache?
+    Cache.delete "active_record:#{key}" if CachedModel.use_memcache?
+  end
+
+  ##
+  # Invalidate the local process cache.  This should be called from a before
+  # filter at the beginning of each request.
+
+  def self.cache_reset
+    CachedModel.cache_local.clear if CachedModel.use_local_cache?
+  end
+
+  ##
+  # Override the find method to look for values in the cache before going to
+  # the database.
+  #--
+  # TODO Push a bunch of code down into find_by_sql where it really should
+  # belong.
+
+  def self.find(*args)
+    args[0] = args.first.to_i if args.first =~ /\A\d+\Z/
+    # Only handle simple find requests.  If the request was more complicated,
+    # let the base class handle it, but store the retrieved records in the
+    # local cache in case we need them later.
+    if args.length != 1 or not Fixnum === args.first then
+      # Rails requires multiple levels of indirection to look up a record
+      # First call super
+      records = super
+      # Then, if it was a :all, just return
+      return records if args.first == :all
+      return records if RAILS_ENV == 'test'
+      case records
+      when Array then
+        records.each { |r| r.cache_store }
+      end
+      return records
+    end
+
+    return super
+  end
+
+  ##
+  # Find by primary key from the cache.
+
+  def self.find_by_sql(*args)
+    return super unless args.first =~ /^SELECT \* FROM #{table_name} WHERE \(#{table_name}\.#{primary_key} = '?(\d+)'?\) +LIMIT 1/
+
+    id = $1.to_i
+
+    # Try to find the record in the local cache.
+    cache_key_local = "#{name}:#{id}"
+    if CachedModel.use_local_cache? then
+      record = CachedModel.cache_local[cache_key_local]
+      return [record] unless record.nil?
+    end
+
+    # Try to find the record in memcache and add it to the local cache
+    if CachedModel.use_memcache? then
+      record = Cache.get "active_record:#{cache_key_local}"
+      unless record.nil? then
+        if CachedModel.use_local_cache? then
+          CachedModel.cache_local[cache_key_local] = record
+        end
+        return [record]
+      end
+    end
+
+    # Fetch the record from the DB
+    records = super
+    records.first.cache_store unless records.empty? # only one
+    return records
+  end
+
+  ##
+  # Delay updating the cache while in a transaction.
+
+  def self.transaction(*args)
+    level = CachedModel.cache_transaction_level += 1
+    CachedModel.cache_delay_commit[level] = []
+
+    value = super
+
+    waiting = CachedModel.cache_delay_commit.delete level
+    waiting.each do |obj| obj.cache_store end
+
+    return value
+  ensure
+    CachedModel.cache_transaction_level -= 1
+  end
+
+  ##
+  # Returns true if use of the local cache is enabled.
+
+  def self.use_local_cache?
+    return @use_local_cache
+  end
+
+  ##
+  # Returns true if use of memcache is enabled.
+
+  def self.use_memcache?
+    return @use_memcache
+  end
+
+  ##
+  # Delete the entry from the cache now that it isn't in the DB.
+
+  def destroy
+    return super
+  ensure
+    cache_delete
+  end
+
+  ##
+  # Invalidate the cache for this record before reloading from the DB.
+
+  def reload
+    cache_delete
+    return super
+  ensure
+    cache_store
+  end
+
+  ##
+  # Store a new copy of ourselves into the cache.
+
+  def update
+    return super
+  ensure
+    cache_store
+  end
+
+  ##
+  # Remove this record from the cache.
+
+  def cache_delete
+    cache_local.delete cache_key_local if CachedModel.use_local_cache?
+    Cache.delete cache_key_memcache if CachedModel.use_memcache?
+  end
+
+  ##
+  # The local cache key for this record.
+
+  def cache_key_local
+    return "#{self.class}:#{id}"
+  end
+
+  ##
+  # The memcache key for this record.
+
+  def cache_key_memcache
+    return "active_record:#{cache_key_local}"
+  end
+
+  ##
+  # The local object cache.
+
+  def cache_local
+    return CachedModel.cache_local
+  end
+
+  ##
+  # Store this record in the cache without associations.  Storing associations
+  # leads to wasted cache space and hard-to-debug problems.
+
+  def cache_store
+    logger.info "Storing #{self} in the cache"
+    obj = dup
+    obj.send :instance_variable_set, :@attributes, attributes_before_type_cast
+    if CachedModel.cache_delay_commit[CachedModel.cache_transaction_level].nil? then
+      if CachedModel.use_local_cache? then
+        cache_local[cache_key_local] = obj
+      end
+      if CachedModel.use_memcache? then
+        Cache.put cache_key_memcache, obj, CachedModel.ttl
+      end
+    else
+      CachedModel.cache_delay_commit[CachedModel.cache_transaction_level] << obj
+    end
+    nil
+  end
+
+end
+