skypager 0.1.2 → 0.2.0

data/lib/skypager/sync.rb

@@ -1,23 +0,0 @@
-module Skypager
-  module Sync
-    def self.sync_dropbox_path(path, options={})
-      dropbox.sync_path(path, options)
-    end
-
-    def self.amazon(options={})
-      require 'skypager/sync/amazon'
-      Skypager::Sync::Amazon.client
-    end
-
-    def self.google(options={})
-      require 'skypager/sync/google'
-      Skypager::Sync::Google.client
-    end
-
-    def self.dropbox(options={})
-      require 'skypager/sync/dropbox'
-      Skypager::Sync::Dropbox.client(options)
-    end
-  end
-end
-

data/lib/skypager/sync/amazon.rb

@@ -1,181 +0,0 @@
-module Skypager
-  module Sync
-    class Amazon
-      include Singleton
-
-      require 'fog'
-
-      def aws_access_key_id
-        options[:aws_access_key_id] || options[:access_key_id] || Skypager.config.aws_access_key_id
-      end
-
-      def aws_secret_access_key
-        options[:aws_secret_access_key] || options[:secret_access_key] || Skypager.config.aws_secret_access_key
-      end
-
-      def storage
-        return @storage if @storage
-
-        # Silence fog warnings
-        Fog::Logger.define_singleton_method(:warning) do |*args|
-          nil
-        end
-
-        @storage = Fog::Storage.new({
-          provider: 'AWS',
-          aws_access_key_id: aws_access_key_id,
-          aws_secret_access_key: aws_secret_access_key,
-          path_style: true
-        })
-
-
-        @storage
-      end
-
-      def cdn
-        @cdn ||= Fog::CDN.new({
-          provider: 'AWS',
-          aws_access_key_id: aws_access_key_id,
-          aws_secret_access_key: aws_secret_access_key
-        })
-      end
-
-      def s3_bucket_website_url
-        if s3_bucket.is_a?(Fog::Storage::AWS::Directory)
-          website_url_for(s3_bucket)
-        end
-      end
-
-      def site_description
-        options[:description] || options[:site_name] || s3_bucket.key
-      end
-
-      # the domain, and the domain with www
-      def site_domain_aliases
-        options[:aliases]
-      end
-
-      def s3_bucket
-        if bucket_name = options[:bucket_name] || Skypager.config.get("bucket_name") || Skypager.app.deploy_options[:bucket_name]
-          if bucket = find_bucket_by_name(bucket_name)
-            return bucket
-          else
-            "There is no bucket named: #{ bucket_name }. You can create one by running 'skypager setup amazon --create-bucket=BUCKET_NAME"
-          end
-        else
-          puts "Can't determine what bucket name to use."
-        end
-      end
-
-      def create_cdn_for(site)
-        o = cdn_options(website_url: site.bucket_host,
-                        comment: site.description,
-                        aliases: site.aliases.join(","))
-
-        existing = cdn.distributions.find do |distribution|
-          distribution.comment == site.description
-        end
-
-        return existing if existing
-
-        cdn.distributions.create(o).tap do |distribution|
-          site.set distribution.domain
-        end
-      end
-
-      def cdn_options(o={})
-        {
-          enabled: true,
-          custom_origin: {
-            'DNSName'=> o.fetch(:website_url) { s3_bucket_website_url },
-            'OriginProtocolPolicy'=>'match-viewer'
-          },
-          comment: o.fetch(:description) { site_description },
-          caller_reference: Time.now.to_i.to_s,
-          cname: o.fetch(:domain_aliases) { site_domain_aliases },
-          default_root_object: 'index.html'
-        }
-      end
-
-      def self.client(options={})
-        @client ||= begin
-                      instance.with_options(options)
-                    end
-      end
-
-
-      def self.method_missing(meth, *args, &block)
-        if client.respond_to?(meth)
-          return client.send(meth, *args, &block)
-        end
-
-        super
-      end
-
-      def website_host_for(bucket_or_bucket_name)
-        URI.parse(webite_url_for(bucket_or_bucket_name)).host
-      end
-
-      def website_url_for(bucket_or_bucket_name)
-        bucket = bucket_or_bucket_name
-
-        if bucket_or_bucket_name.is_a?(String)
-          bucket = storage.directories.get(bucket_or_bucket_name)
-        end
-
-        if bucket
-          "http://#{bucket.key}.s3-website-#{ bucket.location }.amazonaws.com"
-        end
-      end
-
-      def find_or_create_bucket(bucket_name)
-        find_bucket_by_name(bucket_name) || create_bucket(bucket_name)
-      end
-
-      def find_bucket_by_name(bucket_name)
-        storage.directories.get(bucket_name) rescue nil
-      end
-
-      def create_bucket(bucket_name)
-        storage.directories.create(key: bucket_name, public: true).tap do |bucket|
-          storage.put_bucket_website(bucket_name, 'index.html', key: 'error.html')
-          #storage.put_bucket_cors(bucket_name, {"AllowedOrigin"=>"*","AllowedMethod"=>"GET","AllowedHeader"=>"Authorization"})
-        end
-      end
-
-      def create_redirect_bucket(bucket_name, redirect_to_bucket_name)
-        create_bucket(redirect_to_bucket_name) unless find_bucket_by_name(redirect_to_bucket_name)
-        create_bucket(bucket_name)
-      end
-
-      def with_options(opts={})
-        options.merge!(opts)
-        self
-      end
-
-      def options
-        @options ||= {}
-      end
-
-      def has_application_keys?
-        (Skypager.config.aws_access_key_id.to_s.length > 0 && Skypager.config.aws_secret_access_key.to_s.length > 0)
-      end
-
-      def setup(options={})
-        return if has_application_keys?
-
-        unless Skypager.config.aws_access_key_id.to_s.length > 0
-          if value = options[:access_key_id] || ask("What is the AWS Access Key ID?", String)
-            Skypager.config.set 'aws_access_key_id', value
-          end
-        end
-
-        unless Skypager.config.aws_secret_access_key.to_s.length > 0
-          if value = options[:secret_access_key] || ask("What is the AWS Secret Access Key?", String)
-            Skypager.config.set 'aws_secret_access_key', value
-          end
-        end
-      end
-    end
-  end
-end

data/lib/skypager/sync/dropbox.rb

@@ -1,173 +0,0 @@
-module Skypager
-  module Sync
-    class Dropbox
-      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
-                      ::Dropbox::API::Config.app_key    = options.fetch(:dropbox_app_key) { Skypager.config.dropbox_app_key }
-                      ::Dropbox::API::Config.app_secret = options.fetch(:dropbox_app_secret) { Skypager.config.dropbox_app_secret }
-                      ::Dropbox::API::Config.mode       = options.fetch(:dropbox_app_type) { Skypager.config.dropbox_app_type }
-                      instance.with_options(options)
-                    end
-      end
-
-      def sandboxed_app?
-        entry = api.ls.first
-        entry && entry.root == "app_folder"
-      end
-
-      def api
-        @api ||= begin
-                   token = options.fetch(:token) { Skypager.config.dropbox_client_token }
-                   secret = options.fetch(:secret) { Skypager.config.dropbox_client_secret }
-                   ::Dropbox::API::Client.new(token: token  , secret: secret)
-                 end
-      end
-
-      def find(path)
-        api.find(path)
-      rescue ::Dropbox::API::Error::NotFound
-        nil
-      end
-
-      def push_from(local_path, options={})
-        path_prefix = options.fetch(:prefix)
-        root        = options[:root]
-
-        unless find(path_prefix)
-          api.mkdir(path_prefix)
-        end
-
-        uploader = lambda do |node|
-          next if node.to_s == ".DS_Store"
-
-          if node.directory?
-            Array(node.children).each(&uploader)
-          elsif node.file?
-            relative = node.relative_path_from(local_path)
-            target = "#{path_prefix}/#{relative}"
-            target = target.gsub(/^\//,'')
-            api.upload(target, node.read)
-          end
-        end
-
-        Pathname(local_path).children.each(&uploader)
-      end
-
-      def create_site_folder(folder, allow_overwrite=false)
-        found = find(folder)
-
-        unless (!found || (found && !allow_overwrite))
-          api.mkdir("/#{folder}")
-        end
-      end
-
-      def sync(local_path, remote_path, options={})
-        sync_folders(local_path, remote_path, options)
-      end
-
-      # Instructs Skypager to create a syncable folder
-      # between the local and remote path, and optionally
-      # modifies the middleman config for the site
-      def sync_folders(local_path, remote_path, options={})
-        app = options[:app]
-
-        folder = Skypager::Sync::Folder.new(local_path: local_path,
-                                            remote_path: remote_path,
-                                            app: app).synced
-
-        if !!options[:append_config] == true
-          Skypager.append_config(folder.config_line)
-        end
-
-        folder
-      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 requires_setup?
-        !(dropbox_app_key.length > 0 && dropbox_app_secret.length > 0)
-      end
-
-      def dropbox_app_key
-        Skypager.config.dropbox_app_key.to_s
-      end
-
-      def dropbox_app_secret
-        Skypager.config.dropbox_app_secret.to_s
-      end
-
-      def setup(options={})
-        if requires_setup?
-          if dropbox_app_key.length == 0
-            if answer = options[:dropbox_app_key] || ask("What is the dropbox app key?", String)
-              Skypager.config.set("dropbox_app_key", answer)
-            end
-            if answer = options[:dropbox_app_secret] || ask("What is the dropbox app secret?", String)
-              Skypager.config.set("dropbox_app_secret", answer)
-            end
-          end
-        end
-
-        raise 'Missing dropbox application values' if requires_setup?
-
-        ::Dropbox::API::Config.app_key    = Skypager.config.dropbox_app_key
-        ::Dropbox::API::Config.app_secret = Skypager.config.dropbox_app_secret
-
-        consumer = ::Dropbox::API::OAuth.consumer(:authorize)
-        request_token = consumer.get_request_token
-        puts "\nGo to this url and click 'Authorize' to get the token:"
-        puts request_token.authorize_url
-        Launchy.open(request_token.authorize_url)
-
-        query  = request_token.authorize_url.split('?').last
-        params = CGI.parse(query)
-        token  = params['oauth_token'].first
-        print "\nOnce you authorize the app on Dropbox, press enter... "
-        STDIN.gets.chomp
-
-        access_token  = request_token.get_access_token(:oauth_verifier => token)
-
-        Skypager.config.set 'dropbox_client_token', access_token.token
-        Skypager.config.set 'dropbox_client_secret', access_token.secret
-
-        puts "\nAuthorization complete!:\n\n"
-        puts "  Dropbox::API::Config.app_key    = '#{consumer.key}'"
-        puts "  Dropbox::API::Config.app_secret = '#{consumer.secret}'"
-        puts "  client = Dropbox::API::Client.new(:token  => '#{access_token.token}', :secret => '#{access_token.secret}')"
-        puts "\n"
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-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 = {}.to_mash
-
-        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