airbrush 0.0.2

data/lib/airbrush/processors/image/rmagick.rb

@@ -0,0 +1,116 @@
+require 'RMagick'
+
+module Airbrush
+  module Processors
+    module Image
+      class Rmagick < ImageProcessor
+        filter_params :image # ignore any argument called 'image' in any logging
+
+        def resize(image, width, height = nil)
+          width, height = calculate_dimensions(image, width) unless height
+
+          process image do
+            change_geometry("#{width}x#{height}") { |cols, rows, image| image.resize!(cols, rows) }
+          end
+        end
+
+        def crop(image, tl_x, tl_y, br_x, br_y)
+          process image do
+            crop!(tl_x, tl_y, br_x, br_y)
+          end
+        end
+
+        def crop_resize(image, width, height = nil)
+          width, height = calculate_dimensions(image, width) unless height
+          
+          process image do
+            crop_resized!(width, height)
+          end
+        end
+
+        def previews(image, sizes) # sizes => { :small => [200,100], :medium => [400,200], :large => [600,300] }
+          images = sizes.inject(Hash.new) { |m, (k, v)| m[k] = crop_resize(image, *v); m }
+          images[:original] = dimensions(image)
+          images
+        end
+
+        protected
+
+          def process(image, &block)
+            img = Magick::Image.from_blob(image).first
+            img.instance_eval &block
+            img.ensure_rgb!
+            img.format = 'JPEG' # ensure that resized output is a JPEG
+            {
+              :image => img.to_blob, :width => img.columns, :height => img.rows
+            }
+          end
+
+          def dimensions(image_data)
+            image = Magick::Image.from_blob(image_data).first
+            return [image.columns, image.rows]
+          end
+
+          def calculate_dimensions(image_data, size)
+            image = Magick::Image.from_blob(image_data).first
+            return image.columns, image.rows if clipping_required?(image, size)
+
+            ratio = image.columns.to_f / image.rows.to_f
+
+            portrait image do
+              return [ size, size.to_f / ratio ]
+            end
+
+            landscape image do
+              return [ ratio * size, size ]
+            end
+            
+            # Must be a square image.
+            return [ size, size ]
+          end
+
+          def clipping_required?(image, size)
+            size > image.columns or size > image.rows
+          end
+
+          def portrait(image, &block)
+            block.call if image.columns > image.rows
+          end
+
+          def landscape(image, &block)
+            block.call if image.columns < image.rows
+          end
+
+      end
+    end
+  end
+end
+
+module Magick
+  class Image
+    SCT_CMYK_ICC = File.dirname(__FILE__) + '/profiles/cmyk-profile.icc'
+    SCT_SRGB_ICC = File.dirname(__FILE__) + '/profiles/srgb-profile.icc'
+
+    def ensure_rgb!
+      return if rgb?
+
+      if cmyk?
+        add_profile SCT_CMYK_ICC if color_profile == nil
+        add_profile SCT_SRGB_ICC
+        log.debug "Added sRGB profile to image"
+      else
+        log.warn "Non CMYK/RGB color profile encountered, please install a profile for #{colorspace} and update ensure_rgb! implementation"
+      end
+    end
+
+    private
+
+      def rgb?
+        colorspace == Magick::RGBColorspace
+      end
+
+      def cmyk?
+        colorspace == Magick::CMYKColorspace
+      end
+  end
+end

data/lib/airbrush/processors/processor.rb

@@ -0,0 +1,43 @@
+module Airbrush
+  module Processors
+    class Processor
+      class_inheritable_accessor :filtered_params
+
+      def dispatch(command, args)
+        raise "Unknown processor operation #{command} (#{filter(args).inspect unless args.blank?})" unless self.respond_to? command
+        returning self.send(command, *assign(command, args)) do
+          log.debug "Processed #{command} (#{filter(args).inspect unless args.blank?})"
+        end
+      rescue Exception => e
+        buffer = "ERROR: Received error during processor dispatch for command '#{command}' (#{filter(args).inspect unless args.blank?})"
+        log.error buffer; log.error e
+        { :exception => buffer, :message => e.message }
+      end
+
+      def self.filter_params(*symbols)
+        self.filtered_params = symbols
+      end
+
+      protected
+
+        def assign(command, args)
+          params = ParseTreeArray.translate(self.class, command).get_args
+          params.collect do |param|
+            name, default = *param
+            args[name] ? args[name] : (raise "No value (default or otherwise) provided for #{name} in #{command}" unless default; default)
+          end
+        end
+
+      private
+
+        def filter(args)
+          return args if self.filtered_params.blank?
+
+          args.dup.inject({}) do |m, (k, v)|
+            m[k] = self.filtered_params.include?(k) ? '[FILTERED]' : v; m
+          end
+        end
+
+    end
+  end
+end

data/lib/airbrush/publishers/http.rb

@@ -0,0 +1,13 @@
+module Airbrush
+  module Publishers
+    class Http < Publisher
+      def initialize(target)
+        @target = target
+      end
+      
+      def publish(result)
+        # http post/put to target
+      end
+    end
+  end
+end

data/lib/airbrush/publishers/memcache.rb

@@ -0,0 +1,24 @@
+require 'memcache'
+
+module Airbrush
+  module Publishers
+    class Memcache < Publisher
+      attr_reader :host
+      
+      def initialize(host)
+        @host = host
+      end
+
+      def publish(id, results)
+        # need to calculate an outboue queue name somehow, client will also need this to get the results
+        name = unique_name(id)
+        queue = MemCache.new(@host)
+        queue.set(name, results)
+        
+        log.debug "Published results from #{name}"
+      end
+    end
+  end
+end
+
+# resize the dnssd or command line gear in listeners?

data/lib/airbrush/publishers/publisher.rb

@@ -0,0 +1,16 @@
+module Airbrush
+  module Publishers
+    class Publisher
+      
+      def publish
+        raise 'implementations provide concrete publisher functionality'
+      end
+
+      protected
+      
+        def unique_name(id)
+          id.to_s
+        end
+    end
+  end
+end

data/lib/airbrush/server.rb

@@ -0,0 +1,20 @@
+module Airbrush
+  class Server
+    attr_reader :listener
+
+    def initialize(context = {})
+      memcache_host = context[:memcache]
+      memcache_poll = context[:frequency]
+      Object.send :__create_logger__, context[:log_target] if context.include? :log_target
+      log.level = context[:verbose] ? ActiveSupport::BufferedLogger::Severity::DEBUG : ActiveSupport::BufferedLogger::Severity::INFO
+
+      @listener = Airbrush::Listeners::Memcache.new(memcache_host, memcache_poll)
+      @listener.handler = Handler.new(Processors::Image::Rmagick.new, Publishers::Memcache.new(memcache_host))
+    end
+
+    def start
+      @listener.start
+    end
+
+  end
+end

data/lib/airbrush/version.rb

@@ -0,0 +1,9 @@
+module Airbrush #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/airbrush.rb

@@ -0,0 +1,30 @@
+$:.unshift File.dirname(__FILE__)
+
+# required gems
+require 'rubygems'
+require 'active_support'
+
+ActiveSupport::Dependencies.load_paths << File.dirname(__FILE__)
+
+# for the moment lets log dependency loading
+#Dependencies::RAILS_DEFAULT_LOGGER = Logger.new($stdout)
+#Dependencies.log_activity = true
+
+# Load up extensions to existing classes
+Dir[File.dirname(__FILE__) + '/airbrush/core_ext/*.rb'].each { |e| require e }
+
+module Airbrush
+end
+
+class Object
+  def log
+    @@__log__ ||= __create_logger__($stdout)
+  end
+
+  private
+
+    def __create_logger__(target)
+      @@__log__ = ActiveSupport::BufferedLogger.new(target, ActiveSupport::BufferedLogger::Severity::INFO)
+    end
+
+end

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+begin
+  require 'newgem'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/airbrush/version.rb'
+
+version  = Airbrush::VERSION::STRING
+download = 'http://rubyforge.org/projects/airbrush'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.rhtml')
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)