skypager 0.0.2

data/lib/skypager/sync/dropbox/delta.rb

@@ -0,0 +1,67 @@
+module Skypager
+  module Sync
+    class DropboxDelta
+
+      attr_accessor :client,
+                    :data,
+                    :cursor,
+                    :entries,
+                    :path_prefix
+
+      def initialize(client, cursor, path_prefix=nil)
+        @client = client
+        @cursor = cursor
+        @path_prefix = path_prefix
+      end
+
+      def processed!
+        # TODO
+        # Should update cursor
+      end
+
+      def entries
+        return @entries if @entries
+        fetch
+        @entries
+      end
+
+      def _dropbox_delta at=nil
+        at ||= cursor
+        response = client.delta(at, path_prefix)
+        self.cursor = response["cursor"]
+        response
+      end
+
+      def data
+        @data ||= fetch
+      end
+
+      def on_reset path_prefix, cursor
+      end
+
+      def fetch
+        return @response if @response
+
+        response = _dropbox_delta
+
+        if response["reset"] == true
+          on_reset(path_prefix, cursor)
+        end
+
+        self.entries = Hashie::Mash.new({})
+
+        response["entries"].each do |entry|
+          path, meta = entry
+          self.entries[path] = meta
+        end
+
+        if response["has_more"] == true
+          # TODO Implement
+        end
+
+        @response = response
+      end
+
+    end
+  end
+end

data/lib/skypager/sync/folder.rb

@@ -0,0 +1,235 @@
+module Skypager
+  module Sync
+    class Folder
+      attr_accessor :options,
+                    :cursor,
+                    :app
+
+      def initialize(options={})
+        @options  = options
+        @cursor   = options.fetch(:cursor, nil)
+        @app      = options[:app]
+      end
+
+      # Used to generate the config line in the
+      # middleman config.rb
+      def config_line
+        "dropbox_sync('#{ relative_local_path }','#{ remote_path }')"
+      end
+
+      # Gets the reference to the dropbox folder settings for the app
+      # which allows us to persist info about the sync state of the folder
+      def folder_settings
+        data = app.data.dropbox
+        data[:folders][options[:folder]].tap {|h| h && h.symbolize_keys! }
+      end
+
+      def cursor= value
+        folder_settings[:cursor] = value
+        save_folder_settings
+      end
+
+      def save_folder_settings
+        data = app.data.dropbox.dup
+
+        Pathname(app.data_dir).join("dropbox.json").open('w+') do |fh|
+          fh.write(data.to_json)
+        end
+      end
+
+      def auto_prefix
+        options[:site_name]
+      end
+
+      def dropbox?
+        options[:type] == "dropbox"
+      end
+
+      def google?
+        options[:type] == "google"
+      end
+
+      def sync
+        return dropbox_pull if dropbox?
+        return google_sync if google?
+      end
+
+      def dropbox_pull
+        delta = dropbox_delta
+
+        delta.entries.each do |entry|
+          local = matching_local_path_for(entry.path)
+
+          if entry.is_deleted
+            puts "Removing #{ local }"
+            local.rmtree
+          elsif entry.is_dir == true
+            unless local.exist?
+              puts "Creating #{ local } directory"
+              local.mkdir
+            end
+          elsif entry.is_dir == false || entry.is_dir == nil
+            puts "Downloading #{ entry.size } bytes to #{ local }"
+            local.open('wb+') do |fh|
+              fh.write(entry.download)
+            end
+          end
+        end
+
+        self.cursor = delta.cursor
+      end
+
+      def google_sync
+        # TODO
+        # Implement google drive folder cloning
+      end
+
+      def newer_local_files
+        remotes = all_remote_files
+
+        if dropbox?
+          all_local_files.select do |e|
+            remote = remotes.find do |x|
+              "#{x[:path]}".match(/#{ e[:path] }$/)
+            end
+
+            remote.nil? || (remote[:mtime] < e[:mtime])
+          end
+        end
+      end
+
+      def all_dropbox_files
+        h = lambda do |node|
+          base = [{
+            path: node.path,
+            mtime: DateTime.parse(node.modified).to_i
+          }]
+
+          base += node.ls.map(&h) if node.is_dir
+
+          base
+        end
+
+        dropbox_folder_files.map(&h).flatten
+      end
+
+      def dropbox_folder_files
+        Array((dropbox_folder rescue nil).try(:ls))
+      end
+
+      def matching_local_path_for(remote)
+        if sandboxed?
+          parts = remote.to_s.split("/")
+          parts.shift
+          part = parts.join("/")
+          root.join(part)
+        else
+          parts = remote.to_s.split("/")
+          parts.shift
+          part = parts.join("/")
+          local_path.join(part)
+        end
+      end
+
+      def root
+        Pathname(options[:root] || Dir.pwd)
+      end
+
+      def all_local_files
+        h = lambda do |path|
+          base = [{
+            path: path.relative_path_from(local_path).to_s,
+            realpath: path,
+            mtime: path.mtime.to_i
+          }]
+
+          base += path.children.map(&h) if path.directory?
+
+          base
+        end
+
+        local_path.children.map(&h).flatten
+      end
+
+      def all_remote_files
+        if dropbox?
+          all_dropbox_files
+        else
+
+        end
+      end
+
+      def relative_local_path
+        local_path.relative_path_from(root).to_s
+      end
+
+      def local_path
+        root.join(options[:local_path]).tap do |folder|
+          folder.mkdir unless folder.exist?
+        end
+      end
+
+      def synced
+        push_sync
+        self
+      end
+
+      def push_sync
+        return dropbox_push_sync if dropbox?
+        return google_push_sync if google?
+      end
+
+      def dropbox_push_sync
+        api = Skypager.dropbox.api
+
+        newer_local_files.each do |entry|
+          target = "#{ path_prefix }/#{ entry[:path] }"
+          target = target.gsub(/^\//,'')
+          api.upload(target, entry[:realpath].read, overwrite: true)
+        end
+      end
+
+      def google_push_sync
+
+      end
+
+      def dropbox_folder
+        Skypager.dropbox.find(path_prefix)
+      end
+
+      def remote_path
+        options[:remote_path].to_s
+      end
+
+      def sandboxed?
+        Skypager.config.dropbox_app_type == "sandbox"
+      end
+
+      # Which path do we scope our delta calls to?
+      def path_prefix
+        if sandboxed?
+          if remote_path.match(/^\/#{ options[:site_name] }/)
+            remote_path
+          else
+            "/#{ options[:site_name] }/#{ remote_path.gsub(/^\//,'') }"
+          end
+        else
+          unless remote_path.match(/^\//)
+            return "/#{ remote_path }"
+          end
+
+          remote_path
+        end
+      end
+
+      def has_remote_changes?
+        dropbox_delta.entries.length > 0
+      end
+
+      def dropbox_delta
+        @dropbox_delta ||= Skypager.dropbox.delta(cursor, path_prefix: path_prefix)
+      end
+
+    end
+  end
+end

data/lib/skypager/sync/google.rb

@@ -0,0 +1,143 @@
+module Skypager
+  module Sync
+    class Google
+      include Singleton
+
+      def self.method_missing(meth, *args, &block)
+        if client.respond_to?(meth)
+          return client.send(meth, *args, &block)
+        end
+
+        super
+      end
+
+      def self.client(options={})
+        @client ||= begin
+                      instance.with_options(options)
+                    end
+      end
+
+      def refreshable?
+        has_application_keys? && has_refresh_token?
+      end
+
+      # Runs through an interactive session where we get the
+      # necessary tokens needed to integrate with google drive.
+      def setup(options={})
+        get_application_keys unless has_application_keys?
+
+        if options[:client_id]
+          Skypager.config.set "google_client_id", options[:client_id]
+        end
+
+        if options[:client_secret]
+          Skypager.config.set "google_client_secret", options[:client_secret]
+        end
+
+        if has_refresh_token?
+          refresh_access_token!
+        else
+          Launchy.open(auth_client.authorization_uri)
+          say("\n1. Open this page:\n%s\n\n" % auth_client.authorization_uri)
+          auth_client.code = ask("2. Enter the authorization code shown in the page: ", String)
+          auth_client.fetch_access_token!
+          Skypager.config.set "google_refresh_token", auth_client.refresh_token
+          Skypager.config.set "google_access_token", auth_client.access_token
+        end
+      end
+
+      def session
+        api
+      end
+
+      def api
+        @api ||= begin
+                   refresh_access_token!
+                   GoogleDrive.login_with_oauth(Skypager.config.google_access_token)
+                 end
+      end
+
+      def method_missing meth, *args, &block
+        if api.respond_to?(meth)
+          return api.send(meth, *args, &block)
+        end
+
+        super
+      end
+
+      def authorize(token, secret)
+        @api = nil if @api
+        options[:token] = token
+        options[:secret] = secret
+        self
+      end
+
+      def options
+        @options ||= {}
+      end
+
+      def with_options(opts={})
+        options.merge!(opts)
+        self
+      end
+
+      def has_application_keys?
+        (Skypager.config.google_client_id.to_s.length > 0 && Skypager.config.google_client_secret.to_s.length > 0)
+      end
+
+      def get_application_keys
+        unless Skypager.config.google_client_id.to_s.length > 0
+          google_client_id = ask("What is the Google Client ID?", String)
+          Skypager.config.set "google_client_id", google_client_id
+        end
+
+        unless Skypager.config.google_client_secret.to_s.length > 0
+          google_client_secret = ask("What is the Google Client Secret?", String)
+          Skypager.config.set "google_client_secret", google_client_secret
+        end
+      end
+
+      def auth_client
+        return @auth_client if @auth_client
+
+        client = ::Google::APIClient.new(
+            :application_name => "google_drive Ruby library",
+            :application_version => "0.3.11"
+        )
+
+        client_id = "452925651630-egr1f18o96acjjvphpbbd1qlsevkho1d.apps.googleusercontent.com"
+        client_secret = "1U3-Krii5x1oLPrwD5zgn-ry"
+
+        @auth_client = auth = client.authorization
+        auth.client_id = client_id #Skypager.config.google_client_id
+        auth.client_secret = client_secret #Skypager.config.google_client_secret
+        auth.scope =
+            "https://www.googleapis.com/auth/drive " +
+            "https://spreadsheets.google.com/feeds/ " +
+            "https://docs.google.com/feeds/ " +
+            "https://docs.googleusercontent.com/"
+
+        auth.redirect_uri = "urn:ietf:wg:oauth:2.0:oob"
+
+        auth
+      end
+
+      def refresh_token
+        Skypager.config.google_refresh_token.to_s
+      end
+
+      def has_refresh_token?
+        refresh_token.length > 0
+      end
+
+      def refresh_access_token!
+        if has_refresh_token?
+          auth_client.refresh_token = refresh_token
+          auth_client.fetch_access_token!
+          Skypager.config.set "google_access_token", auth_client.access_token
+        end
+      end
+
+    end
+  end
+end

data/lib/skypager/tar.rb

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'rubygems/package'
+require 'zlib'
+require 'fileutils'
+
+module Util
+  module Tar
+    # Creates a tar file in memory recursively
+    # from the given path.
+    #
+    # Returns a StringIO whose underlying String
+    # is the contents of the tar file.
+    def tar(path)
+      tarfile = StringIO.new("")
+      Gem::Package::TarWriter.new(tarfile) do |tar|
+        Dir[File.join(path, "**/*")].each do |file|
+          mode = File.stat(file).mode
+          relative_file = file.sub /^#{Regexp::escape path}\/?/, ''
+
+          if File.directory?(file)
+            tar.mkdir relative_file, mode
+          else
+            tar.add_file relative_file, mode do |tf|
+              File.open(file, "rb") { |f| tf.write f.read }
+            end
+          end
+        end
+      end
+
+      tarfile.rewind
+      tarfile
+    end
+
+    # gzips the underlying string in the given StringIO,
+    # returning a new StringIO representing the
+    # compressed file.
+    def gzip(tarfile)
+      gz = StringIO.new("")
+      z = Zlib::GzipWriter.new(gz)
+      z.write tarfile.string
+      z.close # this is necessary!
+
+      # z was closed to write the gzip footer, so
+      # now we need a new StringIO
+      StringIO.new gz.string
+    end
+
+    # un-gzips the given IO, returning the
+    # decompressed version as a StringIO
+    def ungzip(tarfile)
+      z = Zlib::GzipReader.new(tarfile)
+      unzipped = StringIO.new(z.read)
+      z.close
+      unzipped
+    end
+
+    # untars the given IO into the specified
+    # directory
+    def untar(io, destination)
+      Gem::Package::TarReader.new io do |tar|
+        tar.each do |tarfile|
+          destination_file = File.join destination, tarfile.full_name
+
+          if tarfile.directory?
+            FileUtils.mkdir_p destination_file
+          else
+            destination_directory = File.dirname(destination_file)
+            FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+            File.open destination_file, "wb" do |f|
+              f.print tarfile.read
+            end
+          end
+        end
+      end
+    end
+  end
+end