droxi 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c42bb596852aacff40852b70646a1a74c49930ff
+  data.tar.gz: a1cae76af97bc5064f2ee567035d5a50c6e768c9
+SHA512:
+  metadata.gz: 1a4b91bca5b16d9bc98b3ab37fde5e5404ec86eb8ffc0f28426657a6555882efa34849b020c410205665044a4e2abe34bce85928e011d5d13b4417a2debe2486
+  data.tar.gz: b5fa9257afa11b305124d823efa38dc32c3c8fffc577a094ce6f0b249bccdce1d89f8f95cf4e28114da916a074782c94a96503be0b84d8ec4449c44fe42436b5

data/bin/droxi

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'droxi'
+Droxi.run

data/lib/droxi/commands.rb

@@ -0,0 +1,329 @@
+require 'readline'
+
+module Commands
+  class UsageError < ArgumentError
+  end
+
+  class Command
+    attr_reader :usage, :description
+
+    def initialize(usage, description, procedure)
+      @usage = usage
+      @description = description.squeeze(' ')
+      @procedure = procedure
+    end
+
+    def exec(client, state, *args)
+      if num_args_ok?(args.length)
+        block = proc { |line| yield line if block_given? }
+        @procedure.yield(client, state, args, block)
+      else
+        raise UsageError.new(@usage)
+      end
+    end
+
+    def num_args_ok?(num_args)
+      args = @usage.split.drop(1)
+      min_args = args.reject { |arg| arg.start_with?('[') }.length
+      if args.last.end_with?('...')
+        max_args = num_args
+      else
+        max_args = args.length
+      end
+      (min_args..max_args).include?(num_args)
+    end
+
+    def type_of_arg(index)
+      args = @usage.split.drop(1)
+      index = [index, args.length - 1].min
+      args[index].tr('[].', '')
+    end
+  end
+
+  CD = Command.new(
+    'cd [REMOTE_DIR]',
+    "Change the remote working directory. With no arguments, changes to the \
+     Dropbox root. With a remote directory name as the argument, changes to \
+     that directory. With - as the argument, changes to the previous working \
+     directory.",
+    lambda do |client, state, args, output|
+      if args.empty?
+        state.pwd = '/'
+      elsif args[0] == '-'
+        state.pwd = state.oldpwd
+      else
+        path = state.resolve_path(args[0])
+        if state.is_dir?(client, path)
+          state.pwd = path
+        else
+          output.call('Not a directory')
+        end
+      end
+    end
+  )
+
+  GET = Command.new(
+    'get REMOTE_FILE...',
+    "Download each specified remote file to a file of the same name in the \
+     local working directory.",
+    lambda do |client, state, args, output|
+      state.expand_patterns(client, args).each do |path|
+        begin
+          contents = client.get_file(path)
+          File.open(File.basename(path), 'wb') do |file|
+            file.write(contents)
+          end
+        rescue DropboxError => error
+          output.call(error.to_s)
+        end
+      end
+    end
+  )
+
+  HELP = Command.new(
+    'help [COMMAND]',
+    "Print usage and help information about a command. If no command is \
+     given, print a list of commands instead.",
+    lambda do |client, state, args, output|
+      if args.empty?
+        table_output(NAMES).each { |line| output.call(line) }
+      else
+        cmd_name = args[0]
+        if NAMES.include?(cmd_name)
+          cmd = const_get(cmd_name.upcase.to_s)
+          output.call(cmd.usage)
+          wrap_output(cmd.description).each { |line| output.call(line) }
+        else
+          output.call("Unrecognized command: #{cmd_name}")
+        end
+      end
+    end
+  )
+
+  LCD = Command.new(
+    'lcd [LOCAL_DIR]',
+    "Change the local working directory. With no arguments, changes to the \
+     home directory. With a local directory name as the argument, changes to \
+     that directory. With - as the argument, changes to the previous working \
+     directory.",
+    lambda do |client, state, args, output|
+      path = if args.empty?
+        File.expand_path('~')
+      elsif args[0] == '-'
+        state.local_oldpwd
+      else
+        File.expand_path(args[0])
+      end
+
+      if Dir.exists?(path)
+        state.local_oldpwd = Dir.pwd
+        Dir.chdir(path)
+      else
+        output.call("lcd: #{args[0]}: No such file or directory")
+      end
+    end
+  )
+
+  LS = Command.new(
+    'ls [REMOTE_FILE]...',
+    "List information about remote files. With no arguments, list the \
+     contents of the working directory. When given remote directories as \
+     arguments, list the contents of the directories. When given remote files \
+     as arguments, list the files.",
+    lambda do |client, state, args, output|
+      patterns = if args.empty?
+        ["#{state.pwd}/*".sub('//', '/')]
+      else
+        args.map do |path|
+          path = state.resolve_path(path)
+          begin
+            if state.is_dir?(client, path)
+              "#{path}/*".sub('//', '/')
+            else
+              path
+            end
+          rescue DropboxError
+            path
+          end
+        end
+      end
+
+      items = []
+      patterns.each do |pattern|
+        begin
+          dir = File.dirname(pattern)
+          state.contents(client, dir).each do |path|
+            items << File.basename(path) if File.fnmatch(pattern, path)
+          end
+        rescue DropboxError => error
+          output.call(error.to_s)
+        end
+      end
+      table_output(items).each { |item| output.call(item) }
+    end
+  )
+
+  MKDIR = Command.new(
+    'mkdir REMOTE_DIR...',
+    "Create remote directories.",
+    lambda do |client, state, args, output|
+      args.each do |arg|
+        begin
+          path = state.resolve_path(arg)
+          state.cache[path] = client.file_create_folder(path)
+        rescue DropboxError => error
+          output.call(error.to_s)
+        end
+      end
+    end
+  )
+
+  PUT = Command.new(
+    'put LOCAL_FILE [REMOTE_FILE]',
+    "Upload a local file to a remote path. If a remote file of the same name \
+     already exists, Dropbox will rename the upload. When given only a local \
+     file path, the remote path defaults to a file of the same name in the \
+     remote working directory.",
+    lambda do |client, state, args, output|
+      from_path = args[0]
+      if args.length == 2
+        to_path = args[1]
+      else
+        to_path = File.basename(from_path)
+      end
+      to_path = state.resolve_path(to_path)
+
+      begin
+        File.open(File.expand_path(from_path), 'rb') do |file|
+          state.cache[to_path] = client.put_file(to_path, file)
+        end
+      rescue Exception => error
+        output.call(error.to_s)
+      end
+    end
+  )
+
+  RM = Command.new(
+    'rm REMOTE_FILE...',
+    "Remove each specified remote file or directory.",
+    lambda do |client, state, args, output|
+      state.expand_patterns(client, args).each do |path|
+        begin
+          client.file_delete(path)
+          state.cache.delete(path)
+        rescue DropboxError => error
+          output.call(error.to_s)
+        end
+      end
+    end
+  )
+
+  SHARE = Command.new(
+    'share REMOTE_FILE...',
+    "Get URLs to share remote files. Shareable links created on Dropbox are \
+     time-limited, but don't require any authentication, so they can be given \
+     out freely. The time limit should allow at least a day of shareability.",
+    lambda do |client, state, args, output|
+      state.expand_patterns(client, args).each do |path|
+        begin
+          output.call("#{path}: #{client.shares(path)['url']}")
+        rescue DropboxError => error
+          output.call(error.to_s)
+        end
+      end
+    end
+  )
+
+  NAMES = constants.select do |sym|
+     const_get(sym).is_a?(Command)
+  end.map { |sym| sym.to_s.downcase }
+
+  def self.exec(input, client, state)
+    if input.start_with?('!')
+      shell(input[1, input.length - 1]) { |line| puts line }
+    elsif not input.empty?
+      tokens = input.split
+
+      # Escape spaces with backslash
+      i = 0
+      while i < tokens.length - 1
+        if tokens[i].end_with?('\\')
+          tokens[i] = "#{tokens[i].chop} #{tokens.delete_at(i + 1)}"
+        else
+          i += 1
+        end
+      end
+
+      cmd, args = tokens[0], tokens.drop(1)
+
+      if NAMES.include?(cmd)
+        begin
+          const_get(cmd.upcase.to_sym).exec(client, state, *args) do |line|
+            puts line
+          end
+        rescue UsageError => error
+          puts "Usage: #{error}"
+        end
+      else
+        puts "Unrecognized command: #{cmd}"
+      end
+    end
+  end
+
+  private
+
+  def self.get_screen_size
+    begin
+      Readline.get_screen_size[1]
+    rescue NotImplementedError
+      72
+    end
+  end
+
+  def self.shell(cmd)
+    begin
+      IO.popen(cmd) do |pipe|
+        pipe.each_line { |line| yield line.chomp if block_given? }
+      end
+    rescue Interrupt
+    rescue Exception => error
+      yield error.to_s if block_given?
+    end
+  end
+
+  def self.table_output(items)
+    return [] if items.empty?
+    columns = get_screen_size
+    item_width = items.map { |item| item.length }.max + 2
+    column = 0
+    lines = ['']
+    items.each do |item|
+      if column != 0 && column + item_width >= columns
+        lines << ''
+        column = 0
+      end
+      lines.last << item.ljust(item_width)
+      column += item_width
+    end
+    lines
+  end
+
+  def self.wrap_output(text)
+    columns = get_screen_size
+    column = 0
+    lines = ['']
+    text.split.each do |word|
+      if column != 0 && column + word.length >= columns
+        lines << ''
+        column = 0
+      end
+      if column != 0
+        lines.last << ' '
+        column += 1
+      end
+      lines.last << word
+      column += word.length
+    end
+    lines
+  end
+end

data/lib/droxi/settings.rb

@@ -0,0 +1,70 @@
+require 'fileutils'
+
+CONFIG_FILE_PATH = File.expand_path('~/.config/droxi/droxirc')
+
+class Settings
+  def Settings.[](key)
+    @@settings[key]
+  end
+
+  def Settings.[]=(key, value)
+    if value != @@settings[key]
+      @@dirty = true
+      @@settings[key] = value
+    end
+  end
+
+  def Settings.include?(key)
+    @@settings.include?(key)
+  end
+
+  def Settings.delete(key)
+    if @@settings.include?(key)
+      @@dirty = true
+      @@settings.delete(key)
+    end
+  end
+
+  def Settings.write
+    if @@dirty
+      @@dirty = false
+      FileUtils.mkdir_p(File.dirname(CONFIG_FILE_PATH))
+      File.open(CONFIG_FILE_PATH, 'w') do |file|
+        @@settings.each_pair { |k, v| file.write("#{k}=#{v}\n") }
+      end
+    end
+  end
+
+  private
+
+  def Settings.warn_invalid(line)
+    warn "invalid setting: #{line}"
+    {}
+  end
+
+  def Settings.parse(line)
+    if /^(.+?)=(.+)$/ =~ line
+      key, value = $1.to_sym, $2
+      if [:access_token, :oldpwd].include?(key)
+        {key => value}
+      else
+        warn_invalid(line)
+      end
+    else
+      warn_invalid(line)
+    end
+  end
+
+  def Settings.read
+    if File.exists?(CONFIG_FILE_PATH)
+      File.open(CONFIG_FILE_PATH) do |file|
+        file.each_line.reduce({}) { |a, e| a.merge(parse(e.strip)) }
+      end
+    else
+      {}
+    end
+  end
+
+  @@settings = read
+  @@dirty = false
+end

data/lib/droxi/state.rb

@@ -0,0 +1,126 @@
+require_relative 'settings'
+
+class State
+  attr_reader :oldpwd, :pwd, :cache
+  attr_accessor :local_oldpwd
+
+  def initialize
+    @pwd = '/'
+    @oldpwd = Settings[:oldpwd] || '/'
+    @local_oldpwd = Dir.pwd
+    @cache = {}
+  end
+
+  def have_all_info_for(path)
+    @cache.include?(path) &&
+    (@cache[path].include?('contents') || !@cache[path]['is_dir'])
+  end
+
+  def metadata(client, path)
+    tokens = path.split('/').drop(1)
+
+    for i in 0..tokens.length
+      partial_path = '/' + tokens.take(i).join('/')
+      unless have_all_info_for(partial_path)
+        begin
+          data = @cache[partial_path] = client.metadata(partial_path)
+        rescue DropboxError
+          return
+        end
+        if data.include?('contents')
+          data['contents'].each do |datum|  
+            @cache[datum['path']] = datum
+          end
+        end
+      end
+    end
+
+    @cache[path]
+  end
+
+  def contents(client, path)
+    metadata(client, path)
+    path = "#{path}/".sub('//', '/')
+    @cache.keys.select do |key|
+      key.start_with?(path) && key != path && !key.sub(path, '').include?('/')
+    end
+  end
+
+  def is_dir?(client, path)
+    metadata(client, File.dirname(path))
+    @cache.include?(path) && @cache[path]['is_dir']
+  end
+
+  def pwd=(value)
+    @oldpwd, @pwd = @pwd, value
+    Settings[:oldpwd] = @oldpwd
+  end
+
+  def resolve_path(path)
+    path = "#{@pwd}/#{path}" unless path.start_with?('/')
+    path.gsub!('//', '/')
+    while path.sub!(/\/([^\/]+?)\/\.\./, '')
+    end
+    path.chomp!('/')
+    path = '/' if path.empty?
+    path
+  end
+
+  def expand_patterns(client, patterns)
+    patterns.map do |pattern|
+      final_pattern = resolve_path(pattern)
+
+      matches = []
+      client.metadata(File.dirname(final_pattern))['contents'].each do |data|
+        path = data['path']
+        matches << path if File.fnmatch(final_pattern, path)
+      end
+
+      if matches.empty?
+        [final_pattern]
+      else
+        matches
+      end
+    end.flatten
+  end
+
+  def file_complete(client, word)
+    tab_complete(client, word, false)
+  end
+
+  def dir_complete(client, word)
+    tab_complete(client, word, true)
+  end
+
+  private
+
+  def complete(path, prefix_length, dir_only)
+    @cache.keys.select do |key|
+      key.start_with?(path) && key != path &&
+      !(dir_only && !@cache[key]['is_dir'])
+    end.map do |key|
+      if @cache[key]['is_dir']
+        key += '/' 
+      else
+        key += ' '
+      end
+      key[prefix_length, key.length]
+    end
+  end
+
+  def tab_complete(client, word, dir_only)
+    path = resolve_path(word)
+    prefix_length = path.length - word.length
+
+    if word.end_with?('/')
+      # Treat word as directory
+      metadata(client, path)
+      prefix_length += 1
+    else
+      # Treat word as file
+      metadata(client, File.dirname(path))
+    end
+
+    complete(path, prefix_length, dir_only)
+  end
+end

data/lib/droxi.rb

@@ -0,0 +1,142 @@
+require 'dropbox_sdk'
+require 'readline'
+
+require_relative 'droxi/commands'
+require_relative 'droxi/settings'
+require_relative 'droxi/state'
+
+module Droxi
+  APP_KEY = '5sufyfrvtro9zp7'
+  APP_SECRET = 'h99ihzv86jyypho'
+
+  def self.authorize
+    flow = DropboxOAuth2FlowNoRedirect.new(APP_KEY, APP_SECRET)
+
+    authorize_url = flow.start()
+
+    # Have the user sign in and authorize this app
+    puts '1. Go to: ' + authorize_url
+    puts '2. Click "Allow" (you might have to log in first)'
+    puts '3. Copy the authorization code'
+    print 'Enter the authorization code here: '
+    code = gets.strip
+
+    # This will fail if the user gave us an invalid authorization code
+    begin
+      access_token, user_id = flow.finish(code)
+      Settings[:access_token] = access_token
+    rescue DropboxError
+      puts 'Invalid authorization code.'
+    end
+  end
+
+  def self.get_access_token
+    until Settings.include?(:access_token)
+      authorize()
+    end
+    Settings[:access_token]
+  end
+
+  def self.prompt(info, state)
+    "droxi #{info['email']}:#{state.pwd}> "
+  end
+
+  def self.file_complete(word, dir_only=false)
+    begin
+      path = File.expand_path(word)
+    rescue ArgumentError
+      return []
+    end
+    if word.empty? || (word.length > 1 && word.end_with?('/'))
+      dir = path
+    else
+      dir = File.dirname(path)
+    end
+    Dir.entries(dir).map do |file|
+      (dir + '/').sub('//', '/') + file
+    end.select do |file|
+      file.start_with?(path) && !(dir_only && !File.directory?(file))
+    end.map do |file|
+      if File.directory?(file)
+        file << '/'
+      else
+        file << ' '
+      end
+      if word.start_with?('/')
+        file
+      elsif word.start_with?('~')
+        file.sub(/\/home\/[^\/]+/, '~')
+      else
+        file.sub(Dir.pwd + '/', '')
+      end
+    end
+  end
+
+  def self.dir_complete(word)
+    file_complete(word, true)
+  end
+
+  def self.run
+    client = DropboxClient.new(get_access_token)
+    info = client.account_info
+    puts "Logged in as #{info['display_name']} (#{info['email']})"
+
+    state = State.new
+
+    Readline.completion_proc = proc do |word|
+      words = Readline.line_buffer.split
+      index = words.length
+      index += 1 if Readline.line_buffer.end_with?(' ')
+      if index <= 1
+        type = 'COMMAND'
+      elsif Commands::NAMES.include?(words[0])
+        cmd = Commands.const_get(words[0].upcase.to_sym)
+        type = cmd.type_of_arg(index - 2)
+      end
+
+      options = case type
+      when 'COMMAND'
+        Commands::NAMES.select { |name| name.start_with? word }.map do |name|
+          name + ' '
+        end
+      when 'LOCAL_FILE'
+        file_complete(word)
+      when 'LOCAL_DIR'
+        dir_complete(word)
+      when 'REMOTE_FILE'
+        begin
+          state.file_complete(client, word)
+        rescue DropboxError
+          []
+        end
+      when 'REMOTE_DIR'
+        begin
+          state.dir_complete(client, word)
+        rescue DropboxError
+          []
+        end
+      else
+        []
+      end
+
+      options.map { |option| option.gsub(' ', '\ ').sub(/\\ $/, ' ') }
+    end
+
+    begin
+      Readline.completion_append_character = nil
+    rescue NotImplementedError
+    end
+
+    begin
+      while line = Readline.readline(prompt(info, state), true)
+        Commands.exec(line.chomp, client, state)
+      end
+      puts
+    rescue Interrupt
+      puts
+    end
+
+    state.pwd = '/'
+    Settings.write
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: droxi
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Brandon Mulcahy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dropbox_sdk
+  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'
+description: ftp-like command-line interface to Dropbox
+email: brandon@jangler.info
+executables:
+- droxi
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/droxi
+- lib/droxi.rb
+- lib/droxi/commands.rb
+- lib/droxi/settings.rb
+- lib/droxi/state.rb
+homepage: https://github.com/jangler/droxi
+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: droxi
+test_files: []