rails-async 0.1.0 → 0.1.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+### 0.1.1
+
+* use threads instead of forks
+* require library users to include an `after\_filter` in their application controller
+* fix id bug that occurs when multiple `asynchronously do` blocks are created on the same page.

data/README.md

@@ -1,20 +1,34 @@
-This is Alpha, naive, itch scratching bozo code. 
+A Rails engine that provides a view helper that will speed your page loads. See
+the bottom of the README for the example use, that will probably make more sense
+than me explaining it here.
 
-Good luck.
+This is Alpha, naive, itch scratching bozo code.
 
-## Install
+Don't reinvent the wheel. Always reinvent the wheel.
 
-Get the gem:
+Ponder this, good luck.
 
-    gem install rails-async
+## Install
 
-Or add it to your gemfile:
+Add it to your gemfile:
 
     gem "rails-async", :require => "async"
 
 ## Setup
 
+Add the following to your `app/controllers/application\_controller.rb`:
+
+    class ApplicationController < ActionController::Base
+      helper :async
+      after_filter do
+        Thread.new { AsyncCache.instance.build }
+      end
+
+      # ...
+    end
 
+That's it. If you don't want it available on every request, add it to the
+specific controllers where you intend to use it.
 
 ## Use
 
@@ -44,4 +58,14 @@ Fast page:
       <% end %>
     </ul>
 
-##
+Async worries about responding, you worry about why your code is so slow.
+
+## Unanswered Questions
+
+**Speed**: at what point is an approach like this worse than just rendering the
+whole page at once? Gotta measure to know if you're improved anything.
+
+**Practicality of testing**: what's the mimimum viable test rig?
+
+**Praticality in general**: who's gonna use it? When would this be more useful
+than manual ajax / async page splitting?

data/Rakefile

@@ -1,46 +1,29 @@
+ENV['BUNDLE_GEMFILE'] = File.dirname(__FILE__) + '/test/rails_root/Gemfile'
+
 require 'rubygems'
 require 'rake'
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "rails-async"
-    gem.summary = %Q{Simple async blocks.}
-    gem.description = %Q{Don't wait for your pages to render.}
-    gem.email = "adam.bachman@gmail.com"
-    gem.homepage = "http://github.com/abachman/rails-async"
-    gem.authors = ["Adam Bachman"]
-    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
 require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
+namespace :test do
+  Rake::TestTask.new(:basic => ["generator:cleanup", 
+                                "generator:async"]) do |test|
+    test.libs << 'lib' 
     test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
+    test.pattern = 'test/test_*.rb'
     test.verbose = true
   end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
 end
 
-task :test => :check_dependencies
+namespace :generator do 
+  task :cleanup do
+  end
+
+  task :async do
+    system "cd test/rails_root && bundle install"
+  end
+end
 
-task :default => :test
+task :default => 'test:basic'
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
@@ -50,4 +33,5 @@ Rake::RDocTask.new do |rdoc|
   rdoc.title = "rails-async #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('app/**/*.rb')
 end

data/app/controllers/async_controller.rb

@@ -1,7 +1,6 @@
-puts "CONTROLLER"
 class AsyncController < ApplicationController
   def show
-    @as_cache = AsyncCache.read(params[:tag])
+    @as_cache = AsyncCache.instance.read(params[:tag])
     render :json => {:content => @as_cache}
   end
 end

data/app/helpers/async_helper.rb

@@ -1,7 +1,7 @@
-puts "HELPER"
 module AsyncHelper
   def asynchronously
     id = Time.new.to_i
+    id = "#{ id }#{ AsyncCache.instance.counter }"
 
     # insert javascript callback
     safe_concat %{
@@ -19,21 +19,13 @@ module AsyncHelper
         }); 
       </script>
     }
-
-    connection = ActiveRecord::Base.remove_connection
-    child = Process.fork do 
-      begin
-        ActiveRecord::Base.establish_connection((connection || {}).merge({:allow_concurrency => true})) if defined?(ActiveRecord)
-        # anything rendered within capture will be stored in _content
-        _content = capture do
-          yield
-        end
-        AsyncCache.write(id, _content)
-      ensure
-        ActiveRecord::Base.remove_connection
-      end 
+    
+    AsyncCache.instance.schedule do
+      # anything rendered within capture will be stored in _content
+      _content = capture do
+        yield
+      end
+      AsyncCache.instance.write(id, _content)
     end
-  ensure
-    ActiveRecord::Base.establish_connection((connection || {}).merge({:allow_concurrency => true}))
   end
 end

data/app/models/async_cache.rb

@@ -1,19 +1,45 @@
-puts "MODEL"
 class AsyncCache
-  def self.read(tag)
+  include Singleton
+
+  def initialize
+    @@counter = 0
+    @@chunks = []
+  end
+
+  def schedule(&block)
+    @@counter += 1
+    @@chunks << block
+  end
+
+  def counter
+    @@counter
+  end
+
+  def build
+    @@chunks.each {|chunk| chunk.call }
+  end
+
+  # since the async controller read request happens immediately on pages
+  # that use the `asynchronously do` block, the AsyncCache#read method 
+  # has to block until the file it's looking for exists.
+  def read(tag)
     @content = nil
-    status = Timeout.timeout(5) do 
-      until File.exists?(path(tag))
-        sleep 0.2
+    begin
+      status = Timeout.timeout(10) do 
+        until File.exists?(path(tag))
+          sleep 0.2
+        end
+        @content = File.read(path(tag))
       end
-      @content = File.read(path(tag))
+    rescue Timeout::Error
+      Rails.logger.error("\e[31mTimeout Error in AsyncCache\e[0m")
+      @content = ""
     end
-    Rails.logger.debug("Returned from timeout with status #{ status.inspect }")
 
     @content
   end
 
-  def self.write(tag, content)
+  def write(tag, content)
     if !File.exists?(parent)
       setup
     end
@@ -24,15 +50,15 @@ class AsyncCache
   end
 
 private 
-  def self.setup
+  def setup
     FileUtils.mkdir_p parent
   end
 
-  def self.parent
+  def parent
     File.join(Rails.root, "tmp", "async")
   end
 
-  def self.path tag
+  def path tag
     File.join(parent, tag.to_s)
   end
 end

data/init.rb

@@ -0,0 +1 @@
+require 'async'

data/lib/async/engine.rb

@@ -5,6 +5,5 @@ require 'async'
 
 module Async
   class Engine < Rails::Engine
-    engine_name :async
   end
 end

data/lib/async/version.rb

@@ -0,0 +1,3 @@
+module Async
+  VERSION = "0.1.1"
+end

data/rails-async.gemspec

@@ -1,60 +1,101 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
 # -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+ 
+require 'async/version'
 
 Gem::Specification.new do |s|
-  s.name = %q{rails-async}
-  s.version = "0.1.0"
+  s.name                      = %q{rails-async}
+  s.version                   = Async::VERSION
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Adam Bachman"]
-  s.date = %q{2010-09-19}
-  s.description = %q{Don't wait for your pages to render.}
-  s.email = %q{adam.bachman@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.md",
-     "README.rdoc"
-  ]
+  s.authors                   = ["Adam Bachman"]
+  s.date                      = %q{2010-11-04}
+  s.summary                   = %q{Simple asynchronously loaded blocks in your Rails 3 views.}
+  s.description               = %q{The Rails Async engine lets your controllers respond instantly.}
+  s.email                     = %q{adam.bachman@gmail.com}
+  s.homepage                  = %q{http://github.com/abachman/rails-async}
+  s.require_paths             = ["lib"]
+  s.rubygems_version          = %q{1.3.7}
+
+  s.files                     = Dir.glob("{bin,lib,app}/**/*") + %w(LICENSE README.md ROADMAP.md CHANGELOG.md)
   s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "app/controllers/async_controller.rb",
-     "app/helpers/async_helper.rb",
-     "app/models/async_cache.rb",
-     "config/routes.rb",
-     "lib/async.rb",
-     "lib/async/engine.rb",
-     "rails-async.gemspec",
-     "test/helper.rb",
-     "test/test_async-rails.rb"
-  ]
-  s.homepage = %q{http://github.com/abachman/rails-async}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Simple async blocks.}
-  s.test_files = [
-    "test/helper.rb",
-     "test/test_async-rails.rb"
+    'CHANGELOG.md',
+    'init.rb',
+    'LICENSE',
+    'README.md',
+    'ROADMAP.md',
+    'Rakefile',
+    'app/controllers/async_controller.rb',
+    'app/helpers/async_helper.rb',
+    'app/models/async_cache.rb',
+    'config/routes.rb',
+    'lib/async/engine.rb',
+    'lib/async/version.rb',
+    'lib/async.rb',
+    'rails-async.gemspec'
   ]
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  # require 'find'
+  # Find.find('test/rails_root') do |f|
+  #   if (/\.bundle/ !~ f &&
+  #       /tmp/ !~ f &&
+  #       /log/ !~ f &&
+  #       /seeds\.rb/ !~ f &&
+  #       /\.sqlite/ !~ f &&
+  #       /\.git/ !~ f &&
+  #       !File.directory?(f))
+  #     puts "    '#{f}',"
+  #   end
+  # end
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    else
-      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-  end
+  s.test_files = [
+    'test/helper.rb',
+    'test/test_async_cache.rb',
+    'test/rails_root/Gemfile',
+    'test/rails_root/README',
+    'test/rails_root/Rakefile',
+    'test/rails_root/app/controllers/application_controller.rb',
+    'test/rails_root/app/controllers/start_controller.rb',
+    'test/rails_root/app/helpers/application_helper.rb',
+    'test/rails_root/app/helpers/start_helper.rb',
+    'test/rails_root/app/views/layouts/application.html.erb',
+    'test/rails_root/app/views/start/_account.html.erb',
+    'test/rails_root/app/views/start/fast.html.erb',
+    'test/rails_root/app/views/start/fast_multi.html.erb',
+    'test/rails_root/app/views/start/index.html.erb',
+    'test/rails_root/app/views/start/slow.html.erb',
+    'test/rails_root/config.ru',
+    'test/rails_root/config/application.rb',
+    'test/rails_root/config/boot.rb',
+    'test/rails_root/config/database.yml',
+    'test/rails_root/config/environment.rb',
+    'test/rails_root/config/environments/development.rb',
+    'test/rails_root/config/environments/production.rb',
+    'test/rails_root/config/environments/test.rb',
+    'test/rails_root/config/initializers/backtrace_silencers.rb',
+    'test/rails_root/config/initializers/inflections.rb',
+    'test/rails_root/config/initializers/mime_types.rb',
+    'test/rails_root/config/initializers/secret_token.rb',
+    'test/rails_root/config/initializers/session_store.rb',
+    'test/rails_root/config/locales/en.yml',
+    'test/rails_root/config/routes.rb',
+    'test/rails_root/db/schema.rb',
+    'test/rails_root/doc/README_FOR_APP',
+    'test/rails_root/public/404.html',
+    'test/rails_root/public/422.html',
+    'test/rails_root/public/500.html',
+    'test/rails_root/public/favicon.ico',
+    'test/rails_root/public/images/rails.png',
+    'test/rails_root/public/images/spinner.gif',
+    'test/rails_root/public/javascripts/jquery.js',
+    'test/rails_root/public/javascripts/rails.js',
+    'test/rails_root/public/robots.txt',
+    'test/rails_root/script/rails',
+    'test/rails_root/test/functional/start_controller_test.rb',
+    'test/rails_root/test/performance/browsing_test.rb',
+    'test/rails_root/test/test_helper.rb',
+    'test/rails_root/test/unit/helpers/start_helper_test.rb',
+  ]
 end
 

data/test/helper.rb

@@ -1,10 +1,13 @@
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) +
+                         "/rails_root/config/environment")
+require 'rails/test_help'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'async-rails'
-
-class Test::Unit::TestCase
+require 'minitest/spec'
+begin
+  require 'redgreen'
+rescue LoadError
 end
+
+$: << File.expand_path(File.dirname(__FILE__) + '/..')
+require 'async'

data/test/rails_root/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+gem 'rails', '3.0.0'
+gem 'rails-async', :require => 'async', :path => '/home/adam/projects/rails-async'
+gem 'sqlite3-ruby', :require => 'sqlite3'
+gem 'minitest'
+gem 'redgreen'
+