css-spriter 0.9.2

data/lib/css-spriter/png/idat.rb

@@ -0,0 +1,26 @@
+module PNG
+  class IDAT < Chunk
+    # I don't like that @compressed contains different values depending on how you're using it
+    # maybe we should introduce a builder?
+    def initialize( uncompressed="" )
+      @compressed = ""
+      @compressed += Zlib::Deflate.deflate( uncompressed.pack("C*") ) unless uncompressed == ""
+    end
+
+    def <<( data )
+      @compressed << data
+    end
+
+    def encode
+      @compressed
+    end
+
+    def uncompressed
+      @uncompressed ||= Zlib::Inflate.inflate( @compressed ).unpack("C*")
+    end
+
+    def chunk_name
+      "IDAT"
+    end
+  end
+end

data/lib/css-spriter/png/iend.rb

@@ -0,0 +1,9 @@
+module PNG
+  class IEND < Chunk
+    def encode; "" end
+    
+    def chunk_name
+      "IEND"
+    end
+  end
+end

data/lib/css-spriter/png/ihdr.rb

@@ -0,0 +1,34 @@
+module PNG
+  class IHDR < Chunk
+    SUPPORTED_COLOR_TYPES = [2,3,6]
+    attr_accessor :width, :height, :depth, :color_type
+    # attr_accessor :compression_method, :filter_method, :interlace_method
+
+    def self.new_from_raw( data )
+      raw = data.unpack("N2C5")
+
+      new( *raw[0..6] )
+    end
+
+    def initialize( width, height, depth=8, color_type=2, compression=0, filter=0, interlace=0 )
+      raise "for now, css-spriter only supports non-interlaced images" unless interlace == 0
+      raise "for now, css-spriter only supports images with a bit depth of 8" unless depth == 8
+      unless SUPPORTED_COLOR_TYPES.include? color_type
+        raise "for now, css-spriter only supports color types #{SUPPORTED_COLOR_TYPES.JOIN(',')} color type was #{color_type}"
+      end
+      @width, @height, @depth, @color_type = width, height, depth, color_type
+    end
+
+    def encode
+      to_a.pack("N2C5")
+    end
+
+    def to_a
+      [@width, @height, @depth, @color_type, 0, 0, 0]
+    end
+
+    def chunk_name
+      "IHDR"
+    end
+  end
+end

data/lib/css-spriter/png/image.rb

@@ -0,0 +1,153 @@
+module PNG
+  class Image
+    #color types
+    RGB = 2
+    RGBA = 6
+
+    class << self
+      def image_data( file_name, options={} )
+        image_options = {:rgba => true}.merge( options )
+
+        png = open(file_name)
+
+        return png.to_image unless image_options[:rgba]
+        png.to_image.to_rgba
+      end
+
+      def open( file_name )
+        name = File.basename( file_name, ".png" )
+
+        File.open(file_name, "r") do |f|
+          ihdr, idat = Parser.go!( f )
+          Image.new( ihdr, idat, name )
+        end
+      end
+
+      def write( file_name, data, options = {} )
+        ihdr = PNG::IHDR.new(data.width, data.height, 8, color_type_of(data.pixel_width))
+
+        Image.new(ihdr, nil, file_name, :rows => data).write( file_name, options)
+      end
+
+      def default_filter_type
+        4 # paeth
+      end
+
+    private # class methods
+
+      def color_type_of(pixel_width)
+        case pixel_width
+        when 3
+          RGB
+        when 4
+          RGBA
+        end
+      end
+    end
+
+    def initialize( ihdr, idat, name, options = {} )
+      @ihdr = ihdr
+      @idat = idat
+      @name = name
+      @rows = options[:rows]
+    end
+
+    attr_reader :name
+    def width; @ihdr.width end
+    def height; @ihdr.height end
+    def depth; @ihdr.depth end
+    def color_type; @ihdr.color_type end
+    def uncompressed; @idat.uncompressed end
+
+    def write(file_name, options={})
+      filter_type = options[:filter_type] || Image.default_filter_type
+      File.open(file_name, 'w') do |f|
+        f.write(generate_png( filter_type ))
+      end
+    end
+
+    # check for RGB or RGBA
+    def pixel_width
+      ( color_type == RGB ? 3 : 4)
+    end
+
+    def filter_encoded_rows(filter_type)
+      out = Array.new(height)
+      rows.each_with_index do |row, scanline|
+        last_row = rows.last_scanline(scanline)
+        out[scanline] = encode_row( row, last_row, filter_type, pixel_width)
+      end
+      out
+    end
+
+    def to_image
+      uncompressed = @idat.uncompressed
+
+      #scanline_width - 1 because we're stripping the filter bit
+      n_out = CssSpriter::ImageData.new(:scanline_width => scanline_width - 1,
+                                     :pixel_width => pixel_width,
+                                     :name => self.name,
+                                     :data => Array.new(height))
+      offset = 0
+      height.times do |scanline|
+        end_row = scanline_width + offset
+        row = uncompressed.slice(offset, scanline_width)
+        n_out[scanline] = decode(scanline, row, n_out, pixel_width)
+        offset = end_row
+      end
+      n_out
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      "#{@name} (#{height} x #{width}) [color type: #{color_type}, depth: #{depth}]"
+    end
+
+  private
+
+    def scanline_width
+      # + 1 adds filter byte
+      (width * pixel_width) + 1
+    end
+
+    def rows
+      @rows ||= to_image
+    end
+
+    def decode(current, row, data, pixel_width)
+      filter_type = row.shift
+      decode_row(row, data.last_scanline(current), filter_type, pixel_width)
+    end
+
+    def decode_row(row, last_scanline, filter_type, pixel_width)
+      o = Array.new(row.size)
+      row.each_with_index do |byte, i|
+        o[i] = Filters.decode(filter_type, byte, i, o, last_scanline, pixel_width)
+      end
+      o
+    end
+
+    def encode_row( row, last_scanline, filter_type, pixel_width )
+      o = Array.new(row.size)
+      row.each_with_index do |byte, scanline|
+        o[scanline] = Filters.encode( filter_type, byte, scanline, row, last_scanline, pixel_width)
+      end
+      o.unshift( filter_type )
+    end
+
+    def generate_png( filter_type )
+      file_header = PNG::FileHeader.new.encode
+      raw_data = filter_encoded_rows( filter_type )
+      raw_data.flatten!
+
+      ihdr = PNG::IHDR.new( width, height, depth, color_type ).to_chunk
+      idat = PNG::IDAT.new( raw_data ).to_chunk
+      iend = PNG::IEND.new.to_chunk
+
+      file_header + ihdr + idat + iend
+    end
+  end
+end

data/lib/css-spriter/png/parser.rb

@@ -0,0 +1,54 @@
+module PNG
+  class Parser
+    def self.go!(file)
+      #TODO: Wanted to remove instance go! and use initialize, didn't work.  
+      #Weird
+      Parser.new.go!(file)
+    end
+    def go!( file )
+      check_header( file )
+
+      while(not file.eof?) do 
+        parse_chunk(file)
+      end
+
+      [ @ihdr, @idat ]
+    end
+
+  private
+    def check_header( file )
+      header = file.read(8)
+      raise "Invalid PNG file header" unless ( header == FileHeader.new.encode)
+    end
+
+    def parse_chunk(f)
+      len = f.read(4).unpack("N")
+      type = f.read(4)
+      data = f.read(len[0])
+      crc = f.read(4)
+
+      raise "invalid CRC for chunk type #{type}" if crc_invalid?( type, data, crc )
+
+      handle(type, data)
+    end
+
+    def handle(type, data)
+      case(type)
+      when "IHDR"
+        @ihdr = PNG::IHDR.new_from_raw( data )
+        @width, @height, @depth, @color_type = @ihdr.to_a
+      when "IDAT"
+        @idat ||= PNG::IDAT.new
+        @idat << data 
+      when "IEND"
+        # NOOP
+      else
+        #puts "Ignoring chunk type #{type}"
+      end
+    end
+
+    def crc_invalid?( type, data, crc )
+      [Zlib.crc32( type + data )] != crc.unpack("N")
+    end
+  end
+end

data/lib/css-spriter/processor.rb

@@ -0,0 +1,28 @@
+module CssSpriter
+  class Processor
+    def initialize(opts)
+      @options = opts
+      @processors = dir_processors
+      @css_builder = StylesheetBuilder.new(@options[:source])
+      @css_builder.output_file(@options[:css_file] || @options[:source] + "/sprite.css")
+    end
+
+    def write
+      @processors.each{|d| d.write}
+      @css_builder.write
+    end
+
+    def directories
+      Dir.glob(@options[:source] + "/**/").map{|d| d.gsub(/\/$/, "")}
+    end
+
+    def dir_processors
+      directories.map{|d| DirectoryProcessor.new(d, @options)}
+    end
+
+    def cleanup
+      @processors.each{|d| d.cleanup}
+      @css_builder.cleanup
+    end
+  end
+end

data/lib/css-spriter/sprite.rb

@@ -0,0 +1,39 @@
+class Sprite
+  class ImageFormatException < Exception; end
+  attr_reader :images, :max_height
+
+  def initialize
+    @images = []
+    @locations = {}
+  end
+
+  def append( image )
+    @images.each do |i|
+     unless i.compatible? image
+       raise ImageFormatException.new("Image #{i} not compatible with #{image}")
+     end
+    end
+
+    @images << image
+    @max_height = @images.map{ |i| i.height }.max
+  end
+
+  def locations
+    @images.inject(0) do |x, image|
+      @locations[image.name.to_sym] = { :x => -(x),
+        :width => image.width,
+        :height => image.height}
+      image.width + x
+    end
+    @locations
+  end
+
+  def write( output_filename )
+    return if @images.empty?
+    right_sized = @images.map{|i| i.fill_to_height(@max_height)}
+    # head is the last image, then we merge left
+    head, *tail = right_sized.reverse
+    result = tail.inject( head ){ |head, image| head.merge_left( image ) }
+    PNG::Image.write( output_filename, result )
+  end
+end

data/lib/css-spriter/stylesheet_builder.rb

@@ -0,0 +1,22 @@
+class StylesheetBuilder
+  def initialize(dir)
+    @dir = dir
+    @output_file = @dir + "/sprite.css"
+  end
+
+  def output_file(file)
+    @output_file = file
+  end
+
+  def css
+    @css ||= Dir.glob(@dir + "/**/fragment.css").inject("") {|acc, f| acc + File.read(f)}
+  end
+
+  def write
+    File.open(@output_file, 'w') {|f| f.write(css)}
+  end
+
+  def cleanup
+    File.delete(@output_file) rescue nil
+  end
+end

data/spec/builders/image_builder.rb

@@ -0,0 +1,23 @@
+class ImageBuilder
+  def initialize( general_options={} )
+     default_options = {
+       :width => 100,
+       :height => 100,
+       :name => "test"
+     }
+     @general_options =  default_options.merge general_options
+   end
+
+   def data(width, height)
+     Array.new((width * height * 3) + height).fill(0)
+   end
+
+   def build( specific_options={} )
+     args = @general_options.merge specific_options
+     
+     ihdr = PNG::IHDR.new( args[:width], args[:height] )
+     idat = PNG::IDAT.new( args[:data] || data(args[:width], args[:height]) )
+
+     PNG::Image.new( ihdr, idat, args[:name] )
+   end
+end

data/spec/css_fragments/deep/style/fragment.css

@@ -0,0 +1 @@
+.deep {}

data/spec/css_fragments/some/fragment.css

@@ -0,0 +1 @@
+.some_style {}

data/spec/image_data_spec.rb

@@ -0,0 +1,63 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe CssSpriter::ImageData do 
+  before do 
+      data = [[1,2,3], 
+              [4,5,6]]
+      @id = CssSpriter::ImageData.new(:scanline_width => 3, :pixel_width => 3, :data => data)
+  end
+
+  it "can fill to a specified height" do 
+    result = @id.fill_to_height(3)
+    result.should == [[1,2,3], [4,5,6], [0,0,0]]
+  end
+  it "has scanline width and pixel width attributes" do 
+    @id.scanline_width.should == 3
+    @id.pixel_width.should == 3
+  end
+
+  it "can give you any arbitrary row in the data set" do 
+    @id[0].should == [1,2,3]
+    @id.scanline(0).should == [1,2,3]
+  end
+
+  it "has an empty array by default" do 
+    id = CssSpriter::ImageData.new
+    id.empty?.should be_true
+  end
+
+  it "should return nil when asked for an index that doesn't exist" do 
+    id = CssSpriter::ImageData.new
+    id[0].should be_nil
+  end
+
+  it "can be assigned a row" do 
+    @id[0] = [1,2,3]
+    @id[0].should == [1,2,3]
+  end
+
+  it "behaves like an array" do 
+    @id << [1,2,3]
+    @id.last.should == [1,2,3]
+
+    @id.size.should == 3
+  end
+
+  it "will return the last scanline given a current index" do 
+    @id.last_scanline(1).should == [1,2,3]
+  end
+  
+  describe "RGBA conversion" do
+    it "updates pixel width" do
+      @id.to_rgba.pixel_width.should == 4 # RGBA pixel width
+    end
+    
+    it "updates scanline width" do
+      @id.to_rgba.scanline_width.should == 4
+    end
+    
+    it "puts in an alpha byte with a default value of 255" do
+      @id.to_rgba[0].should == [1,2,3,255]
+    end
+  end
+end