skypager 0.1.2 → 0.2.0

data/lib/skypager/sync/folder.rb

@@ -1,266 +0,0 @@
-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
-
-      def type
-        options[:type]
-      end
-
-      # Used to generate the config line in the
-      # middleman config.rb
-      def config_line
-        if dropbox?
-          "dropbox_sync('#{ relative_local_path }','#{ remote_path }')"
-        end
-      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(push=false)
-        if dropbox?
-          dropbox_pull
-          dropbox_push_sync if push
-        elsif google?
-          google_sync
-        end
-      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 if local.exist?
-          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 #{ 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 files_map
-        remotes = all_remote_files
-
-        fmap = {}
-
-        if dropbox?
-          all_local_files.each do |e|
-            remote = remotes.find do |x|
-              "#{x[:path]}".match(/#{ e[:path] }$/)
-            end
-
-            fmap[e[:path]] = {local: e, remote: remote}
-          end
-        end
-
-        fmap
-      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("/")
-          local_path.join(part)
-        else
-          sanitized = remote.with_leading_slash.gsub(/^#{remote_path.to_s.with_leading_slash}/, '').without_leading_slash
-          local_path.join sanitized
-        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(/^\//,'')
-
-          puts "== Attempting to sync #{ entry[:realpath] } to #{ target }"
-
-          if entry[:realpath].file?
-            api.upload(target, entry[:realpath].read, overwrite: true)
-          end
-        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/github.rb

@@ -1,55 +0,0 @@
-module Skypager
-  module Sync
-    class Github
-      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 options
-        @options ||= {}
-      end
-
-      def with_options(opts={})
-        options.merge!(opts)
-        self
-      end
-
-      def api
-        @api ||= begin
-                   Octokit::Client.new(access_token: Skypager.config.github_access_token)
-                 end
-      end
-
-      def setup(options={})
-        access_token = options[:github_access_token] || Skypager.config.github_access_token
-
-        unless access_token.to_s.length == 40
-          puts "You should generate an access token to use with the Github client."
-          puts "Access tokens allow you to revoke and/or limit access if needed."
-          puts "To learn more about access tokens, and how to generate them, visit: https://help.github.com/articles/creating-an-access-token-for-command-line-use/"
-
-          access_token = ask("Enter a 40 character access token when you have one", String)
-        end
-
-        unless access_token.to_s.length == 40
-          puts "Can not proceed without a valid access token: error code #{ access_token.length }"
-          return
-        end
-
-        Skypager.config.set(:github_access_token, access_token)
-      end
-    end
-  end
-end

data/lib/skypager/sync/google.rb

@@ -1,143 +0,0 @@
-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