tension 0.9.3 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 69774653d546060ae567082eed766dec21e960e1
-  data.tar.gz: b2010ae61c8cac4764b644747df83ec5424f2c4f
+  metadata.gz: 76c048b5004ade369c07e87cf54a73b3459f7151
+  data.tar.gz: e2494f1c0198761e2464ec130b2107ba05aa1ae4
 SHA512:
-  metadata.gz: 54f20566dabb047d69083bad4f754cccffd35daddecfdf5ac6f0b7447d85063e2a65ec60dbb0851dfc1049035ba6b08468c9c913a57b021a3cf38af104d51de0
-  data.tar.gz: 815605457bed700c1edaa25abba43fc10abd2415d653ede03515557b3cf0d553726315ba784fa3ea6e81f9018b8e8338b7d336da2947b90441eabe71ce016373
+  metadata.gz: 599a97dd6849f6a070d7d2cb1ac3a6c7da3e959a4046b9c6558995663fd6afe5a2d6d98138cd2aef8e89ce529ffec28c1ccf8bae42aa35e9da93d9bbd8ad4861
+  data.tar.gz: 4902abbd406722db8bd6c680630ce1285bbc6f7613dd20aeba5e12e01f4349c0fab1083394ce8839a2c4b4c0d8e422550b7c37635a702383035ea86b9954effd

data/lib/tension/asset_group.rb

@@ -0,0 +1,82 @@
+module Tension
+  class AssetGroup
+
+    class << self
+      # Builds a valid routing Path.
+      def path_for(key, action = nil)
+        if key.match( path_regex )
+          return key
+
+        elsif key.include?("#")
+          key, action = key.split("#") 
+        end
+
+        unless key.try(:match, controller_regex) && action.try(:match, action_regex)
+          raise ArgumentError, "[Tension] Couldn't build valid controller path!"
+        end
+
+        "#{ key }##{ action }"
+      end
+
+      # Matches strings like "blog/comments#show".
+      def path_regex
+        /([\w\/]+[^#])#(\w+)/
+      end
+
+      # Matches strings like "blog/comments".
+      def controller_regex
+        /([\w\/]+[^#])/
+      end
+
+      # Matches strings like "show".
+      def action_regex
+        /(\w+)/
+      end
+      
+      def global_asset(type)
+        assets[ "application.#{type}" ]
+      end
+
+      def assets
+        Rails.application.assets
+      end
+    end
+
+
+    attr_reader :controller, :action
+
+    def initialize(key, action = nil)
+      @controller, @action = self.class.path_for( key, action ).split("#")
+    end
+
+    def css
+      best_asset( Tension::CSS )
+    end
+
+    def js
+      best_asset( Tension::JS )
+    end
+
+    def action_asset(type)
+      self.class.assets[ "#{controller}/#{action}.#{type}" ]
+    end
+
+    def controller_asset(type)
+      self.class.assets[ "#{controller}_common.#{type}" ]
+    end
+
+    private
+
+    def best_asset(type)
+      action_asset(type) || controller_asset(type) || self.class.global_asset(type)
+    end
+
+    def method_missing(method_sym, *args)
+      degree, type = method_sym.to_s.split("_")
+      asset_method = "#{degree}_asset"
+
+      respond_to?(asset_method) ? send(asset_method, type) : super
+    end
+
+  end
+end

data/lib/tension/controller.rb

@@ -0,0 +1,18 @@
+require 'active_support/concern'
+
+module Tension
+  module Controller
+    extend ActiveSupport::Concern
+
+    def action_assets
+      controller = request.symbolized_path_parameters[:controller]
+      action     = request.symbolized_path_parameters[:action]
+
+      Tension::Environment.find( controller, action )
+    end
+
+    def assets
+      Tension::Environment
+    end
+  end
+end

data/lib/tension/environment.rb

@@ -1,6 +1,6 @@
 module Tension
 
-  # Tension::Environment exposes `asset_paths`, which describes the assets that
+  # Tension::Environment exposes `assets`, which describes the assets that
   # can be automatically included in templates.
   #
   # It's used automatically on application load (see Tension::Railtie) to populate
@@ -11,144 +11,47 @@ module Tension
 
     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
-        @asset_map = nil if Rails.env.development?
-
-        @asset_map ||= begin
-          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|
-            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|
-                unless map[ controller_path ].has_key?( action )
-                  map.fetch( controller_path ).store( action, Hash.new )
-                end
-
-                action_asset = valid_asset( "#{ [ controller_path, action ].join("/") }.#{ type[:extension] }" )
-                map.fetch( controller_path )
-                   .fetch( action )
-                   .store( type[:extension], action_asset || common_asset )
-              end
-            end
-
-          end
+      def [](key, action = nil)
+        fetch( AssetGroup.path_for(key, action) )
+      end
+      alias_method :find, :[]
 
-          map
+      def eager_load!
+        configured_get_defaults.each do |default|
+          find( default[:controller], default[:action] )
         end
       end
 
-      # All unique, existing asset paths.
-      def asset_paths
-        @asset_paths ||= Set.new.merge( extract_paths(asset_map) ).to_a
+      def assets
+        @assets ||= Hash.new
       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
+      def fetch(path)
+        assets[path] || store(path)
       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
+      def store(path)
+        assets[path] = AssetGroup.new( path )
       end
 
       # Routing defaults (including controller path and action name) for all
       # configured GET routes.
       #
-      def configured_route_defaults
-        @configured_route_defaults ||= begin
+      def configured_get_defaults
+        @configured_get_defaults ||= begin
           get_routes = Rails.application.routes.routes.find_all do |route|
             route.verb.match("GET")
           end
 
-          @configured_route_defaults = get_routes.map do |route|
+          @configured_get_defaults = get_routes.map do |route|
             route.defaults unless route.defaults.empty?
           end
 
-          @configured_route_defaults.compact!
+          @configured_get_defaults.compact!
         end
       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
     end
 
   end

data/lib/tension/helper.rb

@@ -0,0 +1,37 @@
+require 'active_support/concern'
+
+module Tension
+
+  # Helper is included in ActionView::Helpers so it can be called from
+  # templates and layouts.
+  module Helper
+    extend ActiveSupport::Concern
+
+    def best_stylesheet(*args)
+      asset_for( Tension::CSS, *args )
+    end
+
+    def best_javascript(*args)
+      asset_for( Tension::JS, *args )
+    end
+
+    private
+
+    def asset_for(type, *args)
+      controller = request.params[:controller]
+      action     = request.params[:action]
+
+      asset = Tension::Environment.find( controller, action ).send( type )
+
+      include_method = case type.to_s
+      when "js"
+        :javascript_include_tag
+      when "css"
+        :stylesheet_link_tag
+      end
+
+      send( include_method, asset.logical_path, *args )
+    end
+  end
+
+end

data/lib/tension/railtie.rb

@@ -7,12 +7,15 @@ module Tension
     initializer "tension.add_assets_to_precompile_list" do |app|
       ActiveSupport.on_load :after_initialize do
 
-        Rails.application.reload_routes!
-        Tension.load_assets! unless Rails.env.development? or Rails.env.test?
+        if app.config.cache_classes
+          app.reload_routes!
+          Tension::Environment.eager_load!
+        end
 
-        ActionView::Base.send(:include, Tension::TensionHelper)
+        ActionView::Base.send(:include, Tension::Helper)
+        ActionController::Base.send(:include, Tension::Controller)
 
-        Rails.application.config.assets.precompile << lambda do |path, filename|
+        app.config.assets.precompile << lambda do |path, filename|
           Tension::Environment.asset_paths.include?( filename )
         end
 

data/lib/tension/version.rb

@@ -1,3 +1,3 @@
 module Tension
-  VERSION = "0.9.3".freeze
+  VERSION = "0.9.5".freeze
 end

data/lib/tension.rb

@@ -1,9 +1,10 @@
+require 'tension/asset_group'
+require 'tension/controller'
+require 'tension/helper'
 require 'tension/environment'
 require 'tension/railtie' if defined?(Rails)
-require 'tension/tension_helper'
 
 module Tension
-  def self.load_assets!
-    !!Tension::Environment.asset_map
-  end
+  CSS = "css".freeze
+  JS  = "js".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tension
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.5
 platform: ruby
 authors:
 - Piers Mainwaring
@@ -34,9 +34,11 @@ files:
 - LICENSE
 - README.md
 - lib/tension.rb
+- lib/tension/asset_group.rb
+- lib/tension/controller.rb
 - lib/tension/environment.rb
+- lib/tension/helper.rb
 - lib/tension/railtie.rb
-- lib/tension/tension_helper.rb
 - lib/tension/version.rb
 - tension.gemspec
 homepage: https://github.com/piersadrian/tension

data/lib/tension/tension_helper.rb

@@ -1,27 +0,0 @@
-require 'active_support/concern'
-
-module Tension
-
-  # Tagger is included in ActionView::Helpers so it can be called from
-  # templates and layouts.
-  module TensionHelper
-    extend ActiveSupport::Concern
-
-    def asset_for type, *args
-      controller = request.params[:controller]
-      action     = request.params[:action]
-
-      asset = Tension::Environment.asset_map[ controller ][ action ][ type.to_s ]
-
-      include_method = case type
-      when :js
-        :javascript_include_tag
-      when :css
-        :stylesheet_link_tag
-      end
-
-      send( include_method, asset.logical_path, *args ) unless asset.nil?
-    end
-  end
-
-end