web_resource_bundler 0.0.20 → 0.0.21

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

@@ -2,80 +2,93 @@ module WebResourceBundler
   module Filters
     module ImageEncodeFilter
       class CssGenerator
-        TAGS = ['background-image', 'background']
-        SEPARATOR = 'A_SEPARATOR'
-        PATTERN = /((#{TAGS.join('|')})\s*:[^\(]*)url\(\s*['|"]([^\)]*)['|"]\s*\)/
-        MAX_IMAGE_SIZE = 20
+
+        TAGS               = %w(background-image background)
+        SEPARATOR          = 'A_SEPARATOR'
+        PATTERN            = /((#{TAGS.join('|')})\s*:[^\(]*)url\(\s*['|"]([^\)]*)['|"]\s*\)/i
+        MAX_IMAGE_SIZE     = 32 #IE 8 limitation
+        MHTML_CONTENT_TYPE = 'Content-Type: multipart/related; boundary="'
 
         def initialize(settings, file_manager)
-          @settings = settings
+          @settings     = settings
           @file_manager = file_manager 
         end
 
         def set_settings(settings)
           @settings = settings
-          @settings[:max_image_size] = MAX_IMAGE_SIZE unless @settings[:max_image_size]
         end
 
         #construct mhtml head of css file with definition of image data in base64
+        #each image found in css should be defined in header with base64 encoded content
         def construct_mhtml_content(images)
           result = ""
-          unless images.empty?
-            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"
+          if images.any?
+            result << mhtml_header
+            result << mhtml_images_data(images)
+            result << mhtml_footer 
           end
           result
         end
 
+        #generates css file for IE with encoded images using mhtml in cache dir
+        #mhtml_filepath - path to file with images encoded in base64
+        #creating new css content with images encoded in base64
+        def encode_images_for_ie!(content, path)
+          encode_images_basic!(content) do |image_data, tag|
+            "#{tag}url(mhtml:#{construct_mhtml_link(path)}!#{image_data.id})"
+          end
+        end
+    
+        #generates css file with encoded images in cache dir 
+        def encode_images!(content)
+          encode_images_basic!(content) do |image_data, tag|
+            "#{tag}url('data:image/#{image_data.extension};base64,#{image_data.encoded}')"
+          end
+        end
+
+        private
+
+        def mhtml_header
+          MHTML_CONTENT_TYPE + SEPARATOR + '"' + "\n\n"
+        end
+
+        def mhtml_footer
+          "\n--" + SEPARATOR + "--\n"
+        end
+
+        def mhtml_images_data(images)
+          images.inject("") {|data, i| data << i.construct_mhtml_image_data('--' << SEPARATOR) }
+        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
+        #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
-            #ImageData constructor will write in log if image doesn't exist
+          content.gsub!(PATTERN) do |s|
+            tag  = $1
+            url  = $3
             data = ImageData.new(url, @settings[:resource_dir])
-            if !url.empty? and data.exist and data.size <= @settings[:max_image_size] and block_given?
-              #changing string using provided block
-              #using image url as key to prevent one image be encoded many times
+            if !url.empty? && data.exist && data.size <= image_size_limit && block_given?
               images[url] = data unless images[url]
-              s = yield(images[url], tag) if block_given?
+              yield(images[url], tag)
             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
+        def image_size_limit
+          @settings[:max_image_size] ? [MAX_IMAGE_SIZE, @settings[:max_image_size]].min : MAX_IMAGE_SIZE
         end
 
       end

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

@@ -4,25 +4,21 @@ module WebResourceBundler
     module ImageEncodeFilter
       #ImageData contains info about image found in css files
     	class ImageData
-    		MAX_RAND_FOR_ID = 10000
+
+        MHTML_CONTENT_LOCATION = 'Content-Location:'
+        MHTML_CONTENT_ENCODING = 'Content-Transfer-Encoding:base64'
+
     		attr_reader :extension, :id, :path, :exist, :url
 
     		def initialize(url, folder)
-          @url = url
-          #computing absolute file path using folder of css file
-    			@path = File.join(folder, url) 
-          if File.file?(@path)
-    			  @exist = true 
-          else 
-            @exist = false
-          end
-          if WebResourceBundler::Bundler.instance.logger and !@path.include?('://') and !@exist
-            WebResourceBundler::Bundler.instance.logger.info("Image not found #{@path}")
-          end
+          @url   = url
+    			@path  = File.join(folder, url) 
+          @exist = File.file?(@path)
+          report_problem_if_file_not_found
     			if @exist
-    				@size = File.size(@path)
-    				name, @extension = File.basename(@path).split('.')
-    				@id = Digest::MD5.hexdigest(url) 
+    				@size      = File.size(@path)
+    				@id        = Digest::MD5.hexdigest(url) 
+    				@extension = File.basename(@path).split('.').last
     			end
     		end
 
@@ -34,8 +30,8 @@ module WebResourceBundler
     		def construct_mhtml_image_data(separator)
     			if @exist
     				result = separator + "\n"
-    				result << 'Content-Location:' << @id << "\n"
-    				result <<	'Content-Transfer-Encoding:base64' << "\n\n"
+    				result << MHTML_CONTENT_LOCATION << @id << "\n"
+    				result <<	MHTML_CONTENT_ENCODING << "\n\n"
     				result << encoded << "\n\n"
     			end
     		end
@@ -44,6 +40,15 @@ module WebResourceBundler
     			return nil unless @exist
     			Base64.encode64(File.read(@path)).gsub("\n", '')
     		end
+
+        private
+        
+        def report_problem_if_file_not_found
+          if WebResourceBundler::Bundler.logger && !URI.parse(@path).absolute? && !@exist
+            WebResourceBundler::Bundler.logger.info("Image not found #{@path}")
+          end
+        end
+
     	end
     end
   end

data/lib/web_resource_bundler/filters/image_encode_filter.rb

@@ -1,11 +1,15 @@
 $:.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_'
+
+    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)
@@ -16,42 +20,64 @@ module WebResourceBundler::Filters::ImageEncodeFilter
       @generator.set_settings(settings)
     end
 
+    #creates one new css file with mhtml content for IE < 8
+    #original css file content changed with images encoded in it in base64
+    #also its type changed to CSS because from this point it is valid only for
+    #normal browsers and IE > 7
     def apply!(block_data)
-      added_files = [] 
+      new_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)
-        #we've created separate file for IE so current file should be marked as CSS only
-        file.types = [WebResourceBundler::ResourceFileType::CSS]
+        base_name = file.path
+        mhtml_css_file = create_mhtml_css_file(file) 
+        mhtml_file     = create_mhtml_file(file)
+        change_css_file!(file)
         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)
+          encode_images_in_css_file!(file)
+          images = change_images_to_mhtml_links!(mhtml_css_file, mhtml_filepath(base_name))
+          mhtml_file.content = @generator.construct_mhtml_content(images.values)
         end
-        added_files << ie_css_file
-        added_files << mhtml_file
+        block_data.files << mhtml_css_file
+        block_data.files << mhtml_file
       end
-      block_data.files += added_files 
       block_data
     end
+
+    private
+
+    def encode_images_in_css_file!(file)
+      @generator.encode_images!(file.content)
+    end
+
+    def change_images_to_mhtml_links!(file, mhtml_path)
+      @generator.encode_images_for_ie!(file.content, mhtml_path)
+    end
+
+    def change_css_file!(file)
+      file.path = css_filepath(file.path)
+      file.type = WebResourceBundler::ResourceFileType::BASE64_CSS
+    end
+
+    def create_mhtml_css_file(css_file)
+      WebResourceBundler::ResourceFile.new_mhtml_css_file(mhtml_css_filepath(css_file.path), css_file.content.dup)
+    end
+
+    def create_mhtml_file(css_file)
+      WebResourceBundler::ResourceFile.new_mhtml_file(mhtml_filepath(css_file.path))
+    end
     
-    #path of a new file with images encoded
-    def encoded_filepath(base_file_path)
+    #path to new file with images encoded in base64 for normal browsers
+    def css_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)
+    #path to new file for IE with images encoded in it
+    def mhtml_css_filepath(base_file_path)
       File.join(@settings[:cache_dir], IE_FILE_PREFIX + File.basename(base_file_path))
     end
 
-    #filepath of mhtml file for IE
+		#path to file with mhtml content for IE
     def mhtml_filepath(base_file_path)
-      File.join(@settings[:cache_dir], MHTML_FILE_PREFIX + File.basename(base_file_path, ".*") + '.mhtml') 
+      File.join(@settings[:cache_dir], MHTML_FILE_PREFIX + File.basename(base_file_path, '.css') + '.mhtml')
     end
 
   end

data/lib/web_resource_bundler/filters.rb

@@ -5,5 +5,10 @@ require 'filters/cdn_filter'
 
 module WebResourceBundler
   module Filters
+    FILTER_NAMES = {
+			:bundle_filter => BundleFilter,
+			:base64_filter => ImageEncodeFilter,
+			:cdn_filter    => CdnFilter
+		}
   end
-end
+end

data/lib/web_resource_bundler/rails_app_helpers.rb

@@ -1,67 +1,83 @@
 module WebResourceBundler::RailsAppHelpers
 
+  DATA_URI_START = "<!--[if (!IE)|(gte IE 8)]><!-->" 
+  DATA_URI_END   = "<!--<![endif]-->"               
+  MHTML_START    = "<!--[if lte IE 7]>"             
+  MHTML_END      = "<![endif]-->"                    
+
   def web_resource_bundler_process(&block)
     #getting ActionView::NonConcattingString
     #but we want simple string to escape problems
     result = String.new(capture(&block))
-    #result is original block content by default
-    version = Rails::VERSION::STRING
-    if !params['no_bundler'] and WebResourceBundler::Bundler.instance.settings_correct
+    if !params['no_bundler'] && WebResourceBundler::Settings.correct?
       #we want to keep original string unchanged so we can return same content on error
-      block_data = WebResourceBundler::Bundler.instance.process(result.dup, request.host_with_port, request.protocol.gsub(/:\/\//,''))
+      block_data = WebResourceBundler::Bundler.process(result.dup, request.host_with_port, request.protocol.gsub(/:\/\//,''))
       #if everything ok with bundling we should construct resulted html content and change result
-      result = construct_block(block_data, WebResourceBundler::Bundler.instance.settings) if block_data 
-    end
-    case
-      when version >= '3.0.0' then return raw(result) 
-      when (version >= '2.2.0' and version < '2.4.0') then concat(result)
-    else
-      concat(result, block.binding)
+      result = construct_block(block_data, WebResourceBundler::Settings.settings) if block_data 
     end
+		construct_result(Rails::VERSION::STRING, result, block)
   end
 
   def construct_block(block_data, settings)
-    result = ""
-    #we should include only mhtml files if browser IE 7 or 6
-    if mhtml_should_be_added?
-      styles = block_data.files.select do |f| 
-        !([WebResourceBundler::ResourceFileType::MHTML, WebResourceBundler::ResourceFileType::IE_CSS] & f.types).empty?
-      end
-    else
-    #it normal browser - so just including base64 css
-      styles = block_data.files.select {|f| f.types.include?(WebResourceBundler::ResourceFileType::CSS)}
-    end
-    styles.each do |file|
-      url = File.join('/', file.path)
-      result << stylesheet_link_tag(url) 
-      result << "\n"
-    end
-    block_data.scripts.each do |file|
-      url = File.join('/', file.path)
-      result << javascript_include_tag(url) 
-      result << "\n"
-    end
+		result = ""
+		result << data_uri_part(block_data.base64_styles) 
+		result <<		 mhtml_part(block_data.mhtml_styles) 
+		result <<	 scripts_part(block_data.scripts) 
+
     result << block_data.inline_block unless block_data.inline_block.blank?
+
     block_data.child_blocks.each do |block|
       result << construct_block(block, settings)
     end
+
     unless block_data.condition.empty?
-      result = "<!--#{block_data.condition}>\n #{result}<![endif]-->\n"
+      result = "<!--#{block_data.condition}>\n#{result}<![endif]-->\n"
     end
+
     #removing unnecessary new line symbols
     result.gsub!(/\n(\s)+/, "\n")
     result
   end
 
-  def mhtml_should_be_added?
-    result = false
-    pattern = /MSIE (.*?);/
-    header = request.headers['HTTP_USER_AGENT']
-    match = pattern.match(header)
-    if match and match[1] <= '7.0'  
-        result = true
+  private
+
+	#constructs resulted html text
+	#method depends on rails version
+	def construct_result(version, result, block)
+		case
+      when version >= '3.0.0'                      then raw(result) 
+      when version >= '2.2.0' && version < '2.4.0' then concat(result) 
+    else
+      concat(result, block.binding)
+    end
+	end
+
+	def data_uri_part(styles)
+		result = DATA_URI_START + "\n" 
+    styles.inject(result) do |data, file|
+      data << construct_file_link(file.path)
+    end
+    result << DATA_URI_END << "\n"
+	end
+
+	def mhtml_part(styles)
+		result = MHTML_START + "\n"
+    styles.inject(result) do |data, file|
+      data << construct_file_link(file.path)
     end
-    return result
+    result << MHTML_END + "\n"
+	end
+
+	def scripts_part(scripts)
+		scripts.inject("") do |data, file|
+			url  =  File.join('/', file.path)
+			data << javascript_include_tag(url) << "\n"
+		end
+	end
+
+  def construct_file_link(path)
+    url = File.join('/', path)
+    stylesheet_link_tag(url) << "\n"
   end
 
 end

data/lib/web_resource_bundler/settings.rb

@@ -0,0 +1,99 @@
+require 'yaml'
+class WebResourceBundler::Settings
+
+  DEFAULT_LOG_PATH      = 'log/web_resource_bundler.log'
+  DEFAULT_RESOURCE_DIR  = 'public'
+  DEFAULT_SETTINGS_PATH = 'config/web_resource_bundler.yml'
+  DEFAULT_CACHE_DIR     = 'cache'
+  OBLIGATORY_SETTINGS   = [:resource_dir, :log_path, :cache_dir]
+
+  class << self
+
+    attr_accessor :settings
+
+    #creates settings from config file
+    #and merging them with defaults
+    def create_settings(rails_root, rails_env)
+      config = self.read_from_file(rails_root, rails_env) 
+      @settings = self.defaults(rails_root).merge(config)
+      @settings
+    end
+
+    #ensures that settings has obligatory keys present
+    def correct?(settings = @settings)
+      OBLIGATORY_SETTINGS.each { |key| return false unless settings.has_key?(key) }
+      true
+    end
+
+    #returns setting for particular filter, merged with common settings
+    def filter_settings(filter_name)
+      self.commons(@settings).merge(@settings[filter_name])
+    end
+
+    #setting request specific settings like domain and protocol
+    def set_request_specific_data!(settings, domain, protocol)
+      settings[:domain]   = domain
+      settings[:protocol] = protocol
+      settings
+    end
+
+    #sets new settings by merging with existing
+    def set(settings)
+      @settings.merge!(settings)
+    end
+
+		def filter_used?(name)
+			@settings[name] && @settings[name][:use]
+		end
+
+    protected
+
+    #load settings from yaml file depending on environment
+    #if no settings found - returning empty hash
+    def read_from_file(rails_root, rails_env)
+      settings = {} 
+      file_path = self.settings_file_path(rails_root) 
+      if File.exist?(file_path)
+        all_settings = YAML::load(File.open(file_path))
+        if all_settings[rails_env]
+          settings = all_settings[rails_env]
+          settings[:resource_dir] = File.join(rails_root, DEFAULT_RESOURCE_DIR)
+        end
+      end
+      settings
+    end
+
+    #returns path of config file
+    def settings_file_path(rails_root)
+      File.join(rails_root, DEFAULT_SETTINGS_PATH)
+    end
+
+    #creates defaults settings
+    def defaults(rails_root)
+      {
+        :resource_dir  => File.join(rails_root, DEFAULT_RESOURCE_DIR),
+        :log_path      => File.join(rails_root, DEFAULT_LOG_PATH),
+        :cache_dir     => DEFAULT_CACHE_DIR,
+        :bundle_filter => {
+                            :use => true
+                          },
+        :cdn_filter    => {
+                            :use => false
+                          },
+        :base64_filter => {
+                            :use            => true,
+                            :max_image_size => 20
+                          }
+      }
+    end
+
+    #settings common for all filters
+    def commons(settings)
+      {
+        :resource_dir => settings[:resource_dir],
+        :cache_dir    => settings[:cache_dir]
+      }
+    end
+
+  end
+end

data/lib/web_resource_bundler/web_resource_bundler_init.rb

@@ -1,3 +1,3 @@
-WebResourceBundler::Bundler.instance.setup(Rails.root, Rails.env)
+WebResourceBundler::Bundler.setup(Rails.root, Rails.env)
 ActionView::Base.send(:include, WebResourceBundler::RailsAppHelpers)