ruby-box 1.0.0

data/lib/ruby-box/comment.rb

@@ -0,0 +1,10 @@
+module RubyBox
+  class Comment < Item
+    
+    private
+
+    def resource_name
+      'comments'
+    end
+  end
+end

data/lib/ruby-box/discussion.rb

@@ -0,0 +1,16 @@
+module RubyBox
+  class Discussion < Item
+
+    def comments
+      url = "#{RubyBox::API_URL}/#{resource_name}/#{id}/comments"
+      resp = @session.get( url )
+      resp['entries'].map {|i| Comment.new(@session, i)}
+    end
+
+    private
+
+    def resource_name
+      'discussions'
+    end
+  end
+end

data/lib/ruby-box/exceptions.rb

@@ -0,0 +1,17 @@
+module RubyBox 
+  class RubyBoxError < StandardError
+    def initialize(error_json)
+      @error_json = error_json
+    end
+
+    def [](key)
+      @error_json[key]
+    end
+  end
+
+  class ObjectNotFound < StandardError; end
+  class AuthError < RubyBoxError; end
+  class RequestError < RubyBoxError; end
+  class ServerError < StandardError; end
+  class ItemNameInUse < RubyBoxError; end
+end

data/lib/ruby-box/file.rb

@@ -0,0 +1,70 @@
+module RubyBox
+  class File < Item
+
+    def download
+      resp = stream.read
+    end
+
+    def stream( opts={} )
+      url = "#{RubyBox::API_URL}/#{resource_name}/#{id}/content"
+      @session.do_stream( url, opts )
+    end
+
+    def comments
+      url = "#{RubyBox::API_URL}/#{resource_name}/#{id}/comments"
+      resp = @session.get( url )
+      resp['entries'].map {|i| Comment.new(@session, i)}
+    end
+
+    def upload_content( data )
+      url = "#{RubyBox::UPLOAD_URL}/#{resource_name}/content"
+      uri = URI.parse(url)
+      request = Net::HTTP::Post::Multipart.new(uri.path, {
+        "filename" => UploadIO.new(data, "application/pdf", name),
+        "folder_id" => parent.id
+      })
+
+      resp = @session.request(uri, request)
+      if resp['entries']
+        @raw_item = resp['entries'][0]
+      else
+        @raw_item = resp
+      end
+      self
+    end
+
+    def update_content( data )
+
+      url = "#{RubyBox::UPLOAD_URL}/#{resource_name}/#{id}/content"
+      uri = URI.parse(url)
+
+      request = Net::HTTP::Post::Multipart.new(uri.path, {
+        "filename" => prepare_upload(data, name),
+        "folder_id" => parent.id
+      }, {"if-match" => etag })
+
+      resp = @session.request(uri, request)
+      if resp['entries']
+        @raw_item = resp['entries'][0]
+      else
+        @raw_item = resp
+      end
+      self
+    end
+
+    private
+
+    def resource_name
+      'files'
+    end
+
+    def update_fields
+      ['name', 'description']
+    end
+
+    def prepare_upload(data, fname)
+      UploadIO.new(data, "application/pdf", fname)
+    end
+
+  end
+end

data/lib/ruby-box/folder.rb

@@ -0,0 +1,71 @@
+module RubyBox
+  class Folder < Item
+    def items(item_limit=100, offset=0)
+      Enumerator.new do |yielder|
+        while true
+          url = "#{RubyBox::API_URL}/#{resource_name}/#{id}/items?limit=#{item_limit}&offset=#{offset}"
+          resp = @session.get( url )
+          resp['entries'].each do |entry|
+            yielder.yield(RubyBox::Item.factory(@session, entry))
+          end
+          offset += resp['entries'].count
+          break if resp['offset'].to_i + resp['limit'].to_i >= resp['total_count'].to_i
+        end
+      end
+    end
+
+    def files(name=nil, item_limit=100, offset=0)
+      items(item_limit, offset).select do |item|
+        item.kind_of? RubyBox::File and (name.nil? or item.name == name)
+      end
+    end
+
+    def folders(name=nil, item_limit=100, offset=0)
+      items(item_limit, offset).select do |item|
+        item.kind_of? RubyBox::Folder and (name.nil? or item.name == name)
+      end
+    end
+
+    def discussions
+      url = "#{RubyBox::API_URL}/#{resource_name}/#{id}/discussions"
+      resp = @session.get( url )
+      resp['entries'].map {|i| Discussion.new(@session, i)}
+    end
+
+    def upload_file(filename, data)
+      file = RubyBox::File.new(@session, {
+        'name' => filename,
+        'parent' => RubyBox::User.new(@session, {'id' => id})
+      })
+
+      begin
+        resp = file.upload_content(data) #write a new file. If there is a conflict, update the conflicted file.
+      rescue RubyBox::ItemNameInUse => e
+        file = RubyBox::File.new(@session, {
+          'id' => e['context_info']['conflicts'][0]['id']
+        })
+        data.rewind
+        resp = file.update_content( data )
+      end
+    end
+
+    def create_subfolder(name)
+      url = "#{RubyBox::API_URL}/#{resource_name}"
+      uri = URI.parse(url)
+      request = Net::HTTP::Post.new( uri.request_uri )
+      request.body = JSON.dump({ "name" => name, "parent" => {"id" => id} })
+      resp = @session.request(uri, request)
+      RubyBox::Folder.new(@session, resp)
+    end
+
+    private
+
+    def resource_name
+      'folders'
+    end
+
+    def update_fields
+      ['name', 'description']
+    end
+  end
+end

data/lib/ruby-box/item.rb

@@ -0,0 +1,83 @@
+require 'time'
+
+module RubyBox
+  class Item
+
+    def initialize( session, raw_item )
+      @session = session
+      @raw_item = raw_item
+    end
+
+    def update
+      reload_meta unless etag
+
+      url = "#{RubyBox::API_URL}/#{resource_name}/#{id}"
+      uri = URI.parse(url)
+
+      request = Net::HTTP::Put.new(uri.path, {
+        "if-match" => etag,
+        "Content-Type" => 'application/json'
+      })
+      request.body = JSON.dump(serialize)
+
+      @raw_item = @session.request(uri, request)
+      self
+    end
+
+    def delete
+      url = "#{RubyBox::API_URL}/#{resource_name}/#{id}"
+      resp = @session.delete( url )
+    end
+
+    def reload_meta
+      url = "#{RubyBox::API_URL}/#{resource_name}/#{@raw_item['id']}"
+      @raw_item = @session.get( url )
+      self
+    end
+
+    def method_missing(method, *args, &block)
+      key = method.to_s
+      
+      # update @raw_item hash if this appears to be a setter.
+      setter = method.to_s.end_with?('=')
+      key = key[0...-1] if setter
+      @raw_item[key] = args[0] if setter and update_fields.include?(key)
+      
+      # we may have a mini version of the object loaded, fix this.
+      reload_meta if @raw_item[key].nil?
+
+      if @raw_item[key].kind_of?(Hash)
+        return RubyBox::Item.factory(@session, @raw_item[key])
+      elsif RubyBox::ISO_8601_TEST.match(@raw_item[key].to_s)
+        return Time.parse(@raw_item[key])
+      else
+        return @raw_item[key]
+      end
+    end
+
+    protected
+
+    def self.factory(session, entry)
+      case entry['type']
+      when 'folder'
+        return RubyBox::Folder.new(session, entry)
+      when 'file'
+        return RubyBox::File.new(session, entry)
+      when 'comment'
+        return RubyBox::Comment.new(session, entry)        
+      when 'user'
+        return RubyBox::User.new(session, entry)        
+      when 'discussion'
+        return RubyBox::Discussion.new(session, entry)
+      end
+      entry
+    end
+
+    private
+
+    def serialize
+      update_fields.inject({}) {|hash, field| hash[field] = @raw_item[field]; hash}
+    end
+
+  end
+end

data/lib/ruby-box/session.rb

@@ -0,0 +1,102 @@
+require 'oauth2'
+
+module RubyBox  
+  class Session
+    attr_accessor :api_key, :auth_token, :oauth2_client, :access_token
+
+    OAUTH2_URLS = {
+      :site => 'https://www.box.com',
+      :authorize_url => "/api/oauth2/authorize",
+      :token_url => "/api/oauth2/token"
+    }
+    
+    def initialize(opts={})
+      if opts[:client_id]
+        @oauth2_client = OAuth2::Client.new(opts[:client_id], opts[:client_secret], OAUTH2_URLS)
+        @access_token = OAuth2::AccessToken.new(oauth2_client, opts[:access_token]) if opts[:access_token]
+      else # Support legacy API for historical reasons.
+        @api_key = opts[:api_key]
+        @auth_token = opts[:auth_token]
+      end
+    end
+
+    def authorize_url(redirect_uri)
+      @redirect_uri = redirect_uri
+      @oauth2_client.auth_code.authorize_url(:redirect_uri => redirect_uri)
+    end
+
+    def get_access_token(code)
+      @access_token = @oauth2_client.auth_code.get_token(code, { :redirect_uri => @redirect_uri, :token_method => :post })
+      @access_token.token
+    end
+    
+    def build_auth_header
+      "BoxAuth api_key=#{@api_key}&auth_token=#{@auth_token}"
+    end
+
+    def get(url, raw=false)
+      uri = URI.parse(url)
+      request = Net::HTTP::Get.new( uri.request_uri )
+      resp = request( uri, request, raw )
+    end
+
+    def delete(url, raw=false)
+      uri = URI.parse(url)
+      request = Net::HTTP::Delete.new( uri.request_uri )
+      resp = request( uri, request, raw )
+    end
+    
+    def request(uri, request, raw=false)      
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.ssl_version = :SSLv3
+      
+      if @access_token
+        request.add_field('Authorization', "Bearer #{@access_token.token}")
+      else
+        request.add_field('Authorization', build_auth_header)
+      end
+
+      response = http.request(request)
+
+      if response.is_a? Net::HTTPNotFound
+        raise RubyBox::ObjectNotFound
+      end
+      handle_errors( response.code.to_i, response.body, raw )
+    end
+
+    def do_stream(url, opts)
+      params = {
+        :content_length_proc => opts[:content_length_proc],
+        :progress_proc => opts[:progress_proc]        
+      }
+
+      if @access_token
+        params['Authorization'] = "Bearer #{@access_token.token}"
+      else
+        params['Authorization'] = build_auth_header
+      end
+
+      open(url, params)
+    end
+    
+    def handle_errors( status, body, raw )
+      begin
+        parsed_body = JSON.parse(body)
+      rescue
+        msg = body.nil? || body.empty? ? "no data returned" : body
+        parsed_body = { "message" =>  msg }
+      end
+      case status / 100
+      when 4
+        raise(RubyBox::ItemNameInUse.new(parsed_body), parsed_body["message"]) if parsed_body["code"] == "item_name_in_use"
+        raise(RubyBox::AuthError.new(parsed_body), parsed_body["message"]) if parsed_body["code"] == "unauthorized" || status == 401        
+        raise(RubyBox::RequestError.new(parsed_body), parsed_body["message"])
+      when 5
+        raise RubyBox::ServerError, parsed_body["message"]
+      end
+      raw ? body : parsed_body
+    end
+  end
+end

data/lib/ruby-box/user.rb

@@ -0,0 +1,10 @@
+module RubyBox
+  class User < Item
+    
+    private
+
+    def resource_name
+      'users'
+    end
+  end
+end

data/ruby-box.gemspec

@@ -0,0 +1,50 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "ruby-box"
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Benjamin Coe", "Jesse Miller", "Larry Kang"]
+  s.date = "2013-03-02"
+  s.description = "ruby gem for box.com 2.0 api"
+  s.email = "ben@attachments.me"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = `git ls-files`.gsub('"spec/fixtures/\351\201\240\345\277\227\346\225\231\346\216\210.jpg"', '').split($\)
+  s.homepage = "http://github.com/attachmentsme/ruby-box"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "ruby gem for box.com 2.0 api"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<multipart-post>, ["~> 1.1.5"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<webmock>, [">= 0"])
+    else
+      s.add_dependency(%q<multipart-post>, ["~> 1.1.5"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<webmock>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<multipart-post>, ["~> 1.1.5"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<webmock>, [">= 0"])
+  end
+end
+

data/spec/client_spec.rb

@@ -0,0 +1,28 @@
+#encoding: UTF-8
+
+require 'helper/account'
+require 'ruby-box'
+require 'webmock/rspec'
+
+describe RubyBox::Client do
+  before do
+    @session = RubyBox::Session.new
+  end
+
+  describe '#split_path' do
+    it "returns the appropriate path" do
+      client = RubyBox::Client.new(@session)
+      client.split_path('foo/bar').should == ['foo', 'bar']
+    end
+
+    it "leading / is ignored" do
+      client = RubyBox::Client.new(@session)
+      client.split_path('/foo/bar').should == ['foo', 'bar']
+    end
+
+    it "trailing / is ignored" do
+      client = RubyBox::Client.new(@session)
+      client.split_path('foo/bar/').should == ['foo', 'bar']
+    end
+  end
+end