Pistos-ramaze 2008.09

data/lib/ramaze/contrib/sequel/image.rb

@@ -0,0 +1,198 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# Scaffold image models utilizing thumbnailing and Ramaze integration.
+# Resizing is done by ImageScience.
+#
+# Usage:
+#   class Avatar < Sequel::Model
+#     IMAGE = {
+#       # specifies belongs_to, will create relation and foreign key
+#
+#       :owner => :User,
+#
+#
+#       # Remove original and thumbnails on Avatar#destroy
+#
+#       :cleanup => true,
+#
+#
+#       # Algorithm to use in ImageScience
+#       #
+#       # * resize(width, height)
+#       #     Resizes the image to +width+ and +height+ using a cubic-bspline
+#       #     filter.
+#       #
+#       # * thumbnail(size)
+#       #     Creates a proportional thumbnail of the image scaled so its
+#       #     longest edge is resized to +size+.
+#       #
+#       # * cropped_thumbnail(size)
+#       #     Creates a square thumbnail of the image cropping the longest edge
+#       #     to match the shortest edge, resizes to +size+.
+#
+#       :agorithm => :thumbnail,
+#
+#
+#       # Key specifies the filename and accessors, value are arguments to the
+#       # algorithm
+#
+#       :sizes => {
+#         :small => 150,
+#         :medium => 300,
+#         :large => 600
+#       }
+#     }
+#
+#     # Perform the scaffold
+#     include SequelImage
+#   end
+
+module SequelImage
+  def self.included(model)
+    args = model::IMAGE
+    set_foreign_key = args[:foreign_key] || "#{args[:owner]}_id".downcase.to_sym
+    set_belongs_to  = args[:belongs_to]  ||    args[:owner].to_s.downcase.to_sym
+
+    # Define schema
+    model.set_schema do
+      primary_key :id
+
+      varchar :original # path to the original image
+      varchar :mime, :size => 22 # average of /etc/mime.types
+
+      time :created_at
+      time :updated_at
+
+      foreign_key set_foreign_key
+    end
+
+    # Define Relations
+    model.belongs_to set_belongs_to
+
+    # Define Hooks
+    model.send(:hooks).clear
+
+    model.before_create do
+      generate_thumbnails
+      self.created_at = Time.now
+    end
+
+    model.before_save do
+      self.updated_at = Time.now
+    end
+
+    model.before_destroy do
+      cleanup if conf[:cleanup]
+    end
+
+    # Define singleton methods
+    model.extend(SingletonMethods)
+
+    # Define instance methods
+    model.send(:include,
+               InstanceMethods,
+               Ramaze::Helper::CGI,
+               Ramaze::Helper::Link)
+
+    args[:sizes].each do |size, *args|
+      model.send(:define_method, size){ public_file(size) }
+      model.send(:define_method, "#{size}_url"){ file(size) }
+    end
+  end
+
+  module SingletonMethods
+    def store(file, uid, hash = {})
+      image = new(hash)
+
+      type     = file[:type]
+      filename = file[:filename]
+      tempfile = file[:tempfile]
+      raise ArgumentError, 'Empty tempfile' if tempfile.size == 0
+
+      ext         = Ramaze::Tool::MIME.ext_for(type)
+      image.mime  = type
+      target_name = image.next_name(File.basename(filename, File.extname(filename)), ext)
+      target_path = File.join(image.public_root, image.path, target_name)
+
+      FileUtils.mkdir_p(File.dirname(target_path))
+      FileUtils.cp(tempfile.path, target_path)
+
+      image.original = target_path
+      image.save
+    end
+  end
+
+  module InstanceMethods
+    def file(size = nil)
+      File.join('/', path, filename(size))
+    end
+
+    def public_file(size)
+      File.join(public_path, filename(size))
+    end
+
+    def public_path
+      File.join(public_root, path)
+    end
+
+    def path
+      conf[:path] || conf[:owner].to_s.downcase
+    end
+
+    def next_name(uid, ext)
+      uid = uid.to_s.scan(%r![^\\/'".:?&;\s]+!).join('-')
+      "#{uid}#{ext}"
+    end
+
+    def basename
+      File.basename(original, File.extname(original))
+    end
+
+    def public_root
+      Ramaze::Global.public_root
+    end
+
+    def filename(size)
+      if size
+        "#{basename}_#{size}.png"
+      else
+        "#{basename}.png"
+      end
+    end
+
+    def conf
+      self.class::IMAGE
+    end
+
+    def cleanup
+      conf[:sizes].each do |name, args|
+        out = public_file(name)
+        Ramaze::Log.debug "Remove Thumbnail: #{out}"
+        FileUtils.rm_f(out)
+      end
+
+      Ramaze::Log.debug "Remove original: #{original}"
+      FileUtils.rm_f(original)
+    end
+
+    def generate_thumbnails
+      FileUtils.mkdir_p(public_path)
+
+      sizes, algorithm = conf.values_at(:sizes, :algorithm)
+
+      ImageScience.with_image(original) do |img|
+        Ramaze::Log.debug "Process original: #{original}"
+
+        sizes.each do |name, args|
+          out = public_file(name)
+          Ramaze::Log.debug "Generate Thumbnail: #{out}"
+
+          img.send(algorithm, *args) do |thumb|
+            thumb.save(out)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/sequel/relation.rb

@@ -0,0 +1,82 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.     
+
+# Pretty DSL to express Sequel relations
+#
+# Usage:
+#   SequelRelation.relations do
+#     the User do
+#       has_many Article
+#       has_one Avatar
+#     end
+#
+#     the Article do
+#       belongs_to User
+#     end
+#
+#     the Avatar do
+#       belongs_to User
+#     end
+#   end
+
+module SequelRelation
+  def self.relations(&block)
+    rema = RelationshipManager.new(&block)
+    rema.finalize
+  end
+
+  class RelationshipManager
+    TODO = {}
+
+    def initialize(&block)
+      instance_eval(&block)
+    end
+
+    def finalize
+      TODO.keys.each do |model|
+        model.create_table unless model.table_exists?
+      end
+
+      TODO.each do |model, instructions|
+        instructions.each do |args|
+          model.send(*args)
+        end
+      end
+
+      return # remove this line for debugging
+
+      pp TODO
+
+      TODO.keys.each do |model|
+        puts "the #{model}"
+        assoc = model.send(:association_reflections)
+        assoc.each do |key, reflection|
+          puts "  #{reflection[:type]} => #{key}"
+        end
+      end
+    end
+
+    def the(left_model, &block)
+      @left = left_model
+      TODO[@left] = []
+      instance_eval(&block)
+    end
+
+    def belongs_to(model)
+      todo :belongs_to, model.to_s.downcase.to_sym
+    end
+
+    def has_many(model)
+      todo :create_join, model
+      todo :many_to_many, model.to_s.downcase.pluralize.to_sym
+    end
+
+    def has_one(model)
+      todo :belongs_to, model.to_s.downcase.to_sym
+    end
+
+    def todo(method, *args)
+      TODO[@left] << [method, *args]
+    end
+  end
+end

data/lib/ramaze/contrib/sequel_cache.rb

@@ -0,0 +1,92 @@
+#
+# drop-in replacement for Ramaze's built-in MemoryCache built on the Sequel.
+# to use with sessions do
+#
+#   Ramaze::Global::cache_alternative[:sessions] = Ramaze::SequelCache
+#
+# to use with everything do
+#
+#   Ramaze::Global::cache = Ramaze::SequelCache
+#
+
+class Ramaze::SequelCache
+  class Table < Sequel::Model(:ramaze_cache_t)
+    set_schema do
+      primary_key :id
+      string :key
+      string :value
+      index :key, :unique => true
+    end
+
+    ## use sequel's built-in serialize function if you like execptions: the
+    ## serialized data blows up the sql
+    ## serialize :value, :format => :marshal
+
+    transform :value => [
+      lambda{|value| Marshal.load(Base64.decode64(value))},
+      lambda{|value| Base64.encode64(Marshal.dump(value))},
+    ]
+  end
+
+  def table() Table end
+  def t() Table end
+
+  def self.[] key
+    record = Table.find :key => key
+    record ? record.value : nil
+  end
+
+  def self.[]= key, value
+    begin
+      Table.create :key => key, :value => value
+    rescue
+      Table.filter(:key => key).update :value => value
+      unless Table.find(:key => key)
+        Table.create :key => key, :value => value rescue nil
+      end
+    end
+    # ruby always returns 'value' for []= !
+  rescue
+    nil
+  end
+
+  def self.values_at *keys
+    keys.map{|key| Table[key]}
+  end
+
+  def self.delete *keys
+    keys.map do |key|
+      record = Table[key]
+      record.delete if record
+    end
+  end
+
+  def self.clear
+    Table.delete_all
+  end
+
+  def self.new
+    self
+  end
+
+  def self.to_sym
+    name.split(%r/::/).last.to_sym
+  end
+end
+
+
+
+
+if $0 == __FILE__
+  case ARGV.first
+    when /create|up/
+      Ramaze::SequelCache::Table.create_table!
+    when /drop|down/
+      Ramaze::SequelCache::Table.drop_table
+    else
+      abort "usage: ruby #{ __FILE__ } create/up | drop/down"
+  end
+else
+  Ramaze::SequelCache::Table.create_table! unless
+    Ramaze::SequelCache::Table.table_exists?
+end

data/lib/ramaze/contrib.rb

@@ -0,0 +1,82 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # Loads and sets up contrib modules.
+  #
+  # For more information @see Ramaze::Contrib.load
+  #
+  # Usage:
+  #
+  #   Ramaze.contrib :gzip_filter
+
+  def self.contrib(*args)
+    Contrib.load(*args)
+  end
+
+  # A module used for loading contrib modules.
+
+  module Contrib
+
+    # Loads and sets up contrib modules from /ramaze/contrib.
+    #
+    # === Usage:
+    #
+    #   Ramaze::Contrib.load :gzip_filter
+    #
+    # === Creating a contrib module:
+    #
+    #   module Ramaze::Contrib::Test
+    #     def self.setup
+    #       Log.info "Test module set up"
+    #     end
+    #   end
+    #   class TestController < Ramaze::Controller
+    #     map '/test'
+    #     def index; "Chunky Bacon!"; end
+    #   end
+    #
+    #   # Save that to your <app dir>/contrib and use like:
+    #   Ramaze.contrib :test
+
+    def self.load(*contribs)
+      contribs.each do |name|
+        mod_name = name.to_s.camel_case
+        begin
+          const = Contrib.const_get(mod_name)
+          Global.contribs << const
+          const.startup if const.respond_to?(:startup)
+          Log.dev "Loaded contrib: #{const}"
+        rescue NameError
+          files = Dir["{contrib,#{BASEDIR/:ramaze/:contrib}}/#{name}.{so,bundle,rb}"]
+          raise LoadError, "#{mod_name} not found" unless files.any?
+          require(files.first) ? retry : raise
+        end
+      end
+    end
+
+    # Will call .shutdown on all contrib modules which support it.
+    #---
+    # .shudown gets called by Ramaze :essentials.
+    #+++
+
+    def self.shutdown
+      Global.contribs.each do |contrib|
+        contrib.shutdown if contrib.respond_to?(:shutdown)
+      end
+    end
+
+    # Will load all contrib modules from options[:contrib]
+    #---
+    # .startup gets called by Ramaze :essentials.
+    #+++
+
+    def self.startup(options = {})
+      return unless options[:contrib]
+      [options[:contrib]].flatten.each do |contrib|
+        load(contrib)
+      end
+    end
+  end # class Contrib
+end # class Ramaze

data/lib/ramaze/controller/error.rb

@@ -0,0 +1,46 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  class Controller
+    # The default error-page handler. you can overwrite this method
+    # in your controller and create your own error-template for use.
+    #
+    # Error-pages can be in whatever the templating-engine of your controller
+    # is set to.
+    #   Ramaze::Dispatcher::Error.current
+    # holds the exception thrown.
+
+    def error
+      error = Dispatcher::Error.current
+      title = error.message
+
+      unless Action.current.template
+        response['Content-Type'] = 'text/plain'
+        respond %(
+          #{error.message}
+            #{error.backtrace.join("\n            ")}
+
+          #{PP.pp request, '', 200}
+        ).ui
+      end
+
+      backtrace_size = Global.backtrace_size
+      @backtrace = error.backtrace[0..20].map{|line|
+        file, lineno, meth = *Ramaze.parse_backtrace(line)
+        lines = Ramaze.caller_lines(file, lineno, backtrace_size)
+
+        [ lines, lines.object_id.abs, file, lineno, meth ]
+      }
+
+      # for backwards-compat with old error.zmr
+      @colors = [255] * @backtrace.size
+
+      @title = h(title)
+      @editor = ENV['EDITOR'] || 'vim'
+      title
+    rescue Object => ex
+      Log.error(ex)
+    end
+  end
+end

data/lib/ramaze/controller/main.rb

@@ -0,0 +1,2 @@
+class MainController < Ramaze::Controller
+end