view_assets 1.0.4 → 1.1.1

data/lib/tasks/tool.rb

@@ -0,0 +1,29 @@
+namespace :va do
+  namespace :tool do
+    require 'view_assets/manager/manager'
+
+    desc "Change Manifest Name"
+    task :mv, [:type, :original, :new_name] do |t, args|
+      case args.type
+      when 'js'
+        ViewAssets::Manager::JsModifier.new.update(args.original, args.new_name, { :verbal =>  true })
+      when 'css'
+        ViewAssets::Manager::CssModifier.new.update(args.original, args.new_name, { :verbal =>  true })
+      else
+        puts "Unrecognized Type: #{args.type}"
+      end
+    end
+
+    desc "Remove Manifest"
+    task :rm, [:type, :manifest] do |t, args|
+      case args.type
+      when 'js'
+        ViewAssets::Manager::JsModifier.new.remove(args.manifest, { :verbal =>  true })
+      when 'css'
+        ViewAssets::Manager::CssModifier.new.remove(args.manifest, { :verbal =>  true })
+      else
+        puts "Unrecognized Type: #{args.type}"
+      end
+    end
+  end
+end

data/lib/view_assets/finder/directive.rb

@@ -8,29 +8,29 @@ module ViewAssets
         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}'") 
+          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 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
-      
+        # 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
@@ -42,30 +42,30 @@ module ViewAssets
         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
+        # 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
+        # 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
@@ -73,19 +73,19 @@ module ViewAssets
       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
@@ -107,7 +107,7 @@ module ViewAssets
           }x
         end
       end
-      
+
       def javascript? type
         %w(js javascript javascripts).include? type
       end

data/lib/view_assets/finder/finder.rb

@@ -32,17 +32,17 @@ module ViewAssets
       #     :action => nil
       #     :full => false
       #     :tagged => false
+      #     :tagged => false
+      #     :shallow => 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, :tagged => false, :shallow => false }.update(options)
 
-        options[:full]   ||= false
-        options[:tagged] ||= false
-
-        @assets           = []
-        @parsed_manifests = []
-        @controller       = controller
-        @action           = action
+        @assets            = []
+        @parsed_manifests  = []
+        @controller        = controller
+        @action            = action
+        @shallow_retrieval = options[:shallow]
 
         retrieve_controller_assets
         retrieve_action_assets if @action != ''
@@ -54,12 +54,32 @@ module ViewAssets
         @assets
       end
 
+      # manifest path should be a relative path
+      def retrieve_manifest(manifest, options = {})
+        options = { :full => false, :tagged => false, :shallow => false, :non_ext => true }.update(options)
+
+        @assets            = []
+        @parsed_manifests  = []
+        @controller        = options[:controller]
+        @action            = options[:action]
+        @shallow_retrieval = options[:shallow]
+
+        @assets = meta_retrieve(root, manifest)
+        @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
       # TODO: add Rspec Examples
+      # TODO: apply verify function
       def verify
         all_assets.each do |asset|
           raise AssetNotFound.new("File #{asset} DOEST EXIST") unless FileTest.exist?(asset.abs)
@@ -82,7 +102,10 @@ module ViewAssets
         manifest = controller_manifest  if FileTest.exist?(controller_manifest)
 
         # TODO add rspec example
-        return assets if manifest.nil?
+        return @assets if manifest.nil?
+
+        # TODO: test when application is not exist
+        return @assets.push(manifest.rel) if @shallow_retrieval
 
         @assets.concat(retrieve_assets_from(manifest) << manifest.rel)
       end
@@ -115,9 +138,9 @@ module ViewAssets
         end
       end
 
-      # start point of parsing dependent assets
+      # Start Point of Parsing Dependent Assets
       def retrieve_assets_from(manifest)
-        # TODO rspec examples for non-existed files
+        # TODO: Rspec Examples for non-Existed Files
         return [] if @parsed_manifests.include?(manifest) || !FileTest.exist?(manifest)
         @parsed_manifests.push(manifest)
 
@@ -131,6 +154,7 @@ module ViewAssets
         required_assets.flatten
       end
 
+      # Support Multiple Path Params
       def analyze(asset_category, path_params)
         case asset_category
         when 'vendor'
@@ -150,20 +174,24 @@ module ViewAssets
       def retrieve_app_asset(required_asset)
         required_asset = PathInfo.new(required_asset)
 
-        dir   = "#{app_path}/#{required_asset.match(/^\//) ? '' : "#{@controller}/"}"
+        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)
+        return PathInfo.new("#{vendor_path}/#{manifest}").rel if @shallow_retrieval
+
         meta_retrieve(vendor_path, manifest)
       end
 
       def retrieve_lib_assets(manifest)
+        return PathInfo.new("#{lib_path}/#{manifest}").rel if @shallow_retrieval
+
         meta_retrieve(lib_path, manifest)
       end
 
-      # for lib and vendor assets, finder will assume that it was stored in the
+      # 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
@@ -174,7 +202,8 @@ module ViewAssets
       # 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}")
+        # TODO: add Tests for Manifest With File Extension
+        single_file_lib = PathInfo.new("#{manifest_path}/#{manifest}#{PathInfo.new(manifest).with_ext? ? '' : ".#{asset_extension}"}")
 
         manifest_dir               = "#{manifest_path}/#{manifest}"
         indexing_lib               = PathInfo.new("#{manifest_dir}/index.#{asset_extension}")
@@ -183,7 +212,7 @@ module ViewAssets
         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
+          # TODO: refactor => add for a hotfix loading required folders without index
 
           all_assets_in_manifest_dir = [real_manifest.rel]
         else FileTest.exist?(indexing_lib)
@@ -192,6 +221,8 @@ module ViewAssets
           all_assets_in_manifest_dir = Dir["#{manifest_dir}/**/*.#{asset_extension}"].map { |file| PathInfo.new(file).rel }
         end
 
+        # return all_assets_in_manifest_dir if @shallow_retrieval
+
         # TODO add specs for dependent assets sequence
         retrieve_assets_from(real_manifest).flatten
                                            .concat(all_assets_in_manifest_dir)

data/lib/view_assets/manager/manager.rb

@@ -1,24 +1,12 @@
 module ViewAssets
   module Manager
+    require 'yaml'
+    require 'term/ansicolor'
+
     require 'view_assets'
     require 'view_assets/finder/core'
-
-    class Manager
-      def create(instruction)
-
-      end
-
-      def read(asset)
-
-      end
-
-      def update(old_asset, new_asset)
-
-      end
-
-      def remove(asset)
-
-      end
-    end
+    require 'view_assets/packager/actions_map'
+    require 'view_assets/manager/map'
+    require 'view_assets/manager/modifier'
   end
 end

data/lib/view_assets/manager/map.rb

@@ -0,0 +1,110 @@
+module ViewAssets
+  module Manager
+    class Map
+      def draw
+        map = { :vendor => {}, :lib => {}, :app => {} }
+
+        # App
+        # Application
+        application_manifest = PathInfo.new("#{app_path}/#{asset_path}/application")
+        app_covered_action = false
+        if FileTest.exist?("#{application_manifest.abs}.#{ext}")
+          map[:app][application_manifest.to_s] = finder.retrieve_manifest(application_manifest, { :shallow => true })
+          app_covered_action = true
+        end
+
+        # Controllers and Actions
+        actions = action_map.retrieve
+        actions.each do |controller, actions|
+          controller_manifest = PathInfo.new("#{app_path}/#{asset_path}/#{controller}/#{controller}")
+          controller_convered_action = false
+          if FileTest.exist?("#{controller_manifest.abs}.#{ext}")
+            map[:app][controller_manifest.to_s] = finder.retrieve_manifest(controller_manifest, { :shallow => true, :controller => controller })
+
+            controller_convered_action = true
+          end
+
+          actions.each do |action|
+            action_manifest = "#{app_path}/#{asset_path}/#{controller}/#{action}"
+            map[:app][action_manifest] = finder.retrieve(controller, action, { :shallow => true, :controller => controller, :action => action })
+
+            if controller_convered_action || app_covered_action
+              map[:app][action_manifest][0] = map[:app][action_manifest][0].basename
+            end
+          end
+        end
+
+        # Vendor
+        Pathname.new("#{root}/#{vendor_path}/#{asset_path}").children.each do |entry|
+          manifest = PathInfo.new(entry.to_s).rel
+
+          map[:vendor][manifest.basename] = finder.retrieve_manifest(manifest.rel, { :shallow => true })
+        end
+
+        # Lib
+        Pathname.new("#{root}/#{lib_path}/#{asset_path}").children.each do |entry|
+          manifest = PathInfo.new(entry.to_s).rel
+
+          map[:lib][manifest.basename] = finder.retrieve_manifest(manifest.rel, { :shallow => true })
+        end
+
+        FileUtils.mkdir_p("#{root}/assets")
+        File.open("#{root}/assets/#{asset_path}_assets.yml", 'w') { |file| file << YAML.dump(map) }
+
+        map
+      end
+
+      def root
+        Rails.public_path
+      end
+
+      def app_path
+        ::ViewAssets::APP_FOLDER
+      end
+
+      def vendor_path
+        ::ViewAssets::VENDOR_FOLDER
+      end
+
+      def lib_path
+        ::ViewAssets::LIB_FOLDER
+      end
+    end
+
+    class JsMap < Map
+      def ext
+        JS_EXT
+      end
+
+      def asset_path
+        JS_PATH
+      end
+
+      def action_map
+        ::ViewAssets::Packager::JsActionsMap.new
+      end
+
+      def finder
+        ::ViewAssets::Finder::JsFinder.new
+      end
+    end
+
+    class CssMap < Map
+      def ext
+        CSS_EXT
+      end
+
+      def asset_path
+        CSS_PATH
+      end
+
+      def action_map
+        ::ViewAssets::Packager::CssActionsMap.new
+      end
+
+      def finder
+        ::ViewAssets::Finder::CssFinder.new
+      end
+    end
+  end
+end

data/lib/view_assets/manager/modifier.rb

@@ -0,0 +1,214 @@
+module ViewAssets
+  module Manager
+    class Modifier
+      include Term::ANSIColor
+
+      def update(index, new_index, options = {})
+        options = { :verbal => false }.update(options)
+
+        type = retrieve_type(index)
+        validate_index = map[type].key?(index)
+
+        # unless validate_index
+        #   map.each_value do |manifests|
+        #     validate_index = manifests.select do |manifest, indexes|
+        #                        indexes.any? do |map_index|
+        #                          map_index.match(index)
+        #                        end
+        #                      end
+        #
+        #     break if validate_index
+        #   end
+        # end
+
+        raise Error.new(red("#{index} is not exist.")) unless validate_index
+
+        puts green("mv #{index}, #{new_index}") if options[:verbal]
+        update_index(index, new_index)
+        update_requirements(index, new_index, options)
+      end
+
+      def retrieve_type(index)
+        case
+        when /^vendor\/.+$/.match(index)
+          :vendor
+        when /^lib\/.+$/.match(index)
+          :lib
+        when /^app\/.+$/.match(index)
+          :app
+        end
+      end
+
+      def update_index(index, new_index)
+        path_to_index = PathInfo.new(index).abs
+        new_path_to_index = PathInfo.new(new_index).abs
+
+        if FileTest.exists?(path_to_index)
+          FileUtils.mv(path_to_index, new_path_to_index)
+        elsif FileTest.exists?("#{path_to_index}.#{ext}")
+          FileUtils.mv("#{path_to_index}.#{ext}", "#{new_path_to_index}.#{ext}")
+        else
+          raise Error.new(red("Manifest #{index} doesn't exist."))
+        end
+      end
+
+      def update_requirements(index, new_index, options = {})
+        options = { :verbal => false }.update(options)
+
+        map.each_value do |type|
+          type.each do |manifest, requirements|
+            if requirements.any? { |requirement| requirement == index }
+              puts ("Update #{green(manifest)}") if options[:verbal]
+
+              if new_index.empty?
+                requirements.delete(index)
+              else
+                requirements[requirements.index(index)] = new_index
+              end
+
+              modify(manifest, generate_requirements_block(manifest, requirements))
+            end
+          end
+        end
+      end
+
+      def generate_requirements_block(manifest, requirements)
+        if retrieve_type(manifest) == :app
+          # Remove 'app/:asset_path/application' or
+          #        'app/:asset_path/application.:ext'
+          requirements.delete("app/#{asset_path}/application")
+          requirements.delete("app/#{asset_path}/application.#{ext}")
+
+          # Remove 'app/:asset_path/controller/controller' or
+          #        'app/:asset_path/controller/controller.ext'
+          if manifest.count('/') > 2
+            controller_asset = manifest.gsub(
+                                 /(?<path>.+\/.+\/(?<controller>.+)\/).+/,
+                                 '\k<path>\k<controller>'
+                               )
+
+            requirements.delete("#{controller_asset}")
+            requirements.delete("#{controller_asset}.#{ext}")
+          end
+        end
+
+        requirements.delete("#{manifest}.#{ext}")
+        requirements.reject! { |req| req.match(manifest + '/') }
+
+        requirements.each_with_object(["/**"]) do |requirement, block|
+          directive, prefix = case retrieve_type(requirement)
+                              when :vendor
+                                [' *= require_vendor ', "vendor/#{asset_path}/"]
+                              when :lib
+                                [' *= require_lib ', "lib/#{asset_path}/"]
+                              when :app
+                                [' *= require ', "app/#{asset_path}"]
+                              end
+
+          block.push("#{directive}#{requirement.gsub(prefix, "")}")
+        end.push(' */').join("\n")+"\n"
+      end
+
+      def remove(index, options = {})
+        options = { :verbal => false }.update(options)
+
+        raise Error.new(red("#{index} is not exist.")) unless map[retrieve_type(index)].key?(index)
+
+        puts green("rm #{index}") if options[:verbal]
+        index_path = PathInfo.new(index).abs
+        if FileTest.exist?("#{index_path}.#{ext}")
+          FileUtils.rm_r("#{index_path}.#{ext}")
+        elsif FileTest.exist?(index_path)
+          FileUtils.rm_r("#{index_path}")
+        else
+          raise Error.new(red("#{index} Is Not Exist."))
+        end
+
+        update_requirements(index, '', options)
+      end
+
+      def modify(path, new_requirement_block)
+        path = PathInfo.new(path).abs
+        manifest = if FileTest.exists?("#{path}.#{ext}")
+                     "#{path}.#{ext}"
+                   elsif FileTest.exists?("#{path}/index.#{ext}")
+                     "#{path}/index.#{ext}"
+                   else
+                     raise Error.new(red("Can't Load #{path.rel}"))
+                   end
+
+        start_of_requirement_block = false
+        end_of_requirement_block = false
+        asset_content = ''
+
+        Pathname.new(manifest).each_line do |line|
+          legal_directive = analyize(*directive.parse(line))
+
+          start_of_requirement_block = true if legal_directive && !start_of_requirement_block
+          end_of_requirement_block = true if !legal_directive && start_of_requirement_block && !end_of_requirement_block
+
+          if !start_of_requirement_block || end_of_requirement_block
+            asset_content << line
+          end
+        end
+
+        File.open(manifest, 'w') do |file|
+          file << new_requirement_block
+          file << asset_content
+        end
+      end
+
+      def analyize(type, asset)
+        return type != '' || asset != []
+      end
+
+      def map
+        @map_value
+      end
+
+      def update_map
+        @map_value = @map.draw
+      end
+    end
+
+    class JsModifier < Modifier
+      def initialize
+        @map = ::ViewAssets::Manager::JsMap.new
+        @map_value = @map.draw
+      end
+
+      DIRECTIVE = ::ViewAssets::Finder::Directive.new(JS_TYPE)
+      def directive
+        DIRECTIVE
+      end
+
+      def ext
+        JS_EXT
+      end
+
+      def asset_path
+        ::ViewAssets::JS_PATH
+      end
+    end
+
+    class CssModifier < Modifier
+      def initialize
+        @map = ::ViewAssets::Manager::CssMap.new
+        @map_value = @map.draw
+      end
+
+      DIRECTIVE = ::ViewAssets::Finder::Directive.new(CSS_TYPE)
+      def directive
+        DIRECTIVE
+      end
+
+      def ext
+        CSS_EXT
+      end
+
+      def asset_path
+        ::ViewAssets::CSS_PATH
+      end
+    end
+  end
+end