droxi 0.0.5 → 0.1.0

data/lib/droxi/complete.rb

@@ -1,43 +1,43 @@
 # Module containing tab-completion logic and methods.
 module Complete
+  # Return an +Array+ of potential command name tab-completions for a +String+.
+  def self.command(string, names)
+    names.select { |n| n.start_with?(string) }.map { |n| n + ' ' }
+  end
 
   # Return the directory in which to search for potential local tab-completions
   # for a +String+. Defaults to working directory in case of bogus input.
   def self.local_search_path(string)
-    begin
-      File.expand_path(strip_filename(string))
-    rescue
-      Dir.pwd
-    end
+    File.expand_path(strip_filename(string))
+  rescue ArgumentError
+    Dir.pwd
   end
 
   # Return an +Array+ of potential local tab-completions for a +String+.
   def self.local(string)
     dir = local_search_path(string)
-    name = string.end_with?('/') ? '' : File.basename(string)
+    basename = basename(string)
 
-    Dir.entries(dir).select do |entry|
-      entry.start_with?(name) && !/^\.{1,2}$/.match(entry)
-    end.map do |entry|
-      entry << (File.directory?(dir + '/' + entry) ? '/' : ' ')
-      string + entry[name.length, entry.length]
+    matches = Dir.entries(dir).select { |entry| match?(basename, entry) }
+    matches.map do |entry|
+      final_match(string, entry, File.directory?(dir + '/' + entry))
     end
   end
 
   # Return an +Array+ of potential local tab-completions for a +String+,
   # including only directories.
   def self.local_dir(string)
-    local(string).select { |result| result.end_with?('/') }
+    local(string).select { |match| match.end_with?('/') }
   end
 
   # Return the directory in which to search for potential remote
   # tab-completions for a +String+.
   def self.remote_search_path(string, state)
     path = case
-    when string.empty? then state.pwd + '/'
-    when string.start_with?('/') then string
-    else state.pwd + '/' + string
-    end
+           when string.empty? then state.pwd + '/'
+           when string.start_with?('/') then string
+           else state.pwd + '/' + string
+           end
 
     strip_filename(collapse(path))
   end
@@ -45,15 +45,12 @@ module Complete
   # Return an +Array+ of potential remote tab-completions for a +String+.
   def self.remote(string, state)
     dir = remote_search_path(string, state)
-    name = string.end_with?('/') ? '' : File.basename(string)
+    basename = basename(string)
 
-    state.contents(dir).map do |entry|
-      File.basename(entry) 
-    end.select do |entry|
-      entry.start_with?(name) && !/^\.{1,2}$/.match(entry)
-    end.map do |entry|
-      entry << (state.directory?(dir + '/' + entry) ? '/' : ' ')
-      string + entry[name.length, entry.length]
+    entries = state.contents(dir).map { |entry| File.basename(entry) }
+    matches = entries.select { |entry| match?(basename, entry) }
+    matches.map do |entry|
+      final_match(string, entry, state.directory?(dir + '/' + entry))
     end
   end
 
@@ -65,22 +62,30 @@ module Complete
 
   private
 
+  def self.basename(string)
+    string.end_with?('/') ? '' : File.basename(string)
+  end
+
+  def self.match?(prefix, candidate)
+    candidate.start_with?(prefix) && !/^\.\.?$/.match(candidate)
+  end
+
+  def self.final_match(string, candidate, is_dir)
+    string + candidate.partition(basename(string))[2] + (is_dir ? '/' : ' ')
+  end
+
   # Return the name of the directory indicated by a path.
   def self.strip_filename(path)
-    if path != '/'
-      path.end_with?('/') ? path.sub(/\/$/, '') : File.dirname(path)
-    else
-      path
-    end
+    return path if path == '/'
+    path.end_with?('/') ? path.sub(/\/$/, '') : File.dirname(path)
   end
 
   # Return a version of a path with .. and . resolved to appropriate
   # directories.
   def self.collapse(path)
     new_path = path.dup
-    nil while new_path.sub!(/[^\/]+\/\.\.\//, '/')
+    nil while new_path.sub!(%r{[^/]+/\.\./}, '/')
     nil while new_path.sub!('./', '')
     new_path
   end
-
 end

data/lib/droxi/settings.rb

@@ -1,85 +1,84 @@
 # Manages persistent (session-independent) application state.
-class Settings
+module Settings
+  class << self
+    # The path of the application's rc file.
+    attr_accessor :config_file_path
+  end
 
-  # The path of the application's rc file.
-  CONFIG_FILE_PATH = File.expand_path('~/.config/droxi/droxirc')
+  self.config_file_path = File.expand_path('~/.config/droxi/droxirc')
 
   # Return the value of a setting, or +nil+ if the setting does not exist.
-  def Settings.[](key)
-    @@settings[key]
+  def self.[](key)
+    settings[key]
   end
 
   # Set the value of a setting.
-  def Settings.[]=(key, value)
-    if value != @@settings[key]
-      @@dirty = true
-      @@settings[key] = value
-    end
+  def self.[]=(key, value)
+    return value if value == settings[key]
+    self.dirty = true
+    settings[key] = value
   end
 
   # Return +true+ if the setting exists, +false+ otherwise.
-  def Settings.include?(key)
-    @@settings.include?(key)
+  def self.include?(key)
+    settings.include?(key)
   end
 
   # Delete the setting and return its value.
-  def Settings.delete(key)
-    if @@settings.include?(key)
-      @@dirty = true
-      @@settings.delete(key)
-    end
+  def self.delete(key)
+    return unless settings.include?(key)
+    self.dirty = true
+    settings.delete(key)
   end
 
   # Write settings to disk.
-  def Settings.save
-    if @@dirty
-      @@dirty = false
-      require 'fileutils'
-      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") }
-        file.chmod(0600)
-      end
+  def self.save
+    return unless dirty
+    self.dirty = false
+    require 'fileutils'
+    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") }
+      file.chmod(0600)
     end
     nil
   end
 
+  # Read and parse the rc file.
+  def self.read
+    self.dirty = false
+    return {} unless File.exist?(config_file_path)
+    File.open(config_file_path) do |file|
+      file.each_line.reduce({}) { |a, e| a.merge(parse(e.strip)) }
+    end
+  end
+
   private
 
+  class << self
+    # +true+ if the settings have been modified since last write, +false+
+    # otherwise.
+    attr_accessor :dirty
+
+    # A +Hash+ of setting keys to values.
+    attr_accessor :settings
+  end
+
   # Print a warning for an invalid setting and return an empty +Hash+ (the
   # result of an invalid setting).
-  def Settings.warn_invalid(line)
+  def self.warn_invalid(line)
     warn "invalid setting: #{line}"
     {}
   end
 
   # Parse a line of the rc file and return a +Hash+ containing the resulting
   # setting data.
-  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
-
-  # Read and parse the rc file.
-  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
+  def self.parse(line)
+    return warn_invalid(line) unless /^(.+?)=(.+)$/ =~ line
+    key, value = Regexp.last_match[1].to_sym, Regexp.last_match[2]
+    return warn_invalid(line) unless [:access_token, :oldpwd].include?(key)
+    { key => value }
   end
 
-  @@settings = read
-  @@dirty = false
-
+  self.settings = read
 end

data/lib/droxi/state.rb

@@ -4,9 +4,53 @@ require_relative 'settings'
 class GlobError < ArgumentError
 end
 
+# Special +Hash+ of remote file paths to cached file metadata.
+class Cache < Hash
+  # Add a metadata +Hash+ and its contents to the +Cache+ and return the
+  # +Cache+.
+  def add(metadata)
+    store(metadata['path'], metadata)
+    dirname = File.dirname(metadata['path'])
+    if dirname != metadata['path']
+      contents = fetch(dirname, {}).fetch('contents', nil)
+      contents << metadata if contents && !contents.include?(metadata)
+    end
+    return self unless metadata.include?('contents')
+    metadata['contents'].each { |content| add(content) }
+    self
+  end
+
+  # Remove a path from the +Cache+ and return the +Cache+.
+  def remove(path)
+    recursive_remove(path)
+
+    dir = File.dirname(path)
+    return self unless fetch(dir, {}).include?('contents')
+    fetch(dir)['contents'].delete_if { |item| item['path'] == path }
+
+    self
+  end
+
+  # Return +true+ if the path's information is cached, +false+ otherwise.
+  def full_info?(path, require_contents = true)
+    info = fetch(path, nil)
+    info && (!require_contents || !info['is_dir'] || info.include?('contents'))
+  end
+
+  private
+
+  # Recursively remove a path and its sub-files and directories.
+  def recursive_remove(path)
+    if fetch(path, {}).include?('contents')
+      fetch(path)['contents'].each { |item| recursive_remove(item['path']) }
+    end
+
+    delete(path)
+  end
+end
+
 # Encapsulates the session state of the client.
 class State
-
   # +Hash+ of remote file paths to cached file metadata.
   attr_reader :cache
 
@@ -18,14 +62,14 @@ class State
 
   # The previous local working directory path.
   attr_accessor :local_oldpwd
-  
+
   # +true+ if the client has requested to quit, +false+ otherwise.
   attr_accessor :exit_requested
 
   # Return a new application state that uses the given client. Starts at the
   # Dropbox root and with an empty cache.
   def initialize(client)
-    @cache = {}
+    @cache = Cache.new
     @client = client
     @exit_requested = false
     @pwd = '/'
@@ -33,50 +77,15 @@ class State
     @local_oldpwd = Dir.pwd
   end
 
-  # Adds a metadata +Hash+ and its contents to the metadata cache.
-  def cache_add(metadata)
-    @cache[metadata['path']] = metadata
-    if metadata.include?('contents')
-      metadata['contents'].each { |content| cache_add(content) }
-    end
-  end
-
-  # Removes a path from the metadata cache.
-  def cache_remove(path)
-    if directory?(path) && @cache[path].include?('contents')
-      @cache[path]['contents'].each { |item| cache_remove(item['path']) }
-    end
-
-    @cache.delete(path)
-
-    dir = File.dirname(path)
-    if @cache.include?(dir) && @cache[dir].include?('contents')
-      @cache[dir]['contents'].delete_if { |item| item['path'] == path }
-    end
-  end
-
   # Return a +Hash+ of the Dropbox metadata for a file, or +nil+ if the file
   # does not exist.
-  def metadata(path, require_contents=true)
+  def metadata(path, require_contents = true)
     tokens = path.split('/').drop(1)
 
-    for i in 0..tokens.length
+    (0..tokens.length).each do |i|
       partial_path = '/' + tokens.take(i).join('/')
-      unless have_all_info_for(partial_path, require_contents)
-        begin
-          data = @client.metadata(partial_path)
-          if !data['is_deleted']
-            @cache[partial_path] = data 
-            if data.include?('contents')
-              data['contents'].each do |datum|  
-                @cache[datum['path']] = datum
-              end
-            end
-          end
-        rescue DropboxError
-          return nil
-        end
-      end
+      next if @cache.full_info?(partial_path, require_contents)
+      return nil unless fetch_metadata(partial_path)
     end
 
     @cache[path]
@@ -110,17 +119,16 @@ class State
   def resolve_path(arg)
     path = arg.start_with?('/') ? arg.dup : "#{@pwd}/#{arg}"
     path.gsub!('//', '/')
-    nil while path.sub!(/\/([^\/]+?)\/\.\./, '')
+    nil while path.sub!(%r{/([^/]+?)/\.\.}, '')
     nil while path.sub!('./', '')
     path.sub!(/\/\.$/, '')
     path.chomp!('/')
-    path = '/' if path.empty?
-    path
+    path.empty? ? '/' : path
   end
 
   # Expand an +Array+ of file globs into an an +Array+ of Dropbox file paths
   # and return the result.
-  def expand_patterns(patterns, preserve_root=false)
+  def expand_patterns(patterns, preserve_root = false)
     patterns.map do |pattern|
       path = resolve_path(pattern)
       if directory?(path)
@@ -135,40 +143,35 @@ class State
   # (error) output if a block is given.
   def forget_contents(partial_path)
     path = resolve_path(partial_path)
-    if @cache.include?(path) && @cache[path].include?('contents')
+    if @cache.fetch(path, {}).include?('contents')
+      @cache[path]['contents'].dup.each { |m| @cache.remove(m['path']) }
       @cache[path].delete('contents')
-      @cache.keys.each do |key|
-        @cache.delete(key) if key.start_with?(path) && key != path
-      end
     elsif block_given?
-      yield "forget: #{partial_path}: Nothing to forget"
+      yield "forget: #{partial_path}: nothing to forget"
     end
   end
 
   private
 
+  # Cache metadata for the remote file for a given path. Return +true+ if
+  # successful, +false+ otherwise.
+  def fetch_metadata(path)
+    data = @client.metadata(path)
+    return true if data['is_deleted']
+    @cache.add(data)
+    true
+  rescue DropboxError
+    false
+  end
+
   # Return an +Array+ of file paths matching a glob pattern, or a GlobError if
   # no files were matched.
   def get_matches(pattern, path, preserve_root)
     dir = File.dirname(path)
     matches = contents(dir).select { |entry| File.fnmatch(path, entry) }
-    if matches.empty?
-      GlobError.new(pattern)
-    elsif preserve_root
-      prefix = pattern.rpartition('/')[0, 2].join 
-      matches.map { |match| prefix + match.rpartition('/')[2] }
-    else
-      matches
-    end
+    return GlobError.new(pattern) if matches.empty?
+    return matches unless preserve_root
+    prefix = pattern.rpartition('/')[0, 2].join
+    matches.map { |match| prefix + match.rpartition('/')[2] }
   end
-
-  # Return +true+ if the path's information is cached, +false+ otherwise.
-  def have_all_info_for(path, require_contents=true)
-    @cache.include?(path) && (
-      !require_contents ||
-      !@cache[path]['is_dir'] ||
-      @cache[path].include?('contents')
-    )
-  end
-
 end