web_resource_bundler 0.0.14 → 0.0.15

data/lib/web_resource_bundler/web_resource_bundler_init.rb

@@ -1,17 +1,3 @@
-require 'web_resource_bundler'
-require 'yaml'
-root_dir = Rails.root #or RAILS_ROOT if you are using older rails version than 3 
-environment = Rails.env
-settings = { }
-settings_file_path = File.join(root_dir,'config', 'web_resource_bundler.yml')
-if File.exist?(settings_file_path)
-  settings_file = File.open(settings_file_path)
-  all_settings = YAML::load(settings_file)
-  if all_settings[environment]
-    settings = all_settings[environment]
-    settings[:resource_dir] = File.join(root_dir, 'public')
-  end
-end
-
-WebResourceBundler::Bundler.instance.set_settings(settings)
+WebResourceBundler::Bundler.instance.setup(Rails.root, Rails.env)
 ActionView::Base.send(:include, WebResourceBundler::RailsAppHelpers)
+

data/lib/web_resource_bundler.rb

@@ -5,6 +5,7 @@ require 'content_management/css_url_rewriter'
 require 'content_management/resource_file'
 
 require 'file_manager'
+require 'settings_manager'
 require 'logger'
 require 'filters'
 require 'exceptions'
@@ -16,59 +17,45 @@ module WebResourceBundler
   class Bundler
     include Singleton
 
-    attr_reader :settings, :settings_correct, :filters
-    @@logger = nil
-    def self.logger
-      @@logger
-    end
+    attr_reader :settings, :settings_correct, :filters, :logger
 
     def initialize
       @filters = {} 
       @settings = nil
       @file_manager = FileManager.new('','') 
       @parser = BlockParser.new
-      @@logger = nil 
+      @logger = nil 
       @settings_correct = false
     end
 
-    #could be used also when settings are different on each request
-    def set_settings(settings)
-      #all methods user call from rails should not raise any exception
-      begin
-        @settings = settings
-        if @settings[:resource_dir]
-
-          #creating default log file in rails log directory called web_resource_bundler.log
-          unless @settings[:log_path]
-            log_dir = File.expand_path('../log', @settings[:resource_dir])
-            log_name = 'web_resource_bundler.log'
-            @settings[:log_path] = File.join(log_dir, log_name)
-            Dir.mkdir(log_dir) unless File.exist?(log_dir)
-          end
-          @@logger = create_logger(@settings[:log_path]) unless @@logger
-
-          unless @settings[:cache_dir]
-            @settings[:cache_dir] = 'cache'
-          end
-
-          @file_manager.resource_dir, @file_manager.cache_dir = @settings[:resource_dir], @settings[:cache_dir]
-          set_filters(@settings, @file_manager) 
-          #used to determine if bundler in correct state and could be used
-          @settings_correct = true
-        else
-          @settings_correct = false
-        end
-      rescue Exception => e
-        @@logger.error("Incorrect settings initialization, #{settings}\n#{e.to_s}") if @@logger
-        @settings_correct = false
+    #this method should called in initializer
+    def setup(rails_root, rails_env)
+      @settings = SettingsManager.create_settings(rails_root, rails_env)
+      @settings_correct = SettingsManager.settings_correct?(@settings)
+      if @settings_correct
+        @logger = create_logger(@settings[:log_path]) unless @logger
+        @file_manager.resource_dir, @file_manager.cache_dir = @settings[:resource_dir], @settings[:cache_dir]
+        set_filters(@settings, @file_manager) 
       end
     end
 
+    #this method should be used to turn on\off filters
+    #on particular request
+    def set_settings(settings)
+      @settings.merge!(settings)
+      @settings_correct = SettingsManager.settings_correct?(@settings)
+      set_filters(@settings, @file_manager)
+    end
+
     #main method to process html text block
-    def process(block)
+    def process(block, domain, protocol)
       if @settings_correct
         begin
           filters = filters_array
+          #passing current request domain and protocol to each filter
+          filters.each do |filter|
+            SettingsManager.set_request_specific_settings!(filter.settings, domain, protocol)
+          end
           #parsing html text block, creating BlockData instance
           block_data = @parser.parse(block)
           #if filters set and no bundle files exists we should process block data
@@ -79,17 +66,17 @@ module WebResourceBundler
             block_data.apply_filters(filters)
             #writing resulted files with filtered content on disk
             write_files_on_disk(block_data)
-            @@logger.info("files written on disk")
+            @logger.info("files written on disk")
             return block_data
           end
           #bundle up to date, returning existing block with modified file names 
           block_data.apply_filters(filters)
           return block_data
         rescue Exceptions::WebResourceBundlerError => e
-          @@logger.error(e.to_s)
+          @logger.error(e.to_s)
           return nil
         rescue Exception => e
-          @@logger.error(e.backtrace.join("\n") + "Unknown error occured: " + e.to_s)
+          @logger.error(e.backtrace.join("\n") + "Unknown error occured: " + e.to_s)
           return nil
         end
       end
@@ -108,20 +95,15 @@ module WebResourceBundler
 
     #creates filters or change their settings
     def set_filters(settings, file_manager)
-      #common settings same for all filters
-      common_sets = { 
-        :resource_dir => settings[:resource_dir],
-        :cache_dir => settings[:cache_dir]
-      }
-      #used to create filters
       filters_data = {
         :bundle_filter => 'BundleFilter',
         :base64_filter => 'ImageEncodeFilter',
         :cdn_filter => 'CdnFilter'
       }
       filters_data.each_pair do |key, filter_class| 
+        #if filter settings are present and filter turned on
         if settings[key] and settings[key][:use] 
-          filter_settings = settings[key].merge(common_sets) 
+          filter_settings = SettingsManager.send("#{key}_settings", settings) 
           if @filters[key] 
             @filters[key].set_settings(filter_settings)
           else
@@ -133,13 +115,15 @@ module WebResourceBundler
       @filters
     end
 
-    def create_logger(logfile_path)
+    def create_logger(log_path)
       begin
-        file = File.open(logfile_path, File::WRONLY | File::APPEND | File::CREAT)
+        log_dir = File.dirname(log_path)
+        #we should create log dir in rails root if it doesn't exist
+        Dir.mkdir(log_dir) unless File.exist?(log_dir)
+        file = File.open(log_path, File::WRONLY | File::APPEND | File::CREAT)
         logger = Logger.new(file)
       rescue Exception => e
-        logger = Logger.new(STDOUT)
-        logger.error("Can't create log file, check log path: #{logfile_path}\n#{e.to_s}")
+        raise WebResourceBundler::Exceptions::LogCreationError.new(log_path, e.to_s) 
       end
       logger
     end
@@ -166,7 +150,7 @@ module WebResourceBundler
       block_data.files.each do |file|
         content = @file_manager.get_content(file.path)
         #rewriting url to absolute if content is css
-        WebResourceBundler::CssUrlRewriter.rewrite_content_urls!(file.path, content) if file.type[:ext] == 'css'  
+        WebResourceBundler::CssUrlRewriter.rewrite_content_urls!(file.path, content) if file.types.first[:ext] == 'css'  
         file.content = content
       end
       #making the same for each child blocks, recursively

data/spec/sample_block_helper.rb

@@ -29,8 +29,8 @@ class SampleBlockHelper
     block
   end
 
-  def construct_resource_file(type, file, content = nil)
-    resource_file = WebResourceBundler::ResourceFile.new(type, file)
+  def construct_resource_file(file, content, *types)
+    resource_file = WebResourceBundler::ResourceFile.new(file, '', types)
     if content
       resource_file.content = content
     else
@@ -55,10 +55,10 @@ class SampleBlockHelper
   def sample_block_data
     data = BlockData.new
     @styles[0..(@styles.size / 2 - 1)].each do |file|
-      data.files << construct_resource_file(ResourceFileType::CSS, file)
+      data.files << construct_resource_file(file, nil, ResourceFileType::CSS, ResourceFileType::IE_CSS)
     end
     @scripts[0..(@scripts.size / 2 - 1)].each do |file|
-      data.files << construct_resource_file(ResourceFileType::JS, file)
+      data.files << construct_resource_file(file, nil, ResourceFileType::JS)
     end
     data.inline_block = sample_inline_block
     data.child_blocks << child_block_data
@@ -68,10 +68,10 @@ class SampleBlockHelper
   def child_block_data
     child = BlockData.new("[if IE 7]")
     @styles[(@styles.size / 2)..(@styles.size - 1)].each do |file|
-      child.files << construct_resource_file(ResourceFileType::CSS, file)
+      child.files << construct_resource_file(file, nil, ResourceFileType::CSS)
     end
     @scripts[(@scripts.size / 2)..(@scripts.size - 1)].each do |file|
-      child.files << construct_resource_file(ResourceFileType::JS, file)
+      child.files << construct_resource_file(file, nil, ResourceFileType::JS)
     end
     child.inline_block = sample_inline_block
     child

data/spec/spec_helper.rb

@@ -19,20 +19,23 @@ def scripts
   ["/set_cookies.js", "/seal.js", "/salog20.js", "/marketing.js"]
 end
 
+def root_dir
+  File.join(File.dirname(__FILE__), 'test_data')
+end
+
 def settings
   {
-    :resource_dir => File.join(File.dirname(__FILE__), '/public'),
+    :resource_dir => File.join(root_dir, '/public'),
     :cache_dir => 'cache',
-    :log_path => File.join(File.dirname(__FILE__), '/bundler.log'),
+    :log_path => File.join(root_dir, '/log/bundler.log'),
+    :protocol => 'http',
+    :domain => 'localhost:3000',
     :base64_filter => {
       :use => true,
       :max_image_size => 23, #kbytes
-      :protocol => 'http',
-      :domain => 'localhost:3000'
     },
     :bundle_filter => {
       :use => true,
-      :md5_additional_data => ['localhost:3000', 'http'],
       :filename_additional_data => ['en']
     },
     :cdn_filter => {
@@ -56,7 +59,12 @@ def base64_settings
 end
 
 def common_settings
-  {:resource_dir => settings[:resource_dir], :cache_dir => settings[:cache_dir]}
+  {
+    :resource_dir => settings[:resource_dir], 
+    :cache_dir => settings[:cache_dir],
+    :domain => settings[:domain],
+    :protocol => settings[:protocol]
+  }
 end
 
 

data/spec/test_data/config/web_resource_bundler.yml

@@ -0,0 +1,21 @@
+development:
+  :base64_filter:
+    :use: true
+    :max_image_size: 23
+  :bundle_filter:
+    :use: true
+  :cdn_filter:
+    :use: true
+    :http_hosts: ['http://localhost:3000']
+    :https_hosts: ['https://localhost:3000']
+
+production:
+  :base64_filter:
+    :use: true
+    :max_image_size: 23
+  :bundle_filter:
+    :use: true
+  :cdn_filter:
+    :use: true
+    :http_hosts: ['http://s1.wrb.railsware.com', 'http://s2.wrb.railsware.com', 'http://s3.wrb.railsware.com', 'http://s4.wrb.railsware.com']
+    :https_hosts: ['http://s1.wrb.railsware.com', 'http://s2.wrb.railsware.com', 'http://s3.wrb.railsware.com', 'http://s4.wrb.railsware.com']

data/spec/web_resource_bundler/content_management/resource_file_spec.rb

@@ -5,7 +5,7 @@ describe WebResourceBundler::ResourceFile do
       f = WebResourceBundler::ResourceFile.new_css_file('a', 'b')
       f.path.should == 'a'
       f.content.should == 'b'
-      f.type.should == WebResourceBundler::ResourceFileType::CSS
+      f.types.first.should == WebResourceBundler::ResourceFileType::CSS
     end
   end
   describe "#new_js_file" do
@@ -13,7 +13,7 @@ describe WebResourceBundler::ResourceFile do
       f = WebResourceBundler::ResourceFile.new_js_file('a', 'b')
       f.path.should == 'a'
       f.content.should == 'b'
-      f.type.should == WebResourceBundler::ResourceFileType::JS
+      f.types.first.should == WebResourceBundler::ResourceFileType::JS
     end
   end
   describe "#new_mhtml_file" do
@@ -21,7 +21,15 @@ describe WebResourceBundler::ResourceFile do
       f = WebResourceBundler::ResourceFile.new_mhtml_file('a', 'b')
       f.path.should == 'a'
       f.content.should == 'b'
-      f.type.should == WebResourceBundler::ResourceFileType::MHTML
+      f.types.first.should == WebResourceBundler::ResourceFileType::MHTML
+    end
+  end
+  describe "#new_style_file" do
+    it "creates new resource file of CSS and IE_CSS type" do
+      f = WebResourceBundler::ResourceFile.new_style_file('a', 'b')
+      f.path.should == 'a'
+      f.content.should == 'b'
+      f.types.should == [WebResourceBundler::ResourceFileType::CSS, WebResourceBundler::ResourceFileType::IE_CSS]
     end
   end
   describe "#clone" do

data/spec/web_resource_bundler/filters/bundle_filter/filter_spec.rb

@@ -8,10 +8,12 @@ describe WebResourceBundler::Filters::BundleFilter::Filter do
     @block_data = @sample_block_helper.sample_block_data
     css_type = ResourceFileType::CSS
     js_type = ResourceFileType::JS
-    items = [@block_data.styles.map {|f| f.path}.sort] + @bundle_settings[:md5_additional_data]
+    items = [@block_data.styles.map {|f| f.path}.sort] + [@bundle_settings[:protocol], @bundle_settings[:domain]]
+    items += @bundle_settings[:md5_additional_data] if @bundle_settings[:md5_additional_data]
     @css_md5_value = Digest::MD5.hexdigest(items.flatten.join('|'))
     @css_bundle_file = File.join(@settings[:cache_dir], [css_type[:name] + '_' + @css_md5_value, 'en', css_type[:ext]].join('.'))
-    items = [@block_data.scripts.map {|f| f.path}.sort]  + @bundle_settings[:md5_additional_data]
+    items = [@block_data.scripts.map {|f| f.path}.sort] + [@bundle_settings[:protocol], @bundle_settings[:domain]]
+    items += @bundle_settings[:md5_additional_data] if @bundle_settings[:md5_additional_data]
     js_md5_value = Digest::MD5.hexdigest(items.flatten.join('|'))
     @js_bundle_file = File.join(@settings[:cache_dir], [js_type[:name] + '_' + js_md5_value, 'en', js_type[:ext]].join('.'))
   end

data/spec/web_resource_bundler/filters/image_encode_filter/filter_spec.rb

@@ -26,7 +26,7 @@ describe WebResourceBundler::Filters::ImageEncodeFilter::Filter do
 
   describe "#mhtml_filepath" do
     it "returns mhtml file path" do
-      @filter.mhtml_filepath('styles/1.css').should == 'cache/mhtml_1.css'
+      @filter.mhtml_filepath('styles/1.css').should == 'cache/mhtml_1.mhtml'
     end
   end
 
@@ -34,17 +34,30 @@ describe WebResourceBundler::Filters::ImageEncodeFilter::Filter do
     context "block was bundled" do
       before(:each) do
         @bundler_filter = Filters::BundleFilter::Filter.new(@base64_settings, @file_manager)
-      end
+              end
       it "encodes images in css and change filename" do
         block_data = @sample_block_helper.sample_block_data
         bundle_filepath = @bundler_filter.bundle_filepath(WebResourceBundler::ResourceFileType::CSS, block_data.styles)
         @bundler_filter.apply!(block_data)
         @filter.apply!(block_data)
-        generated_files = block_data.files.map {|f| f.path}
+        generated_files = block_data.files.map {|f| f.path}      
         generated_files.include?(File.join(@settings[:cache_dir], @file_prefix + File.basename(bundle_filepath))).should be_true
         generated_files.include?(File.join(@settings[:cache_dir], @ie_file_prefix + File.basename(bundle_filepath))).should be_true
       end
 
+      it "changes type of styles files to CSS only" do
+        block_data = @sample_block_helper.sample_block_data
+        resource_file = WebResourceBundler::ResourceFile.new_style_file(styles.first)
+        block_data.files = [resource_file]
+        block_data.child_blocks = []
+        @bundler_filter.apply!(block_data)
+        @filter.apply!(block_data)
+        block_data.files.size.should == 3
+        %w{CSS IE_CSS MHTML}.each do |type_name|
+          type = eval("WebResourceBundler::ResourceFileType::" + type_name)
+          block_data.files.select {|f| f.types == [type]}.size.should == 1
+        end
+      end
     end
     context "block wasn't bundled" do
       before(:each) do
@@ -53,7 +66,7 @@ describe WebResourceBundler::Filters::ImageEncodeFilter::Filter do
         @block_data.files = []
         @files = %w{sample.css foo.css}
         @files.each do |f|
-          @block_data.files << @sample_block_helper.construct_resource_file(WebResourceBundler::ResourceFileType::CSS, f)
+          @block_data.files << @sample_block_helper.construct_resource_file(f,'', WebResourceBundler::ResourceFileType::CSS)
         end
         @filter.apply!(@block_data)
       end

data/spec/web_resource_bundler/settings_manager_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "../spec_helper"))
+describe WebResourceBundler::SettingsManager do
+
+  before(:each) do
+    @s = settings
+  end
+
+  describe "#create_default_settings" do
+    it "returns default required settings for bundler" do
+      root = '/root' 
+      settings = SettingsManager.create_default_settings(root)
+      settings[:resource_dir].should == File.join(root, SettingsManager::DEFAULT_RESOURCE_DIR)
+      settings[:log_path].should == File.join(root, SettingsManager::DEFAULT_LOG_PATH)
+      settings[:cache_dir].should == SettingsManager::DEFAULT_CACHE_DIR
+      settings[:bundle_filter][:use].should == true
+      settings[:cdn_filter][:use].should == false
+      settings[:base64_filter][:use].should == true
+    end
+  end
+
+  describe "#common_settings" do
+    it "returns settings common to all filters" do
+      settings = SettingsManager.common_settings(@s)
+      settings.keys.size.should == 2
+      settings[:resource_dir].should == @s[:resource_dir]
+      settings[:cache_dir].should == @s[:cache_dir]
+    end
+  end
+
+  describe "#settings_from_file" do
+    it "loads settings from yaml file" do
+      rails_root = root_dir 
+      content = File.read(File.join(root_dir, 'config/web_resource_bundler.yml'))
+      rails_env = 'development'
+      original = YAML::load(content)[rails_env]
+      settings = SettingsManager.settings_from_file(rails_root, rails_env) 
+      original.each_key do |key|
+        settings[key].should == original[key]
+      end
+      settings[:resource_dir].should == File.join(root_dir, SettingsManager::DEFAULT_RESOURCE_DIR)
+    end
+    it "returns empty hash if file isn't exist" do
+      SettingsManager.settings_from_file('', '').should == {}
+    end
+  end
+
+  describe "#settings_correct?" do
+    it "should return true if all required keys present" do
+      SettingsManager.settings_correct?(@s).should be_true
+    end
+    it "returns false if one of the keys isn't present" do
+      @s.delete(:resource_dir)
+      SettingsManager.settings_correct?(@s).should be_false
+    end
+  end
+
+  context "dynamically created filter settings methods" do
+    it "properly creates methods for each filter settings" do
+      %w{cdn_filter_settings base64_filter_settings bundle_filter_settings}.each do |method|
+        if RUBY_VERSION > '1.9.0'
+          key = method.to_sym 
+        else
+          key = method
+        end
+        SettingsManager.public_methods.include?(key).should be_true
+      end
+    end
+    describe "#cdn_filter_settings" do
+      it "returns cdn settings merged with commons" do
+        cdn = SettingsManager.cdn_filter_settings(@s)
+        cdn[:resource_dir].should == @s[:resource_dir]
+        cdn[:cache_dir].should == @s[:cache_dir]
+        cdn[:use].should == @s[:cdn_filter][:use]
+      end
+    end
+  end
+
+  describe "#set_request_specific_settings!" do
+    it "sets domain and protocol for settings" do
+      s = {}
+      SettingsManager.set_request_specific_settings!(s, 'google.com', 'http')
+      s[:domain].should == 'google.com'
+      s[:protocol].should == 'http'
+    end
+  end
+
+end
+