view_assets 0.0.12 → 1.0.0

data/Rakefile

@@ -36,7 +36,7 @@ task :default => :test
 
 task :lines do
   lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
-  
+
   FileList["#{ ENV['PWD'] }/**/*.rb"].each do |file_name|
     next if file_name =~ /vendor/
     File.open(file_name, 'r') do |f|

data/lib/tasks/basic.rb

@@ -0,0 +1,78 @@
+# desc "Explaining what the task does"
+# task :view_assets do
+#   # Task goes here
+# end
+
+namespace :va do
+  desc "Init view_assets framework(create app, lib and vendor folders in /public folder)"
+  task :init do
+    require 'term/ansicolor'
+    include Term::ANSIColor
+
+    public_path = Rails.public_path
+
+    puts "init asset folders in /public: "
+    %w(vendor lib app).map { |d| %w(javascripts stylesheets).map { |t| "#{public_path}/#{d}/#{t}" } }.flatten.each do |dir|
+      FileUtils.mkdir_p dir
+      puts "\t#{green(bold("Create"))} #{dir.gsub(public_path, '')}"
+      if dir.include?('app')
+        fn_extension = dir.include?('javascripts') ? 'js' : 'css'
+        FileUtils.touch "#{dir}/application.#{fn_extension}"
+        puts "\t#{green(bold("Create"))}[0m #{dir.gsub(public_path, '')}/application.#{fn_extension}"
+      end
+    end
+  end
+
+  desc "Compress assets for deployment(Must be executed before running rails app on production mode)"
+  task :compress do
+    require 'view_assets/packager/core'
+    require 'term/ansicolor'
+    include Term::ANSIColor
+
+    puts green(bold("packaging js assets"))
+    ViewAssets::Packager::JsPackager.new.package
+
+    puts green(bold("packaging css assets"))
+    ViewAssets::Packager::CssPackager.new.package
+  end
+
+  desc "Check assets to know whether it is eligible"
+  task :validate, [:controller, :action] do |t, args|
+    args.with_defaults(:controller => '', :action => '')
+
+    require 'view_assets/packager/core'
+    require 'term/ansicolor'
+    include Term::ANSIColor
+
+    if args.controller.empty? || args.action.empty?
+      puts red(bold("Please specify controller and action correctly: rake va:validate[:controller,:action]"))
+    end
+
+    controller = args.controller
+    action = args.action
+
+    puts green(bold("Packaging Js Assets"))
+    js_manifest = ViewAssets::Packager::JsPackager.new.package({ controller => action.split('/') }, { :verbal =>  true, :compress => false, :manifest => false })
+
+    puts green(bold("Packaging Css Assets"))
+    css_manifest = ViewAssets::Packager::CssPackager.new.package({ controller => action.split('/') }, { :verbal =>  true, :compress => false, :manifest => false })
+
+    puts "-------"
+
+    unless js_manifest.empty?
+      # puts green(bold("Validing Js Assets"))
+      js_manifest.each_value do |asset|
+        puts "#{green("Checking:")} #{asset}"
+        `java -jar #{File.expand_path("../yuicompressor-2.4.4.jar", File.dirname(__FILE__))} #{Rails.public_path}#{asset}`
+      end
+    end
+
+    unless css_manifest.empty?
+      # puts green(bold("Validing Css Assets"))
+      css_manifest.each_value do |asset|
+        puts "#{green("Checking:")} #{asset}"
+        `java -jar #{File.expand_path("../yuicompressor-2.4.4.jar", File.dirname(__FILE__))} #{Rails.public_path}#{asset}`
+      end
+    end
+  end
+end

data/lib/view_assets/action_view.rb

@@ -0,0 +1,37 @@
+module ViewAssets
+  module ActionViewHelpers
+    require 'view_assets'
+    require 'view_assets/finder/core'
+    require 'yaml'
+
+    def retrieve_assets(controller, action)
+      assets = []
+      if Rails.env.production?
+        css_path     = "/assets/#{ViewAssets::CSS_PATH}"
+        js_path      = "/assets/#{ViewAssets::JS_PATH}"
+        css_manifest = YAML.load(File.open("#{Rails.public_path}#{css_path}/manifest.yml").read)
+        js_manifest  = YAML.load(File.open("#{Rails.public_path}#{js_path}/manifest.yml").read)
+
+        case
+        when css_location = css_manifest["#{css_path}/#{controller}_#{action}.#{ViewAssets::CSS_EXT}"]
+        when css_location = css_manifest["#{css_path}/#{controller}.#{ViewAssets::CSS_EXT}"]
+        when css_location = css_manifest["#{css_path}/application.#{ViewAssets::CSS_EXT}"]
+        end
+
+        case
+        when js_location = js_manifest["#{js_path}/#{controller}_#{action}.#{ViewAssets::JS_EXT}"]
+        when js_location = js_manifest["#{js_path}/#{controller}.#{ViewAssets::JS_EXT}"]
+        when js_location = js_manifest["#{js_path}/application.#{ViewAssets::JS_EXT}"]
+        end
+
+        assets.push ViewAssets.tag(:css, css_location)
+        assets.push ViewAssets.tag(:js, js_location)
+      else
+        assets.concat ViewAssets::Finder::CssFinder.new.retrieve(controller, action, :tagged => true)
+        assets.concat ViewAssets::Finder::JsFinder.new.retrieve(controller, action, :tagged => true)
+      end
+
+      assets.map { |asset| raw(asset) }
+    end
+  end
+end

data/lib/view_assets/error.rb

@@ -1,6 +1,6 @@
 module ViewAssets
-  class ConfigurationError < StandardError; end
-  # class UnimplementedError < StandardError; end
-  class UnknownDirectiveError < StandardError; end
-  class FileNotFound < StandardError; end
-end
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class UnknownDirectiveError < Error; end
+  class FileNotFound < Error; end
+end

data/lib/view_assets/finder/core.rb

@@ -0,0 +1,8 @@
+module ViewAssets
+  module Finder
+    require 'view_assets/finder/directive'    
+    require 'view_assets/finder/finder'
+    require 'view_assets/finder/js_finder'
+    require 'view_assets/finder/css_finder'
+  end
+end

data/lib/view_assets/finder/css_finder.rb

@@ -0,0 +1,21 @@
+module ViewAssets
+  module Finder
+    class CssFinder < Finder
+      def assets_path
+        CSS_PATH
+      end
+
+      def asset_extension
+        CSS_EXT
+      end
+
+      def asset_type
+        CSS_TYPE
+      end
+
+      def tag(href)
+        ViewAssets.tag(:css, href)
+      end
+    end
+  end
+end

data/lib/view_assets/finder/directive.rb

@@ -0,0 +1,116 @@
+module ViewAssets
+  module Finder
+    class Directive
+      attr_reader :asset_type
+      def initialize(asset_type)
+        # TODO find out asset_types that can run in both directive.rb and asset_finders
+        # raise ConfigurationError.new('asset type should be "js" or "css"') unless %w(css js).include?(asset_type)
+        if [JS_TYPE, CSS_TYPE].include?(asset_type)
+          @asset_type = asset_type
+        else
+          raise ConfigurationError.new("asset type should be '#{JS_TYPE}' or '#{CSS_TYPE}'") 
+        end
+      end
+    
+      # TODO realize this method
+      # remember to take different syntax into consideration
+      def ending_directive?(primitive_params)
+        # primitive_params.match
+      end
+    
+      # TODO add docs
+      def legal_directive?(primitive_params)
+        [vendor_directive, lib_directive, app_directive].any? { |d| d =~ primitive_params }
+      end
+    
+      # return root folder and all the path params that have been split
+      # TODO this method bellow need refactor
+      def parse(primitive_params)
+        asset_root = ''
+        path_param_str = ''
+        path_params = []
+        unknown_directive = false
+      
+        # TODO make sure path_param_str will return nil for non-matched result and array for matched result
+        # rememer to write tests for this section of codes
+        if vendor_directive =~ primitive_params
+          asset_root = 'vendor'
+          path_param_str = primitive_params.match(vendor_directive)[:path_params]
+        elsif lib_directive =~ primitive_params
+          asset_root = 'lib'
+          path_param_str = primitive_params.match(lib_directive)[:path_params]
+        elsif app_directive =~ primitive_params
+          asset_root = 'app'
+          path_param_str = primitive_params.match(app_directive)[:path_params]
+        else
+          # TODO remove UnknownDirectiveError or try to find another way to get thing done
+          # raise UnknownDirectiveError.new "'#{primitive_params}' is not in legal directive format"
+          unknown_directive = true
+        end
+      
+        # TODO refactor codes bellow after the above paragraph was refactored
+        would_be_path_params = path_param_str.strip.split(/,\s?/)
+        # would_be_path_params = [would_be_path_params] if would_be_path_params.kind_of?(String)
+        path_params = would_be_path_params unless would_be_path_params.empty?
+      
+        # unknown_directive ? [nil, nil] : [asset_root, path_params.strip.split(/,\s?/)]
+        # todo add rspec examples for returning a ['', []] when the primitive_params is illegal
+        [asset_root, path_params]
+      end
+    
+      # def all_directives
+      #   /#{tree_directive}|#{file_directive}/
+      # end
+    
+      def vendor_directive
+        @vendor_directive ||= generate_formula 'require_vendor'
+      end
+    
+      def lib_directive
+        @lib_directive ||= generate_formula 'require_lib'
+      end
+
+      def app_directive
+        @app_directive ||= generate_formula
+      end
+    
+      private
+    
+      ##
+      # for javascript
+      #   double-slash syntax => "//= require_vendor xxx"
+      #   space-asterisk syntax => " *= require_vendor xxx"
+      #   slash-asterisk syntax => "/*= require_vendor xxx */"
+      # 
+      # for stylesheets
+      #   space-asterisk syntax => " *= require_vendor xxx"
+      #   slash-asterisk syntax => "/*= require_vendor xxx */"
+      # 
+      # TODO refactor: use reasonable and effective regular expression
+      # TODO use "require_app" as app asset directive and make "require" as a relative directive
+      # TODO BUG => rspec examples is unqualified on slash-asterisk syntax for css
+      #             can't detect mistakes like this: `^/\*=\s#{requiring_type}\s(?<path_params>.*)*\s\*/$`
+      def generate_formula(requiring_type = 'require')
+        if javascript?(asset_type)
+          %r{
+              ^//=\s#{requiring_type}\s(?<path_params>.*)$  # double-slash syntax
+            |
+              ^\s\*=\s#{requiring_type}\s(?<path_params>.*)$  # space-asterisk syntax
+            |
+              ^/\*=\s#{requiring_type}\s(?<path_params>.*)\s\*/$  # slash-asterisk syntax
+          }x
+        else
+          %r{
+              ^\s\*=\s#{requiring_type}\s(?<path_params>.*)$  # space-asterisk syntax
+            |
+              ^/\*=\s#{requiring_type}\s(?<path_params>.*)\s\*/$  # slash-asterisk syntax
+          }x
+        end
+      end
+      
+      def javascript? type
+        %w(js javascript javascripts).include? type
+      end
+    end
+  end
+end

data/lib/view_assets/finder/finder.rb

@@ -0,0 +1,220 @@
+##
+# Manifest file is a file that contains some dependency directives on top
+# of it. Finder will parse these directives if existed and include them
+# in the html.
+# Usually, the first manifest file will be application.[js|css] in
+# /app/assets/[javascripts|stylesheets] folder. However, if there is a
+# :controller.[js|css] file existed in /app/assets/:controller folder,
+# then it will replace application as the first manifest file.
+# It will append assets dependency before every action assets.
+# If both application and :controller manifest file are not existed,
+# then the manifest file list will be empty at first.
+module ViewAssets
+  module Finder
+    class Finder
+      attr_reader :assets, :parsed_manifests, :controller, :action
+      def initialize
+        empty
+      end
+
+      def empty
+        @controller       = ''
+        @action           = ''
+        @assets           = []
+        @parsed_manifests = []
+      end
+
+      ##
+      # This method is the ENTRY of assets finder after its initializtion.
+      # It returns all asset paths wrapped inside a appropriated html
+      # options
+      #     :controller => nil
+      #     :action => nil
+      #     :full => false
+      #     :tagged => false
+      # TODO: need to retrive action-less assets
+      def retrieve(controller = '', action = '', options = {})
+        # raise ":controller and :action can't be nil" if @controller.nil?
+
+        options[:full]   ||= false
+        options[:tagged] ||= false
+
+        @assets           = []
+        @parsed_manifests = []
+        @controller       = controller
+        @action           = action
+
+        retrieve_controller_assets
+        retrieve_action_assets if @action != ''
+        @assets.uniq!
+
+        @assets.map! { |asset| PathInfo.new(asset).abs } if options[:full]
+        @assets.map! { |asset| tag("/#{asset.rel}") }    if options[:tagged]
+
+        @assets
+      end
+
+      private
+
+      ##
+      # Check out whether all assets is existed or not
+      # It is better to be turned off in production
+      def verify
+        all_assets.each do |asset|
+          raise AssetNotFound.new("File #{asset} DOEST EXIST") unless FileTest.exist?(asset.abs)
+        end
+      end
+
+      ##
+      # The env assets will be required before action assets.
+      # The function of env assets is to allow user to require some assets
+      # that would be used throughout the whole application or controller.
+      # Like views in rails, assets finder will use application.[js|css] existed
+      # in /app/assets/[javascripts|stylesheets] folder if:controller.[js|css]
+      # in /app/assets/[javascripts|stylesheets]/:controller is not existed.
+      def retrieve_controller_assets
+        application_manifest = PathInfo.new("#{app_path.to_s}/application.#{asset_extension}")
+        controller_manifest  = PathInfo.new("#{app_path.to_s}/#{@controller}/#{@controller}.#{asset_extension}")
+
+        manifest = nil
+        manifest = application_manifest if FileTest.exist?(application_manifest)
+        manifest = controller_manifest  if FileTest.exist?(controller_manifest)
+
+        # TODO add rspec example
+        return assets if manifest.nil?
+
+        @assets.concat(retrieve_assets_from(manifest) << manifest.rel)
+      end
+
+      ##
+      # If the action assets is only a file, finder will also consider it a
+      # manifest file.
+      # If the action assets is a foler consisting several asset files, finder will
+      # includes all the assets inside this folder. Among these files, a file named
+      # index.[js|css] will be taken as manifest file.
+      def retrieve_action_assets
+        action_path         = PathInfo.new("#{app_path.to_s}/#{@controller}")
+        single_action_path  = PathInfo.new("#{action_path}/#{@action}.#{asset_extension}")
+        indexed_action_path = PathInfo.new("#{action_path}/#{@action}")
+        manifest            = nil
+
+        manifest = single_action_path if FileTest.exist?(single_action_path)
+
+        action_index = "#{indexed_action_path}/index.#{asset_extension}"
+        manifest     = PathInfo.new(action_index) if FileTest.exist?(action_index)
+
+        @assets.concat(retrieve_assets_from(manifest)) unless manifest.nil?
+
+        if FileTest.exist?(indexed_action_path)
+          auto_required_assets = Dir["#{action_path}/#{@action}/**/*.#{asset_extension}"]
+
+          @assets.concat(auto_required_assets.map{ |ass| PathInfo.new(ass).rel })
+        else
+          @assets << manifest.rel unless manifest.nil?
+        end
+      end
+
+      # start point of parsing dependent assets
+      def retrieve_assets_from(manifest)
+        # TODO rspec examples for non-existed files
+        return [] if @parsed_manifests.include?(manifest) || !FileTest.exist?(manifest)
+        @parsed_manifests.push(manifest)
+
+        required_assets = []
+        directive = Directive.new(asset_type)
+
+        Pathname.new(manifest).each_line do |line|
+          required_assets.concat(analyze(*directive.parse(line))) if directive.legal_directive?(line)
+        end
+
+        required_assets.flatten
+      end
+
+      def analyze(asset_category, path_params)
+        case asset_category
+        when 'vendor'
+          path_params.map { |pp| retrieve_vendor_assets(pp) }
+        when 'lib'
+          path_params.map { |pp| retrieve_lib_assets(pp) }
+        when 'app'
+          path_params.map { |pp| retrieve_app_asset(pp) }
+        end
+      end
+
+      # asset.js
+      # /:another_controller/asset.js
+      # =>
+      # /path/to/app/public/app/javascript/:controller/asset.js
+      # /path/to/app/public/app/javascript/:another_controller/asset.js
+      def retrieve_app_asset(required_asset)
+        required_asset = PathInfo.new(required_asset)
+
+        dir   = "#{app_path}/#{required_asset.match(/^\//) ? '' : "#{@controller}/"}"
+        asset = "#{required_asset}#{required_asset.with_ext? ? '' : ".#{asset_extension}"}"
+        PathInfo.new(dir + asset).rel
+      end
+
+      def retrieve_vendor_assets(manifest)
+        meta_retrieve(vendor_path, manifest)
+      end
+
+      def retrieve_lib_assets(manifest)
+        meta_retrieve(lib_path, manifest)
+      end
+
+      # for lib and vendor assets, finder will assume that it was stored in the
+      # root of vendor|lib and the file itself is a manifest file at first. If
+      # that isn't the case, finder will try to locate it in
+      # vendor|lib/:lib_or_vendor_name and take index.js inside that folder as
+      # manifest.
+      #
+      # NOTE: All assets returned will be "unabsolutely_pathized" here. That
+      #       means each string of file path does not contain any root path info.
+      # todo BUG => can't retrieve assets with slash-asterisk(/*= xxx */) directive.
+      # todo add specs for testing required folders without index
+      def meta_retrieve(manifest_path, manifest)
+        single_file_lib = PathInfo.new("#{manifest_path}/#{manifest}.#{asset_extension}")
+
+        manifest_dir               = "#{manifest_path}/#{manifest}"
+        indexing_lib               = PathInfo.new("#{manifest_dir}/index.#{asset_extension}")
+        all_assets_in_manifest_dir = []
+
+        real_manifest = nil
+        if FileTest.exist?(single_file_lib)
+          real_manifest = single_file_lib
+          # TODO refactor => add for a hotfix loading required folders without index
+
+          all_assets_in_manifest_dir = [real_manifest.rel]
+        else FileTest.exist?(indexing_lib)
+          real_manifest = indexing_lib
+
+          all_assets_in_manifest_dir = Dir["#{manifest_dir}/**/*.#{asset_extension}"].map { |file| PathInfo.new(file).rel }
+        end
+
+        # TODO add specs for dependent assets sequence
+        retrieve_assets_from(real_manifest).flatten
+                                           .concat(all_assets_in_manifest_dir)
+                                           .uniq
+      end
+
+      def root
+        Rails.public_path
+      end
+
+      # TODO add tests
+      def app_path
+        "#{root}/app/#{assets_path}"
+      end
+
+      # TODO add tests
+      def lib_path
+        "#{root}/lib/#{assets_path}"
+      end
+
+      # TODO add tests
+      def vendor_path
+        "#{root}/vendor/#{assets_path}"
+      end
+    end
+  end
+end

data/lib/view_assets/finder/js_finder.rb

@@ -0,0 +1,22 @@
+module ViewAssets
+  module Finder
+    class JsFinder < Finder
+      def assets_path
+        # 'assets/javascripts'
+        JS_PATH
+      end
+
+      def asset_extension
+        JS_EXT
+      end
+
+      def asset_type
+        JS_TYPE
+      end
+
+      def tag(src)
+        ViewAssets.tag(:js, src)
+      end
+    end
+  end
+end

data/lib/view_assets/packager/actions_map.rb

@@ -0,0 +1,43 @@
+module ViewAssets
+  module Packager
+    class ActionsMap
+      # # =>
+      # {
+      #   :controller1 => [:action1, :action2, ..],
+      #   ..
+      # }
+      def retrieve
+        action_path.children.select(&:directory?).each_with_object({}) do |controller, action_map|
+          all_children = controller.children.map do |action|
+            action.basename.to_s.chomp(action.extname)
+          end
+
+          controller_name = controller.basename.to_s
+          action_map[controller.basename.to_s] = all_children.select { |action| action.to_s != controller_name }
+        end
+      end
+
+      private
+
+      def action_path
+        Pathname.new(PathInfo.new("#{APP_FOLDER}/#{asset_path}").abs)
+      end
+    end
+
+    class JsActionsMap < ActionsMap
+      def asset_path
+        JS_PATH
+      end
+
+      def method_name
+
+      end
+    end
+
+    class CssActionsMap < ActionsMap
+      def asset_path
+        CSS_PATH
+      end
+    end
+  end
+end

data/lib/view_assets/packager/core.rb

@@ -0,0 +1,7 @@
+module ViewAssets
+  module Packager
+    require 'view_assets/finder/core'
+    require 'view_assets/packager/actions_map'
+    require 'view_assets/packager/packager'
+  end
+end