compass-magick 0.1.2

data/lib/magick/types/solid.rb

@@ -0,0 +1,40 @@
+module Compass::Magick
+  module Types
+    # A type that generates a {Canvas} from a region filled with a solid
+    # color.
+    #
+    # @example
+    #
+    #     Solid.new(Sass::Script::Color.new([255, 255, 255])).to_canvas(
+    #       Sass::Script::Number(320),
+    #       Sass::Script::Number(200)
+    #     )
+    class Solid < Type
+      include Utils
+
+      # Initializes a new Solid instance.
+      #
+      # @param [Sass::Script::Color] color The solid background color.
+      def initialize(color)
+        assert_type 'color', color, Sass::Script::Color
+        @color = color
+      end
+
+      # @return [Sass::Script::Color] The solid background color.
+      attr_reader :color
+
+      def to_canvas(width, height)
+        assert_type 'width',  width,  Sass::Script::Number
+        assert_type 'height', height, Sass::Script::Number
+        color  = to_chunky_color(@color)
+        canvas = Canvas.new(width, height)
+        (0...canvas.height).each do |y|
+          (0...canvas.width).each do |x|
+            canvas.set_pixel(x, y, color)
+          end
+        end
+        canvas
+      end
+    end
+  end
+end

data/lib/magick/types.rb

@@ -0,0 +1,39 @@
+module Compass::Magick
+  # Abstract Type class.
+  #
+  # Defines the methods all Type instances must implement.
+  #
+  # @abstract
+  # @see Compass::Magick::Types
+  class Type
+    include Scriptable
+
+    # Generates a {Canvas} object.
+    #
+    # @abstract
+    # @param [Sass::Script::Number] width The width of the Canvas.
+    # @param [Sass::Script::Number] height The height of the Canvas.
+    # @return [Canvas] The Canvas object which is composed
+    #   on top of the original image.
+    def to_canvas(width, height)
+      raise AbstractMethod.new("#{self.class} must implement 'to_canvas'")
+    end
+  end
+
+  # The Types module includes all fill types available in Compass Magick.
+  #
+  # Types generate {Canvas} objects with the given options, e.g., a solid
+  # color or a linear gradient. The resulting Canvas is then composed on top
+  # of the original image using alpha blending.
+  #
+  # This can be a slow operation, but it reduces the amount of work required
+  # and abstracts the drawing logic in four easy steps - draw B/W shape, fill
+  # rectangle, mask and compose on top of original image.
+  #
+  # @see Compass::Magick::Types::Solid
+  # @see Compass::Magick::Types::Gradients
+  module Types; end
+end
+
+require 'magick/types/solid'
+require 'magick/types/gradients'

data/lib/magick/utils.rb

@@ -0,0 +1,92 @@
+module Compass::Magick
+  # Utilities methods used throughout Compass Magick.
+  module Utils
+    extend self
+
+    # Checks if <tt>arg</tt> is of the expected <tt>type</tt> and raises a
+    # {TypeMismatch} exception otherwise.
+    #
+    # @param [String] name The argument name (used in the exception message).
+    # @param [Object] arg The argument to validate.
+    # @param [Object] type The expected <tt>arg</tt> type.
+    def assert_type(name, arg, type)
+      raise TypeMismatch.new("(#{self.class}) Type mismatch for argument '#{name}'; " +
+          "expected #{type} got #{arg.class}(#{arg.inspect}) instead") unless
+        arg.nil? ||
+        arg.kind_of?(type)
+    end
+
+    # Checks if <tt>arg</tt> is a sub-class of any of the supported
+    # <tt>types</tt> and raises a {NotSupported} exception otherwise.
+    #
+    # @param [String] name The argument name or method signature (used in the
+    #   exception message).
+    # @param [Object] arg The argument to validate.
+    # @param [Array<Object>] types The list of supported <tt>arg</tt> types.
+    def assert_one_of(name, arg, *types)
+      for type in types do
+        return if arg.kind_of?(type)
+      end
+      raise NotSupported.new("#{name} expected argument of type [#{types.join ', '}] got #{arg.class}(#{arg.inspect}) instead")
+    end
+
+    # Converts a Sass::Script::Color to ChunkyPNG::Color object.
+    #
+    # @param [Sass::Script::Color] color The source color in Sass' format.
+    # @return [ChunkyPNG::Color] The source color in ChunkyPNG's format.
+    def to_chunky_color(color)
+      ChunkyPNG::Color.rgba(color.red, color.green, color.blue, color.alpha * 255)
+    end
+
+    # Converts a fill type (solid color or gradient) to a {Canvas} object.
+    #
+    # @param [Object] type The type of fill type to convert. Supported:
+    #   * Sass::Script::Color
+    #   * Sass::Script::String
+    #   * {Compass::Magick::Types::Solid}
+    #   * {Compass::Magick::Types::Gradients::Linear}
+    # @param [Sass::Script::Number] width The width of the generated
+    #   {Canvas}.
+    # @param [Sass::Script::Number] height The height of the generated
+    #   {Canvas}.
+    # @return [Canvas] The canvas in the dimensions given with the fill
+    #   type applied.
+    def to_canvas(type, width, height)
+      Compass::Magick::Utils.assert_one_of 'to_canvas(..)', type, Sass::Script::Color, Sass::Script::String, Compass::Magick::Type, ChunkyPNG::Canvas
+      if type.kind_of?(Sass::Script::Color)
+        Compass::Magick::Types::Solid.new(type).to_canvas(width, height)
+      elsif type.kind_of?(Sass::Script::String)
+        if type.value == 'transparent'
+          ChunkyPNG::Canvas.new(width.value, height.value, ChunkyPNG::Color.rgba(0, 0, 0, 0))
+        else
+          raise NotSupported.new("to_canvas(..) supports String argument of values ['transparent'] got '#{type}' instead")
+        end
+      elsif type.kind_of?(ChunkyPNG::Canvas)
+        type.tile(width.value, height.value)
+      elsif type.kind_of?(Compass::Magick::Types::Solid) || type.kind_of?(Compass::Magick::Types::Gradients::Linear)
+        type.to_canvas(width, height)
+      end
+    end
+
+    # Converts the Sass::Script::Number to a fixed value.
+    #
+    # @param [Sass::Script::Number] number The number to convert.
+    # @param [Float] max The maximum allowed value for this number.
+    # @param [Float] default The default value for this number.
+    # @return [Float]
+    #   If <tt>number</tt> is <tt>nil</tt>, <tt>true</tt> or <tt>false</tt>, the <tt>default</tt> is returned.
+    #   If <tt>number</tt>'s units are '%', it is calculated as a percentage of <tt>max</tt>.
+    #   If the value is negative, it is calculated as an offset against <tt>max</tt>.
+    #   Otherwise, the value is returned as-is.
+    def value_of(number, max, default = nil)
+      return default if number.nil? || (number.kind_of?(Sass::Script::Bool) && ! number.value)
+      assert_type 'number', number, Sass::Script::Number
+      return max * (number.value.to_f / 100) if number.unit_str == '%'
+      return max + number.value if number.value < 0
+      number.value
+    end
+
+    # A helper Point(x, y) structure.
+    class Point < Struct.new(:x, :y); end
+  end
+end

data/lib/magick.rb

@@ -0,0 +1,79 @@
+# Local development requires we have the current directory on $LOAD_PATH.
+$: << File.dirname(__FILE__)
+
+begin
+  require 'oily_png'
+rescue LoadError
+  require 'rubygems'
+  begin
+    require 'oily_png'
+  rescue LoadError
+    puts '(Compass:Magick) Unable to load OilyPNG, reverting to ChunkyPNG.'
+    puts 'OilyPNG is a C extension to speed up the pure Ruby library.'
+    puts "Please install it with the following command:\n\n"
+    puts "  gem install oily_png\n\n"
+    begin
+      require 'chunky_png'
+    rescue LoadError
+      puts "(Compass:Magick) Unable to load ChunkyPNG. Please install it with the following command:\n\n"
+      puts "  gem install chunky_png\n\n"
+      raise
+    end
+  end
+end
+
+# Compass Magick, a library for dynamic image generation.
+#
+# The Compass::Magick module defines constants and exception used throughout
+# the project.
+#
+# @author Stan Angeloff
+module Compass::Magick
+  # The current version of Compass Magick. This value is updated manually on
+  # release. If you are using a Git clone, the version will always end with
+  # '.git'.
+  VERSION = '0.1.2.git'
+
+  # The locations where plug-ins are located. These paths are scanned for
+  # *.rb files and loaded in order.
+  PLUGINS_PATH = [
+    File.join(File.dirname(__FILE__), 'plugins'),
+    File.join(ENV['HOME'], '.magick', 'plugins'),
+    File.join(Dir.getwd,              'plugins')
+  ]
+
+  # Default exception class for Compass Magick
+  class Exception < ::StandardError; end
+
+  # Exception that is raised when an argument's type does not match the
+  # expected.
+  class TypeMismatch < Exception; end
+
+  # Exception that is raised when an abstract method is called.
+  class AbstractMethod < Exception; end
+
+  # Exception that is raised when a method is called with arguments it does
+  # not support.
+  class NotSupported < Exception; end
+
+  # Exception that is raised when a method is called in a context it does not
+  # support.
+  class NotAllowed < Exception; end
+end
+
+require 'magick/utils'
+require 'magick/scriptable'
+require 'magick/command'
+require 'magick/effect'
+require 'magick/canvas'
+require 'magick/shapes'
+require 'magick/types'
+require 'magick/functions'
+
+# Register Compass Magick as a Compass framework.
+#
+# @see http://compass-style.org/docs/tutorials/extensions/
+Compass::Frameworks.register('magick',
+  :stylesheets_directory => File.join(File.dirname(__FILE__), 'stylesheets'),
+  :templates_directory   => File.join(File.dirname(__FILE__), 'templates')
+)

data/lib/plugins/corners.rb

@@ -0,0 +1,29 @@
+module Compass::Magick
+  module Plugins
+    # Applies rounded corners around the {Canvas}.
+    #
+    # @param [Sass::Script::Number] radius The corner radius.
+    # @param [Sass::Script::Bool] top_left Controls the top-left corner
+    #   radius effect (default <tt>true</tt>)
+    # @param [Sass::Script::Bool] top_right Controls the top-right corner
+    #   radius effect (default <tt>true</tt>)
+    # @param [Sass::Script::Bool] bottom_right Controls the bottom-right
+    #   corner radius effect (default <tt>true</tt>)
+    # @param [Sass::Script::Bool] bottom_left Controls the bottom-left
+    #   corner radius effect (default <tt>true</tt>)
+    # @return {Command} A command(-set) which applies the corners on the
+    #   canvas.
+    def magick_corners(radius, top_left = nil, top_right = nil, bottom_right = nil, bottom_left = nil)
+      Command.new do |canvas|
+        Canvas.new(canvas, magick_mask(
+          magick_canvas(
+            Sass::Script::Number.new(canvas.width),
+            Sass::Script::Number.new(canvas.height),
+              magick_fill(Sass::Script::Color.new([0, 0, 0])),
+              magick_border(Sass::Script::Color.new([255, 255, 255]), radius, nil, top_left, top_right, bottom_right, bottom_left)
+          )
+        ))
+      end
+    end
+  end
+end

data/lib/plugins/pattern.rb

@@ -0,0 +1,49 @@
+module Compass::Magick
+
+  # Exception that is raised when a pattern is not configured properly.
+  class PatternException < Exception; end
+
+  module Plugins
+    # Draws a pattern and returns a B/W {Canvas} ready for masking.
+    #
+    # Chris Eppstein's original tweet:  
+    # {http://twitter.com/chriseppstein/status/56095925843668992}
+    #
+    # @param [Sass::Script::Number] width The width of the pattern.
+    # @param [Sass::Script::Number] height The height of the pattern.
+    # @param [Sass::Script::List] values The pattern itself. This is a list
+    #   of values (or a multi-line string) where `1`, `true`, `yes`, `X`, `*`
+    #   and `+` mark where an opaque white pixel will be placed. Any other
+    #   value is ignored and is transparent in the output. The size of the
+    #   list must match the width/height.
+    # @return {Canvas} A B/W Canvas with the pattern applied. The resulting
+    #   image can be applied as a mask.
+    # @example Diagonal stripes:
+    #   magick-pattern(3, 3,
+    #     x _ _
+    #     _ x _
+    #     _ _ x
+    #   );
+    def magick_pattern(width, height, values)
+      Compass::Magick::Utils.assert_type   'width',              width,  Sass::Script::Number
+      Compass::Magick::Utils.assert_type   'height',             height, Sass::Script::Number
+      Compass::Magick::Utils.assert_one_of 'magick-pattern(..)', values, Sass::Script::List, Sass::Script::String
+      if values.kind_of?(Sass::Script::String)
+        list = values.value.strip().split(/[\r\n]+/).map { |line| line.strip().split(/\s/) }.flatten
+      else
+        list = values.value
+      end
+      size = width.value * height.value
+      raise PatternException.new("magick-pattern(..) expects #{size} values, got #{list.size} instead: #{list.inspect}") unless size == list.size
+      canvas = Canvas.new(width, height)
+      opaque = ['1', 'true', 'yes', 'X', '*', '+']
+      for y in (0...height.value)
+        for x in (0...width.value)
+          pixel = list[x + y * height.value].to_s.upcase
+          canvas.set_pixel(x, y, ChunkyPNG::Color::WHITE) if opaque.include?(pixel)
+        end
+      end
+      canvas
+    end
+  end
+end

data/spec/canvas_spec.rb

@@ -0,0 +1,19 @@
+require 'helpers'
+
+describe Compass::Magick::Canvas do
+  describe "#initialize" do
+    it "should assert arguments' type" do
+      lambda { Compass::Magick::Canvas.new(100, 100) }.should raise_error(Compass::Magick::TypeMismatch)
+    end
+  end
+
+  subject { Compass::Magick::Canvas.new(Sass::Script::Number.new(100), Sass::Script::Number.new(100)) }
+
+  it "should be transparent" do
+    subject.get_pixel(0, 0).should == ChunkyPNG::Color::TRANSPARENT
+  end
+
+  it "should encode the image in Base64" do
+    subject.to_data_uri.value.include?('data:image/png;base64,').should be_true
+  end
+end

data/spec/helpers.rb

@@ -0,0 +1,5 @@
+$: << File.join(File.dirname(__FILE__), '..', 'lib', 'magick')
+
+require 'compass'
+require 'chunky_png'
+require 'magick'

data/spec/types/gradients_spec.rb

@@ -0,0 +1,29 @@
+require 'helpers'
+
+describe Compass::Magick::Types::Gradients::Linear do
+  describe "#initialize" do
+    it "should assert arguments' type" do
+      lambda { Compass::Magick::Types::Gradients::Linear.new(45, 'string') }.should                             raise_error(Compass::Magick::TypeMismatch)
+      lambda { Compass::Magick::Types::Gradients::Linear.new(Sass::Script::Number.new(45), 'string') }.should   raise_error(Compass::Magick::TypeMismatch)
+      lambda { Compass::Magick::Types::Gradients::Linear.new(Sass::Script::Number.new(45), ['string']) }.should raise_error(Compass::Magick::TypeMismatch)
+    end
+  end
+
+  subject { Compass::Magick::Types::Gradients::Linear.new(
+    Sass::Script::Number.new(45), [
+      Compass::Magick::Types::Gradients::ColorStop.new(Sass::Script::Number.new(0),   Sass::Script::Color.new([255,   0,   0, 1])),
+      Compass::Magick::Types::Gradients::ColorStop.new(Sass::Script::Number.new(50),  Sass::Script::Color.new([  0, 255,   0, 0.5])),
+      Compass::Magick::Types::Gradients::ColorStop.new(Sass::Script::Number.new(100), Sass::Script::Color.new([  0,   0, 255, 1]))
+    ]
+  ) }
+
+  it { should respond_to(:angle) }
+  it { should respond_to(:stops) }
+
+  it "should generate a linear-filled Canvas" do
+    canvas = subject.to_canvas(Sass::Script::Number.new(101), Sass::Script::Number.new(101))
+    canvas.get_pixel(  0,   0).should == ChunkyPNG::Color.rgba(255,   0,   0, 255)
+    canvas.get_pixel( 50,  50).should == ChunkyPNG::Color.rgba(  0, 255,   0, 127)
+    canvas.get_pixel(100, 100).should == ChunkyPNG::Color.rgba(  0,   0, 255, 255)
+  end
+end

data/spec/types/solid_spec.rb

@@ -0,0 +1,19 @@
+require 'helpers'
+
+describe Compass::Magick::Types::Solid do
+  describe "#initialize" do
+    it "should assert arguments' type" do
+      lambda { Compass::Magick::Types::Solid.new('#ff0000') }.should raise_error(Compass::Magick::TypeMismatch)
+    end
+  end
+
+  subject { Compass::Magick::Types::Solid.new(Sass::Script::Color.new([255, 0, 0])) }
+
+  it { should respond_to(:color) }
+
+  it "should generate a solid Canvas" do
+    canvas = subject.to_canvas(Sass::Script::Number.new(100), Sass::Script::Number.new(100))
+    canvas.get_pixel( 0,  0).should == ChunkyPNG::Color.rgba(255, 0, 0, 255)
+    canvas.get_pixel(99, 99).should == ChunkyPNG::Color.rgba(255, 0, 0, 255)
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+name: compass-magick
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
+platform: ruby
+authors: 
+- Stan Angeloff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-16 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: 62196225
+        segments: 
+        - 0
+        - 11
+        - beta
+        - 5
+        version: 0.11.beta.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: chunky_png
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :development
+  version_requirements: *id003
+description: 
+email: 
+- stanimir@angeloff.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- LICENSE.md
+- lib/magick/canvas.rb
+- lib/magick/command.rb
+- lib/magick/effect.rb
+- lib/magick/functions/canvas.rb
+- lib/magick/functions/drawing.rb
+- lib/magick/functions/operations/effects.rb
+- lib/magick/functions/operations.rb
+- lib/magick/functions/sprites.rb
+- lib/magick/functions/types.rb
+- lib/magick/functions.rb
+- lib/magick/plugins.rb
+- lib/magick/scriptable.rb
+- lib/magick/shapes.rb
+- lib/magick/types/gradients.rb
+- lib/magick/types/solid.rb
+- lib/magick/types.rb
+- lib/magick/utils.rb
+- lib/magick.rb
+- lib/plugins/corners.rb
+- lib/plugins/pattern.rb
+- lib/stylesheets/_magick.sass
+- spec/canvas_spec.rb
+- spec/helpers.rb
+- spec/types/gradients_spec.rb
+- spec/types/solid_spec.rb
+homepage: https://github.com/StanAngeloff/compass-magick
+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.7.2
+signing_key: 
+specification_version: 3
+summary: Dynamic image generation for Compass using ChunkyPNG.
+test_files: 
+- spec/canvas_spec.rb
+- spec/helpers.rb
+- spec/types/gradients_spec.rb
+- spec/types/solid_spec.rb
+has_rdoc: true