winton-attachment_fu 1.0.5 → 1.0.6

data/test/test_helper.rb

@@ -1,150 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-
-ENV['RAILS_ENV'] = 'test'
-ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..'
-
-require 'test/unit'
-require File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
-require 'active_record/fixtures'
-require 'action_controller/test_process'
-
-config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
-ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
-
-db_adapter = ENV['DB']
-
-# no db passed, try one of these fine config-free DBs before bombing.
-db_adapter ||= 
-  begin
-    require 'rubygems'
-    require 'sqlite'
-    'sqlite'
-  rescue MissingSourceFile
-    begin
-      require 'sqlite3'
-      'sqlite3'
-    rescue MissingSourceFile
-    end
-  end
-
-if db_adapter.nil?
-  raise "No DB Adapter selected.  Pass the DB= option to pick one, or install Sqlite or Sqlite3."
-end
-
-ActiveRecord::Base.establish_connection(config[db_adapter])
-
-load(File.dirname(__FILE__) + "/schema.rb")
-
-Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures"
-$LOAD_PATH.unshift(Test::Unit::TestCase.fixture_path)
-
-class Test::Unit::TestCase #:nodoc:
-  include ActionController::TestProcess
-  def create_fixtures(*table_names)
-    if block_given?
-      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names) { yield }
-    else
-      Fixtures.create_fixtures(Test::Unit::TestCase.fixture_path, table_names)
-    end
-  end
-
-  def setup
-    Attachment.saves = 0
-    DbFile.transaction { [Attachment, FileAttachment, OrphanAttachment, MinimalAttachment, DbFile].each { |klass| klass.delete_all } }
-    attachment_model self.class.attachment_model
-  end
-  
-  def teardown
-    FileUtils.rm_rf File.join(File.dirname(__FILE__), 'files')
-  end
-
-  self.use_transactional_fixtures = true
-  self.use_instantiated_fixtures  = false
-
-  def self.attachment_model(klass = nil)
-    @attachment_model = klass if klass 
-    @attachment_model
-  end
-
-  def self.test_against_class(test_method, klass, subclass = false)
-    define_method("#{test_method}_on_#{:sub if subclass}class") do
-      klass = Class.new(klass) if subclass
-      attachment_model klass
-      send test_method, klass
-    end
-  end
-
-  def self.test_against_subclass(test_method, klass)
-    test_against_class test_method, klass, true
-  end
-
-  protected
-    def upload_file(options = {})
-      use_temp_file options[:filename] do |file|
-        att = attachment_model.create :uploaded_data => fixture_file_upload(file, options[:content_type] || 'image/png')
-        att.reload unless att.new_record?
-        return att
-      end
-    end
-
-    def upload_merb_file(options = {})
-      use_temp_file options[:filename] do |file|
-        att = attachment_model.create :uploaded_data => {"size" => file.size, "content_type" => options[:content_type] || 'image/png', "filename" => file, 'tempfile' => fixture_file_upload(file, options[:content_type] || 'image/png')}
-        att.reload unless att.new_record?
-        return att
-      end
-    end
-    
-    def use_temp_file(fixture_filename)
-      temp_path = File.join('/tmp', File.basename(fixture_filename))
-      FileUtils.mkdir_p File.join(fixture_path, 'tmp')
-      FileUtils.cp File.join(fixture_path, fixture_filename), File.join(fixture_path, temp_path)
-      yield temp_path
-    ensure
-      FileUtils.rm_rf File.join(fixture_path, 'tmp')
-    end
-
-    def assert_created(num = 1)
-      assert_difference attachment_model.base_class, :count, num do
-        if attachment_model.included_modules.include? DbFile
-          assert_difference DbFile, :count, num do
-            yield
-          end
-        else
-          yield
-        end
-      end
-    end
-    
-    def assert_not_created
-      assert_created(0) { yield }
-    end
-    
-    def should_reject_by_size_with(klass)
-      attachment_model klass
-      assert_not_created do
-        attachment = upload_file :filename => '/files/rails.png'
-        assert attachment.new_record?
-        assert attachment.errors.on(:size)
-        assert_nil attachment.db_file if attachment.respond_to?(:db_file)
-      end
-    end
-    
-    def assert_difference(object, method = nil, difference = 1)
-      initial_value = object.send(method)
-      yield
-      assert_equal initial_value + difference, object.send(method)
-    end
-    
-    def assert_no_difference(object, method, &block)
-      assert_difference object, method, 0, &block
-    end
-    
-    def attachment_model(klass = nil)
-      @attachment_model = klass if klass 
-      @attachment_model
-    end
-end
-
-require File.join(File.dirname(__FILE__), 'fixtures/attachment')
-require File.join(File.dirname(__FILE__), 'base_attachment_tests')

data/test/validation_test.rb

@@ -1,55 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
-
-class ValidationTest < Test::Unit::TestCase
-  def test_should_invalidate_big_files
-    @attachment = SmallAttachment.new
-    assert !@attachment.valid?
-    assert @attachment.errors.on(:size)
-    
-    @attachment.size = 2000
-    assert !@attachment.valid?
-    assert @attachment.errors.on(:size), @attachment.errors.full_messages.to_sentence
-    
-    @attachment.size = 1000
-    assert !@attachment.valid?
-    assert_nil @attachment.errors.on(:size)
-  end
-
-  def test_should_invalidate_small_files
-    @attachment = BigAttachment.new
-    assert !@attachment.valid?
-    assert @attachment.errors.on(:size)
-    
-    @attachment.size = 2000
-    assert !@attachment.valid?
-    assert @attachment.errors.on(:size), @attachment.errors.full_messages.to_sentence
-    
-    @attachment.size = 1.megabyte
-    assert !@attachment.valid?
-    assert_nil @attachment.errors.on(:size)
-  end
-  
-  def test_should_validate_content_type
-    @attachment = PdfAttachment.new
-    assert !@attachment.valid?
-    assert @attachment.errors.on(:content_type)
-
-    @attachment.content_type = 'foo'
-    assert !@attachment.valid?
-    assert @attachment.errors.on(:content_type)
-
-    @attachment.content_type = 'pdf'
-    assert !@attachment.valid?
-    assert_nil @attachment.errors.on(:content_type)
-  end
-
-  def test_should_require_filename
-    @attachment = Attachment.new
-    assert !@attachment.valid?
-    assert @attachment.errors.on(:filename)
-    
-    @attachment.filename = 'foo'
-    assert !@attachment.valid?
-    assert_nil @attachment.errors.on(:filename)
-  end
-end

data/vendor/red_artisan/core_image/filters/color.rb

@@ -1,27 +0,0 @@
-module RedArtisan
-  module CoreImage
-    module Filters
-      module Color
-        
-        def greyscale(color = nil, intensity = 1.00)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          color = OSX::CIColor.colorWithString("1.0 1.0 1.0 1.0") unless color
-          
-          @original.color_monochrome :inputColor => color, :inputIntensity => intensity do |greyscale|
-            @target = greyscale
-          end
-        end
-        
-        def sepia(intensity = 1.00)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          @original.sepia_tone :inputIntensity => intensity do |sepia|
-            @target = sepia
-          end
-        end
-        
-      end
-    end
-  end
-end

data/vendor/red_artisan/core_image/filters/effects.rb

@@ -1,31 +0,0 @@
-module RedArtisan
-  module CoreImage
-    module Filters
-      module Effects
-        
-        def spotlight(position, points_at, brightness, concentration, color)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          @original.spot_light :inputLightPosition => vector3(*position), :inputLightPointsAt => vector3(*points_at), 
-                               :inputBrightness => brightness, :inputConcentration => concentration, :inputColor => color do |spot|
-            @target = spot
-          end
-        end
-        
-        def edges(intensity = 1.00)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          @original.edges :inputIntensity => intensity do |edged|
-            @target = edged
-          end
-        end
-        
-        private
-        
-          def vector3(x, y, w)
-            OSX::CIVector.vectorWithX_Y_Z(x, y, w)
-          end
-      end
-    end
-  end
-end

data/vendor/red_artisan/core_image/filters/perspective.rb

@@ -1,25 +0,0 @@
-module RedArtisan
-  module CoreImage
-    module Filters
-      module Perspective
-        
-        def perspective(top_left, top_right, bottom_left, bottom_right)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          @original.perspective_transform :inputTopLeft => top_left, :inputTopRight => top_right, :inputBottomLeft => bottom_left, :inputBottomRight => bottom_right do |transformed|
-            @target = transformed
-          end
-        end
-
-        def perspective_tiled(top_left, top_right, bottom_left, bottom_right)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          @original.perspective_tile :inputTopLeft => top_left, :inputTopRight => top_right, :inputBottomLeft => bottom_left, :inputBottomRight => bottom_right do |tiled|
-            @target = tiled
-          end
-        end
-        
-      end
-    end
-  end
-end

data/vendor/red_artisan/core_image/filters/quality.rb

@@ -1,25 +0,0 @@
-module RedArtisan
-  module CoreImage
-    module Filters
-      module Quality
-        
-        def reduce_noise(level = 0.02, sharpness = 0.4)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          @original.noise_reduction :inputNoiseLevel => level, :inputSharpness => sharpness do |noise_reduced|
-            @target = noise_reduced
-          end
-        end
-        
-        def adjust_exposure(input_ev = 0.5)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          @original.exposure_adjust :inputEV => input_ev do |adjusted|
-            @target = adjusted
-          end          
-        end
-        
-      end
-    end
-  end
-end

data/vendor/red_artisan/core_image/filters/scale.rb

@@ -1,47 +0,0 @@
-module RedArtisan
-  module CoreImage
-    module Filters
-      module Scale
-        
-        def resize(width, height)
-          create_core_image_context(width, height)
-
-          scale_x, scale_y = scale(width, height)
-
-          @original.affine_clamp :inputTransform => OSX::NSAffineTransform.transform do |clamped|
-            clamped.lanczos_scale_transform :inputScale => scale_x > scale_y ? scale_x : scale_y, :inputAspectRatio => scale_x / scale_y do |scaled|
-              scaled.crop :inputRectangle => vector(0, 0, width, height) do |cropped|
-                @target = cropped
-              end
-            end
-          end
-        end
-
-        def thumbnail(width, height)
-          create_core_image_context(width, height)
-
-          transform = OSX::NSAffineTransform.transform
-          transform.scaleXBy_yBy *scale(width, height)
-
-          @original.affine_transform :inputTransform => transform do |scaled|
-            @target = scaled
-          end
-        end
-
-        def fit(size)
-          original_size = @original.extent.size
-          scale = size.to_f / (original_size.width > original_size.height ? original_size.width : original_size.height)
-          resize (original_size.width * scale).to_i, (original_size.height * scale).to_i
-        end
-        
-        private
-        
-          def scale(width, height)
-            original_size = @original.extent.size
-            return width.to_f / original_size.width.to_f, height.to_f / original_size.height.to_f
-          end
-          
-      end
-    end
-  end
-end

data/vendor/red_artisan/core_image/filters/watermark.rb

@@ -1,32 +0,0 @@
-module RedArtisan
-  module CoreImage
-    module Filters
-      module Watermark
-        
-        def watermark(watermark_image, tile = false, strength = 0.1)
-          create_core_image_context(@original.extent.size.width, @original.extent.size.height)
-          
-          if watermark_image.respond_to? :to_str
-            watermark_image = OSX::CIImage.from(watermark_image.to_str)
-          end
-          
-          if tile
-            tile_transform = OSX::NSAffineTransform.transform
-            tile_transform.scaleXBy_yBy 1.0, 1.0
-            
-            watermark_image.affine_tile :inputTransform => tile_transform do |tiled|
-              tiled.crop :inputRectangle => vector(0, 0, @original.extent.size.width, @original.extent.size.height) do |tiled_watermark|
-                watermark_image = tiled_watermark
-              end
-            end
-          end
-          
-          @original.dissolve_transition :inputTargetImage => watermark_image, :inputTime => strength do |watermarked|
-            @target = watermarked
-          end
-        end
-
-      end
-    end
-  end
-end

data/vendor/red_artisan/core_image/processor.rb

@@ -1,123 +0,0 @@
-require 'rubygems'
-require 'osx/cocoa'
-require 'active_support'
-
-require 'red_artisan/core_image/filters/scale'
-require 'red_artisan/core_image/filters/color'
-require 'red_artisan/core_image/filters/watermark'
-require 'red_artisan/core_image/filters/quality'
-require 'red_artisan/core_image/filters/perspective'
-require 'red_artisan/core_image/filters/effects'
-
-# Generic image processor for scaling images based on CoreImage via RubyCocoa.
-#
-# Example usage:
-#
-# p = Processor.new OSX::CIImage.from(path_to_image)
-# p.resize(640, 480)
-# p.render do |result|
-#   result.save('resized.jpg', OSX::NSJPEGFileType)
-# end
-#
-# This will resize the image to the given dimensions exactly, if you'd like to ensure that aspect ratio is preserved:
-#
-# p = Processor.new OSX::CIImage.from(path_to_image)
-# p.fit(640)
-# p.render do |result|
-#   result.save('resized.jpg', OSX::NSJPEGFileType)
-# end
-#
-# fit(size) will attempt its best to resize the image so that the longest width/height (depending on image orientation) will match
-# the given size. The second axis will be calculated automatically based on the aspect ratio.
-#
-# Scaling is performed by first clamping the image so that its external bounds become infinite, this helps when scaling so that any
-# rounding discrepencies in dimensions don't affect the resultant image. We then perform a Lanczos transform on the image which scales
-# it to the target size. We then crop the image to the traget dimensions.
-#
-# If you are generating smaller images such as thumbnails where high quality rendering isn't as important, an additional method is
-# available:
-#
-# p = Processor.new OSX::CIImage.from(path_to_image)
-# p.thumbnail(100, 100)
-# p.render do |result|
-#   result.save('resized.jpg', OSX::NSJPEGFileType)
-# end
-#
-# This will perform a straight affine transform and scale the X and Y boundaries to the requested size. Generally, this will be faster
-# than a lanczos scale transform, but with a scaling quality trade.
-#
-# More than welcome to intregrate any patches, improvements - feel free to mail me with ideas.
-#
-# Thanks to
-# * Satoshi Nakagawa for working out that OCObjWrapper needs inclusion when aliasing method_missing on existing OSX::* classes.
-# * Vasantha Crabb for general help and inspiration with Cocoa
-# * Ben Schwarz for example image data and collaboration during performance testing
-#
-# Copyright (c) Marcus Crafter <crafterm@redartisan.com> released under the MIT license
-#
-module RedArtisan
-  module CoreImage
-    class Processor
-  
-      def initialize(original)
-        if original.respond_to? :to_str
-          @original = OSX::CIImage.from(original.to_str)
-        else
-          @original = original
-        end
-      end
-  
-      def render(&block)
-        raise "unprocessed image: #{@original}" unless @target
-        block.call @target
-      end
-      
-      include Filters::Scale, Filters::Color, Filters::Watermark, Filters::Quality, Filters::Perspective, Filters::Effects
-  
-      private
-  
-        def create_core_image_context(width, height)
-      		output = OSX::NSBitmapImageRep.alloc.initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel(nil, width, height, 8, 4, true, false, OSX::NSDeviceRGBColorSpace, 0, 0)
-      		context = OSX::NSGraphicsContext.graphicsContextWithBitmapImageRep(output)
-      		OSX::NSGraphicsContext.setCurrentContext(context)
-      		@ci_context = context.CIContext
-        end
-        
-        def vector(x, y, w, h)
-          OSX::CIVector.vectorWithX_Y_Z_W(x, y, w, h)
-        end
-    end
-  end
-end
-
-module OSX
-  class CIImage
-    include OCObjWrapper
-  
-    def method_missing_with_filter_processing(sym, *args, &block)
-      f = OSX::CIFilter.filterWithName("CI#{sym.to_s.camelize}")
-      return method_missing_without_filter_processing(sym, *args, &block) unless f
-    
-      f.setDefaults if f.respond_to? :setDefaults
-      f.setValue_forKey(self, 'inputImage')
-      options = args.last.is_a?(Hash) ? args.last : {}
-      options.each { |k, v| f.setValue_forKey(v, k.to_s) }
-    
-      block.call f.valueForKey('outputImage')
-    end
-  
-    alias_method_chain :method_missing, :filter_processing
-      
-    def save(target, format = OSX::NSJPEGFileType, properties = nil)
-      bitmapRep = OSX::NSBitmapImageRep.alloc.initWithCIImage(self)
-      blob = bitmapRep.representationUsingType_properties(format, properties)
-      blob.writeToFile_atomically(target, false)
-    end
-  
-    def self.from(filepath)
-      raise Errno::ENOENT, "No such file or directory - #{filepath}" unless File.exists?(filepath)
-      OSX::CIImage.imageWithContentsOfURL(OSX::NSURL.fileURLWithPath(filepath))
-    end
-  end
-end
-