paperclip-storage-ftp 1.0.0.rc1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rspec
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in paperclip-multistorage.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 XING AG
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# FTP Storage for Paperclip
+
+Allow [Paperclip](https://github.com/thoughtbot/paperclip) attachments
+to be stored on FTP servers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'paperclip-storage-ftp'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install paperclip-storage-ftp
+
+## Usage
+
+Somewhere in your code:
+
+    require "paperclip/storage/ftp"
+
+In your model:
+
+    class User < ActiveRecord::Base
+      has_attached_file :avatar,
+
+        # Choose the FTP storage backend
+        :storage => :ftp,
+
+        # Set where to store the file on the FTP server(s).
+        # This supports Paperclip::Interpolations.
+        :path => "/path_on_ftp_server/:attachment/:id/:style/:filename"
+
+        # The full URL of where the attachment is publicly accessible.
+        # This supports Paperclip::Interpolations.
+        :url => "/url_prefix/:attachment/:id/:style/:filename"
+
+        # The list of FTP servers to use
+        :ftp_servers => [
+          {
+            :host     => "ftp1.example.com",
+            :user     => "foo",
+            :password => "bar"
+          },
+          # Add more servers if needed
+          {
+            :host     => "ftp2.example.com",
+            :user     => "foo",
+            :password => "bar"
+          }
+        ]
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = "--color"
+end
+
+task :default => :spec

data/lib/paperclip/storage/ftp.rb

@@ -0,0 +1,78 @@
+require "paperclip"
+require "active_support/all"
+require "tempfile"
+
+require "paperclip/storage/ftp/server"
+
+module Paperclip
+  module Storage
+    module Ftp
+      def exists?(style_name = default_style)
+        if original_filename
+          primary_ftp_server.file_exists?(path(style_name))
+        else
+          false
+        end
+      end
+
+      def to_file(style_name = default_style)
+        if @queued_for_write[style_name]
+          @queued_for_write[style_name].rewind
+          @queued_for_write[style_name]
+        else
+          filename = path(style_name)
+          extname  = File.extname(filename)
+          basename = File.basename(filename, extname)
+          file     = Tempfile.new([basename, extname])
+          primary_ftp_server.get_file(filename, file.path)
+          file.rewind
+          file
+        end
+      end
+
+      def flush_writes #:nodoc:
+        @queued_for_write.each do |style_name, file|
+          file.close
+          ftp_servers.each do |server|
+            remote_path = path(style_name)
+            log("saving ftp://#{server.user}@#{server.host}:#{remote_path}")
+            server.put_file(file.path, remote_path)
+          end
+        end
+
+        after_flush_writes # allows attachment to clean up temp files
+
+        @queued_for_write = {}
+      end
+
+      def flush_deletes
+        @queued_for_delete.each do |path|
+          ftp_servers.each do |server|
+            log("deleting ftp://#{server.user}@#{server.host}:#{path}")
+            server.delete_file(path)
+          end
+        end
+        @queued_for_delete = []
+      end
+
+      def ftp_servers
+        @ftp_servers ||= begin
+          ftp_servers = []
+          @options[:ftp_servers].each do |config|
+            server = Server.new(
+              :host     => config[:host],
+              :user     => config[:user],
+              :password => config[:password]
+            )
+            ftp_servers << server
+          end
+          ftp_servers
+        end
+      end
+
+      def primary_ftp_server
+        ftp_servers.first
+      end
+    end
+  end
+end

data/lib/paperclip/storage/ftp/server.rb

@@ -0,0 +1,54 @@
+require "pathname"
+require "net/ftp"
+
+module Paperclip
+  module Storage
+    module Ftp
+      class Server
+        attr_accessor :host, :user, :password
+        attr_writer   :connection
+
+        def initialize(options = {})
+          options.each do |k,v|
+            send("#{k}=", v)
+          end
+        end
+
+        def file_exists?(path)
+          pathname = Pathname.new(path)
+          connection.nlst(pathname.dirname.to_s).include?(pathname.basename.to_s)
+        end
+
+        def get_file(remote_file_path, local_file_path)
+          connection.getbinaryfile(remote_file_path, local_file_path)
+        end
+
+        def put_file(local_file_path, remote_file_path)
+          pathname = Pathname.new(remote_file_path)
+          mkdir_p(pathname.dirname.to_s)
+          connection.putbinaryfile(local_file_path, remote_file_path)
+        end
+
+        def delete_file(remote_file_path)
+          connection.delete(remote_file_path)
+        end
+
+        def connection
+          @connection ||= Net::FTP.open(host, user, password)
+        end
+
+        def mkdir_p(dirname)
+          pathname = Pathname.new(dirname)
+          pathname.descend do |p|
+            begin
+              connection.mkdir(p.to_s)
+            rescue Net::FTPPermError
+              # This error can be caused by an existing directory.
+              # Ignore, and keep on trying to create child directories.
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/paperclip-storage-ftp.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |gem|
+  gem.authors       = ["Sebastian Röbke"]
+  gem.email         = ["sebastian.roebke@xing.com"]
+  gem.description   = %q{Allow Paperclip attachments to be stored on FTP servers}
+  gem.summary       = %q{Allow Paperclip attachments to be stored on FTP servers}
+  gem.homepage      = "https://github.com/xing/paperclip-storage-ftp"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "paperclip-storage-ftp"
+  gem.require_paths = ["lib"]
+  gem.version       = "1.0.0.rc1"
+
+  gem.add_dependency("paperclip")
+
+  gem.add_development_dependency("rspec")
+  gem.add_development_dependency("rake")
+end

data/spec/paperclip/storage/ftp/server_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path("../../../../spec_helper", __FILE__)
+
+describe Paperclip::Storage::Ftp::Server do
+  let(:server) { Paperclip::Storage::Ftp::Server.new }
+
+  context "initialize" do
+    it "accepts options to initialize attributes" do
+      options = {
+        :host     => "ftp.example.com",
+        :user     => "user",
+        :password => "password"
+      }
+      server = Paperclip::Storage::Ftp::Server.new(options)
+      server.host.should     == "ftp.example.com"
+      server.user.should     == "user"
+      server.password.should == "password"
+    end
+  end
+
+  context "#file_exists?" do
+    it "returns true if the file exists on the server" do
+      server.connection = double("connection")
+      server.connection.should_receive(:nlst).with("/files/original").and_return(["foo.jpg"])
+      server.file_exists?("/files/original/foo.jpg").should be_true
+    end
+
+    it "returns false if the file does not exist on the server" do
+      server.connection = double("connection")
+      server.connection.should_receive(:nlst).with("/files/original").and_return([])
+      server.file_exists?("/files/original/foo.jpg").should be_false
+    end
+  end
+
+  context "#get_file" do
+    it "returns the file object" do
+      server.connection = double("connection")
+      server.connection.should_receive(:getbinaryfile).with("/files/original.jpg", "/tmp/original.jpg")
+      server.get_file("/files/original.jpg", "/tmp/original.jpg")
+    end
+  end
+
+  context "#put_file" do
+    it "stores the file on the server" do
+      server.connection = double("connection")
+      server.should_receive(:mkdir_p).with("/files")
+      server.connection.should_receive(:putbinaryfile).with("/tmp/original.jpg", "/files/original.jpg")
+      server.put_file("/tmp/original.jpg", "/files/original.jpg")
+    end
+  end
+
+  context "#delete_file" do
+    it "deletes the file on the server" do
+      server.connection = double("connection")
+      server.connection.should_receive(:delete).with("/files/original.jpg")
+      server.delete_file("/files/original.jpg")
+    end
+  end
+
+  context "#connection" do
+    it "returns a memoized ftp connection to the given server" do
+      server.host     = "ftp.example.com"
+      server.user     = "user"
+      server.password = "password"
+
+      Net::FTP.should_receive(:open).with(server.host, server.user, server.password).once.and_return(:foo)
+
+      2.times { server.connection.should == :foo }
+    end
+  end
+
+  context "mkdir_p" do
+    it "creates the directory and all its parent directories" do
+      server.connection = double("connection")
+      server.connection.should_receive(:mkdir).with("/").ordered
+      server.connection.should_receive(:mkdir).with("/files").ordered
+      server.connection.should_receive(:mkdir).with("/files/foo").ordered
+      server.connection.should_receive(:mkdir).with("/files/foo/bar").ordered
+      server.mkdir_p("/files/foo/bar")
+    end
+
+    it "does not stop on Net::FTPPermError" do
+      server.connection = double("connection")
+      server.connection.should_receive(:mkdir).with("/").and_raise(Net::FTPPermError)
+      server.connection.should_receive(:mkdir).with("/files")
+      server.mkdir_p("/files")
+    end
+  end
+end

data/spec/paperclip/storage/ftp_spec.rb

@@ -0,0 +1,128 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe Paperclip::Storage::Ftp do
+  let(:attachment) do
+    model_instance = double()
+    model_instance.stub(:id).and_return(1)
+    model_instance.stub(:image_file_name).and_return("foo.jpg")
+
+    Paperclip::Attachment.new(:image, model_instance, {
+      :storage => :ftp,
+      :path    => "/files/:style/:filename",
+      :ftp_servers => [
+        {
+          :host     => "ftp1.example.com",
+          :user     => "user1",
+          :password => "password1"
+        },
+        {
+          :host     => "ftp2.example.com",
+          :user     => "user2",
+          :password => "password2"
+        }
+      ]
+    })
+  end
+
+  context "#exists?" do
+    it "returns false if original_filename not set" do
+      attachment.stub(:original_filename).and_return(nil)
+      attachment.exists?.should be_false
+    end
+
+    it "returns true if the file exists on the primary server" do
+      attachment.primary_ftp_server.should_receive(:file_exists?).with("/files/original/foo.jpg").and_return(true)
+      attachment.exists?.should be_true
+    end
+
+    it "accepts an optional style_name parameter to build the correct file path" do
+      attachment.primary_ftp_server.should_receive(:file_exists?).with("/files/thumb/foo.jpg").and_return(true)
+      attachment.exists?(:thumb)
+    end
+  end
+
+  context "#to_file" do
+    it "returns the file from the primary server as a local tempfile" do
+      tempfile = double("tempfile")
+      tempfile.should_receive(:path).and_return("/tmp/foo")
+      tempfile.should_receive(:rewind).with(no_args)
+      Tempfile.should_receive(:new).with(["foo", ".jpg"]).and_return(tempfile)
+      attachment.primary_ftp_server.should_receive(:get_file).with("/files/original/foo.jpg", "/tmp/foo").and_return(:foo)
+      attachment.to_file.should == tempfile
+    end
+
+    it "accepts an optional style_name parameter to build the correct file path" do
+      tempfile = double("tempfile")
+      tempfile.should_receive(:path).and_return("/tmp/foo")
+      tempfile.should_receive(:rewind).with(no_args)
+      Tempfile.should_receive(:new).with(["foo", ".jpg"]).and_return(tempfile)
+      attachment.primary_ftp_server.should_receive(:get_file).with("/files/thumb/foo.jpg", anything)
+      attachment.to_file(:thumb)
+    end
+
+    it "gets an existing file object from the local write queue, if available" do
+      file = double("file")
+      file.should_receive(:rewind)
+      attachment.instance_variable_set(:@queued_for_write, {:original => file})
+      attachment.to_file.should == file
+    end
+  end
+
+  context "#flush_writes" do
+    it "stores the files on every server" do
+      original_file = double("original_file", :path => "/tmp/original/foo.jpg")
+      thumb_file    = double("thumb_file",    :path => "/tmp/thumb/foo.jpg")
+
+      attachment.instance_variable_set(:@queued_for_write, {
+        :original => original_file,
+        :thumb    => thumb_file
+      })
+
+      thumb_file.should_receive(:close).with(no_args)
+      original_file.should_receive(:close).with(no_args)
+      attachment.ftp_servers.first.should_receive(:put_file).with("/tmp/original/foo.jpg", "/files/original/foo.jpg")
+      attachment.ftp_servers.first.should_receive(:put_file).with("/tmp/thumb/foo.jpg", "/files/thumb/foo.jpg")
+      attachment.ftp_servers.second.should_receive(:put_file).with("/tmp/original/foo.jpg", "/files/original/foo.jpg")
+      attachment.ftp_servers.second.should_receive(:put_file).with("/tmp/thumb/foo.jpg", "/files/thumb/foo.jpg")
+      attachment.should_receive(:after_flush_writes).with(no_args)
+
+      attachment.flush_writes
+
+      attachment.queued_for_write.should == {}
+    end
+  end
+
+  context "#flush_deletes" do
+    it "deletes the files on every server" do
+      attachment.instance_variable_set(:@queued_for_delete, [
+        "/files/original/foo.jpg",
+        "/files/thumb/foo.jpg"
+      ])
+      attachment.ftp_servers.first.should_receive(:delete_file).with("/files/original/foo.jpg")
+      attachment.ftp_servers.first.should_receive(:delete_file).with("/files/thumb/foo.jpg")
+      attachment.ftp_servers.second.should_receive(:delete_file).with("/files/original/foo.jpg")
+      attachment.ftp_servers.second.should_receive(:delete_file).with("/files/thumb/foo.jpg")
+
+      attachment.flush_deletes
+
+      attachment.instance_variable_get(:@queued_for_delete).should == []
+    end
+  end
+
+  context "#ftp_servers" do
+    it "returns the configured ftp servers" do
+      attachment.ftp_servers.first.host.should      == "ftp1.example.com"
+      attachment.ftp_servers.first.user.should      == "user1"
+      attachment.ftp_servers.first.password.should  == "password1"
+      attachment.ftp_servers.second.host.should     == "ftp2.example.com"
+      attachment.ftp_servers.second.user.should     == "user2"
+      attachment.ftp_servers.second.password.should == "password2"
+    end
+  end
+
+  context "#primary_ftp_server" do
+    it "returns the first server in the list" do
+      attachment.primary_ftp_server.should == attachment.ftp_servers.first
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+end
+
+require "paperclip/storage/ftp"
+
+Paperclip.options[:log] = false

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: paperclip-storage-ftp
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+  prerelease: 6
+platform: ruby
+authors:
+- Sebastian Röbke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: paperclip
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Allow Paperclip attachments to be stored on FTP servers
+email:
+- sebastian.roebke@xing.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/paperclip/storage/ftp.rb
+- lib/paperclip/storage/ftp/server.rb
+- paperclip-storage-ftp.gemspec
+- spec/paperclip/storage/ftp/server_spec.rb
+- spec/paperclip/storage/ftp_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/xing/paperclip-storage-ftp
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3195692786080207386
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Allow Paperclip attachments to be stored on FTP servers
+test_files:
+- spec/paperclip/storage/ftp/server_spec.rb
+- spec/paperclip/storage/ftp_spec.rb
+- spec/spec_helper.rb