rails-dev-tweaks 0.3.1

data/MIT-LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2011 Wavii, inc.  http://wavii.com/
+
+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/README.md

@@ -0,0 +1,97 @@
+# rails-dev-tweaks
+A collection of tweaks to improve your Rails (3.1+) development experience.
+
+To install, simply add it to your gemfile:
+
+    gem 'rails-dev-tweaks', '~> 0.3.1'
+
+At the moment, the current tweaks center around speeding up requests by giving granular control over which requests
+cause the Rails autoloader to kick in:
+
+
+# Granular Autoload
+Rails' autoloading facility is a wonderful help for development mode, but sometimes it's a little overkill and ends up
+hampering your rate of iteration while developing a Rails app.  rails-dev-tweaks introduces granular control over which
+kinds of requests are autoloaded.
+
+However, why should you use request-based autoload control instead of smart autoloaders that check file modification
+times, such as [rails-dev-boost](https://github.com/thedarkone/rails-dev-boost)?  The primary worry with smart
+autoloaders is that they have an extremely difficult time tracking all dependencies of a particular constant.  This can
+result in extremely confusing and difficult to debug issues; Theoretically, request-based autoloading should be a bit
+less finicky.
+
+You can specify autoload rules for your app via a configuration block in your application or environment configuration.
+These rules are specified via exclusion (`skip`) and inclusion (`keep`).  Rules defined later override those defined
+before.
+
+    config.dev_tweaks.autoload_rules do
+      # You can used named matchers (see below).  This particular matcher effectively clears any default matchers
+      keep :all
+
+      # Exclude all requests that begin with /search
+      skip '/search'
+      # But include routes that include smerch
+      keep /smerch/
+
+      # Use a block if you want to inspect the request
+      skip {|request| request.post?}
+    end
+
+The default autoload rules should cover most development patterns:
+
+    config.dev_tweaks.autoload_rules do
+      keep :all
+
+      skip '/favicon.ico'
+      skip :assets
+      keep :forced
+    end
+
+## Named Matchers
+Named matchers are classes defined under RailsDevTweaks::GranularAutoload::Matchers:: and simply define a call
+method that is given a ActionDispatch::Request and returns true/false on whether that request matches. Match names
+are converted into a module name via "#{name.to\_s.classify}Matcher".  E.g. :assets will specify the
+RailsDevTweaks::GranularAutoload::Matchers::AssetMatcher.
+
+Any additional arguments given to a `skip` or `keep` call will be passed as initializer arguments to the matcher.
+
+### :all
+Matches every request passed to it.
+
+### :assets
+Rails 3.1 integrated [Sprockets](http://getsprockets.org/) as its asset packager.  Unfortunately, since the asset
+packager is mounted using the traditional Rails dispatching infrastructure, it's hidden behind the Rails autoloader
+(unloader). This matcher will match any requests that are routed to Sprockets (specifically any mounted
+Sprockets::Environment instance).
+
+_The downside_ to this matcher is that your Rails environment won't reload until you make a regular request to the dev
+server (which should be your usual request pattern, anyway).  Assets still reload properly (unless you're referencing
+your application's Ruby code).
+
+### :forced
+To aid in live-debugging when you need to, this matcher will match any request that has `force_autoload` set as a
+parameter (GET or POST), or that has the `Force-Autoload` header set to something.
+
+If you are live-debugging jQuery ajax requests, this helpful snippet will turn on forced autoloading for the remainder
+of the browser's session:
+
+    $.ajaxSetup({"beforeSend": function(xhr) {xhr.setRequestHeader("Force-Autoload", "true")} })
+
+### :path
+Matches the path of the request via a regular expression.
+
+    keep :path, /thing/ # Match any request with "thing" in the path.
+
+Note that `keep '/stuff'` is just shorthand for `keep :path, /^\/stuff/`.  Similarly, `keep /thing/` is shorthand for
+`keep :path, /thing/`
+
+### :xhr
+Matches any XHR request (via request.xhr?).  The assumption here is that you generally don't live-debug your XHR
+requests, and are instead refreshing the page that kicks them off before running against new response code.
+
+
+# License
+rails-dev-tweaks is MIT licensed by Wavii, Inc.  http://wavii.com
+
+See the accompanying file, `MIT-LICENSE`, for the full text.
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+

data/lib/rails-dev-tweaks.rb

@@ -0,0 +1,14 @@
+require 'active_support'
+require 'active_support/dependencies'
+
+module RailsDevTweaks
+  LIB_PATH = File.expand_path('..', __FILE__)
+end
+
+# Ironically, we use autoloading ourselves to enforce our file structure, and less typing.
+ActiveSupport::Dependencies.autoload_paths      << RailsDevTweaks::LIB_PATH
+ActiveSupport::Dependencies.autoload_once_paths << RailsDevTweaks::LIB_PATH # But don't allow *auto-reloading*!
+
+# Reference the railtie to force it to load
+RailsDevTweaks::Railtie
+

data/lib/rails_dev_tweaks/configuration.rb

@@ -0,0 +1,82 @@
+class RailsDevTweaks::Configuration
+
+  attr_reader :granular_autoload_config
+
+  def initialize
+    @granular_autoload_config = GranularAutoloadConfiguration.new
+
+    # And set our defaults
+    self.autoload_rules do
+      keep :all
+
+      skip '/favicon.ico'
+      skip :assets
+      keep :forced
+    end
+  end
+
+  # Takes a block that configures the granular autoloader's rules.
+  def autoload_rules(&block)
+    @granular_autoload_config.instance_eval(&block)
+  end
+
+  class GranularAutoloadConfiguration
+
+    def initialize
+      # Each rule is a simple pair: [:skip, callable], [:keep, callable], etc.
+      @rules = []
+    end
+
+    def keep(*args, &block)
+      self.append_rule(:keep, *args, &block)
+    end
+
+    def skip(*args, &block)
+      self.append_rule(:skip, *args, &block)
+    end
+
+    def append_rule(rule_type, *args, &block)
+      unless rule_type == :skip || rule_type == :keep
+        raise TypeError, "Rule must be :skip or :keep.  Got: #{rule_type.inspect}"
+      end
+
+      # Simple matcher blocks
+      if args.size == 0 && block.present?
+        @rules.unshift [rule_type, block]
+        return self
+      end
+
+      # String match shorthand
+      args[0] = /^#{args[0]}/ if args.size == 1 && args[0].kind_of?(String)
+
+      # Regex match shorthand
+      args = [:path, args[0]] if args.size == 1 && args[0].kind_of?(Regexp)
+
+      if args.size == 0 && block.blank?
+        raise TypeError, 'Cannot process autoload rule as specified.  Expecting a named matcher (symbol), path prefix (string) or block'
+      end
+
+      # Named matcher
+      matcher_class = "RailsDevTweaks::GranularAutoload::Matchers::#{args[0].to_s.classify}Matcher".constantize
+      matcher       = matcher_class.new(*args[1..-1])
+      raise TypeError, "Matchers must respond to :call. #{matcher.inspect} does not." unless matcher.respond_to? :call
+
+      @rules.unshift [rule_type, matcher]
+
+      self
+    end
+
+    def should_reload?(request)
+      @rules.each do |rule_type, callable|
+        return rule_type == :keep if callable.call(request)
+      end
+
+      # We default to reloading to preserve behavior, but we should never get to this unless the configuration is
+      # all sorts of horked.
+      true
+    end
+
+  end
+
+end
+

data/lib/rails_dev_tweaks/granular_autoload/matchers/all_matcher.rb

@@ -0,0 +1,8 @@
+class RailsDevTweaks::GranularAutoload::Matchers::AllMatcher
+
+  def call(request)
+    true
+  end
+
+end
+

data/lib/rails_dev_tweaks/granular_autoload/matchers/asset_matcher.rb

@@ -0,0 +1,29 @@
+class RailsDevTweaks::GranularAutoload::Matchers::AssetMatcher
+
+  def call(request)
+    main_mount = request.headers['action_dispatch.routes'].set.recognize(request)
+
+    # Unwind until we have an actual app
+    while main_mount != nil
+      if main_mount.kind_of? Array
+        main_mount = main_mount.first
+
+      elsif main_mount.kind_of? Rack::Mount::Route
+        main_mount = main_mount.app
+
+      elsif main_mount.kind_of? Rack::Mount::Prefix
+        # Bah, no accessor here
+        main_mount = main_mount.instance_variable_get(:@app)
+
+      # Well, we got something
+      else
+        break
+      end
+    end
+
+    # what do we have?
+    main_mount.kind_of? Sprockets::Environment
+  end
+
+end
+

data/lib/rails_dev_tweaks/granular_autoload/matchers/forced_matcher.rb

@@ -0,0 +1,8 @@
+class RailsDevTweaks::GranularAutoload::Matchers::ForcedMatcher
+
+  def call(request)
+    request.headers['Force-Autoload'] || request.params.has_key?(:force_autoload)
+  end
+
+end
+

data/lib/rails_dev_tweaks/granular_autoload/matchers/path_matcher.rb

@@ -0,0 +1,12 @@
+class RailsDevTweaks::GranularAutoload::Matchers::PathMatcher
+
+  def initialize(regex)
+    @regex = regex
+  end
+
+  def call(request)
+    @regex =~ request.fullpath
+  end
+
+end
+

data/lib/rails_dev_tweaks/granular_autoload/matchers/xhr_matcher.rb

@@ -0,0 +1,8 @@
+class RailsDevTweaks::GranularAutoload::Matchers::XhrMatcher
+
+  def call(request)
+    request.xhr?
+  end
+
+end
+

data/lib/rails_dev_tweaks/granular_autoload/middleware.rb

@@ -0,0 +1,37 @@
+# Here's an idea, let's not reload the entire dev environment for each asset request.  Let's only do that on regular
+# content requests.
+class RailsDevTweaks::GranularAutoload::Middleware
+
+  # Don't cleanup before the very first request
+  class << self
+    attr_writer :processed_a_request
+    def processed_a_request?
+      @processed_a_request
+    end
+  end
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    request = ActionDispatch::Request.new(env.dup)
+
+    # reload, or no?
+    if Rails.application.config.dev_tweaks.granular_autoload_config.should_reload?(request)
+      # Confusingly, we flip the request prepare/cleanup life cycle around so that we're only cleaning up on those
+      # requests that want to be reloaded
+      if self.class.processed_a_request? # No-op if this is the first request.  The initializers take care of that one.
+        ActionDispatch::Reloader.cleanup!
+        ActionDispatch::Reloader.prepare!
+      end
+      self.class.processed_a_request = true
+
+    else
+      Rails.logger.info 'RailsDevTweaks: Skipping ActionDispatch::Reloader hooks for this request.'
+    end
+
+    return @app.call(env)
+  end
+end
+

data/lib/rails_dev_tweaks/railtie.rb

@@ -0,0 +1,14 @@
+class RailsDevTweaks::Railtie < Rails::Railtie
+
+  config.dev_tweaks = RailsDevTweaks::Configuration.new
+
+  config.before_initialize do |app|
+    # We can't inspect the stack because it's deferred...  For now, just assume we have it when config.cache_clasess is
+    # falsy; which should always be the case in the current version of rails anyway.
+    unless app.config.cache_classes
+      app.config.middleware.swap ActionDispatch::Reloader, RailsDevTweaks::GranularAutoload::Middleware
+    end
+  end
+
+end
+

data/lib/rails_dev_tweaks/version.rb

@@ -0,0 +1,4 @@
+module RailsDevTweaks
+  VERSION = '0.3.1'
+end
+

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: rails-dev-tweaks
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+  prerelease: 
+platform: ruby
+authors:
+- Wavii, Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-12 00:00:00.000000000 -07:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &2167156100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0.rc4
+  type: :runtime
+  prerelease: false
+  version_requirements: *2167156100
+description: A collection of tweaks to improve your Rails (3.1+) development experience.
+email:
+- info@wavii.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rails-dev-tweaks.rb
+- lib/rails_dev_tweaks/configuration.rb
+- lib/rails_dev_tweaks/granular_autoload/matchers/all_matcher.rb
+- lib/rails_dev_tweaks/granular_autoload/matchers/asset_matcher.rb
+- lib/rails_dev_tweaks/granular_autoload/matchers/forced_matcher.rb
+- lib/rails_dev_tweaks/granular_autoload/matchers/path_matcher.rb
+- lib/rails_dev_tweaks/granular_autoload/matchers/xhr_matcher.rb
+- lib/rails_dev_tweaks/granular_autoload/middleware.rb
+- lib/rails_dev_tweaks/railtie.rb
+- lib/rails_dev_tweaks/version.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+has_rdoc: true
+homepage: http://wavii.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1289302315746076260
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1289302315746076260
+requirements: []
+rubyforge_project: rails-dev-tweaks
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A collection of tweaks to improve your Rails (3.1+) development experience.
+test_files: []