box_cli 0.1.0

data/lib/box_cli/settings_command.rb

@@ -0,0 +1,24 @@
+module BoxCli
+  class SettingsCommand < Command
+    def initialize(options, args)
+      super
+      collect_globals_from_env
+    end
+
+    def call
+      STDOUT.puts("Options:\n".tap do |s|
+        if @options.__hash__.empty?
+          s << "  (none)\n"
+        else
+          s << @options.__hash__.keys.map(&:to_s).sort.map { |k| "  %s: %s" % [k, @options.__hash__[k.to_sym]] }.join("\n")
+        end
+        s << "\n\nArguments:\n"
+        if @args.empty?
+          s << "  (none)\n"
+        else
+          s << @args.map { |p| "  #{p}" }.join("\n")
+        end
+      end)
+    end
+  end
+end

data/lib/box_cli/terminal.rb

@@ -0,0 +1,13 @@
+module BoxCli
+  class Terminal
+    def self.ask(prompt)
+      highline.ask(prompt)
+    end
+    
+    private
+    
+    def self.highline
+      @highline ||= HighLine.new
+    end
+  end
+end

data/lib/box_cli/upload_command.rb

@@ -0,0 +1,8 @@
+module BoxCli
+  class UploadCommand < BoxCommand
+    def call
+      path, folder_path = @args
+      wrapper.upload(path, folder_path)
+    end
+  end
+end

data/lib/box_cli/version.rb

@@ -0,0 +1,3 @@
+module BoxCli
+  VERSION = '0.1.0'
+end

data/lib/box_cli/wrapper.rb

@@ -0,0 +1,149 @@
+require 'box-api'
+require 'mechanize'
+require 'active_support/ordered_hash'
+require 'active_support/hash_with_indifferent_access'
+
+module Box
+  class Account
+    send(:public, :api)
+  end
+
+  class Api
+    def auth_token
+      @auth_token
+    end
+    
+    query_string_normalizer proc { |query|
+      indifferent = ActiveSupport::HashWithIndifferentAccess.new(query)
+      query.keys.map(&:to_s).sort.map do |key|
+        value = indifferent[key]
+        if value.nil?
+          key
+        elsif Array === value
+          value.map { |v| "#{key}[]=#{URI.encode(v.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))}" }
+        else
+          "#{key}=#{value}"
+        end
+      end.flatten.join('&')
+    }
+  end
+end
+
+module BoxCli
+  class Exception < ::Exception; end
+  class NotFound < Exception; end
+  class NotAuthorized < Exception; end
+  class FolderNameTaken < Exception; end
+  class FileNameTaken < Exception; end
+  
+  class Wrapper
+    def initialize(api_key, username, password)
+      @api_key, @username, @password = api_key, username, password
+    end
+
+    def self.auth_token_manager_class=(auth_token_manager_class)
+      @auth_token_manager_class = auth_token_manager_class
+    end
+    
+    def self.auth_token_manager_class
+      @auth_token_manager_class || AuthTokenManager
+    end
+    
+    def auth_token_manager=(auth_token_manager)
+      @auth_token_manager = auth_token_manager
+    end
+    
+    def auth_token_manager
+      @auth_token_manager || self.class.auth_token_manager_class.new(@username)
+    end
+    
+    def account_info
+      api.get_account_info
+    end
+    
+    def create_folder(folder_name)
+      folder = root.create(folder_name)
+      folder.id
+    rescue Box::Api::NameTaken => e
+      raise FolderNameTaken.new("Folder '#{folder_name}' already exists")
+    end
+
+    def delete(remote_path)
+      item = root.at(remote_path)
+      raise NotFound.new("Nothing found at '#{remote_path}'") unless item
+      api.delete(item.type, item.id)
+    end
+    
+    def info(remote_path)
+      item = root.at(remote_path)
+      raise NotFound.new("Nothing found at '#{remote_path}'") unless item
+      ActiveSupport::OrderedHash[:type, item.type, :data, item.data]
+    end
+
+    def upload(local_path, remote_path)
+      target_folder = root.at(remote_path)
+      basename = File.basename(local_path)
+      target_path = File.join(remote_path, basename)
+      if item = root.at(target_path)
+        raise FileNameTaken.new("File '#{basename}' already exists at #{remote_path}")
+      else
+        api.upload(local_path, target_folder.id)
+      end
+    end
+    
+    def upload_or_overwrite(local_path, remote_path)
+      target_folder = root.at(remote_path)
+      target_path = File.join(remote_path, File.basename(local_path))
+      if item = root.at(target_path)
+        api.overwrite(local_path, item.id)
+      else
+        api.upload(local_path, target_folder.id)
+      end
+    end
+
+    def root_folder_id
+      root.id
+    end
+
+    private
+
+    def api
+      account.api
+    end
+    
+    def account
+      unless @account
+        @api = Box::Api.new(@api_key)
+        account = Box::Account.new(@api)
+        auth_token = auth_token_manager.get_auth_token
+        account.authorize(:auth_token => auth_token) do |auth_url|
+          authorize(auth_url, @username, @password)
+        end
+        unless account.authorized?
+          auth_token_manager.remove
+          raise NotAuthorized
+        end
+        auth_token_manager.save(auth_token)
+        @account = account
+      end
+      @account
+    end
+
+    def authorize(auth_url, username, password)
+      Mechanize.new do |agent|
+        agent.user_agent = :safari
+        agent.get(auth_url) do |login_page|
+          login_page.form_with(:name => 'login_form1') do |login_form|
+            login_form['login'] = username
+            login_form['password'] = password
+            return login_form.submit
+          end
+        end
+      end
+    end
+    
+    def root
+      account.root
+    end
+  end
+end

data/lib/box_cli.rb

@@ -0,0 +1,27 @@
+require 'box_cli/version'
+require 'box_cli/auth_token_manager'
+require 'box_cli/hash_to_pretty'
+require 'box_cli/displayer'
+require 'box_cli/wrapper'
+
+require 'box_cli/command'
+require 'box_cli/box_command'
+require 'box_cli/account_info_command'
+require 'box_cli/create_folder_command'
+require 'box_cli/delete_command'
+require 'box_cli/info_command'
+require 'box_cli/settings_command'
+require 'box_cli/terminal'
+require 'box_cli/upload_command'
+
+require 'active_support/inflector'
+
+module BoxCli
+  def self.dispatch(name, options, args)
+    "BoxCli::#{name.camelize}Command".constantize.new(options, args).call
+    0
+  rescue Exception => e
+    puts "#{e.message}"
+    1
+  end
+end

data/spec/box_cli/account_info_command_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe BoxCli::AccountInfoCommand do
+  it "returns account info for good credentials and an api key", :vcr do
+    BoxCli::Displayer.any_instance.expects(:display).with(regexp_matches(/Status\:\s+get_account_info_ok\s+User:\s+Access:\s+\d+\s+Email:\s+/))
+    BoxCli::AccountInfoCommand.new(options, []).call
+  end
+end

data/spec/box_cli/box_command_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe BoxCli::BoxCommand, '.new', 'options' do
+  subject(:command) { BoxCli::BoxCommand.new(options_with_local_option, ['arg2', 'arg1']) }
+  it "partitions :user, :password, and :api_key into the global options" do
+    expect(command.global_options).to eq OpenStruct.new(options_hash)
+  end
+  it "partitions :some_local_option into the local options" do
+    expect(command.local_options).to eq OpenStruct.new(options_hash_local_option)
+  end
+  it "initializes the args" do
+    expect(command.args).to eq ['arg2', 'arg1']
+  end
+end
+
+describe BoxCli::BoxCommand, '.new', 'prompting' do
+  before do
+    @save_password = ENV['BOX_CLI_PASSWORD']
+    ENV['BOX_CLI_PASSWORD'] = nil
+    BoxCli::Terminal.stubs(:ask)
+    BoxCli::BoxCommand.new(options_with_local_option_without_password, ['arg2', 'arg1'])
+  end
+  after do
+    ENV['BOX_CLI_PASSWORD'] = @save_password
+  end
+  it "prompts for missing global options" do
+    expect(BoxCli::Terminal).to have_received(:ask).with('password: ')
+  end
+end
+
+describe BoxCli::BoxCommand, '#wrapper' do
+  subject(:command) { BoxCli::BoxCommand.new(options_with_local_option, ['arg2', 'arg1']) }
+  before do
+    BoxCli::Wrapper.stubs(:new)
+    command.wrapper
+  end
+  it "creates an instance of BoxCli::Wrapper with the user, password, and api_key" do
+    expect(BoxCli::Wrapper).to have_received(:new).with(options_hash[:api_key], options_hash[:user], options_hash[:password])
+  end
+end
+
+describe BoxCli::BoxCommand, '#wrapper' do
+  subject(:command) { BoxCli::BoxCommand.new(options_with_local_option, ['arg2', 'arg1']) }
+  before do
+    command.wrapper
+  end
+  it "returns a kind of a BoxCli::Wrapper" do
+    expect(command.wrapper).to be_a_kind_of(BoxCli::Wrapper)
+  end
+end

data/spec/box_cli/create_folder_command_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe BoxCli::CreateFolderCommand do
+  let(:folder_name) { 'a_very_unlikely_folder_name' }
+
+  before(:each) do
+    begin
+      BoxCli::DeleteCommand.new(options, [folder_name]).call
+    rescue BoxCli::NotFound
+    end
+  end
+  
+  it "creates a folder when none by that name already exists", :vcr do
+    BoxCli::CreateFolderCommand.new(options, [folder_name]).call
+    expect { BoxCli::InfoCommand.new(options, [folder_name]).call }.to_not raise_error
+  end
+
+  it "raises an exception when a folder by that name already exists", :vcr do
+    BoxCli::CreateFolderCommand.new(options, [folder_name]).call
+    expect { BoxCli::CreateFolderCommand.new(options, [folder_name]).call }.to raise_error BoxCli::FolderNameTaken
+  end
+end

data/spec/box_cli/delete_command_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe BoxCli::DeleteCommand do
+  let(:folder_name) { 'a_very_unlikely_folder_name' }
+
+  before(:each) do
+    begin
+      BoxCli::DeleteCommand.new(options, [folder_name]).call
+    rescue BoxCli::NotFound
+    end
+  end
+  
+  it "raises an exception when there is nothing to delete", :vcr do
+    expect { BoxCli::DeleteCommand.new(options, [folder_name]).call }.to raise_error BoxCli::NotFound
+  end
+
+  it "does not raise an exception when deleting something that exists", :vcr do
+    BoxCli::CreateFolderCommand.new(options, [folder_name]).call
+    expect { BoxCli::DeleteCommand.new(options, [folder_name]).call }.to_not raise_error
+  end
+
+  it "deletes the item when something is there", :vcr do
+    BoxCli::CreateFolderCommand.new(options, [folder_name]).call
+    BoxCli::DeleteCommand.new(options, [folder_name]).call
+    expect { BoxCli::InfoCommand.new(options, [folder_name]).call }.to raise_error BoxCli::NotFound
+  end
+end

data/spec/box_cli/generic_box_command_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'Generic Box Command' do
+  it "fails for bad credentials", :vcr do
+    expect { BoxCli::AccountInfoCommand.new(options_with_bad_credentials, []).call }.to raise_error BoxCli::NotAuthorized
+  end
+  it "fails for a bad api key", :vcr do
+    expect { BoxCli::AccountInfoCommand.new(options_with_bad_api_key, []).call }.to raise_error Box::Api::Restricted
+  end
+end

data/spec/box_cli/hash_to_pretty_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe BoxCli::HashToPretty do
+  it "generates a pretty string for a hash" do
+    expect({ :a => 1, :b => 2 }.extend(BoxCli::HashToPretty).to_pretty).to eq(<<-PRETTY.strip_heredoc)
+    A: 1
+    B: 2
+    PRETTY
+  end
+  it "can handle keys that are strings or symbols" do
+    expect({ :a => 1, 'b' => 2 }.extend(BoxCli::HashToPretty).to_pretty).to eq(<<-PRETTY.strip_heredoc)
+    A: 1
+    B: 2
+    PRETTY
+  end
+  it "Preserves top-level key order when an ordered hash is used" do
+    expect(ActiveSupport::OrderedHash[:b, 2, :a, 1 ].extend(BoxCli::HashToPretty).to_pretty).to eq(<<-PRETTY.strip_heredoc)
+    B: 2
+    A: 1
+    PRETTY
+  end
+  it "lines up the key/value pairs when the keys have different length" do
+    expect({ :a => 1, :beta => 2 }.extend(BoxCli::HashToPretty).to_pretty).to eq(<<-PRETTY.strip_heredoc)
+    A:    1
+    Beta: 2
+    PRETTY
+  end
+  it "Humanizes the keys" do
+    expect({ :social_security_number => '457-55-5462', :title => 'LifeLock CEO' }.extend(BoxCli::HashToPretty).to_pretty).to eq(<<-PRETTY.strip_heredoc)
+    Social security number: 457-55-5462
+    Title:                  LifeLock CEO
+    PRETTY
+  end
+  it "Indents values that are themselves hashes" do
+    expect({ :a => 1, :b => { :x => 2, :y => 3, :z => 4}, :c => 5 }.extend(BoxCli::HashToPretty).to_pretty).to eq(<<-PRETTY.strip_heredoc)
+    A: 1
+    B:
+       X: 2
+       Y: 3
+       Z: 4
+    C: 5
+    PRETTY
+  end
+  it "Provides a means to display hierarchical hash data that don't look like garbage" do
+    expect({ "status" => "get_account_info_ok", "user" => { "login" => "john@iorahealth.com", "email" => "john@iorahealth.com", "access_id" => "11756654", "user_id" => "11756654", "space_amount" => "21474836480", "space_used" => "1657381031", "max_upload_size" => "2147483647" } }.extend(BoxCli::HashToPretty).to_pretty).to eq(<<-PRETTY.strip_heredoc)
+    Status: get_account_info_ok
+    User:
+       Access:          11756654
+       Email:           john@iorahealth.com
+       Login:           john@iorahealth.com
+       Max upload size: 2147483647
+       Space amount:    21474836480
+       Space used:      1657381031
+       User:            11756654
+    PRETTY
+  end
+end

data/spec/box_cli/info_command_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe BoxCli::InfoCommand do
+  let(:folder_name) { 'a_very_unlikely_folder_name' }
+
+  before(:each) do
+    begin
+      BoxCli::DeleteCommand.new(options, [folder_name]).call
+    rescue BoxCli::NotFound
+    end
+  end
+  
+  it "provides output regarding the item if it exists", :vcr do
+    BoxCli::CreateFolderCommand.new(options, [folder_name]).call
+    BoxCli::Displayer.any_instance.expects(:display).with(regexp_matches(/Type:\s+folder\s+Data:\s+.*?Name:\s+#{Regexp.escape(folder_name)}/m))
+    BoxCli::InfoCommand.new(options, [folder_name]).call
+  end
+
+  it "raises an exception if nothing is there", :vcr do
+    expect { BoxCli::InfoCommand.new(options, [folder_name]).call }.to raise_error BoxCli::NotFound
+  end
+end

data/spec/box_cli/settings_command_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe BoxCli::SettingsCommand do
+  it "provides output regarding options" do
+    STDOUT.expects(:puts).with(regexp_matches(/Options:\s+api_key:\s+\w+\s+password:\s+\w+\s+user:\s+\w+/m))
+    BoxCli::SettingsCommand.new(options, []).call
+  end
+  it "provides output regarding arguments" do
+    STDOUT.expects(:puts).with(regexp_matches(/Arguments:\s+arg2\s+arg1/m))
+    BoxCli::SettingsCommand.new(options, ['arg2', 'arg1']).call
+  end
+end

data/spec/box_cli/upload_command_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe BoxCli::UploadCommand do
+ let(:file_name) { 'a_very_unlikely_file_name.txt' }
+ let(:temp_dir) { File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'tmp')) }
+ let(:local_path) { File.join(temp_dir, file_name) }
+
+  before(:each) do
+    begin
+      BoxCli::DeleteCommand.new(options, [file_name]).call
+    rescue BoxCli::NotFound
+    end
+    FileUtils.mkdir_p temp_dir
+    FileUtils.touch local_path
+  end
+  
+  after(:each) do
+    FileUtils.rm local_path
+  end
+  
+  it "uploads a file when none by that name already exists", :vcr do
+    BoxCli::UploadCommand.new(options, [local_path, '/']).call
+    expect { BoxCli::InfoCommand.new(options, [file_name]).call }.to_not raise_error
+  end
+
+  it "raises an exception when a file by that name already exists", :vcr do
+    BoxCli::UploadCommand.new(options, [local_path, '/']).call
+    expect {  BoxCli::UploadCommand.new(options, [local_path, '/']).call }.to raise_error BoxCli::FileNameTaken
+  end
+end

data/spec/box_helpers.rb

@@ -0,0 +1,40 @@
+module BoxHelpers
+  class FakeCommanderOptions
+    attr_reader :__hash__
+    def initialize(options)
+      @__hash__ = options
+    end
+    def method_missing(m, *args)
+      @__hash__[m]
+    end
+  end
+
+  def options
+    FakeCommanderOptions.new(options_hash)
+  end
+
+  def options_with_local_option
+    FakeCommanderOptions.new(options_hash.merge(options_hash_local_option))
+  end
+    
+  def options_with_local_option_without_password
+    FakeCommanderOptions.new(options_hash.merge(options_hash_local_option).reject { |k, v| k == :password })
+  end
+  
+  def options_with_bad_credentials
+    FakeCommanderOptions.new(options_hash.merge(:user => 'nonexistent_user@iorahealth.com'))
+  end
+  
+  def options_with_bad_api_key
+    FakeCommanderOptions.new(options_hash.merge(:api_key => 'mybaloneyhasafirstname'))
+  end
+
+
+  def options_hash
+    { :user => ENV['BOX_CLI_USER'], :password => ENV['BOX_CLI_PASSWORD'], :api_key => ENV['BOX_CLI_API_KEY'] }
+  end
+
+  def options_hash_local_option
+    { :local_option => 'extra' }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'vcr'
+require 'box_helpers'
+require 'mocha_standalone'
+require 'bourne'
+
+PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$LOAD_PATH << File.join(PROJECT_ROOT, "lib")
+require 'box_cli'
+
+class String
+  # From ActiveSupport
+  def strip_heredoc
+    indent = chomp.scan(/^\s*/).min.size
+    gsub(/^\s{#{indent}}/, '')
+  end
+end
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'fixtures/cassettes'
+  c.hook_into :fakeweb
+  c.default_cassette_options = { :serialize_with => :json }
+  c.preserve_exact_body_bytes do |http_message|
+    RUBY_VERSION == '1.8.7' || (http_message.body.encoding.name == 'ASCII-8BIT' || !http_message.body.valid_encoding?)
+  end
+  c.filter_sensitive_data("<BOX_CLI_USER>")     { ENV['BOX_CLI_USER'] }
+  c.filter_sensitive_data("<BOX_CLI_PASSWORD>") { ENV['BOX_CLI_PASSWORD'] }
+  c.filter_sensitive_data("<BOX_CLI_API_KEY>")  { ENV['BOX_CLI_API_KEY'] }
+  c.configure_rspec_metadata!
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.order = :random
+  config.include BoxHelpers
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+end