rails-dev-tweaks-arturo 0.6.2

data/MIT-LICENSE

@@ -0,0 +1,14 @@
+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,134 @@
+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.6.2'
+
+And review the following section to make sure that `rails-dev-tweaks` is
+configured the way you expect:
+
+
+Intended Usage (and Caveats)
+----------------------------
+
+This gem is intended to provide a default configuration that covers most rails
+apps:
+
+* _All_ asset requests _will not_ reload your app's code.  This is probably only
+  a problem if you are using custom sass functions, or otherwise referencing
+  your app from within assets.
+
+* XHR requests **will reload** your app's code.  (This was not the case in prior
+  versions of `rails-dev-tweaks`)
+
+If any of these points don't work out for you, don't fret!  You can override the
+defaults with some simple configuration tweaks to your environment.  Read on:
+
+
+Granular Autoload
+=================
+
+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
+      skip :xhr
+      keep :forced
+    end
+
+By default, every request that skips the autoload hooks will generate an
+additional log line saying so in an effort to be transparent about what is going
+on.  If you prefer, you can disable that log message to keep things a bit more
+tidy in your logs:
+
+    config.dev_tweaks.log_autoload_notice = false
+
+
+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
+`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::Base instance).
+
+
+### :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 @@
+require 'bundler/gem_tasks'

data/lib/rails-dev-tweaks.rb

@@ -0,0 +1,13 @@
+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,87 @@
+class RailsDevTweaks::Configuration
+
+  # By default, we log a notice on each request that has its to_prepare hooks skipped, you can
+  # disable that if you choose!
+  attr_accessor :log_autoload_notice
+
+  attr_reader :granular_autoload_config
+
+  def initialize
+    @log_autoload_notice = true
+
+    @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,7 @@
+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,46 @@
+class RailsDevTweaks::GranularAutoload::Matchers::AssetMatcher
+
+  def call(request)
+    route_engine = request.headers['action_dispatch.routes']
+
+    if route_engine.respond_to?(:router)
+      mounted_app = journey_find_app(route_engine.router, request)
+    else
+      mounted_app = rack_find_app(route_engine.set.dup, request)
+    end
+
+    # What do we have?
+    mounted_app.is_a? Sprockets::Base
+  end
+
+  def journey_find_app(router, request)
+    router.recognize(request) do |route, *args|
+      return route.app
+    end
+  end
+
+  def rack_find_app(router, request)
+    main_mount = router.recognize(request)
+
+    # Unwind until we have an actual app
+    while main_mount != nil
+      if main_mount.is_a? Array
+        main_mount = main_mount.first
+
+      elsif main_mount.is_a? Rack::Mount::Route
+        main_mount = main_mount.app
+
+      elsif main_mount.is_a? Rack::Mount::Prefix
+        # Bah, no accessor here
+        main_mount = main_mount.instance_variable_get(:@app)
+
+      # Well, we got something
+      else
+        break
+      end
+    end
+
+    main_mount
+  end
+
+end

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

@@ -0,0 +1,7 @@
+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,11 @@
+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,7 @@
+class RailsDevTweaks::GranularAutoload::Matchers::XhrMatcher
+
+  def call(request)
+    request.xhr?
+  end
+
+end

data/lib/rails_dev_tweaks/granular_autoload/middleware.rb

@@ -0,0 +1,48 @@
+# 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
+
+      # No-op if this is the first request.  The initializers take care of that one.
+      if self.class.processed_a_request? && reload_dependencies?
+        ActionDispatch::Reloader.cleanup!
+        ActionDispatch::Reloader.prepare!
+      end
+      self.class.processed_a_request = true
+
+    elsif Rails.application.config.dev_tweaks.log_autoload_notice
+      Rails.logger.info 'RailsDevTweaks: Skipping ActionDispatch::Reloader hooks for this request.'
+    end
+
+    return @app.call(env)
+  end
+
+  private
+
+  def reload_dependencies?
+    application = Rails.application
+
+    # Rails 3.2 defines reload_dependencies? and it only reloads if reload_dependencies? returns true.
+      (!application.class.method_defined?(:reload_dependencies?) ||
+        application.send(:reload_dependencies?))
+  end
+end

data/lib/rails_dev_tweaks/railtie.rb

@@ -0,0 +1,13 @@
+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,3 @@
+module RailsDevTweaks
+  VERSION = '0.6.2'
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: rails-dev-tweaks-arturo
+version: !ruby/object:Gem::Version
+  version: 0.6.2
+  prerelease: 
+platform: ruby
+authors:
+- Wavii, Inc.
+- Arturo Pie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+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/version.rb
+- lib/rails_dev_tweaks/railtie.rb
+- lib/rails_dev_tweaks/configuration.rb
+- lib/rails_dev_tweaks/granular_autoload/middleware.rb
+- lib/rails_dev_tweaks/granular_autoload/matchers/all_matcher.rb
+- lib/rails_dev_tweaks/granular_autoload/matchers/xhr_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/asset_matcher.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rails-dev-tweaks
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A collection of tweaks to improve your Rails (3.1+) development experience.
+test_files: []