mdarby-scribd_fu 1.2.3.2 → 2.0

data/init.rb

@@ -1 +1 @@
-require File.dirname(__FILE__) + "/rails/init"
+require File.join(File.dirname(__FILE__), "lib", "scribd_fu")

data/lib/scribd_fu.rb

@@ -1,108 +1,250 @@
-require 'attachment_fu/methods'
-require 'paperclip/methods'
-
 module ScribdFu
-  # A list of content types supported by scribd.
-  CONTENT_TYPES = ['application/pdf', 'image/jpeg', 'image/pjpeg',
-                   'image/gif', 'image/png', 'image/x-png', 'image/jpg',
-                   'application/msword', 'application/mspowerpoint',
-                   'application/vnd.ms-powerpoint', 'application/excel',
-                   'application/vnd.ms-excel', 'application/postscript',
-                   'text/plain', 'application/rtf',
-                   'application/vnd.oasis.opendocument.text',
-                   'application/vnd.oasis.opendocument.presentation',
-                   'application/vnd.oasis.opendocument.spreadsheet',
-                   'application/vnd.sun.xml.writer',
-                   'application/vnd.sun.xml.impress',
-                   'application/vnd.sun.xml.calc',
-    # OOXML, AKA `the MIME types from hell'. Seriously, these are long enough to
-    # start their own dictionary...
+
+  ConfigPath = "#{RAILS_ROOT}/config/scribd_fu.yml".freeze
+
+  # A list of content types supported by iPaper.
+  ContentTypes = [
+    'application/pdf',
+    'application/msword',
+    'application/mspowerpoint',
+    'application/vnd.ms-powerpoint',
+    'application/excel',
+    'application/vnd.ms-excel',
+    'application/postscript',
+    'text/plain',
+    'application/rtf',
+    'application/vnd.oasis.opendocument.text',
+    'application/vnd.oasis.opendocument.presentation',
+    'application/vnd.oasis.opendocument.spreadsheet',
+    'application/vnd.sun.xml.writer',
+    'application/vnd.sun.xml.impress',
+    'application/vnd.sun.xml.calc',
     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
     'application/vnd.openxmlformats-officedocument.spreadsheetml.template',
     'application/vnd.openxmlformats-officedocument.presentationml.presentation',
     'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
     'application/vnd.openxmlformats-officedocument.presentationml.template',
     'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    'application/vnd.openxmlformats-officedocument.wordprocessingml.template']
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.template'
+  ]
+
+  # Available parameters for the JS API
+  # http://www.scribd.com/publisher/api/api?method_name=Javascript+API
+  Available_JS_Params = [ :height, :width, :page, :my_user_id, :search_query,
+                          :jsapi_version, :disable_related_docs, :mode, :auto_size ]
 
-  def self.included(base)
-    base.extend ActsAsScribdDocument
+  class ScribdFuError < StandardError #:nodoc:
   end
 
-  module ActsAsScribdDocument
-    # Synonym for <tt>has_scribdable_attachment(nil)</tt>.
-    def acts_as_scribd_document
-      has_scribdable_attachment
+  class ScribdFuUploadError < ScribdFuError #:nodoc:
+  end
+
+
+  class << self
+
+    def included(base) #:nodoc:
+      base.extend ClassMethods
     end
 
-    # Marks the given +attribute+ as a scribdable document file. If +attribute+
-    # is nil, assumes this is an Attachment_fu model and deals with the setup
-    # accordingly; otherwise, assumes a +paperclip+ model and sets up scribding
-    # related to the particular given attribute.
-    def has_scribdable_attachment(attribute = nil)
-      class_eval do
-        include ScribdFu::InstanceMethods
+    # Login, store, and return a handle to the Scribd user account
+    def scribd_user
+      begin
+        # Ensure we can login to Scribd, and get a handle on the account
+        Scribd::API.instance.key    = config[:key]
+        Scribd::API.instance.secret = config[:secret]
+        @scribd_user = Scribd::User.login(config[:user], config[:password])
+      rescue
+        raise ScribdFuError, "Your Scribd credentials are incorrect"
+      end
+    end
 
-        if attribute.nil?
-          include ScribdFu::AttachmentFu::InstanceMethods
-        else
-          include ScribdFu::Paperclip::InstanceMethods # ignored if already done
+    # Upload a file to Scribd
+    def upload(obj, file_path)
+      begin
+        res = scribd_user.upload(:file => "#{file_path}", :access => access_level)
+        obj.update_attributes({:ipaper_id => res.doc_id, :ipaper_access_key => res.access_key})
+      rescue
+        raise ScribdFuUploadError, "Sorry, but #{obj.class} ##{obj.id} could not be uploaded to Scribd"
+      end
+    end
 
-          add_scribd_attribute attribute # class method added by above include
-        end
+    # Delete an iPaper document
+    def destroy(document)
+      document.destroy
+    end
+
+    # Read, store, and return the ScribdFu config file's contents
+    def config
+      raise ScribdFuError, "#{ConfigPath} does not exist" unless File.file?(ConfigPath)
+
+      # Load the config file and strip any whitespace from the values
+      @config ||= YAML.load_file(ConfigPath).each_pair{|k,v| {k=>v.to_s.strip}}.symbolize_keys!
+    end
+
+    # Get the preferred access level for iPaper documents
+    def access_level
+      config[:access] || 'private'
+    end
+
+    # Load, store, and return the associated iPaper document
+    def load_ipaper_document(id)
+      begin
+        @document ||= scribd_user.find_document(id)
+      rescue
+        raise ScribdFuError, "Scribd Document ##{id} not found!"
       end
     end
+
   end
 
-  module InstanceMethods
-    # Sets up Scribd configuration info when this module is included.
-    def self.included(base)
-      base.extend ClassMethods
+  module ClassMethods
 
-      mattr_reader :scribd_config, :scribd_login
+    # Load and inject ScribdFu goodies
+    def has_ipaper_and_uses(str)
+      check_environment
+      load_base_plugin(str)
 
-      begin
-        require 'rscribd'
-      rescue LoadError
-        raise RequiredLibraryNotFoundError.new('rscribd could not be loaded')
+      include InstanceMethods
+
+      after_save :upload_to_scribd # This *MUST* be an after_save
+      before_destroy :destroy_ipaper_document
+    end
+
+    private
+
+      # Configure ScribdFu for this particular environment
+      def check_environment
+        load_rscribd
+        check_config
+        check_fields
       end
 
-      begin
-        unless @@scribd_login
-          @@scribd_config = YAML.load_file("#{RAILS_ROOT}/config/scribd.yml").symbolize_keys
-          @@scribd_config = @@scribd_config[:scribd]
+      def check_config
+        ScribdFu::config
+      end
 
-          # Ensure we can connect to the Service
-          Scribd::API.instance.key    = @@scribd_config['key'].to_s.strip
-          Scribd::API.instance.secret = @@scribd_config['secret'].to_s.strip
+      # Load the rscribd gem
+      def load_rscribd
+        begin
+          require 'rscribd'
+        rescue LoadError
+          raise ScribdFuError, 'Please install the rscribd gem'
+        end
+      end
 
-          @@scribd_login = Scribd::User.login @@scribd_config['user'].to_s.strip, @@scribd_config['password'].to_s.strip
+      # Load Attachment_Fu specific methods and files
+      def load_attachment_fu
+        require 'scribd_fu/attachment_fu'
+        include ScribdFu::AttachmentFu::InstanceMethods
+      end
+
+      # Load Paperclip specific methods and files
+      def load_paperclip
+        require 'scribd_fu/paperclip'
+        include ScribdFu::Paperclip::InstanceMethods
+      end
+
+      # Ensure ScribdFu-centric attributes exist
+      def check_fields
+        fields = %w{ipaper_id ipaper_access_key}.inject([]){|stack, f| stack << "#{name}##{f}" unless column_names.include?(f); stack}
+        raise ScribdFuError, "These fields are missing: #{fields.to_sentence}" if fields.size > 0
+      end
+
+      # Load either AttachmentFu or Paperclip-specific methods
+      def load_base_plugin(str)
+        if str == 'AttachmentFu'
+          load_attachment_fu
+        elsif str == 'Paperclip'
+          load_paperclip
+        else
+          raise ScribdFuError, "Sorry, only Attachment_fu and Paperclip are supported."
         end
-      rescue
-        raise "config/scribd.yml file not found, or your credentials are incorrect."
       end
+
+  end
+
+  module InstanceMethods
+
+    def self.included(base)
+      base.extend ClassMethods
     end
 
-    def access_level
-      if self.respond_to?(:is_public) && self.is_public != nil
-        scribd_access = self.is_public ? 'public' : 'private'
-      else
-        scribd_access = scribd_config['access']
-      end
+    # Upload the associated file to Scribd for iPaper conversion
+    # This is called +after_save+ and cannot be called earlier,
+    # so don't get any ideas.
+    def upload_to_scribd
+      ScribdFu::upload(self, file_path) if scribdable?
+    end
 
-      scribd_access
+    # Checks whether the associated file is convertable to iPaper
+    def scribdable?
+      ContentTypes.include?(get_content_type) && ipaper_id.blank?
     end
-  end
 
-  module ClassMethods
-    # Sets up the scribd_options accessor, a before_destroy hook to ensure the
-    # deletion of associated Scribd documents, and an after_save hook to upload
-    # to scribd.
-    def self.extended(base)
-      base.class_inheritable_accessor :scribd_options
+    # Responds true if the conversion is converting
+    def conversion_processing?
+      !(conversion_complete? || conversion_successful? || conversion_error?)
+    end
 
-      base.before_destroy    :destroy_scribd_documents
-      base.before_validation :upload_to_scribd
+    # Responds true if the conversion is complete -- note that this gives no
+    # indication as to whether the conversion had an error or was succesful,
+    # just that the conversion completed.
+    def conversion_complete?
+      ipaper_document && ipaper_document.conversion_status != 'PROCESSING'
     end
+
+    # Responds true if the document has been converted.
+    def conversion_successful?
+      ipaper_document && ipaper_document.conversion_status =~ /^DISPLAYABLE|DONE$/
+    end
+
+    # Responds true if there was a conversion error while converting to iPaper.
+    def conversion_error?
+      ipaper_document && ipaper_document.conversion_status == 'ERROR'
+    end
+
+    # Responds the Scribd::Document associated with this model, or nil if it does not exist.
+    def ipaper_document
+      @document ||= ScribdFu::load_ipaper_document(ipaper_id)
+    end
+
+    # Destroys the scribd document for this record. This is called +before_destroy+
+    def destroy_ipaper_document
+      ScribdFu::destroy(ipaper_document) if ipaper_document
+    end
+
+    # Display the iPaper document in a view
+    def display_ipaper(options = {})
+      alt = options.has_key?(:alt) ? options[:alt] : ""
+
+      <<-END
+        <script type="text/javascript" src="http://www.scribd.com/javascripts/view.js"></script>
+        <div id="embedded_flash">#{alt}</div>
+        <script type="text/javascript">
+          var scribd_doc = scribd.Document.getDoc(#{ipaper_id}, '#{ipaper_access_key}');
+          #{js_params(options)}
+          scribd_doc.write("embedded_flash");
+        </script>
+      END
+    end
+
+
+    private
+
+      # Check and collect any Javascript params that might have been passed in
+      def js_params(options)
+        opt = []
+
+        options.each_pair do |k, v|
+          opt << "scribd_doc.addParam('#{k}', '#{v}');" if Available_JS_Params.include?(k)
+        end
+
+        opt.compact.join("\n")
+      end
+
   end
+
 end
+
+# Let's do this.
+ActiveRecord::Base.send(:include, ScribdFu) if Object.const_defined?("ActiveRecord")

data/scribd_fu.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "scribd_fu"
-  s.version  = "1.2.3.2"
-  s.date     = "2009-03-18"
+  s.version  = "2.0"
+  s.date     = "2009-03-29"
   s.summary  = "Quick and easy interactions with Scribd's iPaper service"
   s.email    = "matt@matt-darby.com"
   s.homepage = "http://github.com/mdarby/scribd_fu/tree/master"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mdarby-scribd_fu
 version: !ruby/object:Gem::Version 
-  version: 1.2.3.2
+  version: "2.0"
 platform: ruby
 authors: 
 - Matt Darby
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-18 00:00:00 -07:00
+date: 2009-03-29 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 

data/README

@@ -1 +0,0 @@
-README.textile

data/Rakefile

@@ -1,22 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the Scribd_fu plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-desc 'Generate documentation for the Scribd_fu plugin.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Scribd_fu'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/generators/scribd_config/scribd_config_generator.rb

@@ -1,7 +0,0 @@
-class ScribdConfigGenerator < Rails::Generator::Base
-  def manifest
-    record do |m|
-      m.file 'scribd.yml', 'config/scribd.yml', :collision => :skip
-    end
-  end
-end

data/generators/scribd_config/templates/scribd.yml

@@ -1,9 +0,0 @@
-#Scribd Account Info
-
-scribd:
- key: 
- secret: 
- user: 
- password: 
- access:
-#storage: s3 # Uncomment if Attachment_fu is using Amazon S3 for storage

data/install.rb

@@ -1 +0,0 @@
-# Install hook code here

data/lib/attachment_fu/methods.rb

@@ -1,163 +0,0 @@
-require 'ftools'
-
-module ScribdFu
-  module AttachmentFu
-    module ClassMethods
-      # Adds validations to the current model to check that its attachment is
-      # scribdable.
-      def validates_as_scribd_document
-        validates_presence_of :scribd_id, :scribd_access_key, :content_type
-        validate :scribdable?
-      end
-    end
-
-    module InstanceMethods
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      # Checks whether the attachment is scribdable. This boils down to a check
-      # to ensure that the contents of the attachment are of a content type that
-      # scribd can understand.
-      def scribdable?
-        ScribdFu::CONTENT_TYPES.include?(content_type)
-      end
-
-      def scribd_id=(id)
-        write_attribute :scribd_id, id.to_s.strip
-      end
-
-      def scribd_access_key=(key)
-        write_attribute :scribd_access_key, key.to_s.strip
-      end
-
-      # Destroys the scribd document for this record. This is called
-      # +before_destroy+, as set up by ScribdFu::ClassMethods#extended.
-      #
-      # Also available as destroy_scribd_document, which makes more sense in
-      # terms of pluralization for external calls.
-      def destroy_scribd_documents
-        unless scribd_document.nil?
-          if scribd_document.destroy
-            logger.info "[Scribd_fu] #{Time.now.rfc2822}: Removing Object #{id} successful"
-          else
-            logger.info "[Scribd_fu] #{Time.now.rfc2822}: Removing Object #{id} failed!"
-          end
-        end
-      end
-      alias_method :destroy_scribd_document, :destroy_scribd_documents
-
-      # Uploads the attachment to scribd for processing.. This is called
-      # +before_validation+, as set up by ScribdFu::ClassMethods#extended.
-      def upload_to_scribd
-        if scribdable? and self.scribd_id.blank?
-          with_file_path do |file_path|
-            if resource = scribd_login.upload(:file => "#{file_path}",
-                                              :access => access_level)
-              logger.info "[Scribd_fu] #{Time.now.rfc2822}: Object #{id} successfully uploaded for conversion to iPaper."
-
-              self.scribd_id         = resource.doc_id
-              self.scribd_access_key = resource.access_key
-
-              save
-            else
-              logger.info "[Scribd_fu] #{Time.now.rfc2822}: Object #{id} upload failed!"
-            end
-          end
-        end
-      end
-
-      # Returns a URL for a thumbnail for this model's attachment.
-      #
-      # If Scribd does not provide a thumbnail URL, then Attachment_fu's
-      # thumbnail is fallen back on by returning the value of
-      # <tt>public_filename(:thumb)</tt>.
-      #
-      # Sample use in a view:
-      #  <%= image_tag(@attachment .thumbnail_url, :alt => @attachment.name) %>
-      def thumbnail_url
-        (scribd_document && scribd_document.thumbnail_url) or
-          public_filename(:thumb)
-      end
-
-      # Returns the actual image data of a thumbnail for this model's
-      # attachment.
-      #
-      # If Scribd does not have a thumbnail for this file, then Attachment_fu's
-      # thumbnanil is fallen back on by returning the file at
-      # <tt>full_filename(:thumb)</tt>.
-      #
-      # Sample use in a controller:
-      #  render :inline => @attachment.thumbnail_file,
-      #         :content_type => 'image/jpeg'
-      def thumbnail_file
-        path = (scribd_document && scribd_document.thumbnail_url) ||
-                  full_filename(:thumb)
-
-        open(path).read
-      rescue Errno::ENOENT
-        nil
-      end
-
-      # Yields the correct path to the file, either the local filename or the
-      # S3 URL.
-      #
-      # This method creates a temporary file of the correct filename if
-      # necessary, so as to be able to give scribd the right filename. The file
-      # is destroyed when the passed block ends.
-      def with_file_path(&block) # :yields: full_file_path
-        # TODO We can probably do this using respond_to?
-        if scribd_config['storage'].eql?('s3')
-           yield s3_url
-        elsif save_attachment? # file hasn't been saved, use the temp file
-          temp_rename = File.join(Dir.tmpdir, filename)
-          File.copy(temp_path, temp_rename)
-
-          yield temp_rename
-        else
-          yield full_filename
-        end
-      ensure
-        temp_rename && File.unlink(temp_rename) # always delete this
-      end
-
-      # Responds true if the conversion is complete -- note that this gives no
-      # indication as to whether the conversion had an error or was succesful,
-      # just that the conversion completed.
-      #
-      # Note that this method still returns false if the model does not refer to a
-      # valid document.  scribd_attributes_valid? should be used to determine the
-      # validity of the document.
-      def conversion_complete?
-        scribd_document && scribd_document.conversion_status != 'PROCESSING'
-      end
-
-      # Responds true if the document has been converted.
-      #
-      # Note that this method still returns false if the model does not refer to a
-      # valid document.  scribd_attributes_valid? should be used to determine the
-      # validity of the document.
-      def conversion_successful?
-        scribd_document && scribd_document.conversion_status =~ /^DISPLAYABLE|DONE$/
-      end
-
-      # Responds true if there was a conversion error while converting
-      # to iPaper.
-      #
-      # Note that this method still returns false if the model does not refer to a
-      # valid document.  scribd_attributes_valid? should be used to determine the
-      # validity of the document.
-      def conversion_error?
-        scribd_document && scribd_document.conversion_status == 'ERROR'
-      end
-
-      # Responds the Scribd::Document associated with this model, or nil if it
-      # does not exist.
-      def scribd_document
-        @scribd_document ||= scribd_login.find_document(scribd_id)
-      rescue Scribd::ResponseError # at minimum, the document was not found
-        nil
-      end
-    end
-  end
-end

data/lib/paperclip/methods.rb

@@ -1,231 +0,0 @@
-require 'ftools'
-
-module ScribdFu
-  module Paperclip
-    module ClassMethods
-      # Adds validations to the current model to check that the attachment at
-      # +attribute+ is scribdable. If +attribute+ is nil, then all attachments
-      # that have been marked as scribdable are validated.
-      #
-      # Note that all calls to has_scribdable_attachment should be made before
-      # calling validates_attachment_scribdability with a nil parameter;
-      # otherwise, only those that have been created already will be validated.
-      def validates_attachment_scribdability(attribute = nil)
-        attributes = attribute.nil? ? scribd_attributes : [attribute]
-
-        attributes.each do |attribute|
-          validates_presence_of "#{attribute}_scribd_id",
-                                "#{attribute}_scribd_access_key",
-                                "#{attribute}_content_type"
-          validates_attachment_content_type attribute,
-            :content_type => ScribdFu::CONTENT_TYPES
-        end
-      end
-
-      # Adds the given +attribute+ to the list of attributes that are uploaded
-      # to scribd.
-      #
-      # Note that a scribd attribute should not be added if it is not a
-      # Paperclip attachment attribute.
-      def add_scribd_attribute(attribute)
-        write_inheritable_attribute :scribd_attributes, [] if scribd_attributes.nil?
-
-        scribd_attributes << attribute
-
-        setup_scribd_attribute(attribute)
-      end
-
-      def scribd_attributes
-        read_inheritable_attribute :scribd_attributes
-      end
-
-      private
-        # Sets up methods needed for the given +attribute+ to be scribdable.
-        def setup_scribd_attribute(attribute)
-          define_method("#{attribute}_scribd_id=") do |id|
-            write_attribute "#{attribute}_scribd_id", id.to_s.strip
-          end
-
-          define_method("#{attribute}_scribd_access_key=") do |key|
-            write_attribute "#{attribute}_scribd_access_key", key.to_s.strip
-          end
-        end
-    end
-
-    module InstanceMethods
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      # Checks whether the given attribute is scribdable. This boils down to a
-      # check to ensure that the contents of the attribute are of a content type
-      # that scribd can understand.
-      def scribdable?(attribute)
-        ScribdFu::CONTENT_TYPES.include?(self["#{attribute}_content_type"])
-      end
-
-      # Destroys all scribd documents for this record. This is called
-      # +before_destroy+, as set up by ScribdFu::ClassMethods#extended.
-      def destroy_scribd_documents
-        self.class.scribd_attributes.each do |attribute|
-          document = scribd_document_for(self["#{attribute}_scribd_id"])
-
-          unless document.nil?
-            if document.destroy
-              logger.info "[Scribd_fu] #{Time.now.rfc2822}: Removing Object #{id}##{attribute} successful"
-            else
-              logger.info "[Scribd_fu] #{Time.now.rfc2822}: Removing Object #{id}##{attribute} failed!"
-            end
-          end
-        end
-      end
-
-      # Uploads all scribdable attributes to scribd for processing. This is
-      # called +before_validation+, as set up by
-      # ScribdFu::ClassMethods#extended.
-      def upload_to_scribd
-        self.class.scribd_attributes.each do |attribute|
-          scribd_id = self["#{attribute}_scribd_id"]
-
-          if scribdable?(attribute) and scribd_id.blank?
-            with_file_path_for(attribute) do |filename|
-              if resource = scribd_login.upload(:file   => filename,
-                                                :access => access_level)
-                self.send("#{attribute}_scribd_id=",         resource.doc_id)
-                self.send("#{attribute}_scribd_access_key=", resource.access_key)
-
-                logger.info "[Scribd_fu] #{Time.now.rfc2822}: Object " +
-                            "#{id}##{attribute} successfully uploaded " +
-                            "for conversion to iPaper."
-              else
-                logger.info "[Scribd_fu] #{Time.now.rfc2822}: Object " +
-                            "#{id}##{attribute} upload failed!"
-
-                false # cancel the save
-              end
-            end
-          end
-        end
-      end
-
-      # Returns a URL for a thumbnail for the specified +attribute+ attachment.
-      #
-      # If Scribd does not provide a thumbnail URL, then Paperclip's thumbnail
-      # is fallen back on by returning the value of
-      # <tt>attribute.url(:thumb)</tt>.
-      #
-      # Sample use in a view:
-      #  <%= image_tag(@attachment.thumbnail_url, :alt => @attachment.name) %>
-      def thumbnail_url(attribute)
-        doc = scribd_document_for(attribute)
-
-        (doc && doc.thumbnail_url) or self.send(attribute).url(:thumb)
-      end
-
-      # Returns the actual image data of a thumbnail for the specified
-      # +attribute+ attachment.
-      #
-      # If Scribd does not have a thumbnail for this file, then
-      # Paperclip's thumbnanil is fallen back on by returning the file from
-      # <tt>attribute.to_file(:thumb)</tt>.
-      #
-      # Sample use in a controller:
-      #  render :inline => @attachment.thumbnail_file,
-      #         :content_type => 'image/jpeg'
-      def thumbnail_file(attribute)
-        doc = scribd_document_for(attribute)
-
-        if doc && doc.thumbnail_url
-          open(doc.thumbnail_url).read
-        else
-          send(attribute).to_file(:thumb).open { |f| f.read }
-        end
-      rescue Errno::ENOENT, NoMethodError # file not found or nil thumb file
-        nil
-      end
-
-      # Responds true if the conversion is complete for the given +attribute+ --
-      # note that this gives no indication as to whether the conversion had an
-      # error or was succesful, just that the conversion completed. See
-      # <tt>conversion_successful?</tt> for that information.
-      #
-      # Note also that this method still returns false if the model does not
-      # refer to a valid document.  scribd_attributes_valid? should be used to
-      # determine the validity of the document.
-      def conversion_complete?(attribute)
-        doc = scribd_document_for(attribute)
-
-        doc && doc.conversion_status != 'PROCESSING'
-      end
-
-      # Responds true if the document for the given +attribute+ has been
-      # converted successfully. This *will* respond false if the conversion has
-      # failed.
-      #
-      # Note that this method still returns false if the model does not refer to a
-      # valid document. <tt>scribd_attributes_valid?</tt> should be used to
-      # determine the validity of the document.
-      def conversion_successful?(attribute)
-        doc = scribd_document_for(attribute)
-
-        doc && doc.conversion_status =~ /^DISPLAYABLE|DONE$/
-      end
-
-      # Responds true if there was a conversion error while converting the given
-      # +attribute+ to iPaper.
-      #
-      # Note that this method still returns false if the model does not refer to a
-      # valid document. <tt>scribd_attributes_valid?</tt> should be used to
-      # determine the validity of the document.
-      def conversion_error?(attribute)
-        doc = scribd_document_for(attribute)
-
-        doc && doc.conversion_status == 'ERROR'
-      end
-
-      # Responds the Scribd::Document associated with the given +attribute+, or
-      # nil if it does not exist.
-      def scribd_document_for(attribute)
-        scribd_documents[attribute] ||= scribd_login.find_document(self["#{attribute}_scribd_id"])
-      rescue Scribd::ResponseError # at minimum, the document was not found
-        nil
-      end
-
-      private
-        def scribd_documents
-          @scribd_documents ||= HashWithIndifferentAccess.new
-        end
-
-        # Returns the full filename for the given attribute. If the file is
-        # stored on S3, this is a full S3 URI, while it is a full path to the
-        # local file if the file is stored locally.
-        def full_filename_for(attribute)
-          filename = attachment_for(attribute).path
-        end
-
-        # Yields the correct path to the file for the attachment in
-        # +attribute+, either the local filename or the S3 URL.
-        #
-        # This method creates a temporary file of the correct filename  for the
-        # attachment in +attribute+ if necessary, so as to be able to give
-        # scribd the right filename. The file is destroyed when the passed block
-        # ends.
-        def with_file_path_for(attribute, &block) # :yields: full_file_path
-          attachment = attachment_for(attribute)
-
-          if attachment.respond_to?(:s3)
-             yield attachment.url
-          elsif File.exists?(attachment.path)
-            yield attachment.path
-          else # file hasn't been saved, use a tempfile
-            temp_rename = File.join(Dir.tmpdir, attachment.original_filename)
-            File.copy(attachment.to_file.path, temp_rename)
-
-            yield temp_rename
-          end
-        ensure
-          temp_rename && File.unlink(temp_rename) # always delete this
-        end
-    end
-  end
-end

data/lib/scribd_fu_helper.rb

@@ -1,58 +0,0 @@
-module ScribdFuHelper
-  # Available parameters for the JS API
-  # http://www.scribd.com/publisher/api/api?method_name=Javascript+API
-  AVAILABLE_JS_PARAMS = [ :height, :width, :page, :my_user_id, :search_query,
-                          :jsapi_version, :disable_related_docs, :mode, :auto_size ]
-  
-
-  # Displays the scribd object for the attachment on the given +object+. If
-  # +alt_text_or_attribute+ is given, then it will be used as the alternate text
-  # for an Attachment_fu model, or as the attribute name for a Paperclip
-  # model. If you want to specify alternate text for a Paperclip model, use the
-  # last parameter, +alt_text_if_paperclip+.
-  #
-  # If you are using Paperclip, you _must_ specify +alt_text_or_attribute+ as
-  # the attribute on which the scribd object exists.
-  #
-  # For example, using Attachment_fu:
-  #  <%= display_scribd document %>
-  #  <%= display_scribd document, 'You need Flash to view this document' %>
-  #
-  # Using Paperclip:
-  #  <%= display_scribd user, :biography %>
-  #  <%= display_scribd user, :biography, 'You need Flash for biographies." %>
-  def display_scribd(object, alt_text_or_attribute = '', alt_text_if_paperclip = nil)
-    # Resolve the right scribd ID, access key, and alt text.
-    if object.respond_to?("scribd_id")
-      scribd_id = object.scribd_id
-      scribd_ak = object.scribd_access_key
-
-      alt_text = alt_text_or_attribute
-    else
-      scribd_id = object.send "#{alt_text_or_attribute}_scribd_id"
-      scribd_ak = object.send "#{alt_text_or_attribute}_scribd_access_key"
-
-      alt_text = alt_text_if_paperclip
-    end
-
-    begin
-      # Collect a set of addParam statements to set up JS parameters for the scribd document
-      # (only if they are valid).
-      param_includes = options[:params].collect do |param, value|
-        "scribd_doc.addParam('#{param}', '#{value}');" if AVAILABLE_JS_PARAMS.include?(param)
-      end.compact.join("\n")
-    rescue
-      # Where is 'options' coming from???
-    end
-
-    <<-END
-      <script type="text/javascript" src="http://www.scribd.com/javascripts/view.js"></script>
-      <div id="embedded_flash">#{alt_text}</div>
-      <script type="text/javascript">
-        var scribd_doc = scribd.Document.getDoc(#{scribd_id}, '#{scribd_ak}');
-        #{param_includes}
-        scribd_doc.write("embedded_flash");
-      </script>
-    END
-  end
-end

data/rails/init.rb

@@ -1,7 +0,0 @@
-require 'scribd_fu'
-require 'scribd_fu_helper'
-
-ActiveRecord::Base.send(:include, ScribdFu)
-ActionView::Base.send(:include, ScribdFuHelper)
-
-RAILS_DEFAULT_LOGGER.debug "** [Scribd_fu] loaded"

data/uninstall.rb

@@ -1 +0,0 @@
-# Uninstall hook code here