ramaze 2011.01.30 → 2011.07.25

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

@@ -1,129 +0,0 @@
-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: (%p : %p)" % [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

@@ -1,196 +0,0 @@
-#          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 many_to_one, 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+.
-#
-#       :algorithm => :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_many_to_one  = args[:many_to_one] ||    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.many_to_one set_many_to_one
-
-    # Define Hooks
-    model.before_create :generate_thumbnails do
-      generate_thumbnails
-      self.created_at = Time.now
-    end
-
-    model.before_save :update_time do
-      self.updated_at = Time.now
-    end
-
-    model.before_destroy :cleanup 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         = Rack::Mime::MIME_TYPES.invert[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.options.roots.first
-    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

@@ -1,98 +0,0 @@
-#          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
-
-=begin
-     # uncomment 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
-    end
-
-    def the(left_model, &block)
-      @left = left_model
-      TODO[@left] = []
-      instance_eval(&block)
-    end
-
-    def belongs_to(model)
-      todo :many_to_one, singular_sym(model), :class => model
-    end
-
-    def has_many(model)
-      todo :create_join, model
-      todo :many_to_many, plural_sym(model), :class => model
-    end
-
-    def has_one(model)
-      todo :many_to_one, singular_sym(model), :class => model
-    end
-
-    def todo(method, *args)
-      TODO[@left] << [method, *args]
-    end
-
-    private
-
-    def plural_sym(obj)
-      basename(obj).pluralize.to_sym
-    end
-
-    def singular_sym(obj)
-      basename(obj).to_sym
-    end
-
-    def basename(obj)
-      obj.to_s.split('::').last.downcase
-    end
-  end
-end

data/lib/ramaze/helper/httpdigest.rb

@@ -1,96 +0,0 @@
-begin
-  require 'securerandom' # Ruby >= 1.8.7
-rescue LoadError
-  require 'uuidtools'
-end
-
-require 'digest/md5'
-
-module Ramaze
-  module Helper
-    # Authorization using HTTP Digest.
-    #
-    # For custom authorization failure handling add an {httpdigest_failure}
-    # method in your controller.
-    module HttpDigest
-
-      SESSION_NONCE = 'httpdigest_authentication_nonce'
-      SESSION_OPAQUE = 'httpdigest_authentication_opaque'
-      DIGEST_HEADER = %|Digest realm="%s", qop="auth,auth-int", nonce="%s", opaque="%s"|
-
-      # Delete the nonce and opaque from session to log out.
-      def httpdigest_logout
-        session.delete(SESSION_NONCE)
-        session.delete(SESSION_OPAQUE)
-      end
-
-      def httpdigest_uuid
-        ::SecureRandom.hex(32)
-      end
-
-      def httpdigest_failure_internal(uid,realm)
-        nonce = session[SESSION_NONCE] = httpdigest_uuid
-        opaque = session[SESSION_OPAQUE][realm][uid] = httpdigest_uuid
-        response['WWW-Authenticate'] = DIGEST_HEADER % [realm, nonce, opaque]
-        response['Pragma'] = 'no-cache' # HTTP/1.0
-        response['Cache-Control'] = 'no-cache' # HTTP/1.1
-        response['Last-Modified'] = Time.now.httpdate
-        httpdigest_failure
-      end
-
-      def httpdigest_failure
-        respond 'Unauthorized', 401
-      end
-
-      def httpdigest_http_authorization(uid, realm)
-        http_authorization = request.env['HTTP_AUTHORIZATION']
-        return http_authorization if http_authorization
-
-        httpdigest_failure_internal(uid, realm)
-      end
-
-      def httpdigest_lookup(username, realm)
-        if block_given?
-          yield(username)
-        elsif respond_to?(:httpdigest_lookup_password)
-          httpdigest_lookup_password(username)
-        elsif respond_to?(:httpdigest_lookup_plaintext_password)
-          plain = httpdigest_lookup_plaintext_password(username)
-          Digest::MD5.hexdigest([username, realm, plain].join(':'))
-        else
-          raise "No password lookup handler found"
-        end
-      end
-
-      def httpdigest(uid, realm, &block)
-        session[SESSION_OPAQUE] ||= {}
-        session[SESSION_OPAQUE][realm] ||= {}
-
-        http_authorization = httpdigest_http_authorization(uid, realm)
-
-        httpdigest_failure_internal(uid, realm) unless session_nonce = session[SESSION_NONCE]
-        httpdigest_failure_internal(uid, realm) unless session_opaque = session[SESSION_OPAQUE][realm][uid]
-
-        auth_type, auth_raw = http_authorization.split(' ', 2)
-        httpdigest_failure_internal(uid, realm) unless auth_type == 'Digest'
-
-        authorization = Rack::Auth::Digest::Params.parse(auth_raw)
-
-        digest_response, username, nonce, nc, cnonce, qop, opaque, uri =
-          authorization.values_at(*%w[response username nonce nc cnonce qop opaque uri])
-
-        httpdigest_failure_internal(uid, realm) unless nonce == session_nonce and opaque == session_opaque
-
-        ha1 = httpdigest_lookup(username, realm, &block)
-        a2 = [request.request_method,uri]
-        a2 << Digest::MD5.hexdigest(request.body.read) if qop == "auth-int"
-        ha2 = Digest::MD5.hexdigest(a2.join(':'))
-        md5 = Digest::MD5.hexdigest([ha1, nonce, nc, cnonce, qop, ha2].join(':'))
-
-        httpdigest_failure_internal(uid, realm) unless digest_response == md5
-
-        return username
-      end
-    end
-  end
-end