box-com 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a22a998fddabe194a554b6f6a6bdc196754f147f
+  data.tar.gz: 609f5df6720094f297bb2b0f7ec9296508221e76
+SHA512:
+  metadata.gz: e80c6bab9290a0b62d35a95b80ac945eada2b5e78d5a1a0967fa8eb49e4a410cc160caeb1254cf0dc4d052ae4a8d20b749db79c17c64800eb42d79007ed63f90
+  data.tar.gz: 10b6b0f5c7079ae0e4553c5deb48c082beb7395b89137f8a00740ff518e4a1c8eb62e15d5e39f176751890fabab24db6eae3a45a37ad3b144abf05a78b66317d

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 David Michael
+
+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,29 @@
+# Box
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'box'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install box
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/box/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/box/authorization.rb

@@ -0,0 +1,64 @@
+
+module Box
+  class Authorization
+
+    def self.authorize(config = {})
+      username, password = config[:username], config[:password]
+      raise "Unable to get auth tokens without username and password" unless username && password
+
+      require 'mechanize'
+
+      puts '... attempting to authorize with username and password'
+      client_id, client_secret = config[:client_id], config[:client_secret]
+
+
+      agent   = Mechanize::new
+      session = Session.new(config)
+
+      # Get the authorization URL from Box by specifying redirect URL
+      # as the arbitrary but working Chase bank home page - this must match the address at Box
+      # authorize_url = box_session.authorize_url('https://anywhere.airdye.com/oauth2callback')
+      authorize_url = session.authorize_url(redirect_uri: 'https://www.chase.com')
+
+      # process the first login screen
+      login_page = agent.get(authorize_url)
+
+      # get the login form where you enter the username and password
+      login_form          = login_page.form_with(name: 'login_form')
+      login_form.login    = username
+      login_form.password = password
+
+      # submit the form and get the allow/deny page back
+      allow_page = agent.submit(login_form)
+
+      # find the form that allows consent
+      consent_form = allow_page.form_with(name: 'consent_form')
+
+      # now find the button that submits the allow page with consent
+      accept_button = consent_form.button_with(name: 'consent_accept')
+
+      # Submit the form to cause the redirection with authentication code
+      redirpage = agent.submit(consent_form, accept_button)
+
+      # Use the CGI module to get a hash of the variables (stuff after ?)
+      # and then the authentication code is embedded in [" and "] so
+      # strip those
+      code_query = CGI::parse(redirpage.uri.query)['code'].to_s
+      code = code_query[2,code_query.length-4]
+
+      # get the box access token using the authentication code
+      session.aquire_access_token(code)
+
+      # print the tokens to show we have them
+      p session.access_token
+      p session.refresh_token
+
+      Box::Session.on_token_refresh.call(session.access_token, session.refresh_token)
+
+      # Create a new Box client based on the authenticated session
+      # ap Box.client.root.items
+
+      return session.oauth2_access_token
+    end
+  end
+end

data/lib/box/client.rb

@@ -0,0 +1,168 @@
+
+
+
+module Box
+  class Client
+    VERSION = '2.0'
+    attr_accessor :session
+
+    def initialize(session)
+      @session = session
+    end
+
+    def root
+      Folder.new(self, id: 0)
+    end
+
+    def walk(root, &block)
+      root.items.each do |item|
+        if item.folder?
+          walk(item, &block)
+        elsif item.file?
+          yield item
+        else
+          puts "Unknown item type #{item.id}:#{item.type}"
+        end
+      end
+    end
+
+    # Starting at the "root" of Box which is always "All Files", make successive requests untl you have reached the
+    # final path in the input
+    def folder(path) # /path/to/folder
+      path = Pathname(path).each_filename.to_a
+      folder = root
+      path.each do |name|
+        folder = folder.folders.select {|folder| folder.name == name}.first
+        return nil unless folder
+      end
+      folder
+    end
+
+    def search(query, options = {})
+      params = options.merge({query: query})
+
+      response = get('search', params)
+      parse_items(response.body)
+    end
+
+    # Process the Box "items" returned from a request
+    def parse_items(results)
+      return [] if results['entries'].empty?
+      results['entries'].reduce([]) do |entries, entry|
+        entries << case entry['type']
+          when 'file'   then Box::File.new(self, entry)
+          when 'folder' then Box::Folder.new(self, entry)
+        end
+        entries
+      end
+    end
+
+    def connection
+      conn = Faraday.new(Box::API_URL) do |builder|
+        builder.request :json
+        builder.request :multipart
+        # builder.response :logger
+        builder.response :json, :content_type => /\bjson$/
+        # What a joke. This must be LAST to avoid encoding errors in JSON request body
+        builder.adapter  :net_http
+      end
+
+      conn.headers['Authorization'] = "Bearer #{@session.access_token}"
+      conn
+    end
+
+    def make_uri(path)
+
+    end
+
+    def get(path, params = {}, retries = 0)
+      request('GET', path, params)
+    end
+
+    def post(path, params = {}, retries = 0)
+      request('POST', path, params)
+    end
+
+    def put(path, params = {}, retries = 0)
+      request('PUT', path, params)
+    end
+
+    def delete(path, params = {}, retries = 0)
+      request('DELETE', path, params)
+    end
+
+    def upload(params = {}, retries = 0)
+      # Basic parameters
+      local_path, content_type, file_name, parent_id = params[:local_path], params[:content_type], params[:file_name], params[:parent_id]
+      # If there is a file_id, it means we want to replace it.
+      uri = if params[:box_id]
+        "https://upload.box.com/api/2.0/files/#{params[:box_id]}/content"
+      else
+        'https://upload.box.com/api/2.0/files/content'
+      end
+
+      puts "[Box.com] POST #{uri}"
+
+      # Construct the payload
+      payload = {
+        filename:  Faraday::UploadIO.new(local_path, content_type, file_name),
+        parent_id: parent_id
+      }
+
+      response = connection.post(uri, payload) do |request|
+        request.headers['Content-Type'] = 'multipart/form-data'
+      end
+
+      case response.status
+        when 401
+          try_token_refresh!
+          return upload(params, retries + 1) if retries == 0
+        else
+          return handle_response(response)
+      end
+    end
+
+    # Generic HTTP request method with retries for bad authorization
+    def request(method, path, params = {}, retries = 0)
+      uri = Addressable::URI.parse(::File.join(VERSION, path))
+      if method == 'GET'
+        uri.query_values = params.reduce({}){|hash, (k,v)| hash[k] = v.to_s; hash}
+        # params = {}
+      end
+
+      puts "[Box.com] #{method} #{::File.join(Box::API_URL, uri.to_s)}"
+      response = connection.send(method.downcase, uri.to_s, params)
+
+      case response.status
+        when 401
+          try_token_refresh!
+          return request(method, path, params, retries + 1) if retries == 0
+        else
+          return handle_response(response)
+      end
+    # TODO: We need to retry connection failures - or at least catch them
+    # rescue Faraday::ConnectionFailed => e
+    end
+
+    def try_token_refresh!
+      @session.refresh_token!
+    rescue OAuth2::Error => e
+      raise "Sorry, could not refresh tokens: #{e.message}"
+    end
+
+    def handle_response(response)
+      case response.status
+        when 400
+          raise Box::MalformedAuthHeaders, response.headers
+        when 404
+          raise Box::ResourceNotFound, JSON.dump(response.body)
+        when 409
+          raise Box::NameConflict,  JSON.dump(response.body)
+        when 500
+          ap response.body
+      end
+      return response
+    end
+
+  end
+end

data/lib/box/exceptions.rb

@@ -0,0 +1,16 @@
+module Box
+  class BoxError < StandardError
+  end
+
+  class ArgumentError < BoxError
+  end
+
+  class NameConflict < BoxError
+  end
+
+  class ResourceNotFound < BoxError
+  end
+
+  class MalformedAuthHeaders < BoxError
+  end
+  end

data/lib/box/file.rb

@@ -0,0 +1,61 @@
+module Box
+  class File < Item
+    def_delegators :@metadata, :sha1, :name, :size, :etag, :parent
+
+    def self.download_uri(id)
+      response = Box.client.get("/files/#{id}/content")
+      uri = nil
+      uri = response.headers['location'] if response.status == 302
+      uri
+    end
+
+    def size
+      @metadata['size']
+    end
+
+    def path
+      "/" + path_names.join('/')
+    end
+
+    def path_with_file
+      ::File.join(path, name)
+    end
+
+    def paths
+      @metadata['path_collection']['entries']
+    end
+
+    def path_names
+      paths.map {|path| path['name']}
+    end
+
+    def self.delete_existing(id)
+      Box.client.delete("files/#{id}")
+    end
+
+
+    # Ruby is such a pain in the ass with it's loosy goosy type
+    # @return [Box::File] The newly created file on Box
+    def copy_to(folder, options = {})
+      raise Box::ArgumentError, 'folder must be a Box::Folder' unless folder.is_a?(Box::Folder)
+      raise Box::ArgumentError, 'options must be a Hash' unless options.is_a?(Hash)
+
+      folder_id = folder.id
+
+      params = {parent: {id: folder_id}, name: options[:name]}
+      # This response is a Box file object
+      response = @client.post("files/#{id}/copy", params)
+      Box::File.new(@client, response.body)
+    end
+
+    # Since this is just an update, this method is idempotent always returning a file
+    def move_to(folder, options = {})
+      folder_id = (folder.is_a?(Box::Folder)) ? folder.id : folder
+
+      response = @client.put("files/#{id}", parent:{id: folder_id})
+      Box::File.new(@client, response.body)
+    end
+
+
+  end
+end

data/lib/box/folder.rb

@@ -0,0 +1,65 @@
+module Box
+  class Folder < Item
+    LIMIT = 1000
+    def_delegators :@metadata, :name
+
+    def load_info!
+      @client.get("/folders/#{id}")
+    end
+
+    # Check to see if an item of the same name in the folder
+    def has_item?(name)
+      items.find {|item| item.name == name}
+    end
+
+    def subfolder(folder_name)
+      folders = items.select {|item| item.folder? and item.name == folder_name}
+      return nil if folders.empty?
+      folders.first
+    end
+
+    def find_or_create_subfolder(folder_name)
+      folder = subfolder(folder_name)
+      return folder unless folder.nil?
+
+      puts "[Box.com] Creating subfolder in #{self.name} for #{folder_name}"
+      response = @client.post('folders', {name: folder_name, parent:{id: self.id}})
+
+      if response.status == 201 # created
+        folder = Box::Folder.new(@client, response.body)
+        puts "[Box.com] Created folder for #{folder_name} in #{name} as #{folder.id}"
+        folder
+      else
+        puts "[Box.com] Error creating folder, #{response.body}"
+        nil
+      end
+
+    end
+
+    # Warning: This gets on all files for a directory with no limit by recursively calling itself until it reaches
+    # the limit
+    def items(params = {}, collection = [])
+      # Format params defaults
+      params = {fields: 'sha1,name,path_collection,size', limit: LIMIT, offset: 0}.merge(params)
+      # Add expected fields and limit
+      response = @client.get("/folders/#{id}/items", params)
+      ap response
+      # Add the results to the total collection
+      collection.push *@client.parse_items(response.body)
+
+      total_count = response.body['total_count']
+      offset      = (LIMIT * (params[:offset] + 1))
+
+      if total_count > offset
+        puts "[Box.com] Recursively calling for items in folder #{name} - #{LIMIT}, #{offset}, #{total_count}"
+        return self.items({offset: offset}, collection)
+      end
+
+      collection
+    end
+
+    def folders
+      items.select {|item| item.type == 'folder' }
+    end
+  end
+end

data/lib/box/item.rb

@@ -0,0 +1,40 @@
+require 'forwardable'
+
+module Box
+  class Item
+    attr_accessor :client, :metadata
+    extend Forwardable
+    extend Memoist
+
+    def self.type
+      self.name.demodulize.downcase
+    end
+
+    def initialize(*args)
+      if args.size == 1
+        @client, @metadata = Box.client, Hashie::Mash.new(args[0])
+      else
+        @client, @metadata = args[0], Hashie::Mash.new(args[1])
+      end
+
+    end
+
+    def folder?
+      type == 'folder'
+    end
+
+    def file?
+      type == 'file'
+    end
+
+    def self.find(id)
+      response = Box.client.get("#{type.pluralize}/#{id}")
+      self.new(Box.client, response.body)
+    rescue Box::ResourceNotFound => e
+      nil
+    end
+
+
+    def_delegators :@metadata, :id, :type
+  end
+end

data/lib/box/session.rb

@@ -0,0 +1,72 @@
+module Box
+  class Session
+    extend Memoist
+    attr_accessor :client_id, :client_secret, :access_token, :refresh_token, :on_token_refresh, :oauth2_access_token
+    attr_accessor :config
+
+    class << self
+        attr_accessor :on_token_refresh
+        @on_token_refresh = -> (access_token, refresh_token) {}
+    end
+
+    OAUTH2_URLS = {
+      site:          'https://www.box.com',
+      authorize_url: '/api/oauth2/authorize',
+      token_url:     '/api/oauth2/token'
+    }
+
+    def initialize(config = {})
+      @config = config
+      # We must have at least these variables
+      @client_id     = config[:client_id]
+      @client_secret = config[:client_secret]
+      @access_token  = config[:access_token]
+      @refresh_token = config[:refresh_token]
+
+      if @access_token
+        @oauth2_access_token = OAuth2::AccessToken.new(oauth2_client, @access_token, {refresh_token: @refresh_token})
+      end
+    end
+
+    def oauth2_client
+      OAuth2::Client.new(@client_id, @client_secret, OAUTH2_URLS.dup)
+    end
+    memoize :oauth2_client
+
+    # {redirect_uri: value}
+    def authorize_url(options = {})
+      oauth2_client.auth_code.authorize_url(options)
+    end
+
+    # @return [OAuth2::AccessToken]
+    def aquire_access_token(code)
+      @oauth2_access_token = oauth2_client.auth_code.get_token(code)
+      set_tokens!
+      @oauth2_access_token
+    end
+
+    def set_tokens!
+      @access_token  = @oauth2_access_token.token
+      @refresh_token = @oauth2_access_token.refresh_token
+    end
+
+    def refresh_token!
+      @oauth2_access_token = @oauth2_access_token.refresh!
+      set_tokens!
+      Box::Session.on_token_refresh.call(@oauth2_access_token.token, @oauth2_access_token.refresh_token)
+      @oauth2_access_token
+    rescue OAuth2::Error => e
+      if e.code == 'invalid_client' || ((e.code == 'invalid_grant') && (e.description == 'Refresh token has expired' || e.description == 'Invalid refresh token'))
+        raise e if @config[:disable_auth]
+        puts "Error authenticating Box -> #{e.message}"
+        puts 'Attempting to reauthorize and get new tokens'
+        @oauth2_access_token = Box::Authorization.authorize(config)
+        set_tokens!
+        return @oauth2_access_token
+      else
+        raise e
+      end
+    end
+
+  end
+end

data/lib/box/version.rb

@@ -0,0 +1,3 @@
+module Box
+  VERSION = "0.0.7"
+end

data/lib/box.rb

@@ -0,0 +1,61 @@
+require 'memoist'
+require 'hashie'
+require 'faraday'
+require 'faraday_middleware'
+require 'addressable/uri'
+require 'oauth2'
+
+$LOAD_PATH << File.dirname(__FILE__)
+require 'box/version'
+
+module Box
+  API_URL = 'https://api.box.com'
+  UPLOAD_URL = 'https://upload.box.com/api/2.0'
+  ISO_8601_TEST = Regexp.new(/^[0-9]{4}-[0-9]{2}-[0-9]{2}T/)
+
+  class << self
+    extend Memoist
+
+    def client(config = {})
+      # Accounts for both string and Symbol keyed hashes.
+      # This is basically stringify_keys, just less efficient
+      config = Hashie::Mash.new(config)
+      # You can either pass in the config, or set it from the environment variables
+      config = {
+        access_token:  config['access_token'] || ENV['BOX_ACCESS_TOKEN'],
+        refresh_token: config['refresh_token'] || ENV['BOX_REFRESH_TOKEN'],
+        client_id:     config['client_id'] || ENV['BOX_CLIENT_ID'],
+        client_secret: config['client_secret'] || ENV['BOX_CLIENT_SECRET'],
+        username:      config['username'] || ENV['BOX_USERNAME'],
+        password:      config['password'] || ENV['BOX_PASSWORD']
+      }
+  
+      # Box::Authorization.authorize client_id, client_secret
+      session = create_session(config)
+      Box::Client.new(session)
+    end
+    # memoize :client
+
+    def create_session(config = {})
+      Box::Session.new config
+    end
+
+  end
+end
+
+require 'box/exceptions'
+require 'box/client'
+require 'box/session'
+require 'box/authorization'
+require 'box/item'
+require 'box/folder'
+require 'box/file'
+
+Box::Session.on_token_refresh = -> (access_token,refresh_token) {
+  puts 'Box::Session.on_token_refresh called with'
+  puts access_token
+  puts refresh_token
+}
+
+
+

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: box-com
+version: !ruby/object:Gem::Version
+  version: 0.0.7
+platform: ruby
+authors:
+- David Michael
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-25 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: memoist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+- !ruby/object:Gem::Dependency
+  name: mechanize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.7.2
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: addressable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 2.2.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 2.2.4
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+description: Write a longer description. Optional.
+email:
+- david.michael@giantmachines.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/box.rb
+- lib/box/authorization.rb
+- lib/box/client.rb
+- lib/box/exceptions.rb
+- lib/box/file.rb
+- lib/box/folder.rb
+- lib/box/item.rb
+- lib/box/session.rb
+- lib/box/version.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Write a short summary. Required.
+test_files: []