compass-magick 0.1.2

data/lib/magick/functions/operations.rb

@@ -0,0 +1,211 @@
+require 'magick/functions/operations/effects'
+
+module Compass::Magick
+  module Functions
+    # Methods for operating on a {Compass::Magick::Canvas}, e.g., crop,
+    # compose, etc.
+    module Operations
+      # Composes one {Canvas} on top of another.
+      #
+      # @param [Canvas] overlay The Canvas object to compose.
+      # @param [Integer] x The left coordinate of the composition operation.
+      # @param [Integer] y The top coordinate of the composition operation.
+      # @return {Command} A command which composes the two canvas objects
+      #   together.
+      def magick_compose(overlay, x = nil, y = nil)
+        Compass::Magick::Utils.assert_type 'overlay', overlay, ChunkyPNG::Canvas
+        Compass::Magick::Utils.assert_type 'x', x, Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'y', y, Sass::Script::Number
+        Command.new do |canvas|
+          canvas_x = Compass::Magick::Utils.value_of(x, canvas.width  - overlay.width,  0).to_i
+          canvas_y = Compass::Magick::Utils.value_of(y, canvas.height - overlay.height, 0).to_i
+          raise ChunkyPNG::OutOfBounds, 'Canvas image width is too small to compose overlay'  if canvas.width  < overlay.width  + canvas_x
+          raise ChunkyPNG::OutOfBounds, 'Canvas image height is too small to compose overlay' if canvas.height < overlay.height + canvas_y
+          for y in 0...overlay.height do
+            for x in 0...overlay.width do
+              overlay_pixel = overlay.get_pixel(x, y)
+              canvas_pixel  = canvas.get_pixel(x + canvas_x, y + canvas_y)
+              canvas.set_pixel(x + canvas_x, y + canvas_y, ChunkyPNG::Color.compose_precise(overlay_pixel, canvas_pixel))
+            end
+          end
+        end
+      end
+
+      # Crops the {Canvas} to the given region.
+      #
+      # @param [Integer] x1 The left coordinate of the crop operation.
+      # @param [Integer] y1 The top coordinate of the crop operation.
+      # @param [Integer] x2 The right coordinate of the crop operation.
+      # @param [Integer] y2 The bottom coordinate of the crop operation.
+      # @return {Command} A command which applies the crop to the canvas.
+      def magick_crop(x1 = nil, y1 = nil, x2 = nil, y2 = nil)
+        Compass::Magick::Utils.assert_type 'x1', x1, Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'y1', y1, Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'x2', x2, Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'y2', y2, Sass::Script::Number
+        Command.new do |canvas|
+          canvas_x1 = Compass::Magick::Utils.value_of(x1, canvas.width,  0)
+          canvas_y1 = Compass::Magick::Utils.value_of(y1, canvas.height, 0)
+          canvas_x2 = Compass::Magick::Utils.value_of(x2, canvas.width,  canvas.width)
+          canvas_y2 = Compass::Magick::Utils.value_of(y2, canvas.height, canvas.height)
+          canvas_x1, canvas_x2 = canvas_x2, canvas_x1 if canvas_x1 > canvas_x2
+          canvas_y1, canvas_y2 = canvas_y2, canvas_y1 if canvas_y1 > canvas_y2
+          width     = canvas_x2 - canvas_x1
+          height    = canvas_y2 - canvas_y1
+          canvas.crop(canvas_x1, canvas_y1, width, height)
+        end
+      end
+
+      # Applies the mask on the {Canvas}.
+      #
+      # Composes the alpha channel from the <tt>mask</tt> image with the
+      # one from the canvas and return the original canvas with the
+      # alpha-channel modified. Any opaque pixels from the <tt>mask</tt> are
+      # converted to grayscale using BT709 luminosity factors, i.e. black is
+      # fully transparent and white is fully opaque.
+      #
+      # @param [Integer] x The left coordinate of the mask operation.
+      # @param [Integer] y The top coordinate of the mask operation.
+      # @return {Command} A command which applies the mask on the canvas.
+      def magick_mask(mask, x = nil, y = nil)
+        Compass::Magick::Utils.assert_type 'mask', mask, ChunkyPNG::Canvas
+        Compass::Magick::Utils.assert_type 'x',    x,    Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'y',    y,    Sass::Script::Number
+        Command.new do |canvas|
+          canvas_x = Compass::Magick::Utils.value_of(x, canvas.width  - 1,  0)
+          canvas_y = Compass::Magick::Utils.value_of(y, canvas.height - 1, 0)
+          raise ChunkyPNG::OutOfBounds, 'Canvas image width is too small to fit mask'  if canvas.width  < mask.width  + canvas_x
+          raise ChunkyPNG::OutOfBounds, 'Canvas image height is too small to fit mask' if canvas.height < mask.height + canvas_y
+          for y in 0...mask.height do
+            for x in 0...mask.width do
+              canvas_pixel = canvas.get_pixel(x + canvas_x, y + canvas_y)
+              mask_pixel   = mask.get_pixel(x, y)
+              mask_alpha   = (ChunkyPNG::Color.r(mask_pixel) * 0.2125 + ChunkyPNG::Color.g(mask_pixel) * 0.7154 + ChunkyPNG::Color.b(mask_pixel) * 0.0721) * (ChunkyPNG::Color.a(mask_pixel) / 255.0)
+              canvas.set_pixel(x + canvas_x, y + canvas_y, ChunkyPNG::Color.rgba(
+                ChunkyPNG::Color.r(canvas_pixel),
+                ChunkyPNG::Color.g(canvas_pixel),
+                ChunkyPNG::Color.b(canvas_pixel),
+                ChunkyPNG::Color.a(canvas_pixel) * (mask_alpha / 255.0)
+              ))
+            end
+          end
+        end
+      end
+
+      # Apply an effect on the {Canvas}.
+      #
+      # @param [Sass::Script::String] name The name of the effect to apply.
+      # @param [Array] args The arguments to pass to the effect.
+      # @return {Effect} A command which applies the effect to the canvas.
+      def magick_effect(name, *args)
+        Compass::Magick::Utils.assert_type 'name', name, Sass::Script::String
+        Compass::Magick::Functions::Operations::Effects.send(name.value, *args)
+      end
+
+      # Apply drop shadow on the {Canvas}.
+      #
+      # The alpha channel is used to construct a mask of the original image
+      # which is then used as a base for the horizontal/vertical shadow pass.
+      #
+      # Copyright (c) 2005 by Romain Guy
+      # http://www.curious-creature.org/2005/07/06/non-rectangular-shadow/
+      #
+      # @param [Sass::Script::Number] angle The angle of the shadow.
+      # @param [Sass::Script::Number] distance The distance of the shadow from
+      #   the original canvas.
+      # @param [Sass::Script::Number] size The size (blur) of the shadow.
+      # @param [Sass::Script::Color] color The color of the shadow.
+      # @return {Command} A command which applies the drop shadow to the
+      #   canvas.
+      def magick_drop_shadow(angle = nil, distance = nil, size = nil, color = nil)
+        Compass::Magick::Utils.assert_type 'angle',    angle,    Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'distance', distance, Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'size',     size,     Sass::Script::Number
+        Compass::Magick::Utils.assert_type 'color',    color,    Sass::Script::Color
+        Command.new do |canvas|
+          shadow_angle    = Compass::Magick::Utils.value_of(angle,    360,                               0)
+          shadow_distance = Compass::Magick::Utils.value_of(distance, [canvas.width, canvas.height].min, 5)
+          shadow_size     = Compass::Magick::Utils.value_of(size,     [canvas.width, canvas.height].min, 5)
+          shadow_color    = Compass::Magick::Utils.to_chunky_color(color.nil? ? Sass::Script::Color.new([0, 0, 0, 1]) : color)
+          shadow_canvas   = ChunkyPNG::Canvas.new(canvas.width + shadow_size * 2, canvas.height + shadow_size * 2).replace(canvas, shadow_size, shadow_size)
+          shadow_pixels   = shadow_canvas.pixels
+          shadow_red      = ChunkyPNG::Color.r(shadow_color)
+          shadow_green    = ChunkyPNG::Color.g(shadow_color)
+          shadow_blue     = ChunkyPNG::Color.b(shadow_color)
+          shadow_alpha    = ChunkyPNG::Color.a(shadow_color)
+          angle_radians   = shadow_angle * Math::PI / 180
+          distance_x      = (Math.cos(angle_radians) * shadow_distance).to_i
+          distance_y      = (Math.sin(angle_radians) * shadow_distance).to_i
+          left            = (shadow_size - 1) >> 1
+          right           = shadow_size - left
+          x_start         = left
+          x_finish        = shadow_canvas.width - right
+          y_start         = left
+          y_finish        = shadow_canvas.height - right
+          a_history       = Array.new(shadow_size)
+          history_index   = 0
+          sum_divider     = (shadow_alpha / 255.0) / shadow_size
+          buffer_offset   = 0
+          last_pixel_offset = right * shadow_canvas.width
+          for y in (0...shadow_canvas.height)
+            a_sum         = 0
+            history_index = 0
+            for x in (0...shadow_size)
+              a = ChunkyPNG::Color.a(shadow_pixels[buffer_offset])
+              a_history[x]  = a
+              a_sum         = a_sum + a
+              buffer_offset = buffer_offset + 1
+            end
+            buffer_offset = buffer_offset - right
+            for x in (x_start...x_finish)
+              a = a_sum * sum_divider
+              shadow_pixels[buffer_offset] = ChunkyPNG::Color.rgba(shadow_red, shadow_green, shadow_blue, (shadow_alpha * (a / 255.0)).to_i)
+              a_sum = a_sum - a_history[history_index]
+              a = ChunkyPNG::Color.a(shadow_pixels[buffer_offset + right])
+              a_history[history_index] = a
+              a_sum = a_sum + a
+              history_index = history_index + 1
+              history_index = history_index - shadow_size if history_index >= shadow_size
+              buffer_offset = buffer_offset + 1
+            end
+            buffer_offset = y * shadow_canvas.width
+          end
+          buffer_offset = 0
+          for x in (0...shadow_canvas.width)
+            a_sum         = 0
+            history_index = 0
+            for y in (0...shadow_size)
+              a = ChunkyPNG::Color.a(shadow_pixels[buffer_offset])
+              a_history[y]  = a
+              a_sum         = a_sum + a
+              buffer_offset = buffer_offset + shadow_canvas.width
+            end
+            buffer_offset = buffer_offset - last_pixel_offset
+            for y in (y_start...y_finish)
+              a = a_sum * sum_divider
+              shadow_pixels[buffer_offset] = ChunkyPNG::Color.rgba(shadow_red, shadow_green, shadow_blue, (shadow_alpha * (a / 255.0)).to_i)
+              a_sum = a_sum - a_history[history_index]
+              a = ChunkyPNG::Color.a(shadow_pixels[buffer_offset + last_pixel_offset])
+              a_history[history_index] = a
+              a_sum = a_sum + a
+              history_index = history_index + 1
+              history_index = history_index - shadow_size if history_index >= shadow_size
+              buffer_offset = buffer_offset + shadow_canvas.width
+            end
+            buffer_offset = x
+          end
+          for y in 0...canvas.height do
+            for x in 0...canvas.width do
+              shadow_x = x + shadow_size + distance_x
+              shadow_y = y + shadow_size + distance_y
+              canvas.set_pixel(x, y, ChunkyPNG::Color.compose_precise(
+                canvas.get_pixel(x, y),
+                shadow_pixels[shadow_y * shadow_canvas.width + shadow_x]
+              ))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/magick/functions/sprites.rb

@@ -0,0 +1,28 @@
+module Compass::Magick
+  module Functions
+    # Methods for generating sprites from on a {Compass::Magick::Canvas}.
+    module Sprites
+      # Writes the canvas to a file, encoded as a PNG image. The output is
+      # optimized for best compression.
+      #
+      # @param [Sass::Script::String] basename The PNG image basename. The
+      #   generated file is saved in the configured images directory with a
+      #   .png extension. Directory names are allowed and can be used to
+      #   group a set of objects together.
+      # @param [Canvas] canvas The Canvas object to write.
+      # @return [Sass::Script::String] A URL to the generated sprite image.
+      #   (Depending on your configuration) The path is relative and has the
+      #   cache buster appended after the file extension.
+      def magick_sprite(basename, canvas)
+        Compass::Magick::Utils.assert_type 'basename', basename, Sass::Script::String
+        Compass::Magick::Utils.assert_type 'canvas',   canvas,   ChunkyPNG::Canvas
+        extension = '.png'
+        filename  = basename.value.chomp(extension) + extension
+        filepath  = File.join(Compass.configuration.images_path, filename)
+        FileUtils.mkpath(File.dirname(filepath))
+        canvas.save(filepath, :best_compression)
+        image_url(Sass::Script::String.new(filename))
+      end
+    end
+  end
+end

data/lib/magick/functions/types.rb

@@ -0,0 +1,77 @@
+module Compass::Magick
+  module Functions
+    # Methods for creating new {Compass::Magick::Types}.
+    module Types
+      # Creates a new {Compass::Magick::Types::Solid} instance.
+      #
+      # @param [Sass::Script::Color] color The solid background color.
+      # @return [Compass::Magick::Types::Solid] A type that generates a
+      #   {Canvas} from a region filled with a solid color.
+      def magick_solid(color)
+        Compass::Magick::Types::Solid.new(color)
+      end
+
+      # Creates a new {Compass::Magick::Types::ColorStop} instance.
+      #
+      # @param [Sass::Script::Number] offset The color stop offset, 0-100.
+      # @param [Sass::Script::Color] color The color at the offset.
+      # @return [Compass::Magick::Types::ColorStop] A type that is used when
+      #   constructing gradients to control color stops.
+      def magick_color_stop(offset, color)
+        Compass::Magick::Types::Gradients::ColorStop.new(offset, color)
+      end
+
+      # Creates a new {Compass::Magick::Types::Gradients::Linear} instance.
+      #
+      # @overload magick_linear_gradient(angle, stops)
+      #   @param [Sass::Script::Number] angle The angle of the linear
+      #     gradient.
+      #   @param [Array<Compass::Magick::Types::Gradients::ColorStop>] stops
+      #     A list of color stops to interpolate between.
+      # @overload magick_linear_gradient(stops)
+      #   @param [Array<Compass::Magick::Types::Gradients::ColorStop>] stops
+      #     A list of color stops to interpolate between.
+      # @return [Compass::Magick::Types::Gradients::Linear] A type that
+      #   generates a {Canvas} from a region filled using point-to-point
+      #   linear gradient at an angle.
+      def magick_linear_gradient(*args)
+        angle   = args.shift if args[0].kind_of?(Sass::Script::Number)
+        angle ||= Sass::Script::Number.new(90)
+        stops   = []
+        last_offset = 0
+        args.each_with_index do |stop, index|
+          if stop.kind_of?(Sass::Script::Color)
+            if index > 0
+              if index == args.length - 1
+                offset = 100
+              else
+                next_index  = 0
+                next_offset = nil
+                args.slice(index, args.length).each do |next_stop|
+                  next_index = next_index + 1
+                  if next_stop.kind_of?(Compass::Magick::Types::Gradients::ColorStop)
+                    next_offset = next_stop.offset.value
+                    break
+                  end
+                end
+                next_offset ||= 100
+                offset = last_offset + (next_offset - last_offset) / next_index
+              end
+            else
+              offset = 0
+            end
+            stops.push(Compass::Magick::Types::Gradients::ColorStop.new(Sass::Script::Number.new(offset), stop))
+            last_offset = offset
+          elsif stop.kind_of?(Sass::Script::List)
+            stops.push(Compass::Magick::Types::Gradients::ColorStop.new(stop.value[1], stop.value[0]))
+            last_offset = stop.value[1].value
+          else
+            stops.push(stop)
+            last_offset = stop.offset.value if stop.respond_to?(:offset)
+          end
+        end
+        Compass::Magick::Types::Gradients::Linear.new(angle, stops)
+      end
+    end
+  end
+end

data/lib/magick/functions.rb

@@ -0,0 +1,31 @@
+require 'magick/functions/canvas'
+require 'magick/functions/types'
+require 'magick/functions/drawing'
+require 'magick/functions/operations'
+require 'magick/functions/sprites'
+
+require 'magick/plugins'
+
+module Compass::Magick
+  # The Functions module includes all public Compass Magick functions.
+  #
+  # @see Functions::Canvas
+  # @see Functions::Types
+  # @see Functions::Drawing
+  module Functions
+    include Functions::Canvas
+    include Functions::Types
+    include Functions::Drawing
+    include Functions::Operations
+    include Functions::Sprites
+    include Compass::Magick::Plugins
+  end
+end
+
+# Functions defined in this module are exported for usage in stylesheets
+# (.sass and .scss documents).
+#
+# Compass Magick exports all available {Compass::Magick::Functions functions}.
+module Sass::Script::Functions
+  include Compass::Magick::Functions
+end

data/lib/magick/plugins.rb

@@ -0,0 +1,14 @@
+module Compass::Magick
+  # The Plugins module includes all external Compass Magick functions.
+  #
+  # @see Compass::Magick::PLUGINS_PATH
+  module Plugins; end
+
+  PLUGINS_PATH.each do |path|
+    if File.exists?(path)
+      Dir.glob(File.join(path, '**', '*.rb')).each do |plugin|
+        require plugin
+      end
+    end
+  end
+end

data/lib/magick/scriptable.rb

@@ -0,0 +1,31 @@
+module Compass::Magick
+  # Common Sass node methods module.
+  #
+  # In order to export certain classes for Sass, they must implement a set of
+  # methods. This module provides a no-op implementation.
+  module Scriptable
+    # Sets the options hash for this node.
+    #
+    # @param [{Symbol => Object}] options The options hash.
+    def options=(options)
+      @options = options
+    end
+
+    # @return [{Symbol => Object}] The options hash.
+    attr_reader :options
+
+    # Sets the context for this node.
+    #
+    # @param [Symbol] context
+    # @see #context
+    def context=(context)
+      @context = context
+    end
+
+    # The context in which this node was parsed, which determines how some
+    # operations are performed.
+    #
+    # @return [Symbol]
+    attr_reader :context
+  end
+end

data/lib/magick/shapes.rb

@@ -0,0 +1,94 @@
+module Compass::Magick
+  # Drawing methods shared by Compass Magick commands.
+  #
+  # All of the drawing is done using B/W pixels with varying alpha. These
+  # shapes are used to build masks which are then applied to fill
+  # {Compass::Magick::Type}s to generate the final canvas.
+  module Shapes
+    extend self
+
+    # Draws a circle mask.
+    #
+    # Copyright (c) 2003 by Nils Haeck M.Sc. (Simdesign)
+    # http://www.simdesign.nl
+    #
+    # > The [..] DrawDisk routines is optimized quite well but do not claim
+    # > to be the fastest solution :) It is a floating point precision
+    # > implementation. Further optimisation would be possible if an
+    # > integer approach was chosen (but that would also loose
+    # > functionality).
+    #
+    # @param [Integer] radius The radius of the circle.
+    # @param [Float] feather The feater value determines the
+    #   anti-aliasing the circle will get, defaults to <tt>1.0</tt>.
+    # @return {Canvas} A Canvas with a circle B/W mask.
+    def circle(radius, width, feather = 1.0)
+      mask = ChunkyPNG::Canvas.new(radius, radius, ChunkyPNG::Color.rgba(0, 0, 0, 0))
+      if radius <= width
+        center = (radius - 1) / 2.0
+        rpf2   = (center + feather / 2.0) ** 2
+        rmf2   = (center - feather / 2.0) ** 2
+        lx     = [(center - rpf2).floor, 0].max
+        ly     = [(center - rpf2).floor, 0].max
+        rx     = [(center + rpf2).ceil, radius - 1].min
+        ry     = [(center + rpf2).ceil, radius - 1].min
+        sqx    = Array.new(rx - lx + 1)
+        for x in lx..rx
+          sqx[x - lx] = (x - center) ** 2
+        end
+        for y in ly..ry
+          sqy = (y - center) ** 2
+          for x in lx..rx
+            sqdist = sqy + sqx[x - lx]
+            if sqdist < rmf2
+              mask.set_pixel(x, y, ChunkyPNG::Color::WHITE)
+            else
+              if sqdist < rpf2
+                fact = (((center - Math.sqrt(sqdist)) * 2.0 / feather) * 0.5 + 0.5)
+                mask.set_pixel(x, y, ChunkyPNG::Color.rgba(255, 255, 255, 255 * [0, [fact, 1].min].max))
+              end
+            end
+          end
+        end
+      else
+        center  = (radius - 1) / 2.0
+        inrad   = (center + feather / 2.0) - width
+        ropf2   = (center + feather / 2.0) ** 2
+        romf2   = (center - feather / 2.0) ** 2
+        ripf2   = (inrad  + feather / 2.0) ** 2
+        rimf2   = (inrad  - feather / 2.0) ** 2
+        lx      = [(center - ropf2).floor, 0].max
+        ly      = [(center - ropf2).floor, 0].max
+        rx      = [(center + ropf2).ceil, radius - 1].min
+        ry      = [(center + ropf2).ceil, radius - 1].min
+        feather = width if feather > width
+        sqx     = Array.new(rx - lx + 1)
+        for x in lx..rx
+          sqx[x - lx] = (x - center) ** 2
+        end
+        for y in ly..ry
+          sqy = (y - center) ** 2
+          for x in lx..rx
+            sqdist = sqy + sqx[x - lx]
+            if sqdist >= rimf2
+              if sqdist < ropf2
+                if sqdist < romf2
+                  if sqdist < ripf2
+                    fact = (((Math.sqrt(sqdist) - inrad) * 2 / feather) * 0.5 + 0.5)
+                    mask.set_pixel(x, y, ChunkyPNG::Color.rgba(255, 255, 255, 255 * [0, [fact, 1].min].max))
+                  else
+                    mask.set_pixel(x, y, ChunkyPNG::Color::WHITE)
+                  end
+                else
+                  fact = (((center - Math.sqrt(sqdist)) * 2 / feather) * 0.5 + 0.5)
+                  mask.set_pixel(x, y, ChunkyPNG::Color.rgba(255, 255, 255, 255 * [0, [fact, 1].min].max))
+                end
+              end
+            end
+          end
+        end
+      end
+      mask
+    end
+  end
+end

data/lib/magick/types/gradients.rb

@@ -0,0 +1,182 @@
+module Compass::Magick
+  module Types
+    # The Gradients module defines all available Compass Magick gradient
+    # fills.
+    #
+    # At present, we only support point-to-point linear fill at an angle. The
+    # two points are determined automatically such as the center of the
+    # linear gradient is the center if the given region as well.
+    module Gradients
+      # A type that is used when constructing gradients to have precise
+      # control over color stops.
+      class ColorStop < Type
+        include Utils
+
+        # Initializes a new ColorStop instance.
+        #
+        # @param [Sass::Script::Number] offset The color stop offset, 0-100.
+        # @param [Sass::Script::Color] color The color at the offset.
+        def initialize(offset, color)
+          assert_type 'offset', offset, Sass::Script::Number
+          assert_type 'color',  color,  Sass::Script::Color
+          @offset = offset
+          @color  = color
+        end
+
+        # @return [Sass::Script::Number] The color stop offset, 0-100.
+        attr_reader :offset
+
+        # @return [Sass::Script::Color] The color at the offset.
+        attr_reader :color
+      end
+
+      # A type that generates a {Canvas} from a region filled using
+      # point-to-point linear gradient at an angle.
+      #
+      # @example
+      #
+      #     Linear.new(
+      #       Sass::Script::Number.new(45), [
+      #         ColorStop.new(Sass::Script::Number.new(0),   Sass::Script::Color.new([255,   0,   0])),
+      #         ColorStop.new(Sass::Script::Number.new(50),  Sass::Script::Color.new([  0, 255,   0])),
+      #         ColorStop.new(Sass::Script::Number.new(100), Sass::Script::Color.new([  0,   0, 255]))
+      #       ]
+      #     )
+      class Linear < Type
+        include Utils
+
+        # Initializes a new Linear instance.
+        #
+        # @param [Sass::Script::Number] angle The angle of the linear
+        #   gradient. The two points that form the point-to-point linear fill
+        #   are determined based on this value.
+        # @param [Array<ColorStop>] stops A list of color stops to interpolate
+        #   between.
+        def initialize(angle, stops)
+          assert_type 'angle', angle, Sass::Script::Number
+          assert_type 'stops', stops, Array
+          stops.each_with_index { |stop, index| assert_type "stop[#{index}]", stop, ColorStop }
+          @angle = angle
+          @stops = cache_stops(stops)
+        end
+
+        # @return [Sass::Script::Number] angle The angle of the linear
+        #   gradient.
+        attr_reader :angle
+
+        # @return [Array<ColorStop>] A list of color stops to interpolate
+        #   between.
+        attr_reader :stops
+
+        def to_canvas(width, height)
+          assert_type 'width',  width,  Sass::Script::Number
+          assert_type 'height', height, Sass::Script::Number
+          canvas = Canvas.new(width, height)
+          point_center    = Point.new(canvas.width  / 2,  canvas.height  / 2)
+          length_diagonal = Math.sqrt(canvas.width ** 2 + canvas.height ** 2);
+          segments_rectangle = [
+            [Point.new(0, 0),                                Point.new(canvas.width - 1, 0)],
+            [Point.new(canvas.width - 1, 0),                 Point.new(canvas.width - 1, canvas.height - 1)],
+            [Point.new(canvas.width - 1, canvas.height - 1), Point.new(0, canvas.height - 1)],
+            [Point.new(0, canvas.height - 1),                Point.new(0, 0)]
+          ]
+          point_start  = nil
+          point_finish = nil
+          [-1, 1].each do |direction|
+            segment = [
+              Point.new(point_center.x, point_center.y),
+              Point.new(point_center.x + direction * length_diagonal * Math.cos(@angle.value * Math::PI / 180), point_center.y + direction * length_diagonal * Math.sin(@angle.value * Math::PI / 180))
+            ];
+            segments_rectangle.each do |edge|
+              point = intersect(segment, edge)
+              if point
+                point_start  ||= point if direction == -1
+                point_finish ||= point if direction ==  1
+              end
+            end
+          end
+          # Michael Madsen & dash-tom-bang
+          # http://stackoverflow.com/questions/2869785/point-to-point-linear-gradient#answer-2870275
+          vector_gradient   = [point_finish.x - point_start.x, point_finish.y - point_start.y]
+          length_gradient   = Math.sqrt(vector_gradient[0] * vector_gradient[0] + vector_gradient[1] * vector_gradient[1])
+          vector_normalized = [vector_gradient[0] * (1 / length_gradient), vector_gradient[1] * (1 / length_gradient)]
+          (0...canvas.height).each do |y|
+            (0...canvas.width).each do |x|
+              result_normalized = (vector_normalized[0] * (x - point_start.x) + vector_normalized[1] * (y - point_start.y)) / length_gradient
+              canvas.set_pixel(x, y, interpolate(100 * (result_normalized < 0 ? 0 : result_normalized > 1 ? 1 : result_normalized)))
+            end
+          end
+          canvas
+        end
+
+        private
+
+        def cache_stops(stops)
+          @stops = stops.sort { |left, right| left.offset.value <=> right.offset.value }.map do |stop|
+            {
+              :color  => to_chunky_color(stop.color),
+              :offset => stop.offset.value,
+              :rgba   => [
+                stop.color.red,
+                stop.color.green,
+                stop.color.blue,
+                stop.color.alpha * 255
+              ]
+            }
+          end
+        end
+
+        def intersect(segment1, segment2)
+          # Andre LeMothe
+          # http://www.amazon.com/dp/0672323699/
+          # http://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect#answer-1968345
+          s1_x = segment1[1].x - segment1[0].x
+          s1_y = segment1[1].y - segment1[0].y
+          s2_x = segment2[1].x - segment2[0].x
+          s2_y = segment2[1].y - segment2[0].y
+          s    = (- s1_y * (segment1[0].x - segment2[0].x) + s1_x * (segment1[0].y - segment2[0].y)) / (- s2_x * s1_y + s1_x * s2_y)
+          t    = (  s2_x * (segment1[0].y - segment2[0].y) - s2_y * (segment1[0].x - segment2[0].x)) / (- s2_x * s1_y + s1_x * s2_y)
+          if s >= 0 && s <= 1 && t >= 0 && t <= 1
+            Point.new(
+              segment1[0].x + (t * s1_x),
+              segment1[0].y + (t * s1_y)
+            )
+          else
+            false
+          end
+        end
+
+        def interpolate(offset)
+          start  = nil
+          finish = nil
+          @stops.each do |stop|
+            if offset >= stop[:offset]
+              if start
+                start = stop unless start[:offset] > stop[:offset]
+              else
+                start = stop
+              end
+            end
+            if offset <= stop[:offset]
+              if finish
+                finish = stop unless finish[:offset] < stop[:offset]
+              else
+                finish = stop
+              end
+            end
+          end
+          return @stops[0][:color]  unless start
+          return @stops[-1][:color] unless finish
+          return finish[:color]     if     start[:offset] == finish[:offset]
+          rgba = []
+          # walkytalky
+          # http://stackoverflow.com/questions/3017019/non-linear-color-interpolation#answer-3030245
+          for i in (0..3)
+            rgba[i] = (start[:rgba][i] + (offset - start[:offset]) * (finish[:rgba][i] - start[:rgba][i]) / (finish[:offset] - start[:offset])).to_i
+          end
+          ChunkyPNG::Color.rgba(*rgba)
+        end
+      end
+    end
+  end
+end