web_resource_bundler 0.0.13

data/lib/web_resource_bundler/content_management/block_parser.rb

@@ -0,0 +1,63 @@
+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 = ""
+      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
+        end
+      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(WebResourceBundler::ResourceFileType::JS, value) if File.extname(value) == '.js'
+            when "href" 
+              then files << WebResourceBundler::ResourceFile.new(WebResourceBundler::ResourceFileType::CSS, value) if File.extname(value) == '.css'
+          end
+        end
+      end
+      files
+    end
+
+    #just a short method to start parsing passed block
+    def parse(block)
+      parse_block_with_childs(block, "")
+    end
+
+  end
+end

data/lib/web_resource_bundler/content_management/css_url_rewriter.rb

@@ -0,0 +1,23 @@
+class WebResourceBundler::CssUrlRewriter
+  class << self
+    # 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://')
+      File.expand_path(relative_url, File.dirname(source_url))
+    end
+  
+    # rewrite the URL reference paths
+    # url(../../../images/active_scaffold/default/add.gif);
+    # url(/stylesheets/active_scaffold/default/../../../images/active_scaffold/default/add.gif);
+    # url(/stylesheets/active_scaffold/../../images/active_scaffold/default/add.gif);
+    # 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
+    end
+
+  end
+end 

data/lib/web_resource_bundler/content_management/resource_file.rb

@@ -0,0 +1,35 @@
+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'}
+  end
+
+  class ResourceFile  
+    attr_reader :type
+    attr_accessor :path, :content
+    def initialize(type, path, content = "")
+      @type = type
+      @content = content
+      @path = path
+    end
+    def self.new_js_file(path, content = "")
+      ResourceFile.new(ResourceFileType::JS, path, content) 
+    end
+    def self.new_css_file(path, content = "")
+      ResourceFile.new(ResourceFileType::CSS, path, content)
+    end
+    def self.new_ie_css_file(path, content ="")
+      ResourceFile.new(ResourceFileType::IE_CSS, path, content)
+    end
+    def self.new_mhtml_file(path, content = "")
+      ResourceFile.new(ResourceFileType::MHTML, path, content)
+    end
+    def clone
+      ResourceFile.new(self.type.dup, self.path.dup, self.content.dup)
+    end
+  end
+
+end

data/lib/web_resource_bundler/exceptions.rb

@@ -0,0 +1,26 @@
+module WebResourceBundler::Exceptions
+  class WebResourceBundlerError < Exception
+
+    def initialize(message = "Unknown error occured")
+      @message = message
+    end
+
+    def to_s
+      @message
+    end
+
+  end
+
+  class ResourceNotFoundError < WebResourceBundlerError
+    def initialize(path)
+      super "Resource #{path} not found"
+    end
+  end
+
+  class NonExistentCssImage < WebResourceBundlerError
+    def initialize(image_path)
+      super "Css has url to incorrect image path: #{image_path}"
+    end
+  end
+
+end

data/lib/web_resource_bundler/file_manager.rb

@@ -0,0 +1,30 @@
+module WebResourceBundler
+  class FileManager
+    attr_accessor :resource_dir, :cache_dir
+
+    def initialize(resource_dir, cache_dir)
+      @resource_dir, @cache_dir = resource_dir, cache_dir
+    end
+
+    def full_path(relative_path)
+      File.join(@resource_dir, relative_path)
+    end
+
+    def exist?(relative_path)
+      File.exist? full_path(relative_path)
+    end
+
+    def get_content(relative_path)
+      raise Exceptions::ResourceNotFoundError.new(full_path(relative_path)) unless exist?(relative_path)
+      File.read(full_path(relative_path))
+    end
+
+    def create_cache_dir
+      path = File.join(@resource_dir, @cache_dir)
+      unless File.exist?(path)
+        Dir.mkdir(path)
+      end
+    end
+
+  end
+end

data/lib/web_resource_bundler/filters.rb

@@ -0,0 +1,9 @@
+require 'filters/base_filter'
+require 'filters/image_encode_filter'
+require 'filters/bundle_filter'
+require 'filters/cdn_filter'
+
+module WebResourceBundler
+  module Filters
+  end
+end

data/lib/web_resource_bundler/filters/base_filter.rb

@@ -0,0 +1,28 @@
+module WebResourceBundler
+  module Filters
+    #virtaul base class for filters
+    class BaseFilter
+      attr_reader :settings
+
+      def initialize(settings, file_manager)
+        @settings = Settings.new(settings)
+        @file_manager = file_manager
+      end
+
+      def set_settings(settings)
+        @settings.set(settings)
+      end
+
+      def apply(block_data = nil)
+        #applies filter to block_data
+      end
+
+      #resource is hash {:css => ResourceBundle::Data, :js => ResourceBundle::Data}
+      def change_resulted_files!(resource = nil)
+        #this method changes resource file names to resulted files paths
+        #used to determine if resulted files exist on disk
+      end
+
+    end
+  end
+end

data/lib/web_resource_bundler/filters/bundle_filter.rb

@@ -0,0 +1,58 @@
+$:.unshift File.join(File.dirname(__FILE__), "/bundle_filter")
+require 'bundle_filter/resource_packager'
+require 'base_filter'
+require 'digest/md5'
+module WebResourceBundler::Filters::BundleFilter
+  class Filter < WebResourceBundler::Filters::BaseFilter
+
+    def initialize(settings, file_manager)
+      super(settings, file_manager)
+      @packager = ResourcePackager.new(@settings, @file_manager)
+    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_css_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
+      block_data
+    end
+
+    def get_md5(files)
+      items = [(files.map {|f| f.path }).sort]
+      items += @settings.md5_additional_data if @settings.md5_additional_data
+      Digest::MD5.hexdigest(items.flatten.join('|'))
+    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
+    end
+
+    #just aliases to simplify code
+    def css_bundle_filepath(files)
+      bundle_filepath(WebResourceBundler::ResourceFileType::CSS, files)
+    end
+
+    def js_bundle_filepath(files)
+      bundle_filepath(WebResourceBundler::ResourceFileType::JS, files)
+    end
+
+  end
+end

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

@@ -0,0 +1,49 @@
+module WebResourceBundler::Filters::BundleFilter
+  class ResourcePackager
+    IMPORT_PTR = /\@import ['|"](.*?)['|"];/
+
+    def initialize(settings, file_manager)
+      @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
+        content = file.content
+        output << "/* --------- #{path} --------- */\n"
+        if file.type[: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"
+      end
+      output
+    end
+
+    #finds all imported files in css
+    def extract_imported_files!(content, base_file_path)
+      imported_files = []
+      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 = ""
+      end
+      return imported_files
+    end
+
+  end
+end

data/lib/web_resource_bundler/filters/cdn_filter.rb

@@ -0,0 +1,48 @@
+module WebResourceBundler::Filters::CdnFilter
+  class Filter < WebResourceBundler::Filters::BaseFilter
+    def initialize(settings, file_manager)
+      super(settings, file_manager)
+    end
+
+    def apply!(block_data)
+      block_data.styles.each do |file| 
+        rewrite_content_urls!(file.path, file.content) unless file.content.empty? 
+        file.path = new_filepath(file.path)
+      end
+      block_data
+    end
+
+    def new_filepath(path)
+      File.join(@settings.cache_dir, 'cdn_' + File.basename(path))
+    end
+
+    #insures that image linked to one particular host  
+    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]
+    end
+
+    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
+      end
+    end
+    
+  end
+end

data/lib/web_resource_bundler/filters/image_encode_filter.rb

@@ -0,0 +1,56 @@
+$:.unshift File.dirname(__FILE__)
+require 'image_encode_filter/image_data'
+require 'image_encode_filter/css_generator'
+module WebResourceBundler::Filters::ImageEncodeFilter
+  class Filter < WebResourceBundler::Filters::BaseFilter
+    FILE_PREFIX = 'base64_'
+    IE_FILE_PREFIX = 'base64_ie_'
+    MHTML_FILE_PREFIX = 'mhtml_'
+    def initialize(settings, file_manager)
+      super settings, file_manager
+      @generator = CssGenerator.new(@settings, @file_manager)
+    end
+
+    def set_settings(settings)
+      super settings
+      @generator.set_settings(settings)
+    end
+
+    def apply!(block_data)
+      added_files = [] 
+      block_data.styles.each do |file|
+        #creating new css file with content for IE
+        ie_css_file = WebResourceBundler::ResourceFile.new_ie_css_file(encoded_filepath_for_ie(file.path), file.content.dup)
+        #creating new mhtml file with images encoded in base64
+        mhtml_file = WebResourceBundler::ResourceFile.new_mhtml_file(mhtml_filepath(file.path), "")
+        file.path = encoded_filepath(file.path)
+        unless file.content.empty?
+          @generator.encode_images!(file.content)
+          #getting images to construct mhtml file
+          images = @generator.encode_images_for_ie!(ie_css_file.content, mhtml_file.path)
+          mhtml_file.content = @generator.construct_mhtml_content(images)
+        end
+        added_files << ie_css_file
+        added_files << mhtml_file
+      end
+      block_data.files += added_files 
+      block_data
+    end
+    
+    #path of a new file with images encoded
+    def encoded_filepath(base_file_path)
+      File.join(@settings.cache_dir, FILE_PREFIX + File.basename(base_file_path))
+    end
+
+    #path of a new file for IE with images encoded
+    def encoded_filepath_for_ie(base_file_path)
+      File.join(@settings.cache_dir, IE_FILE_PREFIX + File.basename(base_file_path))
+    end
+
+    #filepath of mhtml file for IE
+    def mhtml_filepath(base_file_path)
+      File.join(@settings.cache_dir, MHTML_FILE_PREFIX + File.basename(base_file_path)) 
+    end
+
+  end
+end

data/lib/web_resource_bundler/filters/image_encode_filter/css_generator.rb

@@ -0,0 +1,85 @@
+module WebResourceBundler
+  module Filters
+    module ImageEncodeFilter
+      class CssGenerator
+        TAGS = ['background-image', 'background']
+        SEPARATOR = 'A_SEPARATOR'
+        PATTERN = /((#{TAGS.join('|')})\s*:[^\(]*)url\(\s*['|"]([^\)]*)['|"]\s*\)/
+        
+
+        def initialize(settings, file_manager)
+          @settings = settings
+          @file_manager = file_manager 
+        end
+
+        def set_settings(settings)
+          @settings.set(settings)
+        end
+
+        #construct mhtml head of css file with definition of image data in base64
+        def construct_mhtml_content(images)
+          result = ""
+          unless images.empty?
+            result << "/* \n" 
+            result << 'Content-Type: multipart/related; boundary="' << SEPARATOR << '"' << "\n\n"
+            #each image found in css should be defined in header with base64 encoded content
+            images.each_key do |key|
+              result += images[key].construct_mhtml_image_data('--' + SEPARATOR)
+            end
+            result << "\n" << '--' << SEPARATOR << '--' << "\n"
+            result << "*/"
+          end
+          result
+        end
+
+        #creates mhtml link to use in css tags instead of image url
+        def construct_mhtml_link(filepath)
+          "#{@settings.protocol}://#{File.join(@settings.domain, filepath)}"
+        end
+        
+        #iterates through all tags found in css
+        #if image exist and has proper size - it should be encoded
+        #each tag with this kind of an image is replaced with new one (mhtml link for IE and base64 code for another browser
+        #returns images hash - in case generator can build proper IE css header with base64 images encoded
+        def encode_images_basic!(content)
+          images = {}
+          new_content = content.gsub!(PATTERN) do |s|
+            tag, url = $1, $3
+            #this constructor will write in log if image doesn't exist
+            data = ImageData.new(url, @settings.resource_dir) 
+            if !url.empty? and data.exist and data.size <= @settings.max_image_size and block_given?
+              #using image url as key to prevent one image be encoded many times
+              images[data.url] = data unless images[data.path]
+              #changing string using provided block
+              s = yield(data, tag) if block_given?
+            else
+              #returning the same string because user failed with image path - such image non existent
+              s
+            end
+          end
+          images
+        end
+
+        #generates css file for IE with encoded images using mhtml in cache dir
+        #mhtml_filepath - path to file with images encoded in base64
+        def encode_images_for_ie!(content, mhtml_filepath)
+          #creating new css content with images encoded in base64
+          images = encode_images_basic!(content) do |image_data, tag|
+            "*#{tag}url(mhtml:#{construct_mhtml_link(mhtml_filepath)}!#{image_data.id})"
+          end
+          images
+        end
+    
+        #generates css file with encoded images in cache dir 
+        def encode_images!(content)
+          #encoding images in content
+          images = encode_images_basic!(content) do |image_data, tag|
+              "#{tag}url('data:image/#{image_data.extension};base64,#{image_data.encoded}')"
+          end
+          images
+        end
+
+      end
+    end
+  end
+end