active_assets 0.2.0.rc4 → 0.2.0

data/.autotest

@@ -0,0 +1,55 @@
+require 'autotest/restart'
+require 'autotest/bundler'
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = 'test/unit test/autocolor'
+
+  # Remove the old test unit mappings
+  at.clear_mappings
+
+  # Don't track other dirs, this just burns cpu.
+  (File.read('.gitignore').split("\n") + Dir['test/fixtures/**/*']).each do |ignore|
+    next if ignore.nil? or ignore.empty?
+    at.add_exception ignore
+  end
+
+  # Test::Unit is normally test_, so autotest doesn't have this mapping. Tests
+  # want to match themselves, that is, if there's no changes, run them all.
+  at.add_mapping(%r%^test/.*_test\.rb$%) { |f, _| f }
+
+  # Allow for matches of lib files to test files in a flat way
+  at.add_mapping(%r%^lib/(.*)\.rb$%) do |f, md|
+    at.files_matching( %r%^test/#{md[1]}_test\.rb$%)
+  end
+
+  # Make sure that we run all tests if the helper changes:
+  at.add_mapping(%r%^test/helper\.rb$%) do |f, _|
+    at.files_matching %r%.*_test\.rb%
+  end
+
+  # If bundle did something, run all tests again
+  at.add_mapping(%r%^Gemfile\.lock$%) do |f, _|
+    at.files_matching %r%.*_test\.rb%
+  end
+
+  # If update support, run all tests
+  at.add_mapping(%r%^test/support/.*\.rb$%) do |f, _|
+    at.files_matching %r%.*_test\.rb%
+  end
+
+  def at.path_to_classname(path)
+    file = File.basename(path, '.rb')
+
+    file.gsub!('test_', '')
+    file.gsub!('_test', '')
+    file.capitalize + 'Test'
+  end
+
+end
+
+# If the Gemfile gets updated, run bundle install
+Autotest.add_hook :updated do |at, *args|
+  if args.flatten.grep(%r%^Gemfile$|^.*\.gemspec$%).any?
+    system 'bundle'
+  end
+end

data/.gitignore

@@ -0,0 +1,13 @@
+.DS_Store
+.rvmrc
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+doc
+
+test/fixtures/rails_root/log
+test/fixtures/rails_root/public/stylesheets/cache
+test/fixtures/rails_root/public/javascripts/cache
+test/fixtures/rails_root/public/stylesheets/sprites
+test/fixtures/rails_root/public/images/sprites

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rails-assets.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2011 Sam Woodard - http://github.com/shwoodard
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -8,7 +8,7 @@ A Railtie that provides a full asset management system, including support for de
 Gemfile
 -------
 
-    gem 'active_assets', '~>0.2.0.rc3'
+    gem 'active_assets'
 
 In your rails app
 -----------------
@@ -99,7 +99,7 @@ ActiveSprites allows you to generate sprites within your Rails apps with `rake s
     Rails.application.sprites do
       sprite 'sprites/world_flags.png' => 'sprites/world_flags.css'
         _"sprite_images/world_flags/Argentina.gif" => ".flags.argentina"
-        _"sprites_images/world_flags/Australia.gif" => ".flags.australia"
+        _"sprite_images/world_flags/Australia.gif" => ".flags.australia"
         ...
       end
     end
@@ -163,5 +163,3 @@ It is possible to add all of the world flags!  Haha, see the following example,
 `_` and `sp` are aliases for `sprite_piece`
 
 Also, you will notice that I gave a symbol for the sprite instead of a mapping.  This will assume that you wish to store your sprite at `path/to/your/public/images/sprites/world_flags.png` and you wish to store your stylesheet at `path/to/your/public/stylesheets/sprites/world_flags.css`.
-
-Copyright © Sam Woodard 2011.  Release under the MIT License.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake/testtask'
+require 'bundler'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :environment do
+  load 'test/fixtures/rails_root/config/environment.rb'
+end
+
+Dir['lib/tasks/**/*.rake'].each {|f| load f}
+
+task :default => :test

data/active_assets.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = "active_assets"
+  s.version     = '0.2.0'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sam Woodard"]
+  s.email       = ["sam@wildfireapp.com"]
+  s.homepage    = "http://github.com/shwoodard/active_assets"
+  s.summary     = %q{A Railtie that provides a full asset management system, including support for development and deployment.}
+  s.description = %q{A Railtie that provides a full asset management system, including support for development and deployment.  It is comprised of two libraries, ActiveSprites and ActiveExpansions.  ActiveSprites generates sprites and their corresponding stylesheet from dsl definition. ActiveExpansions manages javascript and css, including concatenation support for deployment, using Rails expansions plus a dsl.}
+
+  s.rubyforge_project = "activeassets"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rmagick'
+  s.add_development_dependency 'css_parser', '~>1.1.5'
+  s.add_development_dependency "rails", "~>3.0.3"
+  s.add_development_dependency "test-unit", "> 2.0"
+  s.add_development_dependency "ZenTest", "~>4.4.2"
+end

data/lib/active_assets/active_sprites/runner.rb

@@ -66,11 +66,14 @@ module ActiveAssets
               self.tile = orientation == Sprite::Orientation::VERTICAL ? "1x#{sprite_pieces.size}" : "#{sprite_pieces.size}x1"
               self.geometry = "+0+0"
               self.background_color = 'transparent'
+              self.matte_color = sprite.matte_color || '#bdbdbd'
             end
 
+            @sprite.strip!
+
             stylesheet = SpriteStylesheet.new(sprite_path, sprite_pieces)
             stylesheet.write File.join(Rails.application.config.paths.public.to_a.first, sprite_stylesheet_path)
-            write File.join(Rails.application.config.paths.public.to_a.first, sprite_path)
+            write File.join(Rails.application.config.paths.public.to_a.first, sprite_path), sprite.quality
           ensure
             finish
           end
@@ -82,9 +85,11 @@ module ActiveAssets
           @context
         end
 
-        def write(path)
+        def write(path, quality = nil)
           FileUtils.mkdir_p(File.dirname(path))
-          @sprite.write("png:#{path}")
+          @sprite.write("#{File.extname(path)[1..-1]}:#{path}") do
+            self.quality = quality || 75
+          end
         end
 
         def finish

data/lib/active_assets/active_sprites/sprite.rb

@@ -21,7 +21,7 @@ module ActiveAssets
         end
       end
 
-      attr_reader :path, :stylesheet_path, :name, :orientation
+      attr_reader :path, :stylesheet_path, :name, :orientation, :quality, :matte_color
 
       def initialize
         # Ordered Hash?
@@ -48,7 +48,8 @@ module ActiveAssets
         @path ||= sprite_path
         @name = options.delete(:as) || sprite_path
         @stylesheet_path = stylesheet_path
-        @orientation = options[:orientation] || :vertical
+        @orientation = options.delete(:orientation) || :vertical
+        options.each {|k,v| send("#{k}=",v)}
         valid!
         instance_eval(&blk) if block_given?
         self
@@ -81,8 +82,12 @@ module ActiveAssets
 
       private
 
-        def orientation=(orientation)
-          @orientation = orientation
+        def matte_color=(val)
+          @matte_color = val
+        end
+
+        def quality=(val)
+          @quality = val
         end
     end
   end

data/lib/tasks/active_sprites/sprites.rake

@@ -1,4 +1,4 @@
-desc "Sprites bitch!"
+desc "Generate sprites."
 task :sprites => :environment do
   Rails.application.sprites.generate!
-end
+end

data/script/console

@@ -0,0 +1 @@
+irb -I./test/fixtures/rails_root -rrubygems -rbundler/setup -rconfig/environment

data/test/active_assets/active_sprites/runner_test.rb

@@ -1,8 +1,10 @@
 require 'helper'
 require 'fileutils'
+require 'rmagick'
+require 'css_parser'
 
 class RunnerTest < Test::Unit::TestCase
-
+  include Magick
   def setup
     initialize_application_or_load_sprites!
 
@@ -20,15 +22,60 @@ class RunnerTest < Test::Unit::TestCase
     tear_down_assets
   end
 
+  Selector = Struct.new(:selector, :x, :y, :width, :height)
 
   def test_generate
-    visit "/sprite?sprite_path=/images/#{Rails.application.sprites['sprites/4.png'].path}"
-    assert_equal 2400, page.find('#sprite').native.height
-  end
+    sprite = Rails.application.sprites['sprites/4.png']
+    orientation = sprite.orientation
+    sprite_pieces = sprite.sprite_pieces
+    sprite_image = Image.read(Rails.root.join('public/images', sprite.path)).first
+
+    stylesheet_path = Rails.root.join('public/stylesheets', sprite.stylesheet_path)
+    parser = CssParser::Parser.new
+    parser.load_file!(File.basename(stylesheet_path), File.dirname(stylesheet_path), :screen)
+
+    sprite_pieces_with_selector_data = []
 
-  def test_generate_2
-    visit "/sprite?sprite_path=/images/#{Rails.application.sprites['sprites/3.png'].path}"
-    assert_equal 96, page.find('#sprite').native.height
+    parser.each_selector do |selectors, declarations, specificity|
+      sprite_piece = sprite_pieces.find {|sp| sp.css_selector == selectors }
+      width = declarations[%r{width:\s*(\d+)(?:px)?;}, 1].to_i
+      height = declarations[%r{height:\s*(\d+)(?:px)?;}, 1].to_i
+      background = declarations[%r{background:\s*([^;]+)}, 1]
+      x = background[%r{\s-?(\d+)(?:px)?\s}, 1].to_i
+      y = background[%r{\s-?(\d+)(?:px)?$}, 1].to_i
+      sprite_pieces_with_selector_data << [sprite_piece, Selector.new(selectors, x, y, width, height)]
+    end
+
+    sprite_pieces_with_selector_data.each do |sp, selector_data|
+      begin
+        sprite_piece_path = Rails.root.join('public/images', sp.path)
+        sprite_piece_image = Image.read(sprite_piece_path).first
+        curr_sprite_image = sprite_image.crop(
+          selector_data.x,
+          selector_data.y,
+          selector_data.width,
+          selector_data.height
+        )
+        curr_sprite_image_file = Tempfile.new("curr_sprite_img.ppm")
+        curr_sprite_image.write "ppm:#{curr_sprite_image_file.path}"
+        curr_sprite_piece_image_bmp = Tempfile.new("curr_sprite_piece_image_bmp.ppm")
+        sprite_piece_image.write "ppm:#{curr_sprite_piece_image_bmp.path}"
+        pd = percent_difference(curr_sprite_image_file.path, curr_sprite_piece_image_bmp.path)
+        assert pd <= 0.25
+      ensure
+        sprite_piece_image.destroy! if sprite_piece_image
+        curr_sprite_image.destroy! if curr_sprite_image
+        curr_sprite_image_file.close if curr_sprite_image_file
+        curr_sprite_piece_image_bmp.close if curr_sprite_piece_image_bmp
+        curr_sprite_piece_image_bmp = nil
+        curr_sprite_image_file = nil
+        curr_sprite_image = nil
+        sprite_piece_image = nil
+      end
+    end
+  ensure
+    sprite_image.destroy! if sprite_image
+    sprite_image = nil
   end
   
   def test_sprite_exists

data/test/active_assets/active_sprites/sprite_test.rb

@@ -50,4 +50,20 @@ class SpriteTest < Test::Unit::TestCase
       end
     end
   end
+
+  def test_quality
+    Rails.application.sprites do
+      sprite :bas, :quality => 50
+    end
+
+    assert_equal 50, Rails.application.sprites[:bas].quality
+  end
+
+  def test_matte_color
+    Rails.application.sprites do
+      sprite :foobas, :matte_color => '#FFFFFF'
+    end
+
+    assert_equal '#FFFFFF', Rails.application.sprites[:foobas].matte_color
+  end
 end

data/test/fixtures/rails_root/config/application.rb

@@ -1,6 +1,5 @@
 require 'rails/all'
-require 'active_assets/active_expansions/railtie'
-require 'active_assets/active_sprites/railtie'
+require 'active_assets/railtie'
 
 module ActiveAssetsTest
   class Application < Rails::Application

data/test/helper.rb

@@ -2,9 +2,6 @@ ENV['RAILS_ENV'] ||= 'test'
 
 require 'rubygems'
 require 'test/unit'
-require 'capybara'
-require 'capybara/dsl'
-require 'culerity'
 
 require 'rails/all'
 require 'active_assets'
@@ -12,47 +9,22 @@ require 'active_assets'
 require 'socket'
 require 'timeout'
 
+require 'raster_graphics'
+
 TEST_RAILS_ROOT = File.expand_path('../fixtures/rails_root', __FILE__)
-TEST_SINATRA_ROOT = File.expand_path('../fixtures/sinatra_root', __FILE__)
 
 Dir[File.expand_path('../support/**/*.rb', __FILE__)].each {|f| load f }
 
 load File.join(TEST_RAILS_ROOT, 'config/application.rb')
-load File.join(TEST_SINATRA_ROOT, 'active_assets_test_app.rb')
-
-Capybara.configure do |capybara|
-  capybara.app = ActiveAssetsTestApp
-  capybara.default_driver = :culerity
-  capybara.default_selector = :css
-end
-
-def is_port_open?(ip, port)
-  begin
-    Timeout::timeout(1) do
-      begin
-        s = TCPSocket.new(ip, port)
-        s.close
-        return true
-      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-        return false
-      end
-    end
-  rescue Timeout::Error
-  end
-
-  return false
-end
-
-if is_port_open?('127.0.0.1', '2113')
-  Culerity.jruby_invocation = "#{File.expand_path('../../vendor/bin/ng', __FILE__)} org.jruby.Main"
-else
-  Culerity.jruby_invocation = "java -Xms32m -Xmx1024m -jar #{File.expand_path('../../vendor/jruby-complete-1.5.6.jar', __FILE__)}"
-end
-
 
 class Test::Unit::TestCase
   include RailsHelper
-  include Capybara
+
+  include(Module.new do
+    def percent_difference(image_1_path, image_2_path)
+      Pixmap.open(image_1_path) - Pixmap.open(image_2_path)
+    end
+  end)
 
   def sprites
     Rails.application.sprites

data/test/raster_graphics.rb

@@ -0,0 +1,623 @@
+###########################################################################
+# Represents an RGB[http://en.wikipedia.org/wiki/Rgb] colour.  
+class RGBColour
+  # Red, green and blue values must fall in the range 0..255.
+  def initialize(red, green, blue)
+    ok = [red, green, blue].inject(true) {|ok,c| ok &= c.between?(0,255)}
+    unless ok
+      raise ArgumentError, "invalid RGB parameters: #{[red, green, blue].inspect}"
+    end
+    @red, @green, @blue = red, green, blue
+  end
+  attr_reader :red, :green, :blue
+  alias_method :r, :red
+  alias_method :g, :green
+  alias_method :b, :blue
+
+  # the difference between two colours
+  def -(a_colour)
+    (@red - a_colour.red).abs +
+    (@green - a_colour.green).abs +
+    (@blue - a_colour.blue).abs
+  end
+
+  # Return the list of [red, green, blue] values.
+  #     RGBColour.new(100,150,200).values # => [100, 150, 200]
+  # call-seq:
+  # values -> array
+  #
+  def values
+    [@red, @green, @blue]
+  end
+
+  # Equality test: two RGBColour objects are equal if they have the same
+  # red, green and blue values.
+  # call-seq:
+  #     ==(a_colour) -> true or false
+  #
+  def ==(a_colour)
+    values == a_colour.values
+  end
+
+  # Comparison test: compares two RGBColour objects based on their #luminosity value
+  # call-seq:
+  #     <=>(a_colour) -> -1, 0, +1
+  #
+  def <=>(a_colour)
+    self.luminosity <=> a_colour.luminosity
+  end
+
+  # Calculate a integer luminosity value, in the range 0..255
+  #     RGBColour.new(100,150,200).luminosity # => 142
+  # call-seq:
+  #     luminosity -> int
+  #
+  def luminosity
+    Integer(0.2126*@red + 0.7152*@green + 0.0722*@blue)
+  end
+
+  # Return a new RGBColour value where all the red, green, blue values are the
+  # #luminosity value.
+  #     RGBColour.new(100,150,200).to_grayscale.values # => [142, 142, 142]
+  # call-seq:
+  #     to_grayscale -> a_colour
+  #
+  def to_grayscale
+    l = luminosity
+    self.class.new(l, l, l)
+  end
+
+  # Return a new RGBColour object given an iteration value for the Pixmap.mandelbrot
+  # method.
+  def self.mandel_colour(i)
+    self.new( 16*(i % 15), 32*(i % 7), 8*(i % 31) )
+  end
+
+  RED   = RGBColour.new(255,0,0)
+  GREEN = RGBColour.new(0,255,0)
+  BLUE  = RGBColour.new(0,0,255)
+  YELLOW= RGBColour.new(255,255,0)
+  BLACK = RGBColour.new(0,0,0)
+  WHITE = RGBColour.new(255,255,255)
+end
+
+###########################################################################
+# A Pixel represents an (x,y) point in a Pixmap.
+Pixel = Struct.new(:x, :y)
+
+###########################################################################
+class Pixmap
+  def initialize(width, height)
+    @width = width
+    @height = height
+    @data = fill(RGBColour::WHITE)
+  end
+  attr_reader :width, :height
+
+  def fill(colour)
+    @data = Array.new(@width) {Array.new(@height, colour)}
+  end
+
+  def -(a_pixmap)
+    if @width != a_pixmap.width or @height != a_pixmap.height
+      raise ArgumentError, "can't compare images with different sizes"
+    end
+    sum = 0
+    each_pixel {|x,y| sum += self[x,y] - a_pixmap[x,y]}
+    Float(sum) / (@width * @height * 255 * 3)
+  end
+
+  def validate_pixel(x,y)
+    unless x.between?(0, @width-1) and y.between?(0, @height-1)
+      raise ArgumentError, "requested pixel (#{x}, #{y}) is outside dimensions of this bitmap"
+    end
+  end
+
+  ###############################################
+  def [](x,y)
+    validate_pixel(x,y)
+    @data[x][y]
+  end
+  alias_method :get_pixel, :[]
+
+  def []=(x,y,colour)
+    validate_pixel(x,y)
+    @data[x][y] = colour
+  end
+  alias_method :set_pixel, :[]=
+
+  def each_pixel
+    if block_given?
+      @height.times {|y| @width.times {|x| yield x,y}}
+    else
+      to_enum(:each_pixel)
+    end
+  end
+
+  ###############################################
+  # write to file/stream
+  PIXMAP_FORMATS = ["P3", "P6"]   # implemented output formats
+  PIXMAP_BINARY_FORMATS = ["P6"]  # implemented output formats which are binary
+
+  def write_ppm(ios, format="P6")
+    if not PIXMAP_FORMATS.include?(format)
+      raise NotImplementedError, "pixmap format #{format} has not been implemented" 
+    end
+    ios.puts format, "#{@width} #{@height}", "255"
+    ios.binmode if PIXMAP_BINARY_FORMATS.include?(format)
+    @height.times do |y|
+      @width.times do |x|
+        case format
+        when "P3" then ios.print @data[x][y].values.join(" "),"\n"
+        when "P6" then ios.print @data[x][y].values.pack('C3')
+        end
+      end
+    end
+  end
+
+  def save(filename, opts={:format=>"P6"})
+    File.open(filename, 'w') do |f|
+      write_ppm(f, opts[:format])
+    end
+  end
+  alias_method :write, :save
+
+  def print(opts={:format=>"P6"})
+    write_ppm($stdout, opts[:format])
+  end
+
+  def save_as_jpeg(filename, quality=75)
+    # using the ImageMagick convert tool
+    begin
+      pipe = IO.popen("convert ppm:- -quality #{quality} jpg:#{filename}", 'w')
+      write_ppm(pipe)
+    rescue SystemCallError => e
+      warn "problem writing data to 'convert' utility -- does it exist in your $PATH?"
+    ensure
+      pipe.close rescue false
+    end
+  end
+
+  ###############################################
+  # read from file/pipe
+  def self.read_ppm(ios)
+    format = ios.gets.chomp
+    width, height = ios.gets.chomp.split.map {|n| n.to_i }
+    max_colour = ios.gets.chomp
+
+    if (not PIXMAP_FORMATS.include?(format)) or 
+        width < 1 or height < 1 or
+        max_colour != '255'
+    then
+      ios.close
+      raise StandardError, "file '#{filename}' does not start with the expected header"
+    end
+    ios.binmode if PIXMAP_BINARY_FORMATS.include?(format)
+
+    bitmap = self.new(width, height)
+    height.times do |y|
+      width.times do |x|
+        # read 3 bytes
+        red, green, blue = case format
+          when 'P3' then ios.gets.chomp.split
+          when 'P6' then ios.read(3).unpack('C3')
+        end
+        bitmap[x,y] = RGBColour.new(red, green, blue)
+      end
+    end
+    ios.close
+    bitmap
+  end
+
+  def self.open(filename)
+    read_ppm(File.open(filename, 'r'))
+  end
+
+  def self.open_from_jpeg(filename)
+    unless File.readable?(filename)
+      raise ArgumentError, "#{filename} does not exists or is not readable."
+    end
+    begin
+      pipe = IO.popen("convert jpg:#{filename} ppm:-", 'r')
+      read_ppm(pipe)
+    rescue SystemCallError => e
+      warn "problem reading data from 'convert' utility -- does it exist in your $PATH?"
+    ensure
+      pipe.close rescue false
+    end
+  end
+
+  ###############################################
+  # conversion methods
+  def to_grayscale
+    gray = self.class.new(@width, @height)
+    @width.times do |x|
+      @height.times do |y|
+        gray[x,y] = self[x,y].to_grayscale
+      end
+    end
+    gray
+  end
+
+  ###############################################
+  def draw_line(p1, p2, colour)
+    validate_pixel(p1.x, p2.y)
+    validate_pixel(p2.x, p2.y)
+
+    x1, y1 = p1.x, p1.y
+    x2, y2 = p2.x, p2.y
+
+    steep = (y2 - y1).abs > (x2 - x1).abs
+    if steep
+      x1, y1 = y1, x1
+      x2, y2 = y2, x2
+    end
+    if x1 > x2
+      x1, x2 = x2, x1
+      y1, y2 = y2, y1
+    end
+
+    deltax = x2 - x1
+    deltay = (y2 - y1).abs
+    error = deltax / 2
+    ystep = y1 < y2 ? 1 : -1
+
+    y = y1
+    x1.upto(x2) do |x|
+      pixel = steep ? [y,x] : [x,y]
+      self[*pixel] = colour
+      error -= deltay
+      if error < 0
+        y += ystep
+        error += deltax
+      end
+    end
+  end
+
+  ###############################################
+  def draw_line_antialised(p1, p2, colour)
+    x1, y1 = p1.x, p1.y
+    x2, y2 = p2.x, p2.y
+
+    steep = (y2 - y1).abs > (x2 - x1).abs
+    if steep
+      x1, y1 = y1, x1
+      x2, y2 = y2, x2
+    end
+    if x1 > x2
+      x1, x2 = x2, x1
+      y1, y2 = y2, y1
+    end
+    deltax = x2 - x1
+    deltay = (y2 - y1).abs
+    gradient = 1.0 * deltay / deltax
+
+    # handle the first endpoint
+    xend = x1.round
+    yend = y1 + gradient * (xend - x1)
+    xgap = (x1 + 0.5).rfpart
+    xpxl1 = xend
+    ypxl1 = yend.truncate
+    put_colour(xpxl1, ypxl1, colour, steep, yend.rfpart * xgap)
+    put_colour(xpxl1, ypxl1 + 1, colour, steep, yend.fpart * xgap)
+    itery = yend + gradient
+
+    # handle the second endpoint
+    xend = x2.round
+    yend = y2 + gradient * (xend - x2)
+    xgap = (x2 + 0.5).rfpart
+    xpxl2 = xend
+    ypxl2 = yend.truncate
+    put_colour(xpxl2, ypxl2, colour, steep, yend.rfpart * xgap)
+    put_colour(xpxl2, ypxl2 + 1, colour, steep, yend.fpart * xgap)
+
+    # in between
+    (xpxl1 + 1).upto(xpxl2 - 1).each do |x|
+      put_colour(x, itery.truncate, colour, steep, itery.rfpart)
+      put_colour(x, itery.truncate + 1, colour, steep, itery.fpart)
+      itery = itery + gradient
+    end
+  end
+
+  def put_colour(x, y, colour, steep, c)
+    x, y = y, x if steep
+    self[x, y] = anti_alias(colour, self[x, y], c)
+  end
+
+  def anti_alias(new, old, ratio)
+    blended = new.values.zip(old.values).map {|n, o| (n*ratio + o*(1.0 - ratio)).round}
+    RGBColour.new(*blended)
+  end
+
+  ###############################################
+  def draw_circle(pixel, radius, colour)
+    validate_pixel(pixel.x, pixel.y)
+
+    self[pixel.x, pixel.y + radius] = colour
+    self[pixel.x, pixel.y - radius] = colour
+    self[pixel.x + radius, pixel.y] = colour
+    self[pixel.x - radius, pixel.y] = colour
+
+    f = 1 - radius
+    ddF_x = 1
+    ddF_y = -2 * radius
+    x = 0
+    y = radius
+    while x < y
+      if f >= 0
+        y -= 1
+        ddF_y += 2
+        f += ddF_y
+      end
+      x += 1
+      ddF_x += 2
+      f += ddF_x
+      self[pixel.x + x, pixel.y + y] = colour
+      self[pixel.x + x, pixel.y - y] = colour
+      self[pixel.x - x, pixel.y + y] = colour
+      self[pixel.x - x, pixel.y - y] = colour
+      self[pixel.x + y, pixel.y + x] = colour
+      self[pixel.x + y, pixel.y - x] = colour
+      self[pixel.x - y, pixel.y + x] = colour
+      self[pixel.x - y, pixel.y - x] = colour
+    end
+  end
+
+  ###############################################
+  def flood_fill(pixel, new_colour)
+    current_colour = self[pixel.x, pixel.y]
+    queue = RasterQueue.new
+    queue.enqueue(pixel)
+    until queue.empty?
+      p = queue.dequeue
+      if self[p.x, p.y] == current_colour
+        west = find_border(p, current_colour, :west)
+        east = find_border(p, current_colour, :east)
+        draw_line(west, east, new_colour)
+        q = west
+        while q.x <= east.x
+          [:north, :south].each do |direction|
+            n = neighbour(q, direction)
+            queue.enqueue(n) if self[n.x, n.y] == current_colour
+          end
+          q = neighbour(q, :east)
+        end
+      end
+    end
+  end
+
+  def neighbour(pixel, direction)
+    case direction
+    when :north then Pixel[pixel.x, pixel.y - 1]
+    when :south then Pixel[pixel.x, pixel.y + 1]
+    when :east  then Pixel[pixel.x + 1, pixel.y]
+    when :west  then Pixel[pixel.x - 1, pixel.y]
+    end
+  end
+
+  def find_border(pixel, colour, direction)
+    nextp = neighbour(pixel, direction)
+    while self[nextp.x, nextp.y] == colour
+      pixel = nextp
+      nextp = neighbour(pixel, direction)
+    end
+    pixel
+  end
+
+  ###############################################
+  def median_filter(radius=3)
+    if radius.even?
+      radius += 1
+    end
+    filtered = self.class.new(@width, @height)
+
+
+    $stdout.puts "processing #{@height} rows"
+    pb = ProgressBar.new(@height) if $DEBUG
+
+    @height.times do |y|
+      @width.times do |x|
+        window = []
+        (x - radius).upto(x + radius).each do |win_x|
+          (y - radius).upto(y + radius).each do |win_y|
+            win_x = 0 if win_x < 0
+            win_y = 0 if win_y < 0
+            win_x = @width-1 if win_x >= @width
+            win_y = @height-1 if win_y >= @height
+            window << self[win_x, win_y]
+          end
+        end
+        # median
+        filtered[x, y] = window.sort[window.length / 2]
+      end
+      pb.update(y) if $DEBUG
+    end
+
+    pb.close if $DEBUG
+
+    filtered
+  end
+
+  ###############################################
+  def histogram
+    histogram = Hash.new(0)
+    @height.times do |y|
+      @width.times do |x|
+        histogram[self[x,y].luminosity] += 1
+      end
+    end
+    histogram 
+  end
+
+  def to_blackandwhite
+    hist = histogram
+
+    # find the median luminosity
+    median = nil
+    sum = 0
+    hist.keys.sort.each do |lum|
+      sum += hist[lum]
+      if sum > @height * @width / 2
+        median = lum
+        break
+      end
+    end
+
+    # create the black and white image
+    bw = self.class.new(@width, @height)
+    @height.times do |y|
+      @width.times do |x|
+        bw[x,y] = self[x,y].luminosity < median ? RGBColour::BLACK : RGBColour::WHITE
+      end
+    end
+    bw
+  end
+
+  def save_as_blackandwhite(filename)
+    to_blackandwhite.save(filename)
+  end
+
+  ###############################################
+  def draw_bezier_curve(points, colour)
+    # ensure the points are increasing along the x-axis
+    points = points.sort_by {|p| [p.x, p.y]}
+    xmin = points[0].x
+    xmax = points[-1].x
+    increment = 2
+    prev = points[0]
+    ((xmin + increment) .. xmax).step(increment) do |x|
+      t = 1.0 * (x - xmin) / (xmax - xmin)
+      p = Pixel[x, bezier(t, points).round]
+      draw_line(prev, p, colour)
+      prev = p
+    end
+  end
+
+  # the generalized n-degree Bezier summation
+  def bezier(t, points)
+    n = points.length - 1
+    points.each_with_index.inject(0.0) do |sum, (point, i)|
+      sum += n.choose(i) * (1-t)**(n - i) * t**i * point.y
+    end
+  end
+
+  ###############################################
+  def self.mandelbrot(width, height)
+    mandel = Pixmap.new(width,height)
+    pb = ProgressBar.new(width) if $DEBUG
+    width.times do |x|
+      height.times do |y|
+        x_ish = Float(x - width*11/15) / (width/3)
+        y_ish = Float(y - height/2) / (height*3/10)
+        mandel[x,y] = RGBColour.mandel_colour(mandel_iters(x_ish, y_ish))
+      end
+      pb.update(x) if $DEBUG
+    end
+    pb.close if $DEBUG
+    mandel
+  end
+
+  def self.mandel_iters(cx,cy)
+    x = y = 0.0
+    count = 0
+    while Math.hypot(x,y) < 2 and count < 255
+      x, y = (x**2 - y**2 + cx), (2*x*y + cy)
+      count += 1
+    end
+    count
+  end 
+
+  ###############################################
+  # Apply a convolution kernel to a whole image
+  def convolute(kernel)
+    newimg = Pixmap.new(@width, @height)
+    pb = ProgressBar.new(@width) if $DEBUG
+    @width.times do |x|
+      @height.times do |y|
+        apply_kernel(x, y, kernel, newimg)
+      end
+      pb.update(x) if $DEBUG
+    end
+    pb.close if $DEBUG
+    newimg
+  end
+
+  # Applies a convolution kernel to produce a single pixel in the destination
+  def apply_kernel(x, y, kernel, newimg)
+    x0 = [0, x-1].max
+    y0 = [0, y-1].max
+    x1 = x
+    y1 = y
+    x2 = [@width-1, x+1].min
+    y2 = [@height-1, y+1].min
+
+    r = g = b = 0.0
+    [x0, x1, x2].zip(kernel).each do |xx, kcol|
+      [y0, y1, y2].zip(kcol).each do |yy, k|
+        r += k * self[xx,yy].r
+        g += k * self[xx,yy].g
+        b += k * self[xx,yy].b
+	    end
+    end
+    newimg[x,y] = RGBColour.new(luma(r), luma(g), luma(b))
+  end
+
+  # Function for clamping values to those that we can use with colors
+  def luma(value)
+    if value < 0
+      0
+    elsif value > 255
+      255
+    else
+      value
+    end
+  end
+end
+
+
+###########################################################################
+# Utilities
+class ProgressBar
+  def initialize(max)
+    $stdout.sync = true
+    @progress_max = max
+    @progress_pos = 0
+    @progress_view = 68
+    $stdout.print "[#{'-'*@progress_view}]\r["
+  end
+
+  def update(n)
+    new_pos = n * @progress_view/@progress_max
+    if new_pos > @progress_pos
+      @progress_pos = new_pos 
+      $stdout.print '='
+    end
+  end
+
+  def close
+    $stdout.puts '=]'
+  end
+end
+
+class RasterQueue < Array
+  alias_method :enqueue, :push
+  alias_method :dequeue, :shift
+end
+
+class Numeric
+  def fpart
+    self - self.truncate
+  end
+  def rfpart
+    1.0 - self.fpart
+  end
+end
+
+class Integer
+  def choose(k)
+    self.factorial / (k.factorial * (self - k).factorial)
+  end
+  def factorial
+    (2 .. self).reduce(1, :*)
+  end
+end

data/test/raster_graphics_test.rb

@@ -0,0 +1,82 @@
+require 'helper'
+require 'fileutils'
+
+class Pixmap
+  def ==(a_bitmap)
+    return false if @width != a_bitmap.width or @height != a_bitmap.height
+    @width.times do |x|
+      @height.times do |y| 
+        return false if not self[x,y] == (a_bitmap[x,y])
+      end
+    end
+    true
+  end
+end
+
+class RGBColourTest < Test::Unit::TestCase
+  def test_init
+    color = RGBColour.new(0,100,200)
+    assert_equal(100, color.g)
+  end
+  def test_constants
+    assert_equal([255,0,0], [RGBColour::RED.r,RGBColour::RED.g,RGBColour::RED.b])
+    assert_equal([0,255,0], [RGBColour::GREEN.r,RGBColour::GREEN.g,RGBColour::GREEN.b])
+    assert_equal([0,0,255], [RGBColour::BLUE.r,RGBColour::BLUE.g,RGBColour::BLUE.b])
+  end
+  def test_error
+    color = RGBColour.new(0,100,200)
+    assert_raise(ArgumentError) {RGBColour.new(0,0,256)}
+  end
+end
+
+class PixmapTest < Test::Unit::TestCase
+  def setup
+    @w = 20
+    @h = 30
+    @bitmap = Pixmap.new(@w,@h)
+  end
+
+  def teardown
+    Dir[File.expand_path('../fixtures/*.ppm', __FILE__)].each do |f|
+      FileUtils.rm(f)
+    end
+  end
+
+  def test_init
+    assert_equal(@w, @bitmap.width)
+    assert_equal(@h, @bitmap.height)
+    assert_equal(RGBColour::WHITE, @bitmap.get_pixel(10,10))
+  end
+  def test_fill
+    @bitmap.fill(RGBColour::RED)
+    assert_equal(255,@bitmap[10,10].red)
+    assert_equal(0,@bitmap[10,10].green)
+    assert_equal(0,@bitmap[10,10].blue)
+  end
+  def test_get_pixel
+    assert_equal(@bitmap[5,6], @bitmap.get_pixel(5,6))
+    assert_raise(ArgumentError) {@bitmap[100,100]}
+  end
+  def test_grayscale
+    @bitmap.fill(RGBColour::BLUE)
+    @bitmap.height.times {|y| [9,10,11].each {|x| @bitmap[x,y]=RGBColour::GREEN}}
+    @bitmap.width.times  {|x| [14,15,16].each {|y| @bitmap[x,y]=RGBColour::GREEN}}
+    @bitmap.save(File.expand_path('../fixtures/testcross.ppm', __FILE__))
+    Pixmap.open(File.expand_path('../fixtures/testcross.ppm', __FILE__)).to_grayscale.save(File.expand_path('../fixtures/testgray.ppm', __FILE__))
+  end
+  def test_save
+    @bitmap.fill(RGBColour::BLUE)
+    filename = File.expand_path('../fixtures/test.ppm', __FILE__)
+    @bitmap.save(filename)
+    expected_size = 3 + (@w.to_s.length + 1 + @h.to_s.length + 1) + 4 + (@w * @h * 3)
+    assert_equal(expected_size, File.size(filename))
+  end 
+  def test_open
+    @bitmap.fill(RGBColour::RED)
+    @bitmap.set_pixel(10,15, RGBColour::WHITE)
+    filename = File.expand_path('../fixtures/test.ppm', __FILE__)
+    @bitmap.save(filename)
+    new = Pixmap.open(filename)
+    assert(@bitmap == new)
+  end
+end

metadata

@@ -1,15 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: active_assets
 version: !ruby/object:Gem::Version 
-  hash: 15424061
-  prerelease: 6
+  hash: 23
+  prerelease: 
   segments: 
   - 0
   - 2
   - 0
-  - rc
-  - 4
-  version: 0.2.0.rc4
+  version: 0.2.0
 platform: ruby
 authors: 
 - Sam Woodard
@@ -17,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-23 00:00:00 -08:00
+date: 2011-01-25 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,34 +39,18 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 23
+        hash: 25
         segments: 
         - 1
         - 1
-        - 2
-        version: 1.1.2
+        - 5
+        version: 1.1.5
   type: :development
-  name: sinatra
+  name: css_parser
   requirement: *id002
 - !ruby/object:Gem::Dependency 
   prerelease: false
   version_requirements: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 17
-        segments: 
-        - 1
-        - 2
-        - 7
-        version: 1.2.7
-  type: :development
-  name: thin
-  requirement: *id003
-- !ruby/object:Gem::Dependency 
-  prerelease: false
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -81,10 +63,10 @@ dependencies:
         version: 3.0.3
   type: :development
   name: rails
-  requirement: *id004
+  requirement: *id003
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">"
@@ -96,27 +78,10 @@ dependencies:
         version: "2.0"
   type: :development
   name: test-unit
-  requirement: *id005
-- !ruby/object:Gem::Dependency 
-  prerelease: false
-  version_requirements: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 105
-        segments: 
-        - 0
-        - 4
-        - 1
-        - 1
-        version: 0.4.1.1
-  type: :development
-  name: capybara
-  requirement: *id006
+  requirement: *id004
 - !ruby/object:Gem::Dependency 
   prerelease: false
-  version_requirements: &id007 !ruby/object:Gem::Requirement 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -129,7 +94,7 @@ dependencies:
         version: 4.4.2
   type: :development
   name: ZenTest
-  requirement: *id007
+  requirement: *id005
 description: A Railtie that provides a full asset management system, including support for development and deployment.  It is comprised of two libraries, ActiveSprites and ActiveExpansions.  ActiveSprites generates sprites and their corresponding stylesheet from dsl definition. ActiveExpansions manages javascript and css, including concatenation support for deployment, using Rails expansions plus a dsl.
 email: 
 - sam@wildfireapp.com
@@ -140,6 +105,15 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .autotest
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- active_assets.gemspec
+- lib/active_assets.rb
+- lib/active_assets/active_expansions.rb
 - lib/active_assets/active_expansions/asset.rb
 - lib/active_assets/active_expansions/asset_scope.rb
 - lib/active_assets/active_expansions/assets.rb
@@ -150,22 +124,20 @@ files:
 - lib/active_assets/active_expansions/railtie.rb
 - lib/active_assets/active_expansions/stylesheets.rb
 - lib/active_assets/active_expansions/type_inferrable.rb
-- lib/active_assets/active_expansions.rb
+- lib/active_assets/active_sprites.rb
 - lib/active_assets/active_sprites/railtie.rb
 - lib/active_assets/active_sprites/runner.rb
 - lib/active_assets/active_sprites/sprite.rb
 - lib/active_assets/active_sprites/sprite_piece.rb
 - lib/active_assets/active_sprites/sprite_stylesheet.rb
 - lib/active_assets/active_sprites/sprites.rb
-- lib/active_assets/active_sprites.rb
 - lib/active_assets/railtie.rb
-- lib/active_assets.rb
 - lib/rails/active_assets.rb
 - lib/rails/active_expansions.rb
 - lib/rails/active_sprites.rb
 - lib/tasks/active_expansions/cache.rake
 - lib/tasks/active_sprites/sprites.rake
-- README.md
+- script/console
 - test/active_assets/active_expansions/asset_test.rb
 - test/active_assets/active_expansions/expansions_test.rb
 - test/active_assets/active_sprites/runner_test.rb
@@ -233,10 +205,9 @@ files:
 - test/fixtures/rails_root/public/javascripts/bas/bar.js
 - test/fixtures/rails_root/public/stylesheets/bar/bas.css
 - test/fixtures/rails_root/public/stylesheets/bas/bar.css
-- test/fixtures/sinatra_root/active_assets_test_app.rb
-- test/fixtures/sinatra_root/views/layout.erb
-- test/fixtures/sinatra_root/views/sprite.erb
 - test/helper.rb
+- test/raster_graphics.rb
+- test/raster_graphics_test.rb
 - test/support/rails_helper.rb
 has_rdoc: true
 homepage: http://github.com/shwoodard/active_assets
@@ -259,14 +230,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
-      hash: 25
+      hash: 3
       segments: 
-      - 1
-      - 3
-      - 1
-      version: 1.3.1
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: activeassets
@@ -342,8 +311,7 @@ test_files:
 - test/fixtures/rails_root/public/javascripts/bas/bar.js
 - test/fixtures/rails_root/public/stylesheets/bar/bas.css
 - test/fixtures/rails_root/public/stylesheets/bas/bar.css
-- test/fixtures/sinatra_root/active_assets_test_app.rb
-- test/fixtures/sinatra_root/views/layout.erb
-- test/fixtures/sinatra_root/views/sprite.erb
 - test/helper.rb
+- test/raster_graphics.rb
+- test/raster_graphics_test.rb
 - test/support/rails_helper.rb

data/test/fixtures/sinatra_root/active_assets_test_app.rb

@@ -1,12 +0,0 @@
-require 'rubygems'
-require 'active_support/core_ext'
-require 'sinatra/base'
-
-class ActiveAssetsTestApp < Sinatra::Base
-  set :root, File.dirname(__FILE__)
-
-  get '/sprite' do
-    @sprite_path = params[:sprite_path]
-    erb :sprite
-  end
-end

data/test/fixtures/sinatra_root/views/layout.erb

@@ -1,7 +0,0 @@
-<!DOCTYPE html>
-<html>
-  <head><title>Active Assets Test App</title></head>
-  <body>
-    <%= yield %>
-  </body>
-</html>

data/test/fixtures/sinatra_root/views/sprite.erb

@@ -1,3 +0,0 @@
-<% unless @sprite_path.blank? %>
-<img id='sprite' src='<%= @sprite_path %>' alt=''/>
-<% end %>