dragonfly-dropbox_data_store 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 065750e9175d0182bc6efdc75c752b80ab47a823
+  data.tar.gz: 2c4403f42eb29490ce3069cf15da786c55d6f279
+SHA512:
+  metadata.gz: dabb8699df8c8d0e241af30ede930c618d099cfacff1c33a2f59dc8ffbfdb5e178632f4f32898d8f8accc516c03a3357628e0cdde5360bc5868b5daf29e2b29f
+  data.tar.gz: 10603b9be488a4a7b0bcf2ccfe40961952a4d1fb77fd307af1ba524f47f9bb3a21adc5ff56316f53b785dfe95b329c938800c5cc0857cfc77fea90266ca6a0e4

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Daniel Leavitt
+
+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,130 @@
+# Dragonfly::DropboxDataStore
+
+[Dropbox](https://www.dropbox.com/developers) data store for [Dragonfly](https://github.com/markevans/dragonfly) uploads.
+
+Ganked from [here](https://github.com/markevans/dragonfly-s3_data_store) and [here](https://github.com/robin850/carrierwave-dropbox) and then sort of mashed together.
+
+## Installation
+
+### Gem
+
+Add this line to your application's Gemfile:
+
+    gem 'dragonfly-dropbox_data_store'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dragonfly-dropbox_data_store
+
+### Dropbox app setup
+
+Go here and create a new app: https://www.dropbox.com/developers/apps
+
+Select "Dropbox API App" and then "Datastores only."
+
+The latter option means the app can only access files within its application sandbox rather than your whole Dropbox. This sandbox is located in `Apps/{your-app-name}` within your Dropbox.
+
+Once you've created your app, you can use the supplied rake task to generate the rest of your credentials.
+
+    $ rake dropbox:authorize APP_KEY=your_app_key APP_SECRET=your_app_secret
+
+If you're using Rails it should just work. Otherwise you'll have to add something like this to your Rakefile:
+
+```ruby
+# Rakefile
+load "dragonfly/dropbox_data_store/tasks.rake"
+```
+
+Hold on to these creds for the next step.
+
+## Useage
+
+### Configuration
+
+In your Dragonfly config file:
+
+```ruby
+require 'dragonfly/dropbox_data_store'
+
+Dragonfly.app.configure do
+  # ...
+
+  datastore :dropbox,
+  app_key:              ENV['DROPBOX_APP_KEY'],
+  app_secret:           ENV['DROPBOX_APP_SECRET'],
+  access_token:         ENV['DROPBOX_ACCESS_TOKEN'],
+  access_token_secret:  ENV['DROPBOX_ACCESS_TOKEN_SECRET'],
+  user_id:              ENV['DROPBOX_USER_ID'],     
+  root_path:            Rails.env # optional
+
+  # ...
+end
+```
+
+### All config options
+
+```ruby
+:app_key             
+:app_secret             
+:access_token        
+:access_token_secret    
+:user_id             
+:access_type         # only app_folder for now.
+:store_meta          # whether to store file metadata. default: true
+:root_path           # where inside your app dir to put this stuff. default: '/'
+```
+
+### Per-storage options
+
+You can set the path for the uploaded file:
+
+```ruby
+Dragonfly.app.store(some_file, path: 'some/path.txt')
+```
+
+This is _not_ relative to your `root_path`. Dropbox will automatically name files so as to avoid conflicts.
+
+### Dropbox Image URLs
+
+You can get direct Dropbox links to your uploads like so:
+
+```ruby
+Dragonfly.app.remote_url_for('some/uid')
+```
+
+or
+
+```ruby
+my_model.attachment.remote_url
+```
+
+By default these return a "share" URL - a nice shortened permalink to the item in question. If you want expiring links, you can generate them like this:
+
+```ruby
+my_model.attachment.remote_url(expires: true)
+```
+
+They'll expire in about four hours.
+
+## Contributing
+
+Fork & PR.
+
+## To Do
+
+- Get it to work with "dropbox-style" (full permissions) apps. Maybe.
+- Wipe out empty directories.
+- Make the path generation method customizable.
+- See if we can do something useful with Dropbox's metadata.
+
+### Testing
+
+Check the setup instructions to get your creds. Then make a config file:
+  
+    $ cp spec/config.sample.yml spec/config.yml
+
+Fill the new config file in with your creds. The tests only run against the live Dropbox API for now, so you'll need real creds, and you'll want to make sure there's nothing in your app's `/dragonfly_test` dir (it gets wiped out every run.)

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+load "dragonfly/dropbox_data_store/tasks.rake"

data/dragonfly-dropbox_data_store.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dragonfly/dropbox_data_store/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dragonfly-dropbox_data_store"
+  spec.version       = Dragonfly::DropboxDataStore::VERSION
+  spec.authors       = ["Daniel Leavitt"]
+  spec.email         = ["daniel.leavitt@gmail.com"]
+  spec.summary       = %q{Dropbox data store for Dragonfly}
+  spec.description   = %q{Dragonfly plugin for storing attachments on Dropbox}
+  spec.homepage      = "https://github.com/dleavitt/dragonfly-dropbox_data_store"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.0"
+
+  spec.add_runtime_dependency "dragonfly", "~> 1.0"
+  spec.add_runtime_dependency "dropbox-sdk", "~> 1.6"
+end

data/lib/dragonfly/dropbox_data_store/railtie.rb

@@ -0,0 +1,9 @@
+module Dragonfly
+  class DropboxDataStore
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        load "dragonfly/dropbox_data_store/tasks.rake"
+      end
+    end
+  end
+end

data/lib/dragonfly/dropbox_data_store/rake.rb

@@ -0,0 +1,41 @@
+# Ganked verbatim from: https://github.com/janko-m/paperclip-dropbox
+
+require "dropbox_sdk"
+
+module Dragonfly
+  class DropboxDataStore
+    module Rake
+      extend self
+
+      def authorize(app_key, app_secret, access_type)
+        session = create_new_session(app_key, app_secret)
+
+        puts "Visit this URL: #{session.get_authorize_url}"
+        print "And after you approved the authorization confirm it here (y/n): "
+
+        assert_answer!
+        session.get_access_token
+        dropbox_client = DropboxClient.new(session, access_type)
+        account_info = dropbox_client.account_info
+
+        puts <<-MESSAGE
+
+Authorization was successful. Here you go:
+
+access_token: #{session.access_token.key}
+access_token_secret: #{session.access_token.secret}
+user_id: #{account_info["uid"]}
+        MESSAGE
+      end
+
+      def create_new_session(app_key, app_secret)
+        DropboxSession.new(app_key, app_secret)
+      end
+
+      def assert_answer!
+        answer = STDIN.gets.strip
+        exit if answer == "n"
+      end
+    end
+  end
+end

data/lib/dragonfly/dropbox_data_store/tasks.rake

@@ -0,0 +1,15 @@
+# Ganked verbatim from: https://github.com/janko-m/paperclip-dropbox
+
+require "dragonfly/dropbox_data_store/rake"
+
+namespace :dropbox do
+  desc "Obtains your Dropbox credentials"
+  task :authorize do
+    if ENV["APP_KEY"].nil? or ENV["APP_SECRET"].nil?
+      puts "USAGE: `rake dropbox:authorize APP_KEY=your_app_key APP_SECRET=your_app_secret`"
+      exit
+    end
+
+    Dragonfly::DropboxDataStore::Rake.authorize(ENV["APP_KEY"], ENV["APP_SECRET"], 'app_folder')
+  end
+end

data/lib/dragonfly/dropbox_data_store/version.rb

@@ -0,0 +1,5 @@
+module Dragonfly
+  class DropboxDataStore
+    VERSION = "0.0.1"
+  end
+end

data/lib/dragonfly/dropbox_data_store.rb

@@ -0,0 +1,100 @@
+require 'dragonfly'
+require 'dropbox_sdk'
+require 'dragonfly/dropbox_data_store/version'
+require 'dragonfly/dropbox_data_store/railtie' if defined?(Rails)
+
+Dragonfly::App.register_datastore(:dropbox) { Dragonfly::DropboxDataStore }
+
+module Dragonfly
+  class DropboxDataStore
+    attr_accessor :app_key, :app_secret, :access_token, :access_token_secret, 
+                  :user_id, :access_type, :store_meta, :root_path
+    
+    def initialize(opts = {})
+      @app_key             = opts[:app_key]
+      @app_secret          = opts[:app_secret]
+      @access_token        = opts[:access_token]
+      @access_token_secret = opts[:access_token_secret]
+      @user_id             = opts[:user_id]
+      @access_type         = opts[:access_type] || 'app_folder' # dropbox|app_folder
+
+      @store_meta          = opts[:store_meta]
+      # TODO: this should default to 'dragonfly' for dropbox access type
+      @root_path           = opts[:root_path] || ''
+
+      # TODO: path for access_type=dropbox
+      # TODO: how is path typically specified in dragonfly? leading slash?
+    end
+
+    def write(content, opts = {})
+      # TODO: deal with dropbox vs. app_folder stuff
+      # figure out how paths work for each
+      path = opts[:path] || absolute(relative_path_for(content.name || 'file'))
+      data_path = storage.put_file(path, content.file)['path']
+      storage.put_file(meta_path(data_path), YAML.dump(content.meta)) if store_meta?
+      relative(data_path)
+    end
+
+    def read(path)
+      path = absolute(path)
+      # TODO: possibly return some of dropbox's native metadata automatically
+      wrap_error do
+        [ storage.get_file(path),
+          store_meta? && YAML.load(storage.get_file(meta_path(path))) ]
+      end
+    end
+
+    def destroy(path)
+      path = absolute(path)
+      # TODO: purge empty directories
+      wrap_error { storage.file_delete(meta_path(path)) } if store_meta?
+      wrap_error { storage.file_delete(path) }
+    end
+
+    # Only option is "expires" and it's a boolean
+    def url_for(path, opts = {})
+      path = absolute(path)
+      (opts[:expires] ? storage.media(path) : storage.shares(path))['url']
+    end
+
+    # TODO: thumbnail data-uri
+
+    def store_meta?
+      @store_meta != false # Default to true if not set
+    end
+
+    def storage
+      @storage ||= begin
+        session = DropboxSession.new(app_key, app_secret)
+        session.set_access_token(access_token, access_token_secret)
+        DropboxClient.new(session, access_type)
+      end
+    end
+
+    protected
+
+    def wrap_error
+      yield
+    rescue DropboxError
+      nil
+    end
+
+    def absolute(relative_path)
+      relative_path.to_s == '.' ? root_path : File.join(root_path, relative_path)
+    end
+
+    def relative(absolute_path)
+      absolute_path[/^\/?#{Regexp.escape root_path}\/?(.*)$/, 1]
+    end
+
+    def meta_path(data_path)
+      "#{data_path}.meta.yml"
+    end
+
+    # TODO: make this overrideable via param
+    def relative_path_for(filename)
+      time = Time.now
+      "#{time.strftime('%Y/%m/%d/')}#{rand(1e15).to_s(36)}_#{filename.gsub(/[^\w.]+/,'_')}"
+    end
+  end
+end

data/spec/config.example.yml

@@ -0,0 +1,6 @@
+app_key: dummy
+app_secret: dummy
+access_token: dummy
+access_token_secret: dummy
+user_id: 12345
+access_type: app_folder

data/spec/dropbox_data_store_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe Dragonfly::DropboxDataStore do
+
+  def assert_exists(path)
+    path = absolute_path(path)
+    expect { @data_store.storage.get_file(path) }.not_to raise_error
+  end
+
+  def assert_does_not_exist(path)
+    path = absolute_path(path)
+    expect { @data_store.storage.get_file(path) }.to raise_error(DropboxError)
+  end
+
+  def absolute_path(path)
+    File.join(@root_path, path)
+  end
+
+  def fixture(name)
+    File.open(File.join(File.dirname(__FILE__), 'fixtures', "#{name}"))
+  end
+
+  let(:app) { Dragonfly.app }
+  let(:content) { content1 }
+  let(:content1) { Dragonfly::Content.new(app, "pigbot") }
+  let(:content2) { Dragonfly::Content.new(app, "pigbot2") }
+  let(:new_content) { Dragonfly::Content.new(app) }
+
+  it_should_behave_like 'data_store'
+
+  describe "registering with a symbol" do
+    it "registers a symbol for configuring" do
+      app.configure { datastore :dropbox }
+      app.datastore.should be_a(Dragonfly::DropboxDataStore)
+    end
+  end
+
+  describe "write" do
+    it "doesn't overwrite duplicate files" do
+      path = absolute_path("thepath")
+      path1 = @data_store.write(content1, :path => path)
+      path2 = @data_store.write(content2, :path => path)
+      expect(@data_store.read(path1)[0]).to eq content1.data
+      expect(@data_store.read(path2)[0]).to eq content2.data
+      expect(path1).not_to eq path2
+    end
+
+    # yanked wholecloth from: https://github.com/markevans/dragonfly-s3_data_store
+    it "should use the name from the content if set" do
+      content1.name = 'doobie.doo'
+      uid = @data_store.write(content1)
+      uid.should =~ /doobie\.doo$/
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == 'pigbot'
+    end
+
+    it "should work ok with files with funny names" do
+      content.name = "A Picture with many spaces in its name (at 20:00 pm).png"
+      uid = @data_store.write(content)
+      uid.should =~ /A_Picture_with_many_spaces_in_its_name_at_20_00_pm_\.png$/
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == 'pigbot'
+    end
+
+    it "should allow for setting the path manually" do
+      uid = @data_store.write(content, :path => absolute_path('hello/there'))
+      uid.should =~ /hello\/there/
+      new_content.update(*@data_store.read(uid))
+      new_content.data.should == 'pigbot'
+    end
+
+    it 'writes a metadata file' do
+      uid = @data_store.write(content)
+      assert_exists("#{uid}.meta.yml")
+    end
+
+    context 'metadata disabled' do
+      before { @data_store.store_meta = false }
+      
+      it 'does not write a metadata file' do
+        uid = @data_store.write(content)
+        assert_does_not_exist("#{uid}.meta.yml")
+      end
+    end
+  end
+
+  describe 'url_for' do
+    let(:content) { Dragonfly::Content.new(app, fixture('piglets.jpg')) }
+    let(:uid) { @data_store.write(content) }
+
+    it "returns a URL" do
+      expect(@data_store.url_for(uid)).to start_with 'http'
+    end
+
+    context "without the expires option" do
+      it "returns a shortened URL" do
+        expect(@data_store.url_for(uid)).to start_with 'https://db.tt'
+      end
+    end
+
+    context "with the expires option set" do
+      it "returns a full URL" do
+        expect(@data_store.url_for(uid, expires: true)).to start_with 'https://dl.dropboxusercontent.com'
+      end
+    end
+  end
+
+  describe 'destroy' do
+    it 'destroys the metadata file' do
+      uid = @data_store.write(content)
+      assert_exists("#{uid}.meta.yml")
+      @data_store.destroy(uid)
+      assert_does_not_exist("#{uid}.meta.yml")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+require 'dragonfly/dropbox_data_store'
+require 'dragonfly/spec/data_store_examples'
+
+config_path = "#{File.dirname(__FILE__)}/config.yml"
+
+if File.exist?(config_path)
+  CREDS = YAML.load_file(config_path)
+else
+  raise 'Please create a config file at spec/config.yml'
+end
+
+raise 'Please use an app_folder app' if CREDS['access_type'] == 'dropbox'
+
+RSpec.configure do |config|
+  config.order = 'random'
+  
+  config.before(:each) do
+    @root_path = 'dragonfly_test'
+
+    @data_store = Dragonfly::DropboxDataStore.new(
+      :app_key             => CREDS['app_key'],
+      :app_secret          => CREDS['app_secret'],
+      :access_token        => CREDS['access_token'],
+      :access_token_secret => CREDS['access_token_secret'],
+      :user_id             => CREDS['user_id'],
+      :access_type         => CREDS['access_type'],
+      :root_path           => @root_path
+    )
+  end
+
+  config.after(:all) do
+    begin
+      @data_store.storage.file_delete(@root_path)
+    rescue DropboxError
+    end
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: dragonfly-dropbox_data_store
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Leavitt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: dragonfly
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dropbox-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: Dragonfly plugin for storing attachments on Dropbox
+email:
+- daniel.leavitt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dragonfly-dropbox_data_store.gemspec
+- lib/dragonfly/dropbox_data_store.rb
+- lib/dragonfly/dropbox_data_store/railtie.rb
+- lib/dragonfly/dropbox_data_store/rake.rb
+- lib/dragonfly/dropbox_data_store/tasks.rake
+- lib/dragonfly/dropbox_data_store/version.rb
+- spec/config.example.yml
+- spec/dropbox_data_store_spec.rb
+- spec/fixtures/piglets.jpg
+- spec/spec_helper.rb
+homepage: https://github.com/dleavitt/dragonfly-dropbox_data_store
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Dropbox data store for Dragonfly
+test_files:
+- spec/config.example.yml
+- spec/dropbox_data_store_spec.rb
+- spec/fixtures/piglets.jpg
+- spec/spec_helper.rb