google_drive_companion 0.1.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Gemfile.lock
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Edward Price
+
+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,82 @@
+# GoogleDriveCompanion
+
+I was playing with the "google-drive-ruby" gem and thought it was awesome.
+
+I don't like leaving the terminal, so I thought, meh, I am going to write a gem that allows me to push from the command line.
+
+Then, I figured: "Yo!"  The handshake takes to long, so why not set of a unix server socket to run as a daemon, listening for my google drive commands so that it will go faster.
+
+Sweetness!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'google_drive_companion'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install google_drive_companion
+
+## Usage
+
+Get help
+
+    gdrive help
+
+Start the server using environment variables
+
+    username=AzureDiamond@gmail.com password=hunter2 gdrive start
+
+Or create a file in your ~/.google_drive/conf.yaml:
+
+    username: AzureDiamond@gmail.com
+    password: hunter2
+
+Toggle the foreground/daemon flag when you start the server (def. as a daemon):
+
+    gdrive start [run_in_foreground]
+
+Upload a file:
+
+    gdpush /path/to/file.txt
+
+Upload a file from the current dir:
+
+    gdpush this.txt
+
+Upload a file from the current dir, to a remote location:
+
+    gdpush this.txt remote/path/to/that.txt
+
+Move a remote file to another remote folder:
+
+    gdmv /path/to/file.txt /another/path
+
+Download the new file:
+
+    gdpull /another/path/file.txt
+
+Trash the file:
+
+    gddel /another/path/file.txt
+
+Trash whole folders, with reckless abandon!
+
+    gddel another
+
+Kill the server:
+
+    gdrive stop
+
+## Contributing
+
+1. Fork it
+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,12 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  $foo = t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+#  t.warning = true
+end
+
+task default: "test"

data/bin/gddel

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require "google_drive_companion"
+
+begin
+  res = GoogleDriveCompanion::Socket.instance
+  $stdout.puts res.digest(["del"] + ARGV)
+
+rescue Errno::ECONNREFUSED, Errno::ENOENT
+  $stdout.puts <<EOS
+Error connecting to server, please try again after running:
+$ gdrive start
+EOS
+end

data/bin/gdmv

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require "google_drive_companion"
+
+begin
+  res = GoogleDriveCompanion::Socket.instance
+  $stdout.puts res.digest(["mv"] + ARGV)
+
+rescue Errno::ECONNREFUSED, Errno::ENOENT
+  $stdout.puts <<EOS
+Error connecting to server, please try again after running:
+$ gdrive start
+EOS
+end

data/bin/gdpull

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+require "google_drive_companion"
+
+begin
+  res = GoogleDriveCompanion::Socket.instance
+
+  # If it ain't an absolute path, make it so!
+  ARGV[1] ||= GoogleDriveCompanion::Session.split_file(ARGV[0]).last
+  unless ARGV[1][/^\//]
+    ARGV[1] = File.join(Dir.pwd, ARGV[1])
+  end
+
+  $stdout.puts res.digest(["pull"] + ARGV)
+
+rescue Errno::ECONNREFUSED, Errno::ENOENT
+  $stdout.puts <<EOS
+Error connecting to server, please try again after running:
+$ gdrive start
+EOS
+end

data/bin/gdpush

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require "google_drive_companion"
+
+begin
+  res = GoogleDriveCompanion::Socket.instance
+
+  # If it ain't an absolute path, make it so!
+  unless ARGV[0][/^\//]
+    ARGV[0] = File.join(Dir.pwd, ARGV[0])
+  end
+
+  $stdout.puts res.digest(["push"] + ARGV)
+
+rescue Errno::ECONNREFUSED, Errno::ENOENT
+  $stdout.puts <<EOS
+Error connecting to server, please try again after running:
+$ gdrive start
+EOS
+end

data/bin/gdrive

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require "google_drive_companion"
+
+case ARGV[0].downcase
+when "start"
+  GoogleDriveCompanion::Server.instance.run!  ARGV[1]
+else
+  begin
+    instance = GoogleDriveCompanion::Socket.instance
+    puts instance.digest(ARGV)
+    instance.close
+  rescue Errno::ECONNREFUSED, Errno::ENOENT
+    $stdout.puts <<EOS
+Error connecting to server, please try again after running:
+$ gdrive start
+EOS
+  end
+end

data/google_drive_companion.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'google_drive_companion/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "google_drive_companion"
+  gem.version       = GoogleDriveCompanion::VERSION
+  gem.authors       = ["Edward Price"]
+  gem.email         = ["ted.price+github@gmail.com"]
+  gem.description   = %q{Interface with google drive from tha matrix}
+  gem.summary       = %q{Interface with google drive from tha matrix}
+  gem.homepage      = "https://github.com/pricees/google-drive-companion"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency("google_drive")
+  gem.add_development_dependency("minitest")
+  gem.add_development_dependency("mocha")
+end

data/lib/google_drive_companion.rb

@@ -0,0 +1,15 @@
+require "socket"
+require "singleton"
+require "fileutils"
+require "yaml"
+require "google_drive"
+require "json"
+
+module GoogleDriveCompanion
+  # Your code goes here...
+end
+
+require_relative "google_drive_companion/version"
+require_relative "google_drive_companion/server"
+require_relative "google_drive_companion/session"
+require_relative "google_drive_companion/socket"

data/lib/google_drive_companion/server.rb

@@ -0,0 +1,96 @@
+# This module sets up a unix socket daemon process to listen out for commands
+module GoogleDriveCompanion
+  class Server
+    include Singleton
+
+    def socket_file
+      ENV["gdc_socket"] || File.join("", "tmp", "gdc_socket.sock")
+    end
+
+    def pid_file
+      ENV["gdc_pid"] || File.join("", "tmp", "gdc.pid")
+    end
+
+    def check_if_running!
+      if File.exists?(socket_file)
+        puts "Socket file #{socket_file} in use"
+        leave = true
+      end
+
+      if File.exists?(pid_file)
+        pid = File.read(pid_file)
+        puts "Server may be running on #{pid}\n**************\n"
+        leave ||= true
+      end
+      leave && exit(1)
+    end
+
+    def server
+      @server ||= begin
+                    check_if_running!
+                    write(Process.pid, pid_file)
+                    UNIXServer.new(socket_file)
+                  end
+    end
+
+    def close
+      server.close
+    end
+
+    def close!
+      close
+      File.exists?(socket_file) && FileUtils.rm(socket_file)
+      File.exists?(pid_file) && FileUtils.rm(pid_file)
+      Process.kill 9, Process.pid
+    end
+
+    # Attempts to write the pid of the forked process to the pid file.
+    # Kills process if write unsuccesfull.
+    def write(pid, pidfile)
+      File.open pidfile, "w" do |f|
+        f.write pid
+        f.close
+      end
+      $stdout.puts "Daemon running with pid: #{pid}"
+      rescue ::Exception => e
+      raise "While writing the PID to file, unexpected #{e.class}: #{e}"
+    end
+
+    def run!(arg = nil)
+      server
+      Process.daemon unless arg
+      msg_pump.join
+    end
+
+    def respond(s, msg)
+      s.send(msg, 0)
+    rescue Errno::EPIPE
+      $stderr.puts "Socket closed, meh"
+    end
+
+    def msg_pump
+      loop do
+        begin
+          s = server.accept
+          while (cmd = s.recv(1000))
+            cmd = JSON.parse(cmd)
+            case cmd.first
+            when "stop"
+              close!
+            when "help"
+              help_file = File.join(File.dirname(__FILE__), "..", "help.txt")
+              respond(s, File.read(help_file))
+            else
+              GoogleDriveCompanion::Session.handle_msg(cmd)
+              respond(s, "[#{cmd.first}] Success!")
+            end
+          end
+        rescue Exception => bang
+          tmp = "Server error: #{bang}"
+          $stderr.puts tmp
+          respond(s, tmp)
+        end
+      end
+    end
+  end
+end

data/lib/google_drive_companion/session.rb

@@ -0,0 +1,202 @@
+module GoogleDriveCompanion
+
+  module Session
+    extend self
+
+    # Set authentication creditials in ~/.google_drive/conf.yaml
+    #
+    # ~/.google_drive/conf.yaml:
+    #
+    # username: AzureDiamond@gmail.com
+    # password: hunter2
+    #
+    # OR at the env level:
+    #
+    # username=AzureDiamond@gmail.com password=hunter2 [cmd] [arg1, ... ]
+    #
+    def configs
+      @configs ||= begin
+                    fn       = File.join(Dir.home, ".google_drive", "conf.yaml")
+                    configs  = File.exists?(fn) ? YAML::load(File.open(fn)) : ENV
+                  end
+    end
+
+    # Public: Split filename into array by separator
+    #
+    # name - Name of file
+    # sep  - Seperator (def. system separator)
+    #
+    # Examples
+    #
+    #   split_file("/path/to/file.txt")
+    #   # => ["path", "to", "file.txt")
+    #
+    # split_file("-path-to-file.txt----", "-")
+    # res.must_equal(exp)
+    #
+    # Returns array
+    def split_file(name = "", sep = File::SEPARATOR)
+      name.gsub(/^#{sep}+/, '').split(sep)
+    end
+
+    # Public: Return the top level folder of the accounts google drive
+    #
+    # Returns GoogleDrive::Collection
+    def root
+      session.root_collection
+    end
+
+    # Public: Call methods, check against whitelist
+    #
+    #
+    # Returns [something]
+    PROTECTED_METHODS = %w[push pull mv del]
+    def send_protected(ary)
+      if PROTECTED_METHODS.include?(ary.first)
+        send(ary.shift.to_sym, *ary)
+      end
+    end
+
+    # Public: Takes an array of names of gdrive folders and traverss them.  If name is erroneous, it stops at last leaf; if forced, creates the subcollection
+    #
+    # Examples
+    #
+    #   traverse(["foo", "bar"])
+    #   # => <collection "bar">
+    #
+    #   traverse(["foo", "bar", "baz"]) NOTE: bar doesn't exist
+    #   # => <collection "foo">
+    #
+    #   traverse(["foo", "bar", "baz"], :force) NOTE: bar doesn't exist
+    #   # => <collection "baz">
+    #
+    # Returns a GoogleDrive::Collection
+    def traverse(collections, force = false)
+      node = root
+      collections.each do |subcollection|
+        new_node = node.subcollection_by_title(subcollection)
+
+        if new_node
+          node = new_node
+        elsif force
+          node = node.create_subcollection(subcollection)
+        else
+          break
+        end
+      end
+
+      node
+    end
+
+    # Public: Get a file from Google Drive
+    #
+    # ary - Array of collections, last element is title of file
+    #
+    # Example
+    #
+    #   get_file(["foo", "bar", "faz.rb"])
+    #   # => <GoogleDrive::File faz.rb>
+    #
+    #  Returns a GoogleDrive::File
+    def get_file(ary)
+      title = ary.pop
+      traverse(ary).
+        files({ "title" => title, "title-exact" => "true" })[0]
+    end
+
+    # Public: Move file from one remote location to another
+    #
+    # src   - Source remote path to file
+    # dest  - Destination remote path for file
+    # force - Make destination folder path if not already (def. true)
+    # Examples
+    #
+    #   mv("/old/path/to/file.txt", "/new/path/")
+    #   # => mil;
+    #
+    # Raise RuntimeError is remote file doesn't exist
+    # Returns nil
+    def mv(src, dest, force = true)
+      src_ary    = split_file(src)
+      src_node   = traverse(src_ary[0...-1])
+      file       = get_file(src_ary)
+
+      if file
+        traverse(split_file(dest), force).add(file)
+        src_node.remove(file)
+      else
+        raise "Remote file: #{file} doesn't exist yo!"
+      end
+
+      nil
+    end
+
+    # Public: Uploads local file to remote local
+    #
+    # remote_file - Remote file path, File::SEPARATOR delimited
+    # local_file  - Local file path, File::SEPARATOR delimited
+    #
+    # Examples
+    #
+    #   push("/tmp/text.txt")
+    #   # => [ remote file /tmp/text.txt ]
+    #
+    #   push("/tmp/text.txt", "/remote/path/to/text.txt")
+    #   # => [ remote file /remote/path/to/text.txt ]
+    #
+    # Returns GoogleDrive::File
+    def push(local_file, remote_file = nil, force = true)
+
+      remote_file ||= local_file
+      ary           = split_file(remote_file)
+      remote_fn     = ary.pop
+      file          = session.upload_from_file(local_file, remote_fn)
+
+      unless ary.empty?
+        traverse(ary, force).add(file)
+        root.remove(file)
+      end
+      file
+    end
+
+    # Public: Downloads remote file
+    #
+    # remote_file - Remote file path, File::SEPARATOR delimited
+    # local_file  - Local file path, File::SEPARATOR delimited
+    #
+    # Examples
+    #
+    #   pull("/remote/path/to/text.txt", "/tmp/text.txt")
+    #   # => [ file /tmp/text.txt ]
+    #
+    # Returns an integer
+    def pull(remote_file, local_file = nil)
+
+      remote_ary   = split_file(remote_file)
+      local_file ||= remote_ary.last
+
+      get_file(remote_ary).download_to_file(local_file)
+    rescue
+      raise "problem locating remote file: #{remote_file}"
+    end
+
+    # Public: Deletes remote folder
+    #
+    # file    - Remote file path, File::SEPARATOR delimited
+    # permanent - Delete permantantly? (or just put in trash) (def. false)
+    #
+    # Returns boolean
+    def del(file, permanently = false)
+      get_file(split_file(file)).delete(permanently)
+      permanently
+    end
+
+    def handle_msg(cmd)
+      send_protected(cmd) || "bad command!"
+    end
+
+    def session
+      @session = GoogleDrive.login(configs["username"], configs["password"])
+    end
+  end
+end

data/lib/google_drive_companion/socket.rb

@@ -0,0 +1,27 @@
+# Class: The class connects to the UNIX socket and pushes the command line as quickly as possible
+#
+# NOTE: I didn't comment this section, because the code is so amazing, sometimes I just cry looking at it.
+#
+# Oops there it goes, a tear drop right in my Portillo's Italian Sausage.
+module GoogleDriveCompanion
+  class Socket
+    include Singleton
+
+    def socket_file
+      ENV["gdc_socket"] || File.join("", "tmp", "gdc_socket.sock")
+    end
+
+    def socket
+      @socket ||= UNIXSocket.open(socket_file)
+    end
+
+    def close
+      socket.close
+    end
+
+    def digest(msg)
+      socket.send(msg.to_json, 0)
+      socket.recv(10_000)
+    end
+  end
+end

data/lib/google_drive_companion/version.rb

@@ -0,0 +1,3 @@
+module GoogleDriveCompanion
+  VERSION = "0.1.0"
+end

data/lib/help.txt

@@ -0,0 +1,23 @@
+======================
+Google Drive Companion
+======================
+
+gdriver s    # start server
+
+== Upload Files ==
+gdpush [local file] [remote file]
+gdpush /tmp/foo remote/path/bar   # push local file /tmp/foo -> remote/path/bar
+gdpush /tmp/foo [remote file]     # push local file /tmp/foo -> remote /tmp/foo
+gdpush relative.txt [remote file] # push file in current directory, will retain directory structure if remote file unspecified, beware!
+
+== Download Files ==
+gdpull /remote/path/bar.txt                 # Download to the relative path (./bar.txt)
+gdpull /remote/path/bar.txt /tmp/foo.txt    # Download to absoltute path and filename
+
+== Move Files ==
+gdmv /foo/bar.txt /new/path  # push remote file to different directory (/foo/bar.txt - > new/path/bar.txt)
+
+== Remove Remote Files ==
+gddel /new/path/bar.txt  # Delete a file
+gddel /new/              # Delete the whole directory (AHHHHHHHHHH!)
+

data/test/server_test.rb

@@ -0,0 +1,102 @@
+require_relative "test_helper.rb"
+
+describe GoogleDriveCompanion::Server do
+
+  before do
+    @instance = GoogleDriveCompanion::Server.instance
+  end
+
+  it "returns socket filename" do
+    @instance.socket_file.must_equal "/tmp/gdc_socket.sock"
+
+    ENV["gdc_socket"] = "/foo"
+    @instance.socket_file.must_equal "/foo"
+  end
+
+  it "returns pid filename" do
+    @instance.pid_file.must_equal "/tmp/gdc.pid"
+
+    ENV["gdc_pid"] = "/foo"
+    @instance.pid_file.must_equal "/foo"
+  end
+
+  describe "checks if the server is running" do
+
+    it "may be running because of the unix socket file" do
+      @instance.expects(:socket_file).times(2).returns(:foo)
+      @instance.expects(:pid_file).returns(:bar)
+
+      File.expects(:exists?).with(:foo).returns(true)
+      File.expects(:exists?).with(:bar).returns(false)
+
+      @instance.expects(:exit).with(1)
+      refute @instance.check_if_running!
+    end
+
+    it "may be running because of the pidfile" do
+      @instance.expects(:socket_file).returns(:foo)
+      @instance.expects(:pid_file).times(2).returns(:bar)
+
+      File.expects(:exists?).with(:foo).returns(false)
+      File.expects(:exists?).with(:bar).returns(true)
+      File.expects(:read).with(:bar)
+
+      @instance.expects(:exit).with(1)
+      refute @instance.check_if_running!
+    end
+
+    it "isn't running" do
+      @instance.expects(:socket_file).returns(:foo)
+      @instance.expects(:pid_file).returns(:bar)
+
+      File.expects(:exists?).with(:foo).returns(false)
+      File.expects(:exists?).with(:bar).returns(false)
+
+      @instance.expects(:exit).times(0)
+      refute @instance.check_if_running!
+    end
+  end
+
+  it "grabs a new unix socket it appropriate" do
+    @instance.expects(:check_if_running!)
+    @instance.expects(:write)
+    @instance.expects(:socket_file).returns(:socket!)
+    UNIXServer.expects(:new).with(:socket!).returns(:success!)
+
+    @instance.server.must_equal(:success!)
+  end
+
+  it "closes its socket" do
+    @instance.expects(:server).returns(mock(close: :success!))
+    @instance.close.must_equal(:success!)
+  end
+
+  it "kills the server" do
+    @instance.expects(:close)
+    @instance.expects(:socket_file).times(2).returns(:yar!)
+    @instance.expects(:pid_file).times(2).returns(:she_blows!)
+
+    File.expects(:exists?).with(:yar!).returns(true)
+    File.expects(:exists?).with(:she_blows!).returns(true)
+    FileUtils.expects(:rm).times(2)
+    Process.expects(:kill)
+
+    @instance.close!
+  end
+
+  describe "runs the server" do
+      it "as a daemon process" do
+      @instance.expects(:server)
+      Process.expects(:daemon).times(1)
+      @instance.expects(:msg_pump).returns []
+      @instance.run!
+    end
+
+    it "in the foreground" do
+      @instance.expects(:server)
+      Process.expects(:daemon).times(0)
+      @instance.expects(:msg_pump).returns []
+      @instance.run! :foo!
+    end
+  end
+end

data/test/session_test.rb

@@ -0,0 +1,165 @@
+require_relative "test_helper.rb"
+
+describe GoogleDriveCompanion::Session do
+
+  before do
+    @module = GoogleDriveCompanion::Session
+  end
+
+  describe "has a config" do
+
+    it "gets from a file" do
+    end
+
+    it "gets from env" do
+    end
+  end
+
+  it "has a session" do
+    hsh = { "username" => "foo", "password" => "bar" }
+    @module.expects(:configs).times(2).returns(hsh)
+    GoogleDrive.expects(:login).with("foo", "bar").returns(:jeah)
+    @module.session.must_equal(:jeah)
+  end
+
+  it "sends methods" do
+    ary = %w[mv bar baz]
+    @module.expects(:send).with(:mv, "bar", "baz")
+    @module.send_protected(ary)
+  end
+
+  it "handles message" do
+    hsh = { "foo" => "bar" }
+    @module.expects(:send_protected).with(hsh)
+    @module.handle_msg(hsh)
+  end
+
+  describe "handles files" do
+
+    it "seperates files by separator" do
+      exp = %w(path to file.txt)
+      res = @module.split_file("path/to/file.txt")
+      res.must_equal(exp)
+
+      res = @module.split_file("/path/to/file.txt")
+      res.must_equal(exp)
+
+      res = @module.split_file("/path/to/file.txt////")
+      res.must_equal(exp)
+
+      res = @module.split_file("-path-to-file.txt----", "-")
+      res.must_equal(exp)
+    end
+  end
+
+  describe "collections" do
+
+    it "traverses a full collection tree" do
+      root = mock
+      foo  = mock
+      bar  = mock
+      root.expects(:subcollection_by_title).with("foo").returns(foo)
+      foo.expects(:subcollection_by_title).with("bar").returns(bar)
+      bar.expects(:subcollection_by_title).with("baz").returns(:success!)
+      @module.expects(:root).returns(root)
+      @module.traverse(%w(foo bar baz)).must_equal(:success!)
+    end
+
+    it "stops at leaf" do
+      root = mock
+      foo  = mock
+      bar  = mock
+      root.expects(:subcollection_by_title).with("foo").returns(foo)
+      foo.expects(:subcollection_by_title).with("bar").returns(nil)
+      @module.expects(:root).returns(root)
+      @module.traverse(%w(foo bar baz)).must_equal(foo)
+    end
+
+    it "traverses a known collection tree" do
+      root = mock
+      foo  = mock
+      bar  = mock
+      root.expects(:subcollection_by_title).with("foo").returns(foo)
+      foo.expects(:subcollection_by_title).with("bar").returns(nil)
+      foo.expects(:create_subcollection).with("bar").returns(:success!)
+
+      @module.expects(:root).returns(root)
+      @module.traverse(%w(foo bar), :force).must_equal(:success!)
+    end
+  end
+
+  it "gets the root 'directory' of the gdrive" do
+
+    @module.expects(:session).returns(mock(root_collection: :success!))
+    @module.root.must_equal :success!
+  end
+
+
+  describe "handles files on gdrive" do
+
+    it "pushes a file" do
+      m = mock
+      m.expects(:upload_from_file).with("baz.rb", "baz.rb")
+      @module.expects(:session).returns(m)
+
+      ary = %w(baz.rb)
+      @module.push(ary.join("/"))
+    end
+
+    it "pushes a file with collection" do
+      m = mock
+      m.expects(:upload_from_file).with("foo/bar/test.rb", "test.rb").returns(:remote_file)
+      @module.expects(:session).returns(m)
+
+      ary = %w(foo bar test.rb)
+      col = mock
+      col.expects(:add).with(:remote_file)
+      @module.expects(:traverse).with(["baz"], :force).returns(col)
+      @module.expects(:root).returns(mock(:remove))
+      @module.push(ary.join("/"), "baz/test.rb", :force).must_equal :remote_file
+    end
+
+  end
+
+  describe "downloading files" do
+    it "pulls file to local file" do
+      m = mock
+      m.expects(:download_to_file).with("/tmp/out")
+      @module.expects(:get_file).with(%w(foo bar baz.txt)).returns(m)
+      @module.pull("foo/bar/baz.txt", "/tmp/out")
+    end
+
+    it "pulls file to local defaults" do
+      m = mock
+      m.expects(:download_to_file).with("baz.txt")
+      @module.expects(:get_file).with(%w(foo bar baz.txt)).returns(m)
+      @module.pull("foo/bar/baz.txt")
+    end
+  end
+
+  it "deletes files" do
+    path = "/path/to/txt"
+
+    m = mock
+    m.expects(:delete).with(:blah).returns(:blah)
+
+    @module.expects(:get_file).with(%w[path to txt]).returns(m)
+
+    @module.del(path, :blah).must_equal(:blah)
+  end
+
+  it "moves files" do
+    old_path = "/old/path/to/txt"
+    new_path = "/new/path/txt"
+
+    m = mock
+    n = mock
+    n.expects(:add).with(m).returns(:success)
+
+    @module.expects(:traverse).with(%w[old path to]).returns(mock(remove: true))
+    @module.expects(:get_file).with(%w[old path to txt]).returns(m)
+    @module.expects(:traverse).with(%w[new path txt], true).returns(n)
+
+    @module.mv(old_path, new_path).must_be :nil?
+  end
+end

data/test/socket_test.rb

@@ -0,0 +1,38 @@
+require_relative "test_helper.rb"
+
+describe GoogleDriveCompanion::Socket do
+
+  before do
+    @instance = GoogleDriveCompanion::Socket.instance
+  end
+
+  it "returns socket filename" do
+    ENV.delete("gdc_socket")
+
+    @instance.socket_file.must_equal "/tmp/gdc_socket.sock"
+
+    ENV["gdc_socket"] = "/foo"
+    @instance.socket_file.must_equal "/foo"
+  end
+
+  it "returns a socket" do
+    UNIXSocket.expects(:open).returns(:success!)
+    @instance.socket.must_equal(:success!)
+  end
+
+  it "closes its socket" do
+    @instance.expects(:socket).returns(mock(close: :success!))
+    @instance.close.must_equal(:success!)
+  end
+
+  it "sends a json string to the socket" do
+    ary = %w[push /path/to/file]
+
+    socket = mock
+    socket.expects(:send).with(ary.to_json, 0)
+    socket.expects(:recv).with(10_000).returns(:success!)
+
+    @instance.expects(:socket).times(2).returns(socket)
+    @instance.digest(ary).must_equal(:success!)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require "minitest/autorun"
+require "minitest/reporters"
+require "mocha/setup"
+require_relative "../lib/google_drive_companion.rb"
+Minitest::Reporters.use!

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: google_drive_companion
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Edward Price
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google_drive
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Interface with google drive from tha matrix
+email:
+- ted.price+github@gmail.com
+executables:
+- gddel
+- gdmv
+- gdpull
+- gdpush
+- gdrive
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/gddel
+- bin/gdmv
+- bin/gdpull
+- bin/gdpush
+- bin/gdrive
+- google_drive_companion.gemspec
+- lib/google_drive_companion.rb
+- lib/google_drive_companion/server.rb
+- lib/google_drive_companion/session.rb
+- lib/google_drive_companion/socket.rb
+- lib/google_drive_companion/version.rb
+- lib/help.txt
+- test/server_test.rb
+- test/session_test.rb
+- test/socket_test.rb
+- test/test_helper.rb
+homepage: https://github.com/pricees/google-drive-companion
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Interface with google drive from tha matrix
+test_files:
+- test/server_test.rb
+- test/session_test.rb
+- test/socket_test.rb
+- test/test_helper.rb