compass-canvas 0.0.4

data/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License
+===============
+
+> Copyright (c) 2011 Stan Angeloff
+> 
+> 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

@@ -0,0 +1,78 @@
+compass-canvas
+==============
+
+### Canvas drawing support for Compass with Cairo backend(s)
+
+Description
+-----------
+
+Canvas is a Compass plugin that provides a drawing surface similar to the `<canvas>` element in JavaScript and [Turtle graphics][turtle] in other programming languages.
+It uses [Cairo][cairo] as a back-end to perform all graphics operations.
+Canvas supports anti-aliasing, vector graphics, gradients, masks, clipping, complex operations like drop shadow and many more.
+
+  [turtle]: http://en.wikipedia.org/wiki/Turtle_graphics
+  [cairo]:  http://en.wikipedia.org/wiki/Cairo_(graphics)
+
+Installation
+------------
+
+Installation is done through [RubyGems][gems]:
+
+    gem install compass-canvas
+
+### Dependencies
+
+The `compass-canvas` gem depends on the `cairo` gem. In order to install both gems, you must have Cairo's development files present on your system.
+You can usually install these using your OS package manager.
+
+#### Ubuntu
+
+    sudo apt-get install libcairo2-dev
+
+  [gems]: http://rubygems.org/
+
+Example
+-------
+
+    @import 'canvas';
+
+    $shape: triangle(10, 10, 310, 10, 160, 190);
+
+    html {
+      background: canvas(320, 200,
+        $shape
+        brush(10, 10, 160, 100, rgba(red, 0.5) 50%, rgba(red, 0.75))
+        fill
+        reset
+        save
+          translate(40, 20)
+          scale(0.75, 0.75)
+          $shape
+          brush(black)
+          stroke
+          brush(10, 10, 160, 100, rgba(blue, 0.75) 50%, rgba(blue, 0.5))
+          fill
+        restore
+      ) no-repeat 50% 50%;
+    }
+
+License
+-------
+
+Canvas is licensed under the MIT License.
+
+## [Documentation](http://StanAngeloff.github.com/compass-canvas/)
+
+[RDoc is available][rdoc] for the entire project.
+
+For more information on Cairo, visit [The Cairo graphics tutorial][cairo-tutorial].
+
+For a complete reference on Cairo methods, visit [Pycairo documentation][pycairo].
+
+  [rdoc]:           http://rubydoc.info/gems/compass-canvas/frames
+  [cairo-tutorial]: http://zetcode.com/tutorials/cairographicstutorial/
+  [pycairo]:        http://cairographics.org/documentation/pycairo/3/reference/context.html#class-context
+
+### Copyright
+
+> Copyright (c) 2011 Stan Angeloff. See [LICENSE.md](https://github.com/StanAngeloff/compass-canvas/blob/master/LICENSE.md) for details.

data/lib/canvas.rb

@@ -0,0 +1,48 @@
+# Canvas drawing support for Compass with Cairo backend(s).
+#
+# This module defines the current project version and useful helper functions.
+#
+# @author Stan Angeloff
+module Compass::Canvas
+  # The project and Gem version. When building a Gem file for release, the
+  # version is stripped to X.Y.Z. If you are using a Git cloned-repository,
+  # the version will end in +.git+.
+  VERSION = '0.0.4.git'
+
+  # The default backend for drawing.
+  BACKEND = 'cairo'
+
+  # Helper function to construct an absolute path to a given directory in
+  # the project.
+  #
+  # @return [String] The absolute path to the directory.
+  def self.path_to(directory)
+    File.expand_path(File.join(File.dirname(__FILE__), '..', directory))
+  end
+
+  # Locations where plug-ins are installed. These paths are scanned for *.rb files
+  # and loaded in order.
+  PLUGINS_PATH = [
+    Compass::Canvas.path_to('plugins'),
+    File.join(ENV['HOME'], '.compass-canvas', 'plugins'),
+    File.join(Dir.getwd, 'plugins')
+  ]
+
+  # Default exception class.
+  class Exception < ::StandardError; end
+end
+
+require 'canvas/actions'
+require 'canvas/constants'
+require 'canvas/backend'
+require 'canvas/configuration'
+require 'canvas/plugins'
+require 'canvas/functions'
+
+# Register Canvas as a Compass framework.
+#
+# @see http://compass-style.org/docs/tutorials/extensions/
+Compass::Frameworks.register('canvas',
+  :stylesheets_directory => Compass::Canvas.path_to('stylesheets'),
+  :templates_directory   => Compass::Canvas.path_to('templates')
+)

data/lib/canvas/actions.rb

@@ -0,0 +1,39 @@
+module Compass::Canvas
+  # This module contains all actions a backend must implement.
+  module Actions
+    ANTIALIAS    = :antialias
+    ARC          = :arc
+    ARC_REVERSE  = :arc_reverse
+    BRUSH        = :brush
+    CLIP         = :clip
+    CLOSE        = :close
+    CURVE        = :curve
+    DASH_PATTERN = :dash_pattern
+    FILL         = :fill
+    FILL_RULE    = :fill_rule
+    GROUP        = :group
+    LINE         = :line
+    LINE_CAP     = :line_cap
+    LINE_JOIN    = :line_join
+    LINE_WIDTH   = :line_width
+    MASK         = :mask
+    MITER_LIMIT  = :miter_limit
+    MOVE         = :move
+    PAINT        = :paint
+    POP          = :pop
+    PUSH         = :push
+    RESET        = :reset
+    RESTORE      = :restore
+    RETRIEVE     = :retrieve
+    ROTATE       = :rotate
+    SAVE         = :save
+    SCALE        = :scale
+    SLOW_BLUR    = :slow_blur
+    STORE        = :store
+    STROKE       = :stroke
+    TOLERANCE    = :tolerance
+    TRANSFORM    = :transform
+    TRANSLATE    = :translate
+    UNCLIP       = :unclip
+  end
+end

data/lib/canvas/backend.rb

@@ -0,0 +1,145 @@
+require 'base64'
+
+# This module defines the base backend class for all implementations
+module Compass::Canvas::Backend
+  # Base abstract backend class.
+  #
+  # Each implementation must respond to four methods:
+  # - {Compass::Canvas::Backend::Base::load_dependencies} - initializes the backend by loading third-party dependencies
+  # - {Compass::Canvas::Backend::Base::begin_canvas} - initialization code before the canvas is drawn
+  # - {Compass::Canvas::Backend::Base::execute_one} - executes a single action on the canvas
+  # - {Compass::Canvas::Backend::Base::to_blob} - clean up code, must return a
+  #   +String+ representation of the canvas in a PNG format
+  class Base < Sass::Script::Literal
+    # @return [Fixnum] The width of the canvas, in pixels.
+    attr_accessor :width
+    # @return [Fixnum] The height of the canvas, in pixels.
+    attr_accessor :height
+    # @return [String] The external file where the backend will be loaded/saved in a PNG format.
+    attr_accessor :file
+
+    # Initializes a new instance of a backend class.
+    #
+    # @overload initialize(width, height, *actions)
+    #   @param [Fixnum] width The width of the canvas, in pixels.
+    #   @param [Fixnum] height The height of the canvas, in pixels.
+    #   @param [Array<Object>] actions The actions to execute.
+    # @overload initialize(file, width, height, *actions)
+    #   @param [String] file The file where the backend will be saved in a PNG format.
+    #   @param [Fixnum] width The width of the canvas, in pixels.
+    #   @param [Fixnum] height The height of the canvas, in pixels.
+    #   @param [Array<Object>] actions The actions to execute.
+    # @overload initialize(file)
+    #   @param [String] file An external file to read.
+    def initialize(*args)
+      load_dependencies
+      if args[0].is_a?(String)
+        file = args.shift
+        unless args[1].is_a?(Fixnum)
+          if file.include?('url(')
+            file = File.join(Compass.configuration.css_path, file.gsub(/^url\(['"]?|["']?\)$/, '').split('?').shift())
+          else
+            file = File.join(Compass.configuration.images_path, file.split('?').shift())
+          end
+        end
+        @file = file
+      end
+      if args[0].is_a?(Fixnum)
+        @width  = args.shift
+        @height = args.shift
+      end
+      @actions = args
+    end
+
+    # Abstract method.
+    #
+    # Initializes the backend by loading third-party dependencies.
+    #
+    # @raise [Compass::Canvas::Exception] Backend implementation must override this method.
+    def load_dependencies
+      raise Compass::Canvas::Exception.new("(#{self.class}) Class must implement '#{this_method}'.")
+    end
+
+    # Abstract method.
+    #
+    # Initialization code before the canvas is drawn.
+    #
+    # @raise [Compass::Canvas::Exception] Backend implementation must override this method.
+    def begin_canvas
+      raise Compass::Canvas::Exception.new("(#{self.class}) Class must implement '#{this_method}'.")
+    end
+
+    # Abstract method.
+    #
+    # Executes a single action on the canvas.
+    #
+    # @raise [Compass::Canvas::Exception] Backend implementation must override this method.
+    def execute_one(action, *args)
+      raise Compass::Canvas::Exception.new("(#{self.class}) Class must implement '#{this_method}'.")
+    end
+
+    # Abstract method.
+    #
+    # Clean up code, must return a +String+ representation of the canvas in a PNG format.
+    #
+    # @raise [Compass::Canvas::Exception] Backend implementation must override this method.
+    def to_blob
+      raise Compass::Canvas::Exception.new("(#{self.class}) Class must implement '#{this_method}'.")
+    end
+
+    # Creates an empty canvas and executes all stored actions.
+    def execute
+      begin_canvas
+      execute_actions
+    end
+
+    # Returns the canvas as a Base64 encoded Data URI or as a file on disk
+    # depending on the configuration.
+    def value
+      execute
+      if @file
+        extension = '.png'
+        filename  = @file.chomp(extension) + extension
+        path      = File.join(Compass.configuration.images_path, filename)
+        FileUtils.mkpath(File.dirname(path))
+        File.open(path, 'wb') { |io| io << to_blob }
+        filename
+      else
+        "url('data:image/png;base64,#{ Base64.encode64(to_blob).gsub("\n", '') }')"
+      end
+    end
+
+    # Serializes the canvas as a Sass type
+    def to_s(options = {})
+      Sass::Script::String.new(value)
+    end
+
+    protected
+
+    def execute_actions(actions = nil)
+      actions ||= @actions
+      actions.each do |child|
+        if child.is_a?(Compass::Canvas::Backend::Interface::Base)
+          action = child.action
+          args   = child.args
+        elsif child.is_a?(String)
+          action = child.to_sym
+          args   = []
+        else
+          raise Compass::Canvas::Exception.new("(#{self.class}) Unsupported action: #{child.inspect}")
+        end
+        execute_one(action, *args)
+      end
+      self
+    end
+
+    private
+
+    def this_method
+      caller[0][/`([^']*)'/, 1]
+    end
+  end
+end
+
+require 'canvas/backend/interface';
+require 'canvas/backend/cairo';

data/lib/canvas/backend/cairo.rb

@@ -0,0 +1,176 @@
+require 'stringio'
+
+module Compass::Canvas::Backend
+  # Cairo backend implementation.
+  class Cairo < Base
+    # @return [::Cairo::ImageSurface] The internal image surface.
+    attr_accessor :surface
+
+    # Loads the +cairo+ gem dependency. If it is not on +$LOAD_PATH+, attempts
+    # to load RubyGems.
+    def load_dependencies
+      begin
+        require 'cairo'
+      rescue LoadError
+        require 'rubygems'
+        begin
+          require 'cairo'
+        rescue LoadError
+          puts "Compass::Canvas\n_______________\n\n"
+          puts "Unable to load Cairo backend. Please install it with the following command:\n\n"
+          puts "  gem install cairo\n\n"
+          puts "For more information, please visit https://github.com/rcairo/rcairo"
+          raise
+        end
+      end
+    end
+
+    # Creates a new +ImageSurface+ and binds a new context to it.
+    def begin_canvas
+      if @width && @height
+        @surface = ::Cairo::ImageSurface.new(::Cairo::FORMAT_ARGB32, @width, @height)
+      else
+        @surface = ::Cairo::ImageSurface.from_png(@file)
+      end
+      @context = ::Cairo::Context.new(@surface)
+      @context.set_line_width(1)
+      @sources = []
+    end
+
+    # Executes a single action on the context bound to the surface.
+    def execute_one(action, *args)
+      case action
+      when Compass::Canvas::Actions::MOVE
+        @context.move_to(*args)
+      when Compass::Canvas::Actions::LINE
+        @context.line_to(*args)
+      when Compass::Canvas::Actions::CURVE
+        @context.curve_to(*args)
+      when Compass::Canvas::Actions::ARC
+        @context.arc(*args)
+      when Compass::Canvas::Actions::ARC_REVERSE
+        @context.arc_negative(*args)
+      when Compass::Canvas::Actions::PAINT
+        @context.paint(*args)
+      when Compass::Canvas::Actions::STROKE
+        @context.stroke_preserve(*args)
+      when Compass::Canvas::Actions::FILL
+        @context.fill_preserve(*args)
+      when Compass::Canvas::Actions::LINE_WIDTH
+        @context.set_line_width(*args)
+      when Compass::Canvas::Actions::PUSH
+        @context.push_group
+      when Compass::Canvas::Actions::POP
+        @context.pop_group_to_source
+      when Compass::Canvas::Actions::STORE
+        @sources.push(@context.source)
+      when Compass::Canvas::Actions::RETRIEVE
+        @context.set_source(@sources.pop)
+      when Compass::Canvas::Actions::GROUP
+        @context.new_sub_path
+      when Compass::Canvas::Actions::CLIP
+        @context.clip_preserve
+      when Compass::Canvas::Actions::UNCLIP
+        @context.reset_clip
+      when Compass::Canvas::Actions::CLOSE
+        @context.close_path
+      when Compass::Canvas::Actions::RESET
+        @context.new_path
+      when Compass::Canvas::Actions::SAVE
+        @context.save
+      when Compass::Canvas::Actions::RESTORE
+        @context.restore
+      when Compass::Canvas::Actions::ANTIALIAS
+        @context.set_antialias(constant('ANTIALIAS', args))
+      when Compass::Canvas::Actions::FILL_RULE
+        @context.set_fill_rule(constant('FILL_RULE', args))
+      when Compass::Canvas::Actions::TOLERANCE
+        @context.set_tolerance(*args)
+      when Compass::Canvas::Actions::LINE_CAP
+        @context.set_line_cap(constant('LINE_CAP', args))
+      when Compass::Canvas::Actions::LINE_JOIN
+        @context.set_line_join(constant('LINE_JOIN', args))
+      when Compass::Canvas::Actions::MITER_LIMIT
+        @context.set_miter_limit(*args)
+      when Compass::Canvas::Actions::DASH_PATTERN
+        # If at least two lengths exist, create a new pattern
+        if args.length > 1
+          @context.set_dash(args)
+        # Otherwise return to a solid stroke
+        else
+          @context.set_dash(nil, 0)
+        end
+      when Compass::Canvas::Actions::TRANSLATE
+        @context.translate(*args)
+      when Compass::Canvas::Actions::SCALE
+        @context.scale(*args)
+      when Compass::Canvas::Actions::ROTATE
+        @context.rotate(*args)
+      when Compass::Canvas::Actions::TRANSFORM
+        @context.transform(::Cairo::Matrix.new(*args))
+      when Compass::Canvas::Actions::MASK
+        type = args.shift
+        if type.is_a?(Compass::Canvas::Backend::Cairo)
+          surface = type.execute.surface
+          if args.length == 1
+            pattern = ::Cairo::SurfacePattern.new(surface)
+            pattern.set_extend(constant('EXTEND', args))
+            @context.mask(pattern)
+          else
+            x = args.shift if args.length
+            y = args.shift if args.length
+            @context.mask(surface, x || 0, y || 0)
+          end
+        elsif type == Compass::Canvas::Actions::RETRIEVE
+          @context.mask(@sources.pop)
+        else
+          raise Compass::Canvas::Exception.new("(#{self.class}.#{action}) Unsupported canvas, Cairo can only mask with Cairo: #{type.inspect}")
+        end
+      when Compass::Canvas::Actions::BRUSH
+        type = args.shift
+        case type
+        when Compass::Canvas::Constants::SOLID
+          components = args.shift
+          @context.set_source_rgba(*components)
+        when Compass::Canvas::Constants::LINEAR, Compass::Canvas::Constants::RADIAL
+          coordinates = args.shift
+          stops       = args.shift
+          gradient    = ::Cairo::const_get("#{ type.to_s.sub(/^\w/) { |s| s.capitalize } }Pattern").new(*coordinates)
+          stops.each { |value| gradient.add_color_stop_rgba(*value) }
+          @context.set_source(gradient)
+        when Compass::Canvas::Constants::CANVAS
+          canvas = args.shift
+          if canvas.is_a?(Compass::Canvas::Backend::Cairo)
+            pattern = ::Cairo::SurfacePattern.new(canvas.execute.surface)
+            pattern.set_extend(constant('EXTEND', args)) if args.length
+            @context.set_source(pattern)
+          else
+            raise Compass::Canvas::Exception.new("(#{self.class}.#{action}) Unsupported canvas, Cairo can only paint with Cairo: #{canvas.inspect}")
+          end
+        else
+          raise Compass::Canvas::Exception.new("(#{self.class}.#{action}) Unsupported type (supported types are 'solid', 'linear', 'radial'): #{type.inspect}")
+        end
+      when Compass::Canvas::Actions::SLOW_BLUR
+        radius = args.shift
+        @context.pseudo_blur(radius) do
+          execute_actions(args)
+        end
+      else
+        raise Compass::Canvas::Exception.new("(#{self.class}) '#{action}' is not supported.")
+      end
+    end
+
+    # Serializes the +ImageSurface+ to a +String+.
+    def to_blob
+      stream = StringIO.new
+      @surface.write_to_png(stream)
+      stream.string
+    end
+
+    private
+
+    def constant(name, *args)
+      ::Cairo::const_get("#{ name.upcase }_#{ args.join('_').gsub('-', '_').upcase }")
+    end
+  end
+end

data/lib/canvas/backend/interface.rb

@@ -0,0 +1,42 @@
+module Compass::Canvas::Backend
+  # This module defines classes for parsing Sass types and constructing Ruby
+  # objects for use in backend implementations.
+  module Interface
+    # Base class for all interface classes.
+    #
+    # This class unpacks Sass types to Ruby objects before passing them to a
+    # backend implementation.
+    class Base < Sass::Script::Literal
+      # @return [String] The action to take, e.g., +move+, +line+.
+      attr_accessor :action
+      # @return [Array] The arguments to pass, e.g., +X+ and +Y+ coordinates.
+      attr_accessor :args
+
+      # Initializes a new instance of an interface class.
+      #
+      # @param [String] action The action to take, e.g., +move+, +line+.
+      # @param [Array<Sass::Script::Literal>] args The arguments to pass.
+      def initialize(action, *args)
+        @action = action.value.to_sym
+        unless self.respond_to?(@action)
+          recognised = self.class.public_instance_methods - self.class.superclass.public_instance_methods
+          raise Compass::Canvas::Exception.new("(#{self.class}) '#{@action}' is not a recognised action. Did you mean any of the following: '#{ recognised.join("', '") }'?")
+        end
+        arity = self.method(@action).arity.abs
+        unless args.length >= arity
+          raise Compass::Canvas::Exception.new("(#{self.class}.#{@action}) Wrong number of arguments (#{args.length} for #{arity}).")
+        end
+        @args = self.send(@action, *args)
+      end
+
+      # @raise [Compass::Canvas::Exception] Interface objects cannot be used as property values.
+      def to_s(options = {})
+        raise Compass::Canvas::Exception.new("(#{self.class}.#{@action}) Not available in this context.")
+      end
+    end
+  end
+end
+
+require 'canvas/backend/interface/context';
+require 'canvas/backend/interface/path';
+require 'canvas/backend/interface/pattern';

data/lib/canvas/backend/interface/context.rb

@@ -0,0 +1,68 @@
+module Compass::Canvas::Backend::Interface
+  # Interface Context class.
+  class Context < Base
+    # Unpacks argument +width+ from Sass to a Ruby object.
+    def line_width(width)
+      [width.value]
+    end
+
+    # Unpacks argument +type+ from Sass to a Ruby object.
+    def line_cap(type)
+      [type.value]
+    end
+
+    # Unpacks argument +type+ from Sass to a Ruby object.
+    def line_join(type)
+      [type.value]
+    end
+
+    # Unpacks argument +limit+ from Sass to a Ruby object.
+    def miter_limit(limit)
+      [limit.value]
+    end
+
+    # Unpacks argument +type+ from Sass to a Ruby object.
+    def antialias(type)
+      if type.is_a?(Sass::Script::Color)
+        [type.to_s]
+      else
+        [type.value]
+      end
+    end
+
+    # Unpacks argument +type+ from Sass to a Ruby object.
+    def fill_rule(type)
+      [type.value]
+    end
+
+    # Unpacks argument +level+ from Sass to a Ruby object.
+    def tolerance(level)
+      [level.value]
+    end
+
+    # Unpacks arguments +X+ and +Y+ from Sass to Ruby objects.
+    def translate(x, y)
+      [x.value, y.value]
+    end
+
+    # Unpacks arguments +X+ and +Y+ from Sass to Ruby objects.
+    def scale(x, y)
+      [x.value, y.value]
+    end
+
+    # Unpacks argument +angle+ from Sass to a Ruby object.
+    def rotate(angle)
+      [angle.value * (Math::PI / 180.0)]
+    end
+
+    # Unpacks matrix arguments from Sass to Ruby objects.
+    def transform(xx, yx, xy, yy, x0, y0)
+      [xx.value, yx.value, xy.value, yy.value, x0.value, y0.value]
+    end
+
+    def slow_blur(*args)
+      radius = args.shift.value
+      [radius].concat(Compass::Canvas::Functions.unpack(args).flatten)
+    end
+  end
+end

data/lib/canvas/backend/interface/path.rb

@@ -0,0 +1,29 @@
+module Compass::Canvas::Backend::Interface
+  # Interface Path class.
+  class Path < Base
+    # Unpacks arguments +X+ and +Y+ from Sass to Ruby objects.
+    def move(x, y)
+      [x.value, y.value]
+    end
+
+    # Unpacks arguments +X+ and +Y+ from Sass to Ruby objects.
+    def line(x, y)
+      [x.value, y.value]
+    end
+
+    # Unpacks arguments +X+[1..3] and +Y+[1..3] from Sass to Ruby objects.
+    def curve(x1, y1, x2, y2, x3, y3)
+      [x1.value, y1.value, x2.value, y2.value, x3.value, y3.value]
+    end
+
+    # Unpacks arguments +X+, +Y+, +radius+ and +angle+[1..2] from Sass to Ruby objects.
+    def arc(x, y, radius, angle1, angle2)
+      [x.value, y.value, radius.value, angle1.value * (Math::PI / 180.0), angle2.value * (Math::PI / 180.0)]
+    end
+
+    # @see {arc}
+    def arc_reverse(*args)
+      arc(*args)
+    end
+  end
+end

data/lib/canvas/backend/interface/pattern.rb

@@ -0,0 +1,100 @@
+module Compass::Canvas::Backend::Interface
+  # Interface Pattern class.
+  class Pattern < Base
+    # Unpacks brush arguments to a Ruby object.
+    def brush(*args)
+      if args.length == 1
+        type = args.shift
+        if type.is_a?(Sass::Script::Color)
+          [Compass::Canvas::Constants::SOLID, Pattern.split(type)]
+        elsif type.is_a?(Sass::Script::String) && type.value == Compass::Canvas::Actions::RETRIEVE.to_s
+          [Compass::Canvas::Actions::RETRIEVE]
+        elsif type.is_a?(Compass::Canvas::Backend::Base)
+          [Compass::Canvas::Constants::CANVAS, type]
+        else
+          raise Compass::Canvas::Exception.new("(#{self.class}.#{@action}) Unsupported solid brush type: #{type.inspect}")
+        end
+      elsif args.length == 2
+        canvas  = args.shift
+        extends = args.shift
+        if canvas.is_a?(Compass::Canvas::Backend::Base) && extends.is_a?(Sass::Script::String)
+          [Compass::Canvas::Constants::CANVAS, canvas, extends.value]
+        else
+          raise Compass::Canvas::Exception.new("(#{self.class}.#{@action}) Unsupported pattern brush type: #{canvas.inspect}")
+        end
+      elsif args.length > 4
+        index = 0
+        index = index + 1 while index < args.length && args[index].is_a?(Sass::Script::Number)
+        type = Compass::Canvas::Constants::LINEAR if index == 4
+        type = Compass::Canvas::Constants::RADIAL if index == 6
+        if type
+          [type, args.slice(0, index).map { |value| value.value }, Pattern.stops(args.slice(index, args.length))]
+        else
+          raise Compass::Canvas::Exception.new("(#{self.class}.#{@action}) Unsupported gradient brush type: #{args.inspect}")
+        end
+      else
+        raise Compass::Canvas::Exception.new("(#{self.class}.#{@action}) Unsupported brush type: #{args.inspect}")
+      end
+    end
+
+    # Unpacks dash +pattern+ arguments to Ruby objects.
+    def dash_pattern(*pattern)
+      pattern.map { |value| value.value }
+    end
+
+    # Unpacks +canvas+ and optional arguments to a Ruby object.
+    def mask(*args)
+      type = args.shift
+      if type.is_a?(Sass::Script::String) && type.value == Compass::Canvas::Actions::RETRIEVE.to_s
+        type = Compass::Canvas::Actions::RETRIEVE
+      end
+      [type].concat(args.map { |value| value.value })
+    end
+
+    private
+
+    def self.split(value)
+      [value.red / 255.0, value.green / 255.0, value.blue / 255.0, value.alpha]
+    end
+
+    def self.stops(list)
+      result      = []
+      last_offset = 0
+      list.each_with_index do |value, index|
+        if value.is_a?(Sass::Script::Color)
+          if index > 0
+            if index == list.length - 1
+              offset = 100
+            else
+              next_index  = 0
+              next_offset = nil
+              list.slice(index, list.length).each do |next_value|
+                next_index = next_index + 1
+                if next_value.is_a?(Sass::Script::List)
+                  next_value.value.each { |child| next_offset = child.value if child.is_a?(Sass::Script::Number) }
+                  break
+                end
+              end
+              next_offset ||= 100
+              offset = last_offset + (next_offset - last_offset) / next_index
+            end
+          else
+            offset = 0
+          end
+          last_offset = offset
+          result.push([last_offset / 100.0].concat(Pattern.split(value)))
+        elsif value.is_a?(Sass::Script::List)
+          color = nil
+          value.value.each do |child|
+            color       = child if child.is_a?(Sass::Script::Color)
+            last_offset = child.value if child.is_a?(Sass::Script::Number)
+          end
+          result.push([last_offset / 100.0].concat(Pattern.split(color))) if color
+        else
+          raise Compass::Canvas::Exception.new("(#{self.class}) Unsupported gradient brush color-stop: #{value.inspect}")
+        end
+      end
+      result
+    end
+  end
+end

data/lib/canvas/configuration.rb

@@ -0,0 +1,3 @@
+Compass::Configuration.add_configuration_property(:canvas_backend, "The backend to use for all canvas drawing operations") do
+  Compass::Canvas::BACKEND
+end

data/lib/canvas/constants.rb

@@ -0,0 +1,9 @@
+module Compass::Canvas
+  # This module contains all constants shared between interfaces and backends.
+  module Constants
+    CANVAS = :canvas
+    LINEAR = :linear
+    RADIAL = :radial
+    SOLID  = :solid
+  end
+end

data/lib/canvas/functions.rb

@@ -0,0 +1,37 @@
+require 'canvas/functions/canvas'
+require 'canvas/functions/context'
+require 'canvas/functions/path'
+require 'canvas/functions/pattern'
+
+module Compass::Canvas
+  # The +Functions+ module aggregates all exported functions.
+  #
+  # @see Compass::Canvas::Functions::Canvas
+  # @see Compass::Canvas::Functions::Context
+  # @see Compass::Canvas::Functions::Path
+  # @see Compass::Canvas::Functions::Pattern
+  module Functions
+    include Canvas
+    include Context
+    include Path
+    include Pattern
+    include Compass::Canvas::Plugins::Functions
+
+    def self.unpack(value)
+      if value.is_a?(Compass::Canvas::Backend::Interface::Base)
+        value
+      elsif value.is_a?(Sass::Script::Literal)
+        Compass::Canvas::Functions.unpack(value.value)
+      elsif value.is_a?(Array)
+        value.map { |child| Compass::Canvas::Functions.unpack(child) }
+      else
+        value
+      end
+    end
+  end
+end
+
+# Exports {Compass::Canvas::Functions} to Sass.
+module Sass::Script::Functions
+  include Compass::Canvas::Functions
+end

data/lib/canvas/functions/canvas.rb

@@ -0,0 +1,21 @@
+module Compass::Canvas
+  module Functions
+    # Functions for creating a canvas backend.
+    module Canvas
+      # Creates a new {Compass::Canvas::Backend}.
+      #
+      # This function cannot be created in Sass as it is a variadic function.
+      #
+      # @return [Compass::Canvas::Backend] A new backend instance.
+      def canvas(*args)
+        backend = Compass.configuration.canvas_backend.sub(/^\w/) { |s| s.capitalize }
+        begin
+          klass = Compass::Canvas::Backend.const_get(backend)
+        rescue NameError
+          raise Compass::Canvas::Exception.new("(Compass::Canvas) '#{backend}' backend is not installed.")
+        end
+        klass.new(*Compass::Canvas::Functions.unpack(args).flatten)
+      end
+    end
+  end
+end

data/lib/canvas/functions/context.rb

@@ -0,0 +1,20 @@
+module Compass::Canvas
+  module Functions
+    # Functions for creating a Context interface.
+    module Context
+      # Creates a new {Compass::Canvas::Backend::Interface::Context}.
+      #
+      # @return [Compass::Canvas::Backend::Interface::Context] A new Context interface.
+      def canvas_context(*args)
+        Compass::Canvas::Backend::Interface::Context.new(*args)
+      end
+
+      # Constructs a slow-blur group.
+      #
+      # This function cannot be created in Sass as it is a variadic function.
+      def slow_blur(radius, *args)
+        canvas_context(Sass::Script::String.new(Compass::Canvas::Actions::SLOW_BLUR.to_s), *[radius].concat(args))
+      end
+    end
+  end
+end

data/lib/canvas/functions/path.rb

@@ -0,0 +1,13 @@
+module Compass::Canvas
+  module Functions
+    # Functions for creating a Path interface.
+    module Path
+      # Creates a new {Compass::Canvas::Backend::Interface::Path}.
+      #
+      # @return [Compass::Canvas::Backend::Interface::Path] A new Path interface.
+      def canvas_path(*args)
+        Compass::Canvas::Backend::Interface::Path.new(*args)
+      end
+    end
+  end
+end

data/lib/canvas/functions/pattern.rb

@@ -0,0 +1,34 @@
+module Compass::Canvas
+  module Functions
+    # Functions for creating a Pattern interface.
+    module Pattern
+      # Creates a new {Compass::Canvas::Backend::Interface::Pattern}.
+      #
+      # @return [Compass::Canvas::Backend::Interface::Pattern] A new Pattern interface.
+      def canvas_pattern(*args)
+        Compass::Canvas::Backend::Interface::Pattern.new(*args)
+      end
+
+      # Constructs a paint pattern.
+      #
+      # This function cannot be created in Sass as it is a variadic function.
+      def brush(*args)
+        canvas_pattern(Sass::Script::String.new(Compass::Canvas::Actions::BRUSH), *args)
+      end
+
+      # Constructs a dash pattern array from positive On/Off lengths.
+      #
+      # This function cannot be created in Sass as it is a variadic function.
+      def dash_pattern(*args)
+        canvas_pattern(Sass::Script::String.new(Compass::Canvas::Actions::DASH_PATTERN), *args)
+      end
+
+      # Constructs a mask from a canvas.
+      #
+      # This function cannot be created in Sass as it is a variadic function.
+      def mask(*args)
+        canvas_pattern(Sass::Script::String.new(Compass::Canvas::Actions::MASK), *args)
+      end
+    end
+  end
+end

data/lib/canvas/plugins.rb

@@ -0,0 +1,16 @@
+module Compass::Canvas
+  # This module includes external files in registered locations.
+  #
+  # @see Compass::Canvas::PLUGINS_PATH
+  module Plugins
+    module Functions; end
+  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/plugins/drop-shadow.rb

@@ -0,0 +1,14 @@
+module Compass::Canvas::Plugins::Functions
+  def slow_drop_shadow(x, y, radius, brush, *args)
+    Sass::Script::List.new(
+      [Sass::Script::String.new('push')].concat([canvas_context(Sass::Script::String.new('slow_blur'), radius, args)]).concat([Sass::Script::String.new('pop'), Sass::Script::String.new('store')]).concat([
+        brush,
+        Sass::Script::String.new('save'),
+        canvas_context(Sass::Script::String.new('translate'), x, y),
+        canvas_pattern(Sass::Script::String.new('mask'), Sass::Script::String.new('retrieve')),
+        Sass::Script::String.new('restore')
+      ].concat(args)),
+      :space
+    )
+  end
+end

data/stylesheets/_canvas.scss

@@ -0,0 +1,3 @@
+@import 'canvas/context';
+@import 'canvas/path';
+@import 'canvas/pattern';

data/stylesheets/canvas/_context.scss

@@ -0,0 +1,43 @@
+@function line-width($width) {
+  @return canvas-context('line_width', $width);
+}
+
+@function line-cap($type) {
+  @return canvas-context('line_cap', $type);
+}
+
+@function line-join($type) {
+  @return canvas-context('line_join', $type);
+}
+
+@function miter-limit($limit) {
+  @return canvas-context('miter_limit', $limit);
+}
+
+@function antialias($type) {
+  @return canvas-context('antialias', $type);
+}
+
+@function fill-rule($type) {
+  @return canvas-context('fill_rule', $type);
+}
+
+@function tolerance($level) {
+  @return canvas-context('tolerance', $level);
+}
+
+@function translate($x, $y) {
+  @return canvas-context('translate', $x, $y);
+}
+
+@function scale($x, $y) {
+  @return canvas-context('scale', $x, $y);
+}
+
+@function rotate($angle) {
+  @return canvas-context('rotate', $angle);
+}
+
+@function transform($xx: 1.0, $yx: 0.0, $xy: 0.0, $yy: 1.0, $x0: 0.0, $y0: 0.0) {
+  @return canvas-context('transform', $xx, $yx, $xy, $yy, $x0, $y0);
+}

data/stylesheets/canvas/_path.scss

@@ -0,0 +1,2 @@
+@import 'canvas/path/primitives';
+@import 'canvas/path/shapes';

data/stylesheets/canvas/_pattern.scss

@@ -0,0 +1,3 @@
+// @function brush(*args) {}
+// @function dash_pattern(*args) {}
+// @function mask(*args) {}

data/stylesheets/canvas/path/_primitives.scss

@@ -0,0 +1,19 @@
+@function move-to($x, $y) {
+  @return canvas-path('move', $x, $y);
+}
+
+@function line-to($x, $y) {
+  @return canvas-path('line', $x, $y);
+}
+
+@function arc($x, $y, $radius, $angle1, $angle2) {
+  @return canvas-path('arc', $x, $y, $radius, $angle1, $angle2);
+}
+
+@function arc-reverse($x, $y, $radius, $angle1, $angle2) {
+  @return canvas-path('arc_reverse', $x, $y, $radius, $angle1, $angle2);
+}
+
+@function curve-to($x1, $y1, $x2, $y2, $x3, $y3) {
+  @return canvas-path('curve', $x1, $y1, $x2, $y2, $x3, $y3);
+}

data/stylesheets/canvas/path/_shapes.scss

@@ -0,0 +1,47 @@
+@function rectangle($x1, $y1, $x2, $y2) {
+  @return (
+    move-to($x1, $y1)
+    line-to($x2, $y1)
+    line-to($x2, $y2)
+    line-to($x1, $y2)
+    close
+  );
+}
+
+@function circle($x, $y, $radius) {
+  @return arc($x, $y, $radius, 0, 360);
+}
+
+@function rounded-rectangle($x1, $y1, $x2, $y2, $x_radius, $y_radius: $x_radius) {
+  $max_x_radius: ($x2 - $x1) / 2.0;
+  $max_y_radius: ($y2 - $y1) / 2.0;
+  @if $x_radius > $max_x_radius {
+    $x_radius: $max_x_radius;
+  }
+  @if $y_radius > $max_y_radius {
+    $y_radius: $max_y_radius;
+  }
+  $half_x_radius: $x_radius / 2.0;
+  $half_y_radius: $y_radius / 2.0;
+  @return (
+    move-to($x1 + $x_radius, $y1)
+    line-to($x2 - $x_radius, $y1)
+    curve-to($x2 - $half_x_radius, $y1, $x2, $y1 + $half_y_radius, $x2, $y1 + $y_radius)
+    line-to($x2, $y2 - $y_radius)
+    curve-to($x2, $y2 - $half_y_radius, $x2 - $half_x_radius, $y2, $x2 - $x_radius, $y2)
+    line-to($x1 + $x_radius, $y2)
+    curve-to($x1 + $half_x_radius, $y2, $x1, $y2 - $half_y_radius, $x1, $y2 - $y_radius)
+    line-to($x1, $y1 + $y_radius)
+    curve-to($x1, $y1 + $half_y_radius, $x1 + $half_x_radius, $y1, $x1 + $x_radius, $y1)
+    close
+  );
+}
+
+@function triangle($x1, $y1, $x2, $y2, $x3, $y3) {
+  @return (
+    move-to($x1, $y1)
+    line-to($x2, $y2)
+    line-to($x3, $y3)
+    close
+  )
+}

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: compass-canvas
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Stan Angeloff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: compass
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 0
+        - 11
+        version: "0.11"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cairo
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 10
+        version: "1.10"
+  type: :runtime
+  version_requirements: *id002
+description: 
+email: 
+- stanimir@angeloff.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- LICENSE.md
+- lib/canvas.rb
+- lib/canvas/functions/canvas.rb
+- lib/canvas/functions/path.rb
+- lib/canvas/functions/pattern.rb
+- lib/canvas/functions/context.rb
+- lib/canvas/backend.rb
+- lib/canvas/functions.rb
+- lib/canvas/backend/cairo.rb
+- lib/canvas/backend/interface/path.rb
+- lib/canvas/backend/interface/pattern.rb
+- lib/canvas/backend/interface/context.rb
+- lib/canvas/backend/interface.rb
+- lib/canvas/constants.rb
+- lib/canvas/configuration.rb
+- lib/canvas/plugins.rb
+- lib/canvas/actions.rb
+- stylesheets/_canvas.scss
+- stylesheets/canvas/_pattern.scss
+- stylesheets/canvas/_path.scss
+- stylesheets/canvas/_context.scss
+- stylesheets/canvas/path/_primitives.scss
+- stylesheets/canvas/path/_shapes.scss
+- plugins/drop-shadow.rb
+homepage: http://StanAngeloff.github.com/compass-canvas/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Canvas drawing support for Compass with Cairo backend(s).
+test_files: []
+