typo 5.5 → 6.0.4

data/lib/backpack_api.rb

@@ -1,202 +0,0 @@
-# Requires that XmlSimple is already loaded, like it is from within script/console in the latest beta Rails
-# Author: David Heinemeier Hansson, 37signals
-
-require 'yaml'
-require 'net/https'
-
-class BackpackAPI
-  attr_accessor :username, :token, :current_page_id
-
-  def initialize(username, token)
-    @username, @token = username, token
-    connect
-  end
-
-  def connect(use_ssl = false)
-    @connection = Net::HTTP.new("#{@username}.backpackit.com", use_ssl ? 443 : 80)
-    @connection.use_ssl = use_ssl
-    @connection.verify_mode = OpenSSL::SSL::VERIFY_NONE if use_ssl
-  end
-
-  def page_id=(id)
-    self.current_page_id = id
-  end
-  alias :pi= :page_id=
-
-  def request(path, parameters = {}, second_try = false)
-    parameters = { "token" => @token }.merge(parameters)
-
-    response = @connection.post("/ws/#{path}", parameters.to_yaml, "X-POST_DATA_FORMAT" => "yaml")
-
-    if response.code == "200"
-      result = XmlSimple.xml_in(response.body)
-      result.delete "success"
-      result.empty? ? true : result
-    elsif response.code == "302" && !second_try
-      connect(true)
-      request(path, parameters, true)
-    else
-      raise "Error occured (#{response.code}): #{response.body}"
-    end
-  end
-  alias :r :request
-
-
-  # Items ----
-
-  def list_items(page_id = current_page_id)
-    request "page/#{page_id}/items/list"
-  end
-  alias :li :list_items
-
-  def create_item(content, page_id = current_page_id)
-    request "page/#{page_id}/items/add", "item" => { "content" => content }
-  end
-  alias :ci :create_item
-
-  def update_item(item_id, content, page_id = current_page_id)
-    request "page/#{page_id}/items/update/#{item_id}", "item" => { "content" => content }
-  end
-  alias :ui :update_item
-
-  def destroy_item(item_id, page_id = current_page_id)
-    request "page/#{page_id}/items/destroy/#{item_id}"
-  end
-  alias :di :destroy_item
-
-  def toggle_item(item_id, page_id = current_page_id)
-    request "page/#{page_id}/items/toggle/#{item_id}"
-  end
-  alias :ti :toggle_item
-
-  def move_item(item_id, direction, page_id = current_page_id)
-    request "page/#{page_id}/items/move/#{item_id}", "direction" => "move_#{direction}"
-  end
-  alias :mi :move_item
-
-
-  # Notes ----
-
-  def list_notes(page_id = current_page_id)
-    request "page/#{page_id}/notes/list"
-  end
-  alias :li :list_notes
-
-  def create_note(title, body, page_id = current_page_id)
-    request "page/#{page_id}/notes/create", "note" => { "title" => title, "body" => body }
-  end
-  alias :cn :create_note
-
-  def update_note(note_id, title, body, page_id = current_page_id)
-    request "page/#{page_id}/notes/update/#{note_id}", "note" => { "title" => title, "body" => body }
-  end
-  alias :un :update_note
-
-  def destroy_note(note_id, page_id = current_page_id)
-    request "page/#{page_id}/notes/destroy/#{note_id}"
-  end
-  alias :dn :destroy_note
-
-
-  # Emails ----
-
-  def list_emails(page_id = current_page_id)
-    request "page/#{page_id}/emails/list"
-  end
-  alias :le :list_emails
-
-  def show_email(email_id, page_id = current_page_id)
-    request "page/#{page_id}/emails/show/#{email_id}"
-  end
-  alias :se :show_email
-
-  def destroy_email(email_id, page_id = current_page_id)
-    request "page/#{page_id}/emails/destroy/#{email_id}"
-  end
-  alias :de :destroy_email
-
-
-  # Tags ----
-
-  def list_pages_with_tag(tag_id)
-    request "tags/select/#{tag_id}"
-  end
-  alias :lpt :list_pages_with_tag
-
-  def tag_page(tags, page_id = current_page_id)
-    request "page/#{page_id}/tags/tag", "tags" => tags
-  end
-  alias :tp :tag_page
-
-
-  # Pages ----
-
-  def list_pages
-    request "pages/all"
-  end
-  alias :lp :list_pages
-
-  def create_page(title, body)
-    request "pages/new", "page" => { "title" => title, "description" => body }
-  end
-  alias :cp :create_page
-
-  def show_page(page_id = current_page_id)
-    request "page/#{page_id}"
-  end
-  alias :sp :show_page
-
-  def destroy_page(page_id = current_page_id)
-    request "page/#{page_id}/destroy"
-  end
-  alias :dp :destroy_page
-
-  def update_title(title, page_id = current_page_id)
-    request "page/#{page_id}/update_title", "page" => { "title" => title }
-  end
-  alias :ut :update_title
-
-  def update_body(body, page_id = current_page_id)
-    request "page/#{page_id}/update_body", "page" => { "description" => body }
-  end
-  alias :ub :update_body
-
-  def link_page(linked_page_id, page_id = current_page_id)
-    request "page/#{page_id}/link", "linked_page_id" => linked_page_id
-  end
-  alias :lip :link_page
-
-  def unlink_page(linked_page_id, page_id = current_page_id)
-    request "page/#{page_id}/unlink", "linked_page_id" => linked_page_id
-  end
-  alias :ulip :unlink_page
-
-  def share_page(email_addresses, public_page = nil, page_id = current_page_id)
-    parameters = { "email_addresses" => email_addresses }
-    parameters = parameters.merge({ "page" => { "public" => public_page ? "1" : "0" }}) unless public_page.nil?
-    request "page/#{page_id}/share", parameters
-  end
-
-
-  # Reminders ---
-
-  def list_reminders
-    request "reminders"
-  end
-  alias :lr :list_reminders
-
-  def create_reminder(content, remind_at = "")
-    request "reminders/create", "reminder" => { "content" => content, "remind_at" => remind_at }
-  end
-  alias :cr :create_reminder
-
-  def update_reminder(reminder_id, content, remind_at)
-    request "reminders/update/#{reminder_id}", "reminder" => { "content" => content, "remind_at" => remind_at }
-  end
-  alias :ur :update_reminder
-
-  def destroy_reminder(reminder_id)
-    request "reminders/destroy/#{reminder_id}"
-  end
-  alias :dr :destroy_reminder
-end

data/lib/bare_migration.rb

@@ -1,145 +0,0 @@
-# bare_migration.rb
-# Scott Bronson
-# 26 Jan 2006
-#
-# This module provides bare ActiveRecord::Base objects for migration
-# scripts.
-#
-# Most migration scripts use model classes to move data.  This is
-# fine when the schema you're migrating from is compatible with your
-# current models.  It's disastrous when your models have changed
-# significantly.
-#
-# This class allows you to use bare ActiveRecord classes in your migrate
-# scripts instead of your models so there is no chance of compatibility
-# problems.
-#
-# TODO: Make associations work (has_a, etc.) without requiring legacy calls
-# TODO: If a class already exists when defining it then Ruby just adds to
-#       the existing class.  This is why migration objects need to be
-#       named "BareArticle12" instead of just "BareArticle".  This stinks
-#       and should be fixed.  It won't be an easy fix though.
-# TODO: I know that STI (inheritance) won't work, but it should be
-#       simple enough to change instantiate_without_callbacks to make
-#       it work.
-# TODO: Create a test framework.
-
-
-# To use:
-#
-# - Create bare inner classes instead of models in your migration script.
-#   For instance, this would declare a bare object that matches an Article
-#   model:
-#
-#   class Migration < ActiveRecord::Migration
-#     class BareArticle
-#       include BareMigration
-#     end
-#     ...
-#   end
-#
-#   Don't forget to nest the declaration of the bare model in order to ensure
-#   that the class name is unique. Another option is to declare it outside
-#   the scope of the migration with a number based on the migration
-#   number, say Bare3Article
-#
-#   Use set_table_name if the object doesn't calculate its table name
-#   properly.
-#
-# - Then, use the bare objects to migrate the data:
-#
-#   BareArticle.find(:all).each do |a|
-#     a.published = 1
-#   end
-#
-# - Now your Article module can change all it wants and your migration
-#   script will still work.
-
-
-module BareMigration
-  def self.append_features(base)
-    base.extend(ClassMethods)
-
-    # Set the table name by eradicating "Bare" from the calculated table name.
-    # You can still use set_table_name if this is wrong.
-    base.set_table_name(base.table_name.sub(/.*?bare\d*_?/, ''))
-
-    # Default to ignoring the inheritance column
-    base.inheritance_column = :ignore_inheritance_column
-  end
-
-  module ClassMethods
-    # The problem with STI is that it causes AR to instantiate and
-    # return classes DIFFERENT from the class that called find()
-    # (classes that come from your app/models dir, a no-no when
-    # migrating).  For now, this routine overrides that behavior
-    # so that you will ONLY get the same class as the one that called
-    # find.  (todo: make STI work again)
-    def instantiate_without_callbacks(record)
-      object = allocate
-      object.instance_variable_set("@attributes", record)
-      object
-    end
-
-    def find_and_update(find_type=:all, *rest, &update_block)
-      self.transaction do
-        self.find(find_type, *rest).each do |item|
-          update_block[item]
-          item.save!
-        end
-      end
-    end
-  end
-end
-
-class ActiveRecord::Migration
-  def self.opposite_of(method)
-    method = method.to_s
-    method.sub!(/^add_/, 'remove_') || method.sub!(/^remove_/, 'add_') ||
-      method.sub!(/^create/, 'drop') || method.sub!(/^drop/, 'create') ||
-        method.sub!(/^rename_column/, 'reverse_columns')
-  end
-
-  def self.modify_schema(method, *args)
-    case method.to_s
-    when 'create_table'
-      block = args.last.is_a?(Proc) ? args.pop : Proc.new {|t| nil}
-      create_table *args, &block
-    when 'remove_column'
-      remove_column args[0], args[1]
-    when 'reverse_columns'
-      (table, to_col, from_col) = args
-      rename_column table, from_col, to_col
-    else
-      send(method, *args)
-    end
-  end
-
-  def self.modify_tables_and_update(*colspecs, &block)
-    unless colspecs.first.is_a?(Array)
-      colspecs = [colspecs]
-    end
-    begin
-      updated_classes = []
-      colspecs.each do |spec|
-        if spec[1].is_a?(Class)
-          updated_classes << spec[1]
-          spec[1] = spec[1].table_name.to_sym
-        end
-      end
-      colspecs.each {|spec| modify_schema(*spec) }
-      updated_classes.uniq!
-      if updated_classes.size == 1 && block && block.arity == 1
-        say "About to call find_and_update"
-        updated_classes.first.find_and_update(:all, &block)
-      else
-        block.call if block
-      end
-    rescue Exception => e
-      colspecs.reverse.each do |(method, table, column, *rest)|
-        modify_schema(opposite_of(method), table, column, *rest) rescue nil
-      end
-      raise e
-    end
-  end
-end

data/lib/email_notify.rb

@@ -1,32 +0,0 @@
-class EmailNotify
-  def self.logger
-    @@logger ||= RAILS_DEFAULT_LOGGER || Logger.new(STDOUT)
-  end
-
-  def self.send_comment(comment, user)
-    return if user.email.blank?
-
-    begin
-      email = NotificationMailer.create_comment(comment, user)
-      EmailNotify.send_message(user,email)
-    rescue => err
-      logger.error "Unable to send comment email: #{err.inspect}"
-    end
-  end
-
-  def self.send_article(article, user)
-    return if user.email.blank?
-
-    begin
-      email = NotificationMailer.create_article(article, user)
-      EmailNotify.send_message(user,email)
-    rescue => err
-      logger.error "Unable to send article email: #{err.inspect}"
-    end
-  end
-
-  def self.send_message(user, email)
-    email.content_type = "text/html; charset=utf-8"
-    NotificationMailer.deliver(email)
-  end
-end

data/lib/filemanager.rb

@@ -1,53 +0,0 @@
-=begin
-  filemanager.rb
-  Copyright (C) 2008  Leon Li
-
-  You may redistribute it and/or modify it under the same
-  license terms as Ruby.
-=end
-require 'uri'
-require 'fileutils'
-FM_ID = 'filemanager'
-FM_ROOT = File.join(RAILS_ROOT, 'vendor', 'plugins', FM_ID)
-FM_PATH_PUBLIC = File.join(FM_ROOT, 'public')
-
-=begin
-if $FM_OVERWRITE || ! File.exist?(FM_ROOT)
-fm_rails_path = File.dirname(File.dirname(__FILE__)) + "/#{FM_ID}"
-FileUtils.cp_r(fm_rails_path, File.join(RAILS_ROOT, 'vendor', 'plugins'))
-FileUtils.cp_r(FM_PATH_PUBLIC, RAILS_ROOT)
-FileUtils.rm_rf(FM_PATH_PUBLIC)
-end
-=end
-
-FM_CONFIG_FILE = File.join(RAILS_ROOT, 'config', 'filemanager.yml')
-unless File.exist?(FM_CONFIG_FILE)
-  FileUtils.cp(File.join(FM_ROOT, 'filemanager.yml'))
-end
-require "erb"
-require "yaml"
-$FM_PROPERTIES = YAML::load(ERB.new(IO.read(FM_CONFIG_FILE)).result)
-
-FM_IMAGE_TYPES   = $FM_PROPERTIES['image.type'].split(' ') 
-FM_FLASH_TYPES   = $FM_PROPERTIES['flash.type'].split(' ')
-FM_MOVIE_TYPES   = $FM_PROPERTIES['movie.type'].split(' ')
-FM_RM_TYPES      = $FM_PROPERTIES['rm.type'].split(' ')
-FM_OFFICE_TYPES  = $FM_PROPERTIES['office.type'].split(' ')
-FM_EXCEL_TYPES   = $FM_PROPERTIES['excel.type'].split(' ')
-FM_WORD_TYPES    = $FM_PROPERTIES['word.type'].split(' ')
-FM_PPT_TYPES     = $FM_PROPERTIES['ppt.type'].split(' ')
-FM_HELP_TYPES    = $FM_PROPERTIES['help.type'].split(' ')
-FM_PLAIN_TYPES  = $FM_PROPERTIES['plain.type'].split(' ')
-FM_NONE_TYPES    = $FM_PROPERTIES['none.type'].split(' ')
-FM_SUPPORT_TYPES = FM_IMAGE_TYPES + FM_FLASH_TYPES + FM_MOVIE_TYPES + FM_RM_TYPES + FM_OFFICE_TYPES + FM_HELP_TYPES + FM_PLAIN_TYPES
-FM_UNKNOWN_TYPE = 'unknown'
-
-FM_RESOURCES_PATH= $FM_PROPERTIES['resources.path']
-FM_LOCK_PATH     = $FM_PROPERTIES['resources.url']
-FM_ENCODING_TO   = $FM_PROPERTIES['encoding.to']
-FM_ENCODING_FROM = $FM_PROPERTIES['encoding.from'].nil? ? '' : $FM_PROPERTIES['encoding.from']
-
-FM_TEMP_DIR      = $FM_PROPERTIES['temp.dir'].nil? ? File.join(FM_ROOT, 'temp') : $FM_PROPERTIES['temp.dir']
-
-FileUtils.rm_rf(Dir.glob("#{FM_TEMP_DIR}/*"))
-

data/lib/filemanager/controller.rb

@@ -1,217 +0,0 @@
-=begin
-  controller.rb
-  Copyright (C) 2008  Leon Li
-
-  You may redistribute it and/or modify it under the same
-  license terms as Ruby.
-=end
-module Filemanager
-  module Controller
-		def set_up
-	    @lock_path = FM_LOCK_PATH
-	    @source = params[:source]
-	    @source = decode(@source) unless @source.nil?
-	    @path = (params[:path].nil? || ! params[:path].index('..').nil?) ? '' : params[:path]
-	    @path = '' if @path == '/'
-	    @path = decode(@path)
-	    @resource_path = FM_RESOURCES_PATH
-	    @current_path = @resource_path + @path
-	    @current_file = (File.directory?(@current_path) ? Dir.new(@current_path) : File.new(@current_path))
-	    @parent_path = (!@path.blank? && !@path.rindex('/').nil?) ? (@path.rindex('/') == 0 ? '/' : @path[0..(@path.rindex('/')-1)]) : nil
-	    @path_suffix = @path.index('.').nil? || @path[-1] == '.' ? '' : @path[@path.index('.')+1..-1].downcase
-	    if File.directory?(@current_path)
-	      @all_files = Dir.entries(@current_path)
-	      @directories = @all_files.map{|f| File.directory?(@current_path + File::SEPARATOR + f) ? f : nil}.compact
-	      @files = @all_files.map{|f| File.directory?(@current_path + File::SEPARATOR + f) ? nil : f}.compact
-	      @file_total_size = @files.inject(0){|size, f| size + File.size(@current_path + File::SEPARATOR + f)}
-	    end
-	  end
-	  
-	  def tear_off
-	    @current_file.close unless @current_file.nil?
-	  end
-	  
-	  def index
-	    
-	  end
-	  
-	  def view
-	    #    respond_to do |wants|
-	    #      wants.js {  render :text => File.size(@current_path) > 1000000 ? 'File too big' : File.read(@current_path) }
-	    #    end
-	  end
-	  
-	  def file_content
-	      File.size(@current_path) > 1000000 ? 'File too big' : File.read(@current_path)
-	  end
-	  
-	#  def office
-	#    render :action=>'excel' if is_excel?
-	#    render :action=>'word' if is_word?
-	#    render :action=>'ppt' if is_ppt?
-	#    render :action=>'help' if is_help?
-	#  end
-	  
-	  def rename
-	    old_name = @current_path + File::SEPARATOR + decode(params[:old_name])
-	    new_name = @current_path + File::SEPARATOR + decode(params[:new_name])
-	    File.rename(old_name, new_name)
-	    success
-	  end
-	  
-	  def remove
-	    FileUtils.rm_rf(@source.map{|s| @current_path + File::SEPARATOR + s})
-	    success
-	  end
-	  
-	  def new_file
-	    File.new(@current_path + File::SEPARATOR + decode(params[:new_name]), 'w')
-	    success
-	  end
-	  
-	  def new_folder
-	    Dir.mkdir(@current_path + File::SEPARATOR + decode(params[:new_name]))
-	    success
-	  end
-	  
-	  def copy
-	    session[:source] = @source.map{|s| @current_path + File::SEPARATOR + s}
-	    session[:remove] = false
-	    success
-	  end
-	  
-	  def cut
-	    session[:source] = @source.map{|s| @current_path + File::SEPARATOR + s}
-	    session[:remove] = true
-	    success
-	  end
-	  
-	  def paste
-	    return error if session[:remove].nil? || session[:source].nil?
-	    begin
-	      session[:remove] == true ? FileUtils.mv(session[:source], @current_path) : FileUtils.cp_r(session[:source], @current_path)
-	      session[:remove] = nil
-	      session[:source] = nil
-	      success
-	    rescue => exception
-	      result(exception)
-	    end
-	    
-	  end
-	  
-	  def download
-	    now = Time.new
-	    now = "#{now.to_i}#{now.usec}"
-	    temp_file = FM_TEMP_DIR + File::SEPARATOR + now + '.zip'
-	    FileUtils.cd(@current_path) do |dir|
-	      system "zip -r #{temp_file} #{@source.map{|s| '"' + s + '"'}.join(' ')}"
-	    end
-	    send_file(temp_file)
-	  end
-	  
-	  
-	  def upload
-	    file = params[:upload]
-	    filename = decode(file.original_filename)
-	    File.open(@current_path + File::SEPARATOR + filename, "wb") do |f|   
-	      f.write(file.read)  
-	    end
-	    to_index
-	  end
-	  
-	  
-	  
-	  #TODO
-	  def adjust_size
-	    
-	  end
-	  
-	  #TODO
-	  def rotate
-	    
-	  end
-	  
-	  #TODO
-	  def unzip
-	    filename = decode(params[:old_name])
-	    FileUtils.cd(@current_path) do |dir|
-	      system "unzip -o #{filename}"
-	    end
-	    to_index
-	  end
-	  
-	  def to_index
-	    redirect_to :action => 'index', :path => encode(@path)
-	  end
-	  
-	  def success
-	    result("SUCCESS")
-	  end
-	  
-	  def error()
-	    result("ERROR")
-	  end
-	  
-	  def result(message)
-	    respond_to do |wants|
-	      wants.js { render :text => message }
-	    end
-	  end
-	  
-	  #methods for view
-	  def method_missing(method_id, *args)
-	    method_id_s = method_id.to_s
-	    if method_id_s[0, 3] == 'is_' && method_id_s[-1, 1] == '?'
-	      instance_eval %{
-	                        def #{method_id}(*args)
-	                          FM_#{method_id_s[3..-2].upcase}_TYPES.include?(@path_suffix)
-	                        end
-	                      }
-	      send(method_id, *args)
-	    else
-	      super
-	    end
-	  end
-	  
-	  def transfer(from, to, target)
-	    if FM_ENCODING_TO.nil?
-	      target
-	    else
-	      if target.is_a?(Array)
-	        target.map{|i| to.nil? ? i : Iconv.conv(to, from, i)}
-	      else
-	        Iconv.conv(to, from, target)
-	      end
-	    end
-	  end
-	  
-	  def encode(target)
-	    transfer(FM_ENCODING_FROM, FM_ENCODING_TO, target);
-	  end
-	  
-	  def decode(target)
-	    transfer(FM_ENCODING_TO, FM_ENCODING_FROM, target);
-	  end
-	  
-    def hsize(size)
-      size = size/1024
-      if size > 1024
-        size = size/1024
-        size = format('%0.2f',(size)) + ' mb'
-      else
-        size = format('%0.2f', size) + ' kb'
-      end
-    end
-    
-    def get_file_type(file)
-      type = File.extname(file)
-      
-      unless type.blank?
-        type = type.downcase[1..-1]
-        return type if FM_SUPPORT_TYPES.include?(type)
-      end
-      FM_UNKNOWN_TYPE
-    end
-
-  end
-end