ramaze 2008.06 → 2008.11

data/lib/ramaze/cache/memcached.rb

@@ -43,13 +43,11 @@ module Ramaze
       nil
     end
 
-    # out of some reason MemCache sometimes doesn't respond to
-    # get_multi, have to investigate this further.
-    #
-    # for now, i'll just use the dumbed down version and ask it
-    # whether it implements this functionality or not.
+    # Fetch for multiple keys at once.
 
     def get_multi(*keys)
+      # MemCache only responds to get_multi if the memcache-client_extensions gem
+      # is installed, so we check first and resort to another approach if not.
       if @cache.respond_to?(:get_multi)
         @cache.get_multi(*keys)
       else

data/lib/ramaze/contrib/auto_params.rb

@@ -47,11 +47,11 @@ module Ramaze
       self[:params] = par.map{ |pa|
         case pa
         when Array
-          pa.map{|p| CGI.unescape(p.to_s)}
+          pa.map{|p| Rack::Utils.unescape(p)}
         when nil
           nil
         else
-          CGI.unescape(pa.to_s)
+          Rack::Utils.unescape(pa)
         end
       } unless par.nil?
       self[:params] ||= []

data/lib/ramaze/contrib/auto_params/get_args.rb

@@ -1,5 +1,6 @@
 # from merb/core_ext/get_args.rb
 begin
+  require 'parse_tree'
   require 'ruby2ruby'
 
   class ParseTreeArray < Array
@@ -54,4 +55,4 @@ begin
     include GetArgs
   end
 rescue LoadError
-end
+end

data/lib/ramaze/contrib/gems.rb

@@ -14,8 +14,12 @@ module Ramaze
         @gems << GemStone.new(name, options)
       end
 
+      # options include:
+      #  :install_dir => where to install gems
+      #  :extconf     => additional options for building extensions
+
       def options opts = {}
-        @options ||= { :docs => true }
+        @options ||= {}
         @options.merge! opts unless opts.empty?
         @options
       end
@@ -31,36 +35,31 @@ module Ramaze
 
       def initialize(name, options = {})
         @name, @options = name, options
+        require 'rubygems/dependency_installer'
+        @installer = Gem::DependencyInstaller.new(@options)
       end
 
       def setup(ran = false)
-        # rubygems resets the path after each successful install
-        Gem.use_paths Gems.options[:install_dir] if Gems.options[:install_dir]
-
-        Gem.activate(name, *[@options[:version]].compact)
+        Gem.activate(name, *[options[:version]].compact)
         require options[:lib] || name
       rescue LoadError => error
         puts error
         return if ran
-        puts "attempting install"
         install
         setup(ran = true)
       end
 
       def install
-        require 'rubygems/gem_runner'
-        version, source = options.values_at(:version, :source)
-
-        cmd = %w[install] << name
-        cmd << "--no-rdoc" << "--no-ri" unless Gems.options[:docs]
-        cmd << "--install-dir" << Gems.options[:install_dir] if Gems.options[:install_dir]
-        cmd << "--version" << version if version
-        cmd << "--source" << source if source
+        if extconf = (options[:extconf] || Gems.options[:extconf])
+          old_argv = ARGV.clone
+          ARGV.replace extconf.split(' ')
+        end
 
-        puts cmd * ' '
-        Gem::GemRunner.new.run(cmd)
-      rescue Gem::SystemExitException => e
-        raise unless e.exit_code == 0
+        print "Installing #{name}..."
+        @installer.install name, options[:version]
+        puts "done.\n\n"
+      ensure
+        ARGV.replace old_argv if extconf
       end
     end
   end

data/lib/ramaze/contrib/gzip_filter.rb

@@ -3,13 +3,22 @@
 
 # gzip_filter.rb
 #
-# Use this to compress "large" pages with gzip.  All major browsers support gzipped pages.
-# This filter brought to you by your friends in #ramaze: Pistos, manveru, rikur and Kashia.
+# Use this to compress "large" pages with gzip.  All major browsers support
+# gzipped pages.
+# This filter brought to you by your friends in #ramaze:
+# Pistos, manveru, rikur and Kashia.
 #
 # Usage, in start.rb:
 #
 #   require 'ramaze/contrib/gzip_filter'
 #   Ramaze::Dispatcher::Action::FILTER << Ramaze::Filter::Gzip
+#
+# Setting options (at any point in your code):
+#
+#   Ramaze::Filter::Gzip.trait(
+#     :threshold    => 1024,
+#     :content_type => /^text\/.+/
+#   )
 
 require 'zlib'
 
@@ -17,8 +26,9 @@ module Ramaze
   module Filter
     class Gzip
 
-      trait :enabled => true
-      trait :threshold => 32768 # bytes
+      trait :enabled => true,
+            :content_type => /^text\/.+/,
+            :threshold => 32768 # bytes
 
       class << self
 
@@ -27,21 +37,24 @@ module Ramaze
         # Enables being plugged into Dispatcher::Action::FILTER
 
         def call( response, options = {} )
-          return response if not trait[ :enabled ]
-          return response if response.body.nil?
-          return response if response.body.respond_to?( :read )
+          return response unless trait[ :enabled ]
+          return response unless body = response.body
+          return response if body.respond_to?( :read )
 
           accepts = request.env[ 'HTTP_ACCEPT_ENCODING' ]
           return response if accepts.nil? || ( accepts !~ /(x-gzip|gzip)/ )
 
-          if response.content_type == 'text/html' && response.body.size > trait[ :threshold ]
+          acceptable_size = body.size >= trait[ :threshold ]
+          acceptable_type = response.content_type =~ trait[:content_type]
+
+          if acceptable_type and acceptable_size
             output = StringIO.new
             def output.close
               # Zlib closes the file handle, so we want to circumvent this
               rewind
             end
             gz = Zlib::GzipWriter.new( output )
-            gz.write( response.body )
+            gz.write( body )
             gz.close
 
             response.body = output.string

data/lib/ramaze/contrib/maruku_uv.rb

@@ -0,0 +1,59 @@
+# A hack to make MaRuKu use UltraViolet for highlighting
+# To specify the style to use use for example:
+#     uv_style: amy
+#     html_use_syntax: true
+#     code_lang: ruby
+# In the document header area.
+
+require 'maruku'
+
+module MaRuKu
+  module Out
+    module HTML
+      def uv_highlight(source, lang, style)
+        require 'uv'
+
+        html = Uv.parse(source, 'xhtml', lang, lines = false, style)
+
+        # Prepare <code> containing <pre>
+        code = Document.new(html, :respect_whitespace => :all).root
+        code.name = 'code'
+        code.attributes['class'] = lang
+        code.attributes['lang'] = lang
+
+        # Prepare <pre>
+        pre = Element.new('pre')
+        pre << code
+        pre.attributes['class'] = style
+        pre
+      rescue => ex
+        puts ex
+        to_html_code_using_pre(source)
+      end
+
+      def to_html_code
+        source = self.raw_code
+        use_syntax = get_setting(:html_use_syntax)
+        uv_style = get_setting(:uv_style)
+
+        lang = self.attributes[:lang] || @doc.attributes[:code_lang]
+        lang ||= 'ruby' if attributes[:ruby]
+
+        # we always use syntax highlighting, this is a doc wiki
+        if lang and use_syntax
+          element = uv_highlight(source, lang, uv_style)
+        else
+          element = to_html_code_using_pre(source)
+        end
+
+        color = get_setting(:code_background_color)
+
+        if color != Globals[:code_background_color]
+          element.attributes['style'] = "background-color: #{color};"
+        end
+
+        add_ws element
+      end
+    end # HTML
+  end # Out
+end # MaRuKu

data/lib/ramaze/contrib/profiling.rb

@@ -1,7 +1,7 @@
 require "ruby-prof"
 
 module Ramaze
-  module Dispatcher
+  class Dispatcher
     class ActionProfiler < Action
       def self.call(path)
         if RubyProf.running?

data/lib/ramaze/contrib/rest.rb

@@ -1,14 +1,17 @@
-Ramaze::Route['REST dispatch'] = lambda{|path, request|
-  case request.request_method
-  when 'GET'
-    path << 'show/'
-  when 'POST'
-    path << 'create/'
-  when 'PUT'
-    path << 'update/'
-  when 'DELETE'
-    path << 'destroy/'
-  else
-    path
+Ramaze::Rewrite['REST dispatch'] = lambda do |path, request|
+  path << '/' unless path[-1] == '/'
+
+  method = if request.request_method == 'POST' and request.params.has_key?('method')
+             request.params['method'].upcase
+           else
+             request.request_method
+           end
+  
+  case method
+  when 'GET' then path << 'show/'
+  when 'POST' then path << 'create/'
+  when 'PUT' then path << 'update/'
+  when 'DELETE' then path << 'destroy/'
+  else path
   end
-}
+end

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

@@ -0,0 +1,25 @@
+require 'sequel'
+
+module Sequel
+  class Model
+    # Force join table generation
+    #
+    # Usage:
+    #   User.create_join(Article, 'articles_users')
+    #   # or let the method figure out the correct join table using sequel
+    #   # conventions.
+    #   User.create_join(Article)
+    def self.create_join(to, name = nil)
+      from = self
+      name ||= [table_name.to_s, to.table_name.to_s].sort.join('_')
+      from_key = "#{from.table_name.to_s.singularize}_id"
+      to_key = "#{to.table_name.to_s.singularize}_id"
+
+      db.create_table! name do
+        primary_key :id
+        foreign_key from_key, :class => from
+        foreign_key to_key, :class => to
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+require 'ramaze/gestalt'
+
+# job = Job[4]
+# puts CGI::pretty(FormField.new(job, :contract, show_errors = true, Job::CONTRACTS).to_s)
+
+class FormField
+  attr_accessor :this, :field, :show_errors, :hint, :db_type, :id, :value
+
+  # show_errors may be a number indicating how many errors it should display at
+  # maximum, 0 displays none, -1 all
+
+  def initialize(this, field, show_errors = true, hint = nil)
+    @this, @field, @show_errors, @hint =
+      this, field.to_sym, show_errors, hint
+    @db_type = db_type
+    @id = "form_#{@field}"
+    @value = this.send(@field)
+  end
+
+  def db_type
+    if field_schema = this.class.db_schema[field]
+      field_schema[:db_type]
+    else
+      nil
+    end
+  end
+
+  def to_s
+    unless label = @this.class::FORM_LABEL[field]
+      raise("No FORM_LABEL for %p on %p" % [field, @this.class])
+    end
+
+    label += ':'
+    id = @id
+    _self = self
+
+    Ramaze::Gestalt.build{
+      div(:class => :pair){
+        label(:for => id){ label }
+        _self.build_tag(self)
+        _self.build_errors(self)
+      }
+    }
+  end
+
+  def password(gestalt)
+    gestalt.input(@args.merge :type => :password, :value => value)
+  end
+
+  def checkbox(gestalt)
+    @args[:checked] = :checked if value
+    gestalt.input(@args.merge :type => :checkbox)
+  end
+
+  def select(gestalt)
+    gestalt.select @args do
+      v = value.to_s
+      hint.each do |h|
+        h = h.to_s
+        if h == v
+          gestalt.option(:value => h, :selected => :selected){ h }
+        else
+          gestalt.option(:value => h){ h }
+        end
+      end
+    end
+  end
+
+  def input(gestalt)
+    gestalt.input(@args.merge :type => :text, :value => value)
+  end
+
+  def file(gestalt)
+    gestalt.input(@args.merge :type => :file)
+  end
+
+  def textarea(gestalt)
+    gestalt.textarea(@args){ value.to_s }
+  end
+
+  def build_tag(gestalt)
+    @args = {:id => id, :name => field}
+
+    case hint
+    when :password
+      password(gestalt)
+    when :boolean, :checkbox
+      checkbox(gestalt)
+    when :textarea
+      textarea(gestalt)
+    when :file
+      file(gestalt)
+    when Array, Range
+      select(gestalt)
+    else
+      case db_type
+      when 'varchar', 'integer'
+        input(gestalt)
+      when 'boolean'
+        checkbox(gestalt)
+      when 'string'
+        textarea(gestalt)
+      else
+        raise "Unsupported type: (#{db_type || hint} : #{field})"
+      end
+    end
+  end
+
+  def build_errors(gestalt)
+    each_error do |error|
+      gestalt.span(:class => :error){ error }
+    end
+  end
+
+  # TODO: suggest 'validated?' feature to sequel
+  def each_error(&block)
+    return unless show_errors
+
+    this.validate if this.errors.empty?
+    this.errors[field].first(show_errors).each(&block)
+  end
+
+  module Model
+    def form_field(field, hint = nil)
+      show_errors = Ramaze::Request.current.post? ? 1 : 0
+      FormField.new(self, field, show_errors, hint).to_s
+    end
+  end
+end

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