dragonfly 0.3.6 → 0.3.7

data/.yardopts

@@ -3,6 +3,7 @@
 README.md
 extra_docs/GettingStarted.md
 extra_docs/UsingWithRails.md
+extra_docs/ExampleUseCases.md
 extra_docs/ActiveRecord.md
 extra_docs/DataStorage.md
 extra_docs/Shortcuts.md

data/README.md

@@ -42,7 +42,7 @@ View (to display):
     <%= image_tag @album.cover_image.url('400x200') %>
     <%= image_tag @album.cover_image.url('100x100!', :png) %>
     <%= image_tag @album.cover_image.url('100x100#') %>
-    <%= image_tag @album.cover_image.url('50x50+30+30sw', :tif) %>
+    <%= image_tag @album.cover_image.url('50x50+30+30sw', :tiff) %>
     <%= image_tag @album.cover_image.url(:rotate, 15) %>
     ...etc.
 

data/Rakefile

@@ -27,7 +27,7 @@ end
 
 require 'yard'
 YARD::Rake::YardocTask.new do |t|
-  t.files   = ['lib/**/*.rb', 'markdown_docs/*']
+  t.files   = ['lib/**/*.rb']
   t.options = %w(-e yard/setup.rb)
 end
 YARD::Rake::YardocTask.new 'yard:changed' do |t|

data/VERSION

@@ -1 +1 @@
-0.3.6
+0.3.7

data/dragonfly.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dragonfly}
-  s.version = "0.3.6"
+  s.version = "0.3.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mark Evans"]
-  s.date = %q{2009-12-19}
+  s.date = %q{2010-01-02}
   s.email = %q{mark@new-bamboo.co.uk}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -30,6 +30,7 @@ Gem::Specification.new do |s|
      "extra_docs/Analysers.md",
      "extra_docs/DataStorage.md",
      "extra_docs/Encoding.md",
+     "extra_docs/ExampleUseCases.md",
      "extra_docs/GettingStarted.md",
      "extra_docs/Index.md",
      "extra_docs/Processing.md",

data/extra_docs/ExampleUseCases.md

@@ -0,0 +1,17 @@
+Example Use Cases
+=================
+
+Image thumbnails in Rails
+-------------------------
+
+Rails thumbnails on Heroku with S3
+----------------------------------
+
+Serving attachments with no processing
+--------------------------------------
+
+Generating test data
+--------------------
+
+Text image replacement
+----------------------

data/features/steps/dragonfly_steps.rb

@@ -43,15 +43,15 @@ Then /the response should have mime-type '(.+?)'/ do |mime_type|
   @response.headers['Content-Type'].should == mime_type
 end
 
-Then "the image should have width '(.+?)'" do |width|
+Then /^the image should have width '(.+?)'$/ do |width|
   @response.body.should have_width(width.to_i)
 end
 
-Then "the image should have height '(.+?)'" do |height|
+Then /^the image should have height '(.+?)'$/ do |height|
   @response.body.should have_height(height.to_i)
 end
 
-Then "the image should have format '(.+?)'" do |format|
+Then /^the image should have format '(.+?)'$/ do |format|
   @response.body.should have_format(format)
 end
 

data/features/support/env.rb

@@ -5,6 +5,11 @@ require 'test/unit/assertions'
 require 'ruby-debug'
 require File.dirname(__FILE__) + '/../../spec/image_matchers.rb'
 
+# A hack as system calls weren't using my path
+extra_paths = %w(/opt/local/bin)
+ENV['PATH'] ||= ''
+ENV['PATH'] += ':' + extra_paths.join(':')
+
 # A hash of <name for reference> => <dragonfly uid> pairs
 TEMP_FILES = {}
 

data/lib/dragonfly/parameters.rb

@@ -154,8 +154,8 @@ module Dragonfly
         uid,
         format,
         processing_method,
-        processing_options.sort{|a,b| a[1].to_s <=> b[1].to_s },
-        encoding.sort{|a,b| a[1].to_s <=> b[1].to_s }
+        processing_options.sort{|a,b| a[0].to_s <=> b[0].to_s },
+        encoding.sort{|a,b| a[0].to_s <=> b[0].to_s }
       ]
     end
 

data/lib/dragonfly/processing/r_magick_processor.rb

@@ -5,7 +5,7 @@ module Dragonfly
 
     class RMagickProcessor < Base
       
-      GRAVITY_MAPPINGS = {
+      GRAVITIES = {
         'nw' => Magick::NorthWestGravity,
         'n'  => Magick::NorthGravity,
         'ne' => Magick::NorthEastGravity,
@@ -17,10 +17,65 @@ module Dragonfly
         'se' => Magick::SouthEastGravity
       }
       
+      FONT_STYLES = {
+        'normal' => Magick::NormalStyle,
+        'italic' => Magick::ItalicStyle,
+        'oblique' => Magick::ObliqueStyle
+      }
+      
+      FONT_STRETCHES = {
+        'normal'          => Magick::NormalStretch,
+        'semi-condensed'  => Magick::SemiCondensedStretch,
+        'condensed'       => Magick::CondensedStretch,
+        'extra-condensed' => Magick::ExtraCondensedStretch,
+        'ultra-condensed' => Magick::UltraCondensedStretch,
+        'semi-expanded'   => Magick::SemiExpandedStretch,
+        'expanded'        => Magick::ExpandedStretch,
+        'extra-expanded'  => Magick::ExtraExpandedStretch,
+        'ultra-expanded'  => Magick::UltraExpandedStretch
+      }
+      
+      FONT_WEIGHTS = {
+        'normal'  => Magick::NormalWeight,
+        'bold'    => Magick::BoldWeight,
+        'bolder'  => Magick::BolderWeight,
+        'lighter' => Magick::LighterWeight,
+        '100'     => 100,
+        '200'     => 200,
+        '300'     => 300,
+        '400'     => 400,
+        '500'     => 500,
+        '600'     => 600,
+        '700'     => 700,
+        '800'     => 800,
+        '900'     => 900
+      }
+      
+      # HashWithCssStyleKeys is solely for being able to access a hash
+      # which has css-style keys (e.g. 'font-size') with the underscore
+      # symbol version
+      # @example
+      #   opts = {'font-size' => '23px', :color => 'white'}
+      #   opts = HashWithCssStyleKeys[opts]
+      #   opts[:font_size]   # ===> '23px'
+      #   opts[:color]       # ===> 'white'
+      class HashWithCssStyleKeys < Hash
+        def [](key)
+          super || (
+            str_key = key.to_s
+            css_key = str_key.gsub('_','-')
+            super(str_key) || super(css_key) || super(css_key.to_sym)
+          )
+        end
+      end
+      
+      
+      # Processing methods
+      
       def crop(temp_object, opts={})
         x       = opts[:x].to_i
         y       = opts[:y].to_i
-        gravity = GRAVITY_MAPPINGS[opts[:gravity]] || Magick::ForgetGravity
+        gravity = GRAVITIES[opts[:gravity]] || Magick::ForgetGravity
         width   = opts[:width].to_i
         height  = opts[:height].to_i
 
@@ -34,17 +89,9 @@ module Dragonfly
         image.crop(gravity, x, y, width, height).to_blob
       end
       
-      def generate(width, height)
-        image = Magick::Image.new(width, height)
-        num_points = 7
-        args = []
-        num_points.times do
-          args << rand(width)
-          args << rand(height)
-          args << "rgb(#{rand(256)},#{rand(256)},#{rand(256)})"
-        end
-        image = image.sparse_color(Magick::ShepardsColorInterpolate, *args)
-        image.format = 'png'
+      def generate(width, height, format='png')
+        image = Magick::Image.read("plasma:fractal"){self.size = "#{width}x#{height}"}.first
+        image.format = format.to_s
         image.to_blob
       end
       
@@ -59,7 +106,7 @@ module Dragonfly
         
         width   = opts[:width] ? opts[:width].to_i : image.columns
         height  = opts[:height] ? opts[:height].to_i : image.rows
-        gravity = GRAVITY_MAPPINGS[opts[:gravity]] || Magick::CenterGravity
+        gravity = GRAVITIES[opts[:gravity]] || Magick::CenterGravity
 
         image.crop_resized(width, height, gravity).to_blob
       end
@@ -77,6 +124,52 @@ module Dragonfly
           temp_object
         end
       end
+      
+      def text(temp_object, opts={})
+        opts = HashWithCssStyleKeys[opts]
+        
+        draw = Magick::Draw.new
+        draw.gravity = Magick::CenterGravity
+        draw.text_antialias = true
+        
+        # Settings
+        draw.font         = opts[:font] if opts[:font]
+        draw.font_family  = opts[:font_family] if opts[:font_family]
+        draw.pointsize    = opts[:font_size].to_f if opts[:font_size]
+        draw.fill         = opts[:color] if opts[:color]
+        draw.stroke       = opts[:stroke_color] if opts[:stroke_color]
+        draw.font_style   = FONT_STYLES[opts[:font_style]] if opts[:font_style]
+        draw.font_stretch = FONT_STRETCHES[opts[:font_stretch]] if opts[:font_stretch]
+        draw.font_weight  = FONT_WEIGHTS[opts[:font_weight]] if opts[:font_weight]
+
+        text = temp_object.data
+
+        # Calculate dimensions
+        metrics = draw.get_type_metrics(text)
+        width, height = metrics.width, metrics.height
+
+        pt, pr, pb, pl = parse_padding_string(opts[:padding]) if opts[:padding]
+        padding_top    = opts[:padding_top]    || pt || 0
+        padding_right  = opts[:padding_right]  || pr || 0
+        padding_bottom = opts[:padding_bottom] || pb || 0
+        padding_left   = opts[:padding_left]   || pl || 0
+
+        # Hack - for small font sizes, the width seems to be affected by rounding errors
+        padding_right += 2
+
+        total_width = padding_left + width + padding_right
+        total_height = padding_top + height + padding_bottom
+
+        # Draw the background
+        image = Magick::Image.new(total_width, total_height){
+          self.background_color = opts[:background_color] || 'transparent'
+        }
+        # Draw the text
+        draw.annotate(image, width, height, padding_left, padding_top, text)
+        # Output image as string
+        image.format = 'png'
+        image.to_blob
+      end
 
       def vignette(temp_object, opts={})
         x      = opts[:x].to_f      || temp_object.width  * 0.1
@@ -93,6 +186,29 @@ module Dragonfly
         Magick::Image.from_blob(temp_object.data).first
       end
 
+      # Use css-style padding declaration, i.e.
+      # 10        (all sides)
+      # 10 5      (top/bottom, left/right)
+      # 10 5 10   (top, left/right, bottom)
+      # 10 5 10 5 (top, right, bottom, left)
+      def parse_padding_string(str)
+        padding_parts = str.gsub('px','').split(/\s+/).map{|px| px.to_i}
+        case padding_parts.size
+        when 1
+          p = *padding_parts
+          [p,p,p,p]
+        when 2
+          p,q = *padding_parts
+          [p,q,p,q]
+        when 3
+          p,q,r = *padding_parts
+          [p,q,r,q]
+        when 4
+          padding_parts
+        else raise ArgumentError, "Couldn't parse padding string '#{str}' - should be a css-style string"
+        end
+      end
+
     end
 
   end

data/spec/dragonfly/processing/rmagick_processor_spec.rb

@@ -2,174 +2,268 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Dragonfly::Processing::RMagickProcessor do
   
-  before(:each) do
-    sample_file = File.dirname(__FILE__) + '/../../../samples/beach.png' # 280x355
-    @image = Dragonfly::TempObject.new(File.new(sample_file))
-    @processor = Dragonfly::Processing::RMagickProcessor.new
-  end
-  
-  describe "#resize" do
-    
-    it "should work correctly with xNN" do
-      image = @processor.resize(@image, :geometry => 'x30')
-      image.should have_width(24)
-      image.should have_height(30)
+  describe "generate" do
+    before(:each) do
+      @processor = Dragonfly::Processing::RMagickProcessor.new
     end
     
-    it "should work correctly with NNx" do
-      image = @processor.resize(@image, :geometry => '30x')
-      image.should have_width(30)
-      image.should have_height(38)
+    it "should generate an image with the given dimensions, defaulting to png format" do
+      image = @processor.generate(23,12)
+      image.should have_width(23)
+      image.should have_height(12)
+      image.should have_format('png')
     end
-    
-    it "should work correctly with NNxNN" do
-      image = @processor.resize(@image, :geometry => '30x30')
-      image.should have_width(24)
-      image.should have_height(30)
+    it "should allow specifying the format" do
+      image = @processor.generate(23, 12, :gif)
+      image.should have_format('gif')
     end
-    
-    it "should work correctly with NNxNN!" do
-      image = @processor.resize(@image, :geometry => '30x30!')
-      image.should have_width(30)
-      image.should have_height(30)
+  end
+
+  describe "processing methods" do
+  
+    before(:each) do
+      sample_file = File.dirname(__FILE__) + '/../../../samples/beach.png' # 280x355
+      @image = Dragonfly::TempObject.new(File.new(sample_file))
+      @processor = Dragonfly::Processing::RMagickProcessor.new
     end
+  
+    describe "resize" do
     
-    it "should work correctly with NNxNN%" do
-      image = @processor.resize(@image, :geometry => '25x50%')
-      image.should have_width(70)
-      image.should have_height(178)
-    end
+      it "should work correctly with xNN" do
+        image = @processor.resize(@image, :geometry => 'x30')
+        image.should have_width(24)
+        image.should have_height(30)
+      end
     
-    describe "NNxNN>" do
-      
-      it "should not resize if the image is smaller than specified" do
-        image = @processor.resize(@image, :geometry => '1000x1000>')
-        image.should have_width(280)
-        image.should have_height(355)
+      it "should work correctly with NNx" do
+        image = @processor.resize(@image, :geometry => '30x')
+        image.should have_width(30)
+        image.should have_height(38)
       end
-      
-      it "should resize if the image is larger than specified" do
-        image = @processor.resize(@image, :geometry => '30x30>')
+    
+      it "should work correctly with NNxNN" do
+        image = @processor.resize(@image, :geometry => '30x30')
         image.should have_width(24)
         image.should have_height(30)
       end
-      
-    end
     
-    describe "NNxNN<" do
-      
-      it "should not resize if the image is larger than specified" do
-        image = @processor.resize(@image, :geometry => '10x10<')
-        image.should have_width(280)
-        image.should have_height(355)
+      it "should work correctly with NNxNN!" do
+        image = @processor.resize(@image, :geometry => '30x30!')
+        image.should have_width(30)
+        image.should have_height(30)
+      end
+    
+      it "should work correctly with NNxNN%" do
+        image = @processor.resize(@image, :geometry => '25x50%')
+        image.should have_width(70)
+        image.should have_height(178)
       end
+    
+      describe "NNxNN>" do
+      
+        it "should not resize if the image is smaller than specified" do
+          image = @processor.resize(@image, :geometry => '1000x1000>')
+          image.should have_width(280)
+          image.should have_height(355)
+        end
+      
+        it "should resize if the image is larger than specified" do
+          image = @processor.resize(@image, :geometry => '30x30>')
+          image.should have_width(24)
+          image.should have_height(30)
+        end
       
-      it "should resize if the image is smaller than specified" do
-        image = @processor.resize(@image, :geometry => '400x400<')
-        image.should have_width(315)
-        image.should have_height(400)
       end
+    
+      describe "NNxNN<" do
       
-    end
+        it "should not resize if the image is larger than specified" do
+          image = @processor.resize(@image, :geometry => '10x10<')
+          image.should have_width(280)
+          image.should have_height(355)
+        end
+      
+        it "should resize if the image is smaller than specified" do
+          image = @processor.resize(@image, :geometry => '400x400<')
+          image.should have_width(315)
+          image.should have_height(400)
+        end
+      
+      end
     
-  end
+    end
   
-  describe "crop" do # Difficult to test here other than dimensions
+    describe "crop" do # Difficult to test here other than dimensions
     
-    it "should not crop if no args given" do
-      image = @processor.crop(@image)
-      image.should have_width(280)
-      image.should have_height(355)
-    end
+      it "should not crop if no args given" do
+        image = @processor.crop(@image)
+        image.should have_width(280)
+        image.should have_height(355)
+      end
     
-    it "should crop using the offset given" do
-      image = @processor.crop(@image, :x => '7', :y => '12')
-      image.should have_width(273)
-      image.should have_height(343)
-    end
+      it "should crop using the offset given" do
+        image = @processor.crop(@image, :x => '7', :y => '12')
+        image.should have_width(273)
+        image.should have_height(343)
+      end
     
-    it "should crop using the dimensions given" do
-      image = @processor.crop(@image, :width => '10', :height => '20')
-      image.should have_width(10)
-      image.should have_height(20)
-    end
+      it "should crop using the dimensions given" do
+        image = @processor.crop(@image, :width => '10', :height => '20')
+        image.should have_width(10)
+        image.should have_height(20)
+      end
     
-    it "should crop in one dimension if given" do
-      image = @processor.crop(@image, :width => '10')
-      image.should have_width(10)
-      image.should have_height(355)
-    end
+      it "should crop in one dimension if given" do
+        image = @processor.crop(@image, :width => '10')
+        image.should have_width(10)
+        image.should have_height(355)
+      end
     
-    it "should take into account the gravity given" do
-      image1 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'nw')
-      image2 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'se')
-      image1.should_not == image2
-    end
+      it "should take into account the gravity given" do
+        image1 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'nw')
+        image2 = @processor.crop(@image, :width => '10', :height => '10', :gravity => 'se')
+        image1.should_not == image2
+      end
     
-    it "should clip bits of the image outside of the requested crop area when not nw gravity" do
-      # Rmagick was previously throwing an error when the cropping area was outside the image size, when
-      # using a gravity other than nw
-      image = @processor.crop(@image, :width => '500', :height => '1000', :x => '100', :y => '200', :gravity => 'se')
-      image.should have_width(180)
-      image.should have_height(155)
-    end
+      it "should clip bits of the image outside of the requested crop area when not nw gravity" do
+        # Rmagick was previously throwing an error when the cropping area was outside the image size, when
+        # using a gravity other than nw
+        image = @processor.crop(@image, :width => '500', :height => '1000', :x => '100', :y => '200', :gravity => 'se')
+        image.should have_width(180)
+        image.should have_height(155)
+      end
     
-  end
+    end
   
-  describe "resize_and_crop" do
+    describe "resize_and_crop" do
     
-    it "should do nothing if no args given" do
-      image = @processor.resize_and_crop(@image)
-      image.should have_width(280)
-      image.should have_height(355)
-    end
+      it "should do nothing if no args given" do
+        image = @processor.resize_and_crop(@image)
+        image.should have_width(280)
+        image.should have_height(355)
+      end
     
-    it "should crop to the correct dimensions" do
-      image = @processor.resize_and_crop(@image, :width => '100', :height => '100')
-      image.should have_width(100)
-      image.should have_height(100)
-    end
+      it "should crop to the correct dimensions" do
+        image = @processor.resize_and_crop(@image, :width => '100', :height => '100')
+        image.should have_width(100)
+        image.should have_height(100)
+      end
     
-    it "should allow cropping in one dimension" do
-      image = @processor.resize_and_crop(@image, :width => '100')
-      image.should have_width(100)
-      image.should have_height(355)
-    end
+      it "should allow cropping in one dimension" do
+        image = @processor.resize_and_crop(@image, :width => '100')
+        image.should have_width(100)
+        image.should have_height(355)
+      end
     
-    it "should take into account the gravity given" do
-      image1 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'nw')
-      image2 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'se')
-      image1.should_not == image2
-    end
+      it "should take into account the gravity given" do
+        image1 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'nw')
+        image2 = @processor.resize_and_crop(@image, :width => '10', :height => '10', :gravity => 'se')
+        image1.should_not == image2
+      end
     
-  end
+    end
   
-  describe "rotate" do
+    describe "rotate" do
     
-    it "should rotate by 90 degrees" do
-      image = @processor.rotate(@image, :amount => '90')
-      image.should have_width(355)
-      image.should have_height(280)
-    end
+      it "should rotate by 90 degrees" do
+        image = @processor.rotate(@image, :amount => '90')
+        image.should have_width(355)
+        image.should have_height(280)
+      end
     
-    it "should not rotate given a larger height and the '>' qualifier" do
-      image = @processor.rotate(@image, :amount => 90, :qualifier => '>')
-      image.should have_width(280)
-      image.should have_height(355)
-    end
+      it "should not rotate given a larger height and the '>' qualifier" do
+        image = @processor.rotate(@image, :amount => 90, :qualifier => '>')
+        image.should have_width(280)
+        image.should have_height(355)
+      end
     
-    it "should rotate given a larger height and the '<' qualifier" do
-      image = @processor.rotate(@image, :amount => 90, :qualifier => '<')
-      image.should have_width(355)
-      image.should have_height(280)
-    end
+      it "should rotate given a larger height and the '<' qualifier" do
+        image = @processor.rotate(@image, :amount => 90, :qualifier => '<')
+        image.should have_width(355)
+        image.should have_height(280)
+      end
     
-    it "should do nothing if no amount given" do
-      image = @processor.rotate(@image)
-      image.should have_width(280)
-      image.should have_height(355)
-    end
+      it "should do nothing if no amount given" do
+        image = @processor.rotate(@image)
+        image.should have_width(280)
+        image.should have_height(355)
+      end
     
+    end
+
+    describe "text" do
+      before(:each) do
+        @text =  Dragonfly::TempObject.new("mmm")
+      end
+
+      it "should create a text image, defaulted to png" do
+        image = @processor.text(@text)
+        image.should have_width(34)
+        image.should have_height(14)
+        image.should have_format('png')
+      end
+
+      # it "should ignore percent characters used by rmagick"
+
+      describe "padding" do
+        it "1 number shortcut" do
+          image = @processor.text(@text, :padding => '10')
+          image.should have_width(54)
+          image.should have_height(34)
+        end
+        it "2 numbers shortcut" do
+          image = @processor.text(@text, :padding => '10 5')
+          image.should have_width(44)
+          image.should have_height(34)
+        end
+        it "3 numbers shortcut" do
+          image = @processor.text(@text, :padding => '10 5 8')
+          image.should have_width(44)
+          image.should have_height(32)
+        end
+        it "4 numbers shortcut" do
+          image = @processor.text(@text, :padding => '1 2 3 4')
+          image.should have_width(40)
+          image.should have_height(18)
+        end
+        it "should override the general padding declaration with the specific one (e.g. 'padding-left')" do
+          image = @processor.text(@text, :padding => '10', 'padding-left' => 9)
+          image.should have_width(53)
+          image.should have_height(34)
+        end
+        it "should ignore 'px' suffixes" do
+          image = @processor.text(@text, :padding => '1px 2px 3px 4px')
+          image.should have_width(40)
+          image.should have_height(18)
+        end
+        it "bad padding string" do
+          lambda{
+            @processor.text(@text, :padding => '1 2 3 4 5')
+          }.should raise_error(ArgumentError)
+        end
+      end
+    end
+
   end
   
 end
+
+describe Dragonfly::Processing::RMagickProcessor::HashWithCssStyleKeys do
+  before(:each) do
+    @hash = Dragonfly::Processing::RMagickProcessor::HashWithCssStyleKeys[
+      :font_style => 'normal',
+      :'font-weight' => 'bold',
+      'font_colour' => 'white',
+      'font-size' => 23,
+      :hello => 'there'
+    ]
+  end
+  describe "accessing using underscore symbol style" do
+    it{ @hash[:font_style].should == 'normal' }
+    it{ @hash[:font_weight].should == 'bold' }
+    it{ @hash[:font_colour].should == 'white' }
+    it{ @hash[:font_size].should == 23 }
+    it{ @hash[:hello].should == 'there' }
+    it{ @hash[:non_existent_key].should be_nil }
+  end
+end

data/spec/spec_helper.rb

@@ -8,6 +8,11 @@ require 'argument_matchers'
 require 'simple_matchers'
 require 'image_matchers'
 
+# A hack as system calls weren't using my path
+extra_paths = %w(/opt/local/bin)
+ENV['PATH'] ||= ''
+ENV['PATH'] += ':' + extra_paths.join(':')
+
 SAMPLES_DIR = File.expand_path(File.dirname(__FILE__) + '/../samples') unless defined?(SAMPLES_DIR)
 
 Spec::Runner.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dragonfly
 version: !ruby/object:Gem::Version 
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors: 
 - Mark Evans
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-19 00:00:00 +00:00
+date: 2010-01-02 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,6 +46,7 @@ files:
 - extra_docs/Analysers.md
 - extra_docs/DataStorage.md
 - extra_docs/Encoding.md
+- extra_docs/ExampleUseCases.md
 - extra_docs/GettingStarted.md
 - extra_docs/Index.md
 - extra_docs/Processing.md