sprite-factory 1.0.0

data/test/integration_test.rb

@@ -0,0 +1,100 @@
+require File.expand_path('test_case', File.dirname(__FILE__))
+
+module SpriteFactory
+  class IntegrationTest < SpriteFactory::TestCase
+
+    #----------------------------------------------------------------------------
+
+    def test_generate_regular_sprite
+      integration_test(REGULAR_PATH)
+    end
+
+    def test_generate_horizontal_regular_sprite
+      integration_test(REGULAR_PATH, :output   => output_path('regular.horizontal'),
+                                     :selector => 'img.horizontal_',
+                                     :layout   => :horizontal)
+    end
+
+    def test_generate_vertical_regular_sprite
+      integration_test(REGULAR_PATH, :output   => output_path('regular.vertical'),
+                                     :selector => 'img.vertical_',
+                                     :layout   => :vertical)
+    end
+
+    def test_generate_regular_sprite_with_padding
+      integration_test(REGULAR_PATH, :output   => output_path('regular.padded'),
+                                     :selector => 'img.padded_',
+                                     :padding  => 10)
+    end
+
+    def test_generate_regular_sprite_with_fixed_size
+      integration_test(REGULAR_PATH, :output   => output_path('regular.fixed'),
+                                     :selector => 'img.fixed_',
+                                     :width    => 100,
+                                     :height   => 100)
+    end
+
+    def test_generate_regular_sprite_with_sassy_style
+      integration_test(REGULAR_PATH, :output   => output_path('regular.sassy'),
+                                     :selector => 'img.sassy_',
+                                     :style    => :sass)
+    end
+
+    #----------------------------------------------------------------------------
+
+    def test_generate_irregular_sprite
+      integration_test(IRREGULAR_PATH)
+    end
+
+    def test_generate_horizontal_irregular_sprite
+      integration_test(IRREGULAR_PATH, :output   => output_path('irregular.horizontal'),
+                                       :selector => 'img.horizontal_',
+                                       :layout   => :horizontal)
+    end
+
+    def test_generate_vertical_irregular_sprite
+      integration_test(IRREGULAR_PATH, :output   => output_path('irregular.vertical'),
+                                       :selector => 'img.vertical_',
+                                       :layout   => :vertical)
+    end
+
+    def test_generate_irregular_sprite_with_padding
+      integration_test(IRREGULAR_PATH, :output   => output_path('irregular.padded'),
+                                       :selector => 'img.padded_',
+                                       :padding  => 10)
+    end
+
+    def test_generate_irregular_sprite_with_fixed_size
+      integration_test(IRREGULAR_PATH, :output   => output_path('irregular.fixed'),
+                                       :selector => 'img.fixed_',
+                                       :width    => 100,
+                                       :height   => 100)
+    end
+
+    def test_generate_irregular_sprite_with_sassy_style
+      integration_test(IRREGULAR_PATH, :output   => output_path('irregular.sassy'),
+                                       :selector => 'img.sassy_',
+                                       :style    => :sass)
+    end
+
+    #----------------------------------------------------------------------------
+
+    def test_generate_custom_sprite
+      integration_test(CUSTOM_PATH) do |images|
+        rules = []
+        rules << "div.running img.button { cursor: pointer; #{images[:running][:style]} }"
+        rules << "div.stopped img.button { cursor: pointer; #{images[:stopped][:style]} }"
+        rules.join("\n")
+      end
+    end
+
+    #----------------------------------------------------------------------------
+
+    def test_generate_sprite_from_other_formats
+      integration_test(FORMATS_PATH, :library => :rmagick)
+    end
+
+    #----------------------------------------------------------------------------
+
+  end
+end

data/test/layout_test.rb

@@ -0,0 +1,228 @@
+require File.expand_path('test_case', File.dirname(__FILE__))
+
+module SpriteFactory
+  class LayoutTest < SpriteFactory::TestCase
+
+    #==========================================================================
+    # test REGULAR images
+    #==========================================================================
+
+    def test_horizontal_layout_of_regular_images
+      images = get_regular_images
+      expected = [
+        { :x =>  0, :y => 0 },
+        { :x => 20, :y => 0 },
+        { :x => 40, :y => 0 },
+        { :x => 60, :y => 0 },
+        { :x => 80, :y => 0 }
+      ]
+      verify_layout(100, 10, expected, images, :layout => :horizontal)
+    end
+
+
+    #--------------------------------------------------------------------------
+
+    def test_vertical_layout_of_regular_images
+      images = get_regular_images
+      expected = [
+        { :x => 0, :y =>  0 },
+        { :x => 0, :y => 10 },
+        { :x => 0, :y => 20 },
+        { :x => 0, :y => 30 },
+        { :x => 0, :y => 40 }
+      ]
+      verify_layout(20, 50, expected, images, :layout => :vertical)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_padded_horizontal_layout_of_regular_images
+      images = get_regular_images
+      expected = [
+        { :cssx =>   0, :cssy => 0, :cssw => 40, :cssh => 50, :x =>  10, :y => 20 },
+        { :cssx =>  40, :cssy => 0, :cssw => 40, :cssh => 50, :x =>  50, :y => 20 },
+        { :cssx =>  80, :cssy => 0, :cssw => 40, :cssh => 50, :x =>  90, :y => 20 },
+        { :cssx => 120, :cssy => 0, :cssw => 40, :cssh => 50, :x => 130, :y => 20 },
+        { :cssx => 160, :cssy => 0, :cssw => 40, :cssh => 50, :x => 170, :y => 20 }
+      ]
+      verify_layout(200, 50, expected, images, :layout => :horizontal, :hpadding => 10, :vpadding => 20)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_padded_vertical_layout_of_regular_images
+      images = get_regular_images
+      expected = [
+        { :cssx => 0, :cssy =>   0, :cssw => 40, :cssh => 50, :x => 10, :y =>  20 },
+        { :cssx => 0, :cssy =>  50, :cssw => 40, :cssh => 50, :x => 10, :y =>  70 },
+        { :cssx => 0, :cssy => 100, :cssw => 40, :cssh => 50, :x => 10, :y => 120 },
+        { :cssx => 0, :cssy => 150, :cssw => 40, :cssh => 50, :x => 10, :y => 170 },
+        { :cssx => 0, :cssy => 200, :cssw => 40, :cssh => 50, :x => 10, :y => 220 }
+      ]
+      verify_layout(40, 250, expected, images, :layout => :vertical, :hpadding => 10, :vpadding => 20)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_fixed_horizontal_layout_of_regular_images
+      images = get_regular_images
+      expected = [
+        { :cssx =>   0, :cssy => 0, :cssw => 50, :cssh => 50, :x =>  15, :y => 20 },
+        { :cssx =>  50, :cssy => 0, :cssw => 50, :cssh => 50, :x =>  65, :y => 20 },
+        { :cssx => 100, :cssy => 0, :cssw => 50, :cssh => 50, :x => 115, :y => 20 },
+        { :cssx => 150, :cssy => 0, :cssw => 50, :cssh => 50, :x => 165, :y => 20 },
+        { :cssx => 200, :cssy => 0, :cssw => 50, :cssh => 50, :x => 215, :y => 20 }
+      ]
+      verify_layout(250, 50, expected, images, :layout => :horizontal, :width => 50, :height => 50)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_fixed_vertical_layout_of_regular_images
+      images = get_regular_images
+      expected = [
+        { :cssx => 0, :cssy =>   0, :cssw => 50, :cssh => 50, :x =>  15, :y =>  20 },
+        { :cssx => 0, :cssy =>  50, :cssw => 50, :cssh => 50, :x =>  15, :y =>  70 },
+        { :cssx => 0, :cssy => 100, :cssw => 50, :cssh => 50, :x =>  15, :y => 120 },
+        { :cssx => 0, :cssy => 150, :cssw => 50, :cssh => 50, :x =>  15, :y => 170 },
+        { :cssx => 0, :cssy => 200, :cssw => 50, :cssh => 50, :x =>  15, :y => 220 }
+      ]
+      verify_layout(50, 250, expected, images, :layout => :vertical, :width => 50, :height => 50)
+    end
+
+    #==========================================================================
+    # test IRREGULAR images
+    #==========================================================================
+
+    def test_horizontal_layout_of_irregular_images
+      images = get_irregular_images
+      expected = [
+        { :x =>   0, :y =>  0 },
+        { :x =>  20, :y =>  5 },
+        { :x =>  60, :y => 10 },
+        { :x => 120, :y => 15 },
+        { :x => 200, :y => 20 }
+      ]
+      verify_layout(300, 50, expected, images, :layout => :horizontal)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_vertical_layout_of_irregular_images
+      images = get_irregular_images
+      expected = [
+        { :x => 40, :y =>   0 },
+        { :x => 30, :y =>  50 },
+        { :x => 20, :y =>  90 },
+        { :x => 10, :y => 120 },
+        { :x =>  0, :y => 140 }
+      ]
+      verify_layout(100, 150, expected, images, :layout => :vertical)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_padded_horizontal_layout_of_irregular_images
+      images = get_irregular_images
+      expected = [
+        { :cssx =>   0, :cssy =>  0, :cssw =>  40, :cssh => 90, :x =>  10, :y => 20 },
+        { :cssx =>  40, :cssy =>  5, :cssw =>  60, :cssh => 80, :x =>  50, :y => 25 },
+        { :cssx => 100, :cssy => 10, :cssw =>  80, :cssh => 70, :x => 110, :y => 30 },
+        { :cssx => 180, :cssy => 15, :cssw => 100, :cssh => 60, :x => 190, :y => 35 },
+        { :cssx => 280, :cssy => 20, :cssw => 120, :cssh => 50, :x => 290, :y => 40 }
+      ]
+      verify_layout(400, 90, expected, images, :layout => :horizontal, :hpadding => 10, :vpadding => 20)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_padded_vertical_layout_of_irregular_images
+      images = get_irregular_images
+      expected = [
+        { :cssx => 40, :cssy =>   0, :cssw =>  40, :cssh => 90, :x => 50, :y =>  20 },
+        { :cssx => 30, :cssy =>  90, :cssw =>  60, :cssh => 80, :x => 40, :y => 110 },
+        { :cssx => 20, :cssy => 170, :cssw =>  80, :cssh => 70, :x => 30, :y => 190 },
+        { :cssx => 10, :cssy => 240, :cssw => 100, :cssh => 60, :x => 20, :y => 260 },
+        { :cssx =>  0, :cssy => 300, :cssw => 120, :cssh => 50, :x => 10, :y => 320 }
+      ]
+      verify_layout(120, 350, expected, images, :layout => :vertical, :hpadding => 10, :vpadding => 20)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_fixed_horizontal_layout_of_irregular_images
+      images = get_irregular_images
+      expected = [
+        { :cssx =>   0, :cssy => 0, :cssw => 100, :cssh => 100, :x =>  40, :y => 25 },
+        { :cssx => 100, :cssy => 0, :cssw => 100, :cssh => 100, :x => 130, :y => 30 },
+        { :cssx => 200, :cssy => 0, :cssw => 100, :cssh => 100, :x => 220, :y => 35 },
+        { :cssx => 300, :cssy => 0, :cssw => 100, :cssh => 100, :x => 310, :y => 40 },
+        { :cssx => 400, :cssy => 0, :cssw => 100, :cssh => 100, :x => 400, :y => 45 }
+      ]
+      verify_layout(500, 100, expected, images, :layout => :horizontal, :width => 100, :height => 100)
+    end
+
+    #--------------------------------------------------------------------------
+
+    def test_fixed_vertical_layout_of_irregular_images
+      images = get_irregular_images
+      expected = [
+        { :cssx => 0, :cssy =>   0, :cssw => 100, :cssh => 100, :x => 40, :y =>  25 },
+        { :cssx => 0, :cssy => 100, :cssw => 100, :cssh => 100, :x => 30, :y => 130 },
+        { :cssx => 0, :cssy => 200, :cssw => 100, :cssh => 100, :x => 20, :y => 235 },
+        { :cssx => 0, :cssy => 300, :cssw => 100, :cssh => 100, :x => 10, :y => 340 },
+        { :cssx => 0, :cssy => 400, :cssw => 100, :cssh => 100, :x =>  0, :y => 445 }
+      ]
+      verify_layout(100, 500, expected, images, :layout => :vertical, :width => 100, :height => 100)
+    end
+
+    #==========================================================================
+    # private test helpers
+    #==========================================================================
+
+    private
+
+    def get_regular_images
+      return [
+        {:width => 20, :height => 10},
+        {:width => 20, :height => 10},
+        {:width => 20, :height => 10},
+        {:width => 20, :height => 10},
+        {:width => 20, :height => 10}
+      ]
+    end
+
+    def get_irregular_images
+      return [
+        {:width => 20,  :height => 50},
+        {:width => 40,  :height => 40},
+        {:width => 60,  :height => 30},
+        {:width => 80,  :height => 20},
+        {:width => 100, :height => 10}
+      ]
+    end
+
+    #--------------------------------------------------------------------------
+
+    def verify_layout(expected_width, expected_height, expected_images, images, options = {})
+      max = Layout.send(options[:layout] || :horizontal, images, options)
+      assert_equal(expected_width, max[:width])
+      assert_equal(expected_height, max[:height])
+      assert_equal(expected_images.length, images.length)
+      images.length.times.each do |n|
+        expected = expected_images[n]
+        actual   = images[n]
+        assert_equal(expected[:x],                       actual[:x],    "image #{n} - unexpected x")
+        assert_equal(expected[:y],                       actual[:y],    "image #{n} - unexpected y")
+        assert_equal(expected[:cssx] || expected[:x],    actual[:cssx], "image #{n} - unexpected cssx")
+        assert_equal(expected[:cssy] || expected[:y],    actual[:cssy], "image #{n} - unexpected cssy")
+        assert_equal(expected[:cssw] || actual[:width],  actual[:cssw], "image #{n} - unexpected cssw")
+        assert_equal(expected[:cssh] || actual[:height], actual[:cssh], "image #{n} - unexpected cssh")
+      end
+    end
+
+    #--------------------------------------------------------------------------
+
+  end # class LayoutTest
+end # module SpriteFactory
+

data/test/library_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path('test_case', File.dirname(__FILE__))
+
+class SpriteFactory::LibraryTest < SpriteFactory::TestCase
+
+  #--------------------------------------------------------------------------
+
+  LIBRARIES = {
+    :rmagick   => SpriteFactory::Library::RMagick,
+    :chunkypng => SpriteFactory::Library::ChunkyPng
+  }
+
+  #--------------------------------------------------------------------------
+
+  LIBRARIES.each do |name, library| # use metaprogramming to define independent tests for each library
+
+    define_method "test_load_regular_using_#{name}" do
+      assert_images(REGULAR_INFO, library.load(REGULAR))
+    end
+
+    define_method "test_load_irregular_using_#{name}" do
+      assert_images(IRREGULAR_INFO,  library.load(IRREGULAR))
+    end
+
+    define_method "test_create_using_#{name}" do
+      with_clean_output do
+        images = library.load(REGULAR)
+        x = 0
+        images.each do |image|
+          image[:x] = x
+          image[:y] = 0
+          x = x + image[:width]
+        end
+        width  = images.map{|i| i[:width]}.inject(0){|n,w| n = n + w }
+        height = images.map{|i| i[:height]}.max
+        library.create(output_path('regular.horizontal.png'), images, width, height)
+        assert_reference_image('regular.horizontal.png')
+      end
+    end
+
+  end
+
+  #--------------------------------------------------------------------------
+
+  private
+
+  def assert_images(expected, actual, msg = nil)
+    assert_equal(expected.length, actual.length, "#{msg} - expected the same number of images")
+    expected.length.times do |n|
+      assert_equal(expected[n][:filename], actual[n][:filename], "#{msg} - unexpected filename at index #{n}")
+      assert_equal(expected[n][:width],    actual[n][:width],    "#{msg} - unexpected width at index #{n}")
+      assert_equal(expected[n][:height],   actual[n][:height],   "#{msg} - unexpected height at index #{n}")
+    end
+  end
+
+  #----------------------------------------------------------------------------
+
+end

data/test/runner_test.rb

@@ -0,0 +1,156 @@
+require File.expand_path('test_case', File.dirname(__FILE__))
+
+module SpriteFactory
+  class RunnerTest < SpriteFactory::TestCase
+
+    #----------------------------------------------------------------------------
+
+    def test_defaults
+
+      Runner.publicize_methods do
+
+        r = Runner.new(REGULAR_PATH) 
+        assert_equal(REGULAR_PATH,            r.input)
+        assert_equal(REGULAR_PATH,            r.output)
+        assert_equal(REGULAR_PATH + ".png",   r.output_image_file)
+        assert_equal(REGULAR_PATH + ".css",   r.output_style_file)
+        assert_equal(REGULAR,                 r.image_files)
+        assert_equal(:horizontal,             r.layout_name)
+        assert_equal(:css,                    r.style_name)
+        assert_equal(:rmagick,                r.library_name)
+
+        r = Runner.new(IRREGULAR_PATH)
+        assert_equal(IRREGULAR_PATH,          r.input)
+        assert_equal(IRREGULAR_PATH,          r.output)
+        assert_equal(IRREGULAR_PATH + ".png", r.output_image_file)
+        assert_equal(IRREGULAR_PATH + ".css", r.output_style_file)
+        assert_equal(IRREGULAR,               r.image_files)
+        assert_equal(:horizontal,             r.layout_name)
+        assert_equal(:css,                    r.style_name)
+        assert_equal(:rmagick,                r.library_name)
+
+        r = Runner.new(REGULAR_PATH, :output => IRREGULAR_PATH)
+        assert_equal(REGULAR_PATH,            r.input)
+        assert_equal(IRREGULAR_PATH,          r.output)
+        assert_equal(IRREGULAR_PATH + ".png", r.output_image_file)
+        assert_equal(IRREGULAR_PATH + ".css", r.output_style_file)
+        assert_equal(REGULAR,                 r.image_files)
+        assert_equal(:horizontal,             r.layout_name)
+        assert_equal(:css,                    r.style_name)
+        assert_equal(:rmagick,                r.library_name)
+
+        r = Runner.new(REGULAR_PATH, :layout => :vertical, :library => :chunkypng, :style => :sass)
+        assert_equal(REGULAR_PATH,            r.input)
+        assert_equal(REGULAR_PATH,            r.output)
+        assert_equal(REGULAR_PATH + ".png",   r.output_image_file)
+        assert_equal(REGULAR_PATH + ".sass",  r.output_style_file)
+        assert_equal(REGULAR,                 r.image_files)
+        assert_equal(:vertical,               r.layout_name)
+        assert_equal(:sass,                   r.style_name)
+        assert_equal(:chunkypng,              r.library_name)
+
+      end
+    
+    end
+
+    #----------------------------------------------------------------------------
+
+    def test_default_padding
+      Runner.publicize_methods do
+        r = Runner.new(REGULAR_PATH)
+        assert_equal(0, r.hpadding)
+        assert_equal(0, r.vpadding)
+
+        r = Runner.new(REGULAR_PATH, :padding => 10)
+        assert_equal(10, r.hpadding)
+        assert_equal(10, r.vpadding)
+
+        r = Runner.new(REGULAR_PATH, :hpadding => 10, :vpadding => 20)
+        assert_equal(10, r.hpadding)
+        assert_equal(20, r.vpadding)
+      end
+    end
+
+    #----------------------------------------------------------------------------
+
+    def test_default_css_path
+      Runner.publicize_methods do
+        r1 = Runner.new(REGULAR_PATH)
+        r2 = Runner.new(REGULAR_PATH, :csspath => "http://s3.amazonaws.com/sf")
+        r3 = Runner.new(REGULAR_PATH, :csspath => "<%= image_path('$IMAGE') %>")
+        r4 = Runner.new(REGULAR_PATH, :csspath => lambda{|image| "/very/dynamic/path/#{image}"})
+
+        assert_equal("regular.png",                            r1.css_path, "by default, csspath should be basename of the generated sprite image")
+        assert_equal("http://s3.amazonaws.com/sf/regular.png", r2.css_path, "allow customization by prepending to basename of the generated sprite image")
+        assert_equal("<%= image_path('regular.png') %>",       r3.css_path, "allow customization by providing custom format string with $IMAGE token to be replaced with basename of the generated sprite image")
+        assert_equal("/very/dynamic/path/regular.png",         r4.css_path, "allow customization by lambda function - allow caller to decide how to generate css path to sprite image")
+      end
+    end
+
+    #----------------------------------------------------------------------------
+
+    def test_trailing_slash_on_input_is_ignored
+      Runner.publicize_methods do
+        r = Runner.new("#{REGULAR_PATH}/")
+        assert_equal(REGULAR_PATH,          r.input)
+        assert_equal(REGULAR_PATH,          r.output)
+        assert_equal(REGULAR_PATH + ".png", r.output_image_file)
+        assert_equal(REGULAR_PATH + ".css", r.output_style_file)
+        assert_equal(REGULAR,               r.image_files)
+      end
+    end
+
+    #----------------------------------------------------------------------------
+
+    def test_invalid_config
+
+      assert_runtime_error "input must be a single directory" do
+        SpriteFactory.run!("")
+      end
+
+      assert_runtime_error "input must be a single directory" do
+        SpriteFactory.run!(REGULAR.first)
+      end
+
+      assert_runtime_error "no output file specified" do
+        SpriteFactory.run!(REGULAR_PATH, :output => "")
+      end
+
+      assert_runtime_error "no image files found" do
+        SpriteFactory.run!(EMPTY_PATH)
+      end
+
+      assert_runtime_error "unknown layout diagonal" do
+        SpriteFactory.run!(REGULAR_PATH, :layout => :diagonal)
+      end
+
+      assert_runtime_error "unknown style funky" do
+        SpriteFactory.run!(REGULAR_PATH, :style => :funky)
+      end
+
+      assert_runtime_error "unknown library hogwarts" do
+        SpriteFactory.run!(REGULAR_PATH, :library => :hogwarts)
+      end
+
+      assert_runtime_error "set :width for fixed width, or :hpadding for horizontal padding, but not both." do
+        SpriteFactory.run!(REGULAR_PATH, :width => 50, :padding => 10)
+      end
+
+      assert_runtime_error "set :height for fixed height, or :vpadding for vertical padding, but not both." do
+        SpriteFactory.run!(REGULAR_PATH, :height => 50, :padding => 10)
+      end
+
+      assert_runtime_error "image regular1 does not fit within a fixed width of 10" do
+        SpriteFactory.run!(REGULAR_PATH, :width => 10)
+      end
+
+      assert_runtime_error "image regular1 does not fit within a fixed height of 10" do
+        SpriteFactory.run!(REGULAR_PATH, :height => 10)
+      end
+
+    end
+
+    #----------------------------------------------------------------------------
+
+  end
+end