tension 0.3 → 0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 067f889277f3fb790d4fb64e6b196754f2ca9b92
+  data.tar.gz: ac1afed7e475d2e99cc72c330d224c1611951f13
+SHA512:
+  metadata.gz: 2124f18b0a5c85ac50891d6ac74d6fa3f528afbc08dbee97177b66553ef357e8a05c8a1ad5b57f2154cd1eb0585be6ce33529c7da8660ad9c8b742d8bd9393d7
+  data.tar.gz: 107bb478074ab4b6c502217b29a5b21db0a44ebb22cdd422887c9261788db40e5178a6a8ee7111390a65a63bc983a3a5e3282f53a10959ce98ad71155ed69ce0

data/README.md

@@ -3,4 +3,40 @@ Tension
 _Tighten up Rails's asset pipeline for CSS & JS._
 
 Rails's asset pipeline is smart and well–implemented under the hood, but it can
-be a challenge to organize your CSS and JavaScript so that 
+be a challenge to organize your CSS and JavaScript so that you don't have to
+struggle to maintain which files get compiled, where they live, and how they're
+included in views and templates.
+
+_Tension_ helps you out. It takes Rails's existing controller/view file structure
+and applies it to JavaScript and CSS assets as well. Let's take a sample Rails app:
+
+    app
+    + assets
+    + controllers
+      + account
+      + api
+      + blog
+        + posts_controller.rb
+    + models
+    + views
+      + account
+      + api
+      + blog
+        + posts
+          + index.html.erb
+      + layouts
+        + blog.html.erb
+
+The standard structure Rails enforces is __module__ → __controller__ →
+__action__. For the PostsController, the __action__ logic is tucked away alongside
+other actions in `posts_controller.rb`, but its view is a separate file namespaced
+under the _blog_ module and _posts_ controller.
+
+This is a logical, intuitive structure. Our assets should follow it too.
+
+Using Rails's asset pipeline you can drop an asset anywhere within the `assets`
+directory and Rails will compile and serve it, but Rails enforces no logical
+structure on your files. This leads to messy, hard-to-maintain code, and it gets
+worse when you precompile assets in production.
+
+...

data/lib/tension/environment.rb

@@ -0,0 +1,167 @@
+module Tension
+
+  # Tension::Environment exposes `asset_paths`, which describes the assets that
+  # can be automatically included in templates.
+  #
+  # It's used automatically on application load (see Tension::Railtie) to populate
+  # the asset pipeline's list of assets to precompile, and caches the result in-
+  # process for use by Tension::Tagger when templates are rendered.
+  #
+  class Environment
+
+    class << self
+
+      GLOBAL_KEY    = "::globals".freeze
+      COMMON_SUFFIX = "_common".freeze
+      ASSET_TYPES   = [{ container: "javascripts", extension: "js" },
+                       { container: "stylesheets", extension: "css" }].freeze
+
+      # This method collects all asset paths for the asset pipeline to
+      # precompile. It determines which additional assets to include in the
+      # pipeline's precompilation process, so they can be automatically added
+      # to templates later (see Tension::Tagger).
+      #
+      # If an application's routes include `resources :people`, `asset_map`
+      # will attempt to locate the following assets:
+      #
+      #   + people_common.{js,css}
+      #   + people/index.{js,css}
+      #   + people/show.{js,css}
+      #   + people/new.{js,css}
+      #   + people/edit.{js,css}
+      #
+      # Note that Tension ignores Sprockets' interpretation of `index.{js,css}`
+      # as a shared file, and therefore requires the `_common` suffix for
+      # controller-wide assets.
+      #
+      # Returns: an Hash of controller paths, each containing that controller's
+      # routed GET actions mapped to each action's best matching asset. E.g.
+      #
+      #   { "people" => {
+      #       "index" => {
+      #         "js" => "javascripts/people/index.js",
+      #         "css" => "javascripts/people_common.css"
+      #       },
+      #       "show" => {
+      #         "js" => "javascripts/application.js",
+      #         "css" => "javascripts/people_common.css"
+      #       }
+      #   }
+      #
+      def asset_map
+        if @asset_map.nil?
+          @asset_map = Hash.new
+          globals    = Hash.new
+
+          ASSET_TYPES.each do |type|
+            # Find and store the global asset for this type.
+            global_asset = valid_asset( "application.#{ type[:extension] }" )
+            globals.store( type[:extension], global_asset )
+          end
+
+          # TODO: add support for looking up the tree...
+          search_paths.each_pair do |controller_path, actions|
+            next unless local_controller?( controller_path )
+
+            @asset_map.store( controller_path, Hash.new )
+
+            ASSET_TYPES.each do |type|
+              # Attempt to locate a common asset for this controller.
+              common_path = "#{ controller_path }#{ COMMON_SUFFIX }.#{ type[:extension] }"
+              common_asset = valid_asset( common_path ) || globals.fetch( type[:extension] )
+
+              actions.each do |action|
+                if @asset_map[ controller_path ][ action ].nil?
+                  @asset_map.fetch( controller_path )
+                            .store( action, Hash.new )
+                end
+
+                action_asset = valid_asset( "#{ [ controller_path, action ].join("/") }.#{ type[:extension] }" )
+                @asset_map.fetch( controller_path )
+                          .fetch( action )
+                          .store( type[:extension], action_asset || common_asset )
+              end
+            end
+
+          end
+        end
+
+        @asset_map
+      end
+
+      # All unique, existing asset paths.
+      def asset_paths
+        @asset_paths ||= Set.new.merge( extract_paths(asset_map) ).to_a
+      end
+
+
+      private
+
+      # Recursively extracts all paths from the `asset_map`.
+      def extract_paths hash
+        paths = Array.new
+
+        hash.each_pair do |key, value|
+          if value.is_a?(Hash)
+            paths.concat( extract_paths(value) )
+          else
+            paths << value.pathname.to_s
+          end
+        end
+
+        paths
+      end
+
+      # A hash of controller paths mapped to action names. These controller/action
+      # pairs correspond to configured routes for which assets may be required.
+      #
+      #   e.g. { "blog"       => [ "index", "show" ],
+      #          "admin/blog" => [ "index", "show", "edit" ] }
+      #
+      def search_paths
+        @search_paths ||= configured_route_defaults.reduce( Hash.new ) do |accum, route_default|
+          accum[ route_default[:controller] ] ||= Array.new
+          accum[ route_default[:controller] ].push( route_default[:action] )
+
+          accum
+        end
+      end
+
+      # Routing defaults (including controller path and action name) for all
+      # configured GET routes.
+      #
+      def configured_route_defaults
+        if @configured_route_defaults.nil?
+          get_routes = Rails.application.routes.routes.find_all do |route|
+            route.verb.match("GET")
+          end
+
+          @configured_route_defaults = get_routes.map do |route|
+            route.defaults unless route.defaults.empty?
+          end
+
+          @configured_route_defaults.compact!
+        end
+
+        @configured_route_defaults
+      end
+
+      # Returns: a real BundledAsset present in the Sprockets index, or nil
+      # if no asset was found.
+      #
+      def valid_asset asset_path
+        Rails.application.assets.find_asset( asset_path )
+      end
+
+      # Returns: true if the controller targeted in the routes is present in this
+      # app's local code rather than in a gem. Gems are responsible for ensuring
+      # availability of their own assets.
+      #
+      def local_controller? controller_path
+        File.exists?("#{ Rails.root }/app/controllers/#{ controller_path }_controller.rb")
+      end
+
+    end
+
+  end
+end

data/lib/tension/railtie.rb

@@ -4,14 +4,19 @@ module Tension
   require "rails"
 
   class Railtie < Rails::Railtie
+    initializer "tension.add_assets_to_precompile_list" do |app|
+      ActiveSupport.on_load :after_initialize do
 
-    initializer "tension.asset_pipeline" do |app|
-      ActiveSupport.on_load :rails do
-        if !Rails.env.development? && !Rails.env.test?
-          Rails.application.config.assets.precompile += Tension::Collector.collect_assets
+        Rails.application.reload_routes!
+        Tension.load_assets!
+
+        ApplicationHelper.send(:include, Tension::TensionHelper)
+
+        Rails.application.config.assets.precompile << lambda do |path, filename|
+          Tension::Environment.asset_paths.include?( filename )
         end
+
       end
     end
-
   end
 end

data/lib/tension/tension_helper.rb

@@ -0,0 +1,26 @@
+module Tension
+
+  # Tagger is included in ActionView::Helpers so it can be called from
+  # templates and layouts.
+  module TensionHelper
+    extend ActiveSupport::Concern
+
+    # Just call 
+    def asset_for type, request = request
+      asset = Tension::Environment.asset_map
+                                  .fetch( request.params[:controller] )
+                                  .fetch( request.params[:action] )
+                                  .fetch( type.to_s )
+
+      include_method = case type
+      when :js
+        :javascript_include_tag
+      when :css
+        :stylesheet_link_tag
+      end
+
+      send( include_method, asset.logical_path )
+    end
+  end
+
+end

data/lib/tension.rb

@@ -0,0 +1,21 @@
+require 'active_support/ordered_options'
+
+require 'tension/environment'
+require 'tension/railtie' if defined?(Rails)
+require 'tension/tension_helper'
+
+module Tension
+  def self.load_assets!
+    !!Tension::Environment.asset_map
+  end
+
+  # def self.config
+  #   @config ||= begin
+  #     config = ActiveSupport::OrderedOptions.new
+
+  #     config.enabled = !Rails.env.development? && !Rails.env.test?
+
+  #     config
+  #   end
+  # end
+end

data/tension.gemspec

@@ -1,11 +1,12 @@
 Gem::Specification.new do |s|
   s.name = "tension"
 
-  s.version = "0.3"
-  s.date    = "2013-02-22"
+  s.version = "0.9"
+  s.date    = "2013-03-21"
+  s.license = "MIT"
 
   s.summary     = "Tighten up Rails's asset pipeline for CSS & JS."
-  s.description = "Tension brings some sanity to CSS & JS organization for modern front–end development."
+  s.description = "Tension brings some sanity to Rails's CSS & JS organization for modern front–end development."
 
   s.authors  = [ "Piers Mainwaring" ]
   s.email    = "piers@impossibly.org"
@@ -13,6 +14,5 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/piersadrian/tension"
   s.require_paths = [ "lib" ]
 
-  s.add_dependency "activerecord",  "~> 3.2.0"
-  s.add_dependency "activesupport", "~> 3.2.0"
+  s.add_dependency "rails", ">= 3.2"
 end

metadata

@@ -1,50 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: tension
 version: !ruby/object:Gem::Version
-  version: '0.3'
-  prerelease: 
+  version: '0.9'
 platform: ruby
 authors:
 - Piers Mainwaring
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-22 00:00:00.000000000 Z
+date: 2013-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
-  prerelease: false
+  name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 3.2.0
-    none: false
+        version: '3.2'
   type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-    none: false
-- !ruby/object:Gem::Dependency
-  name: activesupport
   prerelease: false
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.2.0
-    none: false
-  type: :runtime
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 3.2.0
-    none: false
-description: Tension brings some sanity to CSS & JS organization for modern front–end
-  development.
+        version: '3.2'
+description: Tension brings some sanity to Rails's CSS & JS organization for modern
+  front–end development.
 email: piers@impossibly.org
 executables: []
 extensions: []
@@ -53,32 +34,32 @@ files:
 - LICENSE
 - README.md
 - lib/tension.rb
-- lib/tension/application.rb
+- lib/tension/environment.rb
 - lib/tension/railtie.rb
-- lib/tension/tagger.rb
+- lib/tension/tension_helper.rb
 - tension.gemspec
 homepage: https://github.com/piersadrian/tension
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-  none: false
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Tighten up Rails's asset pipeline for CSS & JS.
 test_files: []

data/lib/tension/application.rb

@@ -1,62 +0,0 @@
-module Tension
-  class Application
-
-    class << self
-
-      # This method collects all asset paths for the asset pipeline to
-      # precompile. It's called from `config/application.rb` when determining
-      # which additional assets to include in the pipeline's precompilation
-      # process. Tension will assume that any subdirectories in your assets
-      # directory are module scopes. You can also explicitly set module scopes:
-      #
-      #   Rails.application.config.tension_modules = %W( blog account )
-      #
-      # Tension::Application will then search for all javascripts and stylesheets
-      # one filesystem level deep in those scopes. The search paths become:
-      #
-      #   app/assets/{javascripts,stylesheets}/*.{js,css}
-      #   app/assets/{javascripts,stylesheets}/{blog,account}/**/*.{js,css}
-      # 
-      # Any assets in these paths will be added to the pipeline and compiled.
-
-      def collect_assets
-        assets = %W(stylesheets javascripts).map do |type|
-          glob_within_asset_path( type ) + module_scopes.map do |scope|
-            glob_within_asset_path( type, scope )
-          end
-        end
-
-        assets.flatten
-      end
-
-
-      private
-
-      def module_scopes
-        # find dirs in app/assets
-      end
-
-      # Loads the file paths within a given subdirectory of "app/assets/".
-      def glob_within_asset_path type, *path_parts
-        # Only recursively find children if a particular subdirectory of an
-        # asset `type` is given. That way we can specify WHICH subdirectories
-        # of a `type` have assets that matter.
-        path_parts << "**" if path_parts.present?
-
-        root_path = File.join(Rails.root, "app", "assets", type)
-        pattern   = File.expand_path( File.join(*path_parts, "*.*"), root_path )
-
-        paths = Dir.glob( pattern ).map do |file_path|
-          # Remove extra, pre-compilation file extensions and any part of the
-          # filepath at or above the asset `type`.
-          file_path.gsub( file_path.match(/(\.css|\.js)(.*)/)[2], '' )
-                   .gsub( root_path + "/", '' ) rescue nil
-        end
-
-        paths.compact
-      end
-
-    end
-
-  end
-end

data/lib/tension/tagger.rb

@@ -1,82 +0,0 @@
-module Pipeline
-  class Builder
-
-    GLOBAL_ASSET_NAME = "application".freeze
-    SHARED_SUFFIX     = "_common".freeze
-    ASSET_SPECIFICITY_ORDER = [ :action, :controller, :module ].freeze
-
-    # Determines which JS/CSS files should be included based on the current
-    # controller, action, and which files actually exist. If the current
-    # controller is "OrcaHealth::PagesController" and action is "products",
-    # this method (called with `type = :js`) will attempt to include
-    #
-    #   + orca_health/pages/products.js
-    #   + orca_health/pages_common.js
-    #   + orca_health.js
-    #
-    # in that order. ONLY THE FIRST ASSET LOCATED WILL BE INCLUDED. Hence,
-    # you should always use Sprockets directives to include dependencies.
-    #
-    # Any files that don't exist will not be included in the page. Pass
-    # `{ except: :application }` to exclude `application.{js,css}`.
-
-    def self.asset_paths type, controller_path, action_name, options = {}
-      options[:except] = [ options[:except] ] unless options[:except].is_a? Array
-
-      # Check if the best asset's already been loaded and stored.
-      asset = known_asset_paths[ controller_path ].try(:fetch, action_name, nil).try(:fetch, type, nil)
-
-      if asset.nil?
-        path_components = controller_path.split("/")
-        controller_name = path_components.pop
-        module_path     = path_components.join("/")
-
-        possible_paths = {
-          module:     module_path,
-          controller: [ module_path, controller_name + SHARED_SUFFIX ].join("/"),
-          action:     [ module_path, controller_name, action_name ].join("/")
-        }
-
-        # Find and store the best possible asset for this controller/action combo.
-        asset = most_specific_asset_path( type, possible_paths )
-
-        known_asset_paths[ controller_path ] ||= Hash.new
-        known_asset_paths[ controller_path ][ action_name ] ||= Hash.new
-        known_asset_paths[ controller_path ][ action_name ][ type ] = asset
-      end
-
-      assets = if options[:except].include? :application
-        [ asset ]
-      else
-        [ GLOBAL_ASSET_NAME, asset ]
-      end
-
-      assets.compact
-    end
-
-
-    private
-
-    def self.known_asset_paths
-      @known_asset_paths ||= Hash.new
-    end
-
-    def self.most_specific_asset_path filetype, paths
-      ASSET_SPECIFICITY_ORDER.each do |name|
-        path = paths[name]
-
-        # Using the Sprockets `#index` helps performance in production.
-        asset = if Rails.env.production?
-          Rails.application.assets.index.find_asset([ path, filetype ].join("."))
-        else
-          Rails.application.assets.find_asset([ path, filetype ].join("."))
-        end
-
-        # This loop is relatively expensive, so return the asset path as soon
-        # as possible rather than continue looping.
-        break path if asset.present?
-      end
-    end
-
-  end
-end