web_resource_bundler 0.0.20 → 0.0.21

data/VERSION

@@ -1 +1 @@
-0.0.20
+0.0.21

data/lib/web_resource_bundler/content_management/block_data.rb

@@ -4,32 +4,31 @@ module WebResourceBundler
 
     def initialize(condition = "")
       @inline_block = ""
-      @files = []
-      @condition = condition
+      @files        = []
+      @condition    = condition
       @child_blocks = []
     end
 
     def styles
-      @files.select do |f|
-        !([WebResourceBundler::ResourceFileType::CSS, 
-          WebResourceBundler::ResourceFileType::IE_CSS] & f.types).empty?
-      end
+      @files.select { |f| f.type[:ext] == 'css' } 
     end
 
     def scripts
-      @files.select {|f| f.types.include?(WebResourceBundler::ResourceFileType::JS)}
+      @files.select { |f| f.type[:ext] == 'js'}
+    end
+
+    def base64_styles
+      @files.select { |f| WebResourceBundler::ResourceFileType::CSS_TYPES.include?(f.type)}
+    end
+
+    def mhtml_styles
+      @files.select { |f| WebResourceBundler::ResourceFileType::MHTML_TYPES.include?(f.type)}
     end
 
     def clone
-      clon = self.dup 
-      clon.files = self.files.map {|f| f.clone}
-      if clon.child_blocks.size > 0
-        clon.child_blocks = self.child_blocks.map do |block|
-          block.clone
-        end
-      else
-        clon.child_blocks = []
-      end
+      clon              = self.dup 
+      clon.files        = self.files.map {|f| f.clone}
+      clon.child_blocks = clon.child_blocks.any? ? self.child_blocks.map { |block| block.clone } : []
       clon
     end
 
@@ -47,16 +46,14 @@ module WebResourceBundler
       block_data.child_blocks.each do |child|
         result += BlockData.all_childs(child)
       end
-      return result
+      result
     end
 
     def apply_filters(filters)
-      unless filters.empty?
+      if filters.any?
         filters.each do |filter|
           items = BlockData.all_childs(self)
-          items.each do |block_data|
-            filter.apply!(block_data)
-          end
+          items.each { |block_data| filter.apply!(block_data) } 
         end      
       end
     end

data/lib/web_resource_bundler/content_management/block_parser.rb

@@ -1,63 +1,69 @@
 module WebResourceBundler
-  class BlockParser
-    CONDITIONAL_BLOCK_PATTERN = /<!--\s*\[\s*if[^>]*IE\s*\d*[^>]*\]\s*>(.*?)<!\s*\[\s*endif\s*\]\s*-->/xmi
-    CONDITION_PATTERN = /<!--\s*(\[[^<]*\])\s*>/
-    LINK_PATTERN = /(<(link|script[^>]*?src\s*=).*?(><\/script>|>))/
-    URL_PATTERN = /(href|src) *= *["']([^"'?]+)/i
-
-    #parsing block content recursively
-    #nested comments NOT supported
-    #result is BlockData with conditional blocks in child_blocks
-    def parse_block_with_childs(block, condition)
-      block_data = BlockData.new(condition)
-      block.gsub!(CONDITIONAL_BLOCK_PATTERN) do |s|
-        new_block = CONDITIONAL_BLOCK_PATTERN.match(s)[1]
-        new_condition = CONDITION_PATTERN.match(s)[1]
-        block_data.child_blocks << parse_block_with_childs(new_block, new_condition)
-        s = ""
+  module BlockParser
+
+    CONDITIONAL_BLOCK_PATTERN = /<!--\s*\[\s*if[^>]*IE\s*\d*[^>]*\]\s*>(.*?)<!\s*\[\s*endif\s*\]\s*-->/
+    CONDITION_PATTERN         = /<!--\s*(\[[^<]*\])\s*>/
+    LINK_PATTERN              = /(<(link|script[^>]*?src\s*=).*?(><\/script>|>))/i
+    URL_PATTERN               = /(href|src) *= *["']([^"'?]+)/i
+
+    class << self
+
+      #just a short method to start parsing block
+      def parse(block)
+        parse_block_with_childs(block, "")
+      end
+
+      private
+
+      #parsing block content recursively
+      #nested comments NOT supported
+      #result is BlockData with conditional blocks in child_blocks
+      def parse_block_with_childs(block, condition)
+        block_data = BlockData.new(condition)
+        block.gsub!(CONDITIONAL_BLOCK_PATTERN) do |s|
+          child_block     = $1 
+          child_condition = CONDITION_PATTERN.match(s)[1]
+          block_data.child_blocks << parse_block_with_childs(child_block, child_condition)
+          ""
+        end
+        block_data.files        = find_files(block)
+        block_data.inline_block = remove_links(block)
+        block_data
       end
-      files = find_files(block)
-      block_data.files = files
-      block_data.inline_block = remove_links(block)
-      block_data
-    end
-
-    #removing resource links from block
-    #example: "<link href="bla"><script src="bla"></script>my inline content" => "my inline content"
-    def remove_links(block)
-      inline_block = block.gsub(LINK_PATTERN) do |s|
-        extension = File.extname(URL_PATTERN.match(s)[2])
-        if /\.js|\.css/.match(extension) and not s.include?('://')
-          #we should delete link to local css or js resource
-          '' 
-        else
-          #link to remote resource should be kept
-          s
+
+      #removing resource links from block
+      #example: "<link href="bla"><script src="bla"></script>my inline content" => "my inline content"
+      def remove_links(block)
+        inline_block = block.gsub(LINK_PATTERN) do |s|
+          url       = URL_PATTERN.match(s)[2]
+          extension = File.extname(url)
+          /\.js|\.css/.match(extension) && !URI.parse(url).absolute? ? '' : s
         end
+        inline_block
       end
-      return inline_block
-    end
-
-    #looking for css and js files included and create BlockFiles with files paths
-    def find_files(block)
-      files = []
-      block.scan(URL_PATTERN).each do |property, value|
-        unless value.include?('://') 
-          case property
-            when "src" 
-              then files << WebResourceBundler::ResourceFile.new_js_file(value) if File.extname(value) == '.js'
-            when "href" 
-              then files << WebResourceBundler::ResourceFile.new_style_file(value) if File.extname(value) == '.css'
+
+      #looking for css and js files included and create BlockFiles with files paths
+      def find_files(block)
+        files = []
+        block.scan(URL_PATTERN).each do |attribute, path|
+          if !URI.parse(path).absolute?
+            resource =  create_resource_file(attribute, path)
+            files    << resource if resource
           end
         end
+        files
+      end
+
+      def create_resource_file(attribute, path)
+        case attribute
+          when "src" 
+            then WebResourceBundler::ResourceFile.new_js_file(path) if File.extname(path) == '.js'
+          when "href" 
+            then WebResourceBundler::ResourceFile.new_css_file(path) if File.extname(path) == '.css'
+        end
       end
-      files
-    end
 
-    #just a short method to start parsing passed block
-    def parse(block)
-      parse_block_with_childs(block, "")
-    end
+    end 
 
   end
 end

data/lib/web_resource_bundler/content_management/css_url_rewriter.rb

@@ -1,10 +1,10 @@
 class WebResourceBundler::CssUrlRewriter
   class << self
+		URL_TAG_PATTERN = /url\s*\(['|"]?([^\)'"]+)['|"]?\)/i
     # rewrites a relative path to an absolute path, removing excess "../" and "./"
     # rewrite_relative_path("stylesheets/default/global.css", "../image.gif") => "/stylesheets/image.gif"
-
     def rewrite_relative_path(source_url, relative_url)
-      return relative_url if relative_url.include?('http://')
+      return relative_url if URI.parse(relative_url).absolute?
       File.expand_path(relative_url, File.dirname(source_url))
     end
   
@@ -15,7 +15,7 @@ class WebResourceBundler::CssUrlRewriter
     # url(/stylesheets/../images/active_scaffold/default/add.gif);
     # url('/images/active_scaffold/default/add.gif');
     def rewrite_content_urls!(filename, content)
-      content.gsub!(/url\s*\(['|"]?([^\)'"]+)['|"]?\)/) { "url('#{rewrite_relative_path(filename, $1)}')" }
+      content.gsub!(URL_TAG_PATTERN) { "url('#{rewrite_relative_path(filename, $1)}')" }
       content
     end
 

data/lib/web_resource_bundler/content_management/resource_file.rb

@@ -1,38 +1,51 @@
 module WebResourceBundler
   
   class ResourceFileType
-    CSS = {:value => 1, :name => 'style', :ext => 'css'}
-    JS = {:value => 2, :name => 'script', :ext => 'js'}
-    IE_CSS = {:value => 3, :name => 'style', :ext => 'css'}
-    MHTML = {:value => 4, :name => 'style', :ext => 'mhtml'}
+
+    CSS					= {:value => 1 , :name => 'style'  , :ext => 'css'   } 
+    JS					= {:value => 2 , :name => 'script' , :ext => 'js'    } 
+    MHTML_CSS		= {:value => 3 , :name => 'style'  , :ext => 'css'   } 
+    BASE64_CSS	= {:value => 4 , :name => 'style'  , :ext => 'css'   } 
+    MHTML				= {:value => 5 , :name => 'mhtml'  , :ext => 'mhtml' } 
+
+		CSS_TYPES		= [CSS, BASE64_CSS]
+		MHTML_TYPES = [CSS, MHTML_CSS, MHTML]
   end
 
   class ResourceFile  
-    attr_accessor :types #array of ResourceFileType's objects
-    attr_accessor :path, :content
-    def initialize(path, content, *types)
-      @types = types.flatten
+
+    attr_accessor :type, :path, :content
+
+    def initialize(path, content, type)
+      @type    = type
       @content = content
-      @path = path
-    end
-    def self.new_js_file(path, content = "")
-      ResourceFile.new(path, content, ResourceFileType::JS) 
-    end
-    def self.new_css_file(path, content = "")
-      ResourceFile.new(path, content, ResourceFileType::CSS)
-    end
-    def self.new_ie_css_file(path, content ="")
-      ResourceFile.new(path, content, ResourceFileType::IE_CSS)
-    end
-    def self.new_style_file(path, content ="")
-      ResourceFile.new(path, content, ResourceFileType::CSS, ResourceFileType::IE_CSS)
-    end
-    def self.new_mhtml_file(path, content = "")
-      ResourceFile.new(path, content, ResourceFileType::MHTML)
+      @path    = path
     end
+
+		class << self
+
+			def new_js_file(path, content = "")
+				ResourceFile.new(path, content, ResourceFileType::JS) 
+			end
+
+			def new_css_file(path, content = "")
+				ResourceFile.new(path, content, ResourceFileType::CSS)
+			end
+
+			def new_mhtml_css_file(path, content = "")
+				ResourceFile.new(path, content, ResourceFileType::MHTML_CSS)
+			end
+
+			def new_mhtml_file(path, content = "")
+				ResourceFile.new(path, content, ResourceFileType::MHTML)
+			end
+
+		end
+    
     def clone
-      ResourceFile.new(self.path.dup, self.content.dup, self.types.dup)
+      ResourceFile.new(self.path.dup, self.content.dup, self.type.dup)
     end
+
   end
 
 end

data/lib/web_resource_bundler/exceptions.rb

@@ -5,9 +5,7 @@ module WebResourceBundler::Exceptions
       @message = message
     end
 
-    def to_s
-      @message
-    end
+    def to_s; @message; end
 
   end
 

data/lib/web_resource_bundler/file_manager.rb

@@ -1,9 +1,14 @@
 module WebResourceBundler
   class FileManager
-    attr_accessor :resource_dir, :cache_dir
+    attr_reader :resource_dir, :cache_dir
 
-    def initialize(resource_dir, cache_dir)
-      @resource_dir, @cache_dir = resource_dir, cache_dir
+    def initialize(attributes)
+      set_settings(attributes)
+    end
+
+    def set_settings(attributes)
+      @resource_dir = attributes[:resource_dir]
+      @cache_dir    = attributes[:cache_dir]
     end
 
     def full_path(relative_path)
@@ -25,6 +30,12 @@ module WebResourceBundler
         Dir.mkdir(path)
       end
     end
+    
+    def write_file(path, content)
+      File.open(full_path(path), "w") do |f|
+        f.print(content)
+      end
+    end
 
   end
 end

data/lib/web_resource_bundler/filters/bundle_filter/resource_packager.rb

@@ -1,48 +1,66 @@
 module WebResourceBundler::Filters::BundleFilter
   class ResourcePackager
-    IMPORT_PTR = /\@import ['|"](.*?)['|"];/
+    IMPORT_PTR = /\@import ['|"](.*?)['|"];/i
 
     def initialize(settings, file_manager)
-      @settings = settings
+      @settings     = settings
       @file_manager = file_manager 
     end
 
     #recursively iterates through all files and imported files
     def bundle_files(files)
       output = ""
-      files.select{|f| not f.content.empty? }.each do |file|
-        path = file.path
+      files.select { |f| !f.content.empty? }.each do |file|
         content = file.content
-        output << "/* --------- #{path} --------- */\n"
-        if file.types.first[:ext] == 'css'
-          imported_files = extract_imported_files!(content, path)
-          #getting imported (@import ...) files contents
-          imported_resource_files = [] 
-          imported_files.each do |imported_file|
-            imported_resource_files << WebResourceBundler::ResourceFile.new_css_file(imported_file, @file_manager.get_content(imported_file))
-          end
-          #bundling imported files
-          output << bundle_files(imported_resource_files) unless imported_resource_files.empty?
-        end
-        #adding ';' symbol in case javascript developer forget to do this
-        content << ';' if File.extname(path) == '.js'
-        output << content
-        output << "\n/* --------- END #{path} --------- */\n"
+        path    = file.path
+        output  << bundled_file_header(path) 
+        output  << include_imported_files(content, path) if file.type[:ext] == 'css'
+        content << javascript_fix                        if file.type[:ext] == '.js' 
+        output  << content
+        output  << bundled_file_footer(path)
       end
       output
     end
 
-    #finds all imported files in css
+    private
+
+    #to avoid problems with javascript we should add closing ;
+    def javascript_fix
+      ';' 
+    end
+
+    def include_imported_files(content, base_path)
+      imported_file_paths     = extract_imported_files!(content, base_path)
+      imported_resource_files = build_imported_files(imported_file_paths) 
+      imported_resource_files.any? ? bundle_files(imported_resource_files) : ''
+    end
+  
+    #finds all imported files paths in css
     def extract_imported_files!(content, base_file_path)
-      imported_files = []
+      paths = []
       content.gsub!(IMPORT_PTR) do |result|
-        imported_file = IMPORT_PTR.match(result)[1]
-        if imported_file
-          imported_files << File.join(File.dirname(base_file_path), imported_file)
-        end
-        result = ""
+        path  = $1 
+        paths << File.join(File.dirname(base_file_path), path) if path 
+        ""
+      end
+      paths
+    end
+
+    def bundled_file_header(path)
+      "/* --------- #{path} --------- */\n"
+    end
+
+    def bundled_file_footer(path)
+      "\n/* --------- END #{path} --------- */\n"
+    end
+
+    #created resource files using imported files paths
+    def build_imported_files(imported_file_paths) 
+      files = []
+      imported_file_paths.map do |path|
+        files << WebResourceBundler::ResourceFile.new_css_file(path, @file_manager.get_content(path)) if File.basename(path).split('.')[-1] == 'css'
       end
-      return imported_files
+      files
     end
 
   end

data/lib/web_resource_bundler/filters/bundle_filter.rb

@@ -1,6 +1,8 @@
 $:.unshift File.join(File.dirname(__FILE__), "/bundle_filter")
+
 require 'bundle_filter/resource_packager'
 require 'base_filter'
+
 module WebResourceBundler::Filters::BundleFilter
   class Filter < WebResourceBundler::Filters::BaseFilter
 
@@ -10,23 +12,29 @@ module WebResourceBundler::Filters::BundleFilter
     end
 
     def apply!(block_data)
-      new_files = []
-      unless block_data.styles.empty?
-        new_css_filename = css_bundle_filepath(block_data.styles)
-        new_css_content = @packager.bundle_files(block_data.styles)
-        new_css_file = WebResourceBundler::ResourceFile.new_style_file(new_css_filename, new_css_content)
-        new_files << new_css_file 
-      end
-      unless block_data.scripts.empty?
-        new_js_filename = js_bundle_filepath(block_data.scripts)
-        new_js_content = @packager.bundle_files(block_data.scripts)
-        new_js_file = WebResourceBundler::ResourceFile.new_js_file(new_js_filename, new_js_content)
-        new_files << new_js_file
-      end
-      block_data.files = new_files
+      new_files        =  []
+      new_files        << create_css_bundle(block_data.styles) if block_data.styles.any?
+      new_files        << create_js_bundle(block_data.scripts) if block_data.scripts.any?
+      block_data.files =  new_files
       block_data
     end
 
+    private
+
+    #creates one bundle resource file from css files
+    def create_css_bundle(styles)
+      filename = css_bundle_filepath(styles)
+      content  = @packager.bundle_files(styles)
+      WebResourceBundler::ResourceFile.new_css_file(filename, content)
+    end
+
+    #creates one bundle resource file from js files
+    def create_js_bundle(scripts)
+      filename = js_bundle_filepath(scripts)
+      content  = @packager.bundle_files(scripts)
+      WebResourceBundler::ResourceFile.new_js_file(filename, content)
+    end
+
     def get_md5(files)
       items = [(files.map {|f| f.path }).sort]
       items << @settings[:protocol]
@@ -36,14 +44,11 @@ module WebResourceBundler::Filters::BundleFilter
     end
 
     def bundle_filepath(type, files)
-      unless files.empty?
-        items = [type[:name] + '_' + get_md5(files)]
-        items += @settings[:filename_additional_data] if @settings[:filename_additional_data]
-        items << type[:ext]
-        return File.join(@settings[:cache_dir], items.join('.'))
-      else
-        return nil
-      end
+      return nil if files.empty?
+      items = [type[:name] + '_' + get_md5(files)]
+      items += @settings[:filename_additional_data] if @settings[:filename_additional_data]
+      items << type[:ext]
+      File.join(@settings[:cache_dir], items.join('.'))
     end
 
     #just aliases to simplify code

data/lib/web_resource_bundler/filters/cdn_filter.rb

@@ -1,5 +1,9 @@
 module WebResourceBundler::Filters::CdnFilter
   class Filter < WebResourceBundler::Filters::BaseFilter
+
+		FILE_PREFIX				= 'cdn_'
+		IMAGE_URL_PATTERN	= /url\s*\(['|"]?([^\)'"]+\.(jpg|gif|png|jpeg|bmp))['|"]?\)/i
+
     def initialize(settings, file_manager)
       super(settings, file_manager)
     end
@@ -12,37 +16,37 @@ module WebResourceBundler::Filters::CdnFilter
       block_data
     end
 
-    def new_filepath(path)
-      File.join(@settings[:cache_dir], 'cdn_' + File.basename(path))
+		private
+
+		def new_filepath(path)
+      File.join(@settings[:cache_dir], FILE_PREFIX + File.basename(path))
     end
 
     #insures that image linked to one particular host  
+		#host type depends on request protocol type
     def host_for_image(image_url)
-      #hosts are different depending on protocol 
-      if @settings[:protocol] == 'https' 
-        hosts = @settings[:https_hosts]
-      else
-        hosts = @settings[:http_hosts]
-      end
-      #getting host based on image url hash
-      host_index = image_url.hash % hosts.size
-      hosts[host_index]
+      hosts = get_hosts
+      index = image_url.hash % hosts.size
+      hosts[index]
     end
 
+		def get_hosts
+			key = @settings[:protocol] == 'https' ? :https_hosts : :http_hosts
+			@settings[key]
+		end
+
+		#rewrites image urls excluding mhtml and base64 urls
     def rewrite_content_urls!(file_path, content)
-      content.gsub!(/url\s*\(['|"]?([^\)'"]+)['|"]?\)/) do |s|
-        matched_url = $1
-        #we shouldn't change url value for base64 encoded images
-        if not (/base64/.match(s) or /mhtml/.match(s)) and matched_url.match(/\.(jpg|gif|png|jpeg|bmp)/)
-          #using CssUrlRewriter method to get image url 
-          url = WebResourceBundler::CssUrlRewriter.rewrite_relative_path(file_path, matched_url)
-          host = host_for_image(url)
-          s = "url('#{File.join(host, url)}')"
-        else
-          s
-        end
+      content.gsub!(IMAGE_URL_PATTERN) do |s|
+				url = WebResourceBundler::CssUrlRewriter.rewrite_relative_path(file_path, $1)
+				host = host_for_image(url)
+				s = url_css_tag(host, url) 
       end
     end
-    
+
+		def url_css_tag(host, url)
+			"url('#{File.join(host, url)}')"
+		end
+
   end
 end