datapimp 0.0.1 → 1.0.0

data/lib/datapimp/clients/amazon.rb

@@ -0,0 +1,172 @@
+module Datapimp
+  module Clients
+    class Amazon
+      include Singleton
+
+      require 'fog/aws'
+
+      def aws_access_key_id
+        options[:aws_access_key_id] || options[:access_key_id] || Datapimp.config.aws_access_key_id
+      end
+
+      def aws_secret_access_key
+        options[:aws_secret_access_key] || options[:secret_access_key] || Datapimp.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] || Datapimp.config.get("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 'datapimp setup amazon --create-bucket=BUCKET_NAME"
+          end
+        else
+          raise 'Could not determine bucketname for Datapimp.amazon.s3_bucket'
+        end
+      end
+
+      def create_cdn_for(website_url, comment, aliases)
+        aliases = aliases.join(",") if aliases.is_a?(Array)
+
+        existing = cdn.distributions.find do |distribution|
+          distribution.comment == comment
+        end
+
+        return existing if existing
+
+        cdn.distributions.create(cdn_options(website_url: website_url, comment: comment, aliases: aliases))
+      end
+
+      def cdn_options(o={})
+        {
+          enabled: true,
+          custom_origin: {
+            'DNSName'=> o.fetch(:website_url) { s3_bucket_website_url },
+            'OriginProtocolPolicy'=>'http-only'
+          },
+          comment: o.fetch(:comment) { site_description },
+          caller_reference: Time.now.to_i.to_s,
+          cname: o.fetch(: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(website_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?
+        (Datapimp.config.aws_access_key_id.to_s.length > 0 && Datapimp.config.aws_secret_access_key.to_s.length > 0)
+      end
+
+      def interactive_setup(options={})
+        secret_key    = Datapimp.config.aws_secret_access_key.to_s
+        access_key_id  = Datapimp.config.aws_access_key_id.to_s
+
+        secret_key = ask("What is the AWS Secret Access Key?") unless secret_key.length > 8
+        access_key_id = ask("What is the AWS Access Key ID?") unless access_key_id.length > 8
+
+        Datapimp.config.set(:aws_access_key_id, access_key_id) if access_key_id.length > 8
+        Datapimp.config.set(:aws_secret_access_key, secret_key) if secret_key.length > 8
+      end
+    end
+  end
+end

data/lib/datapimp/clients/dropbox.rb

@@ -0,0 +1,178 @@
+module Datapimp
+  module Clients
+    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={})
+        require 'dropbox-api' unless defined?(::Dropbox::API)
+        @client ||= begin
+                      ::Dropbox::API::Config.app_key    = options.fetch(:dropbox_app_key) { Datapimp.config.dropbox_app_key }
+                      ::Dropbox::API::Config.app_secret = options.fetch(:dropbox_app_secret) { Datapimp.config.dropbox_app_secret }
+                      ::Dropbox::API::Config.mode       = options.fetch(:dropbox_app_type) { Datapimp.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) { Datapimp.config.dropbox_client_token }
+                   secret = options.fetch(:secret) { Datapimp.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 Datapimp 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 = Datapimp::Sync::Folder.new(local_path: local_path,
+                                            remote_path: remote_path,
+                                            app: app).synced
+
+        if !!options[:append_config] == true
+          Datapimp.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
+        Datapimp.config.dropbox_app_key.to_s
+      end
+
+      def dropbox_app_secret
+        Datapimp.config.dropbox_app_secret.to_s
+      end
+
+      def setup(options={})
+        interactive_setup(options)
+      end
+
+      def interactive_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)
+              Datapimp.config.set("dropbox_app_key", answer)
+            end
+            if answer = options[:dropbox_app_secret] || ask("What is the dropbox app secret?", String)
+              Datapimp.config.set("dropbox_app_secret", answer)
+            end
+          end
+        end
+
+        raise 'Missing dropbox application values' if requires_setup?
+
+        ::Dropbox::API::Config.app_key    = Datapimp.config.dropbox_app_key
+        ::Dropbox::API::Config.app_secret = Datapimp.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)
+
+        Datapimp.config.set 'dropbox_client_token', access_token.token
+        Datapimp.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/datapimp/clients/github.rb

@@ -0,0 +1,59 @@
+module Datapimp
+  module Clients
+    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={})
+        require 'octokit' unless defined?(::Oktokit)
+
+        @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: Datapimp.config.github_access_token)
+                 end
+      end
+
+      def setup(options={})
+        access_token = options[:github_access_token] || Datapimp.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/"
+
+          if respond_to?(:ask)
+            access_token = ask("Enter a 40 character access token when you have one", String)
+          end
+        end
+
+        unless access_token.to_s.length == 40
+          puts "Can not proceed without a valid access token: error code #{ access_token.length }"
+          return
+        end
+
+        Datapimp.config.set(:github_access_token, access_token)
+      end
+    end
+  end
+end

data/lib/datapimp/clients/google.rb

@@ -0,0 +1,145 @@
+module Datapimp
+  module Clients
+    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={})
+        require 'google_drive' unless defined?(::GoogleDrive)
+
+        @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]
+          Datapimp.config.set "google_client_id", options[:client_id]
+        end
+
+        if options[:client_secret]
+          Datapimp.config.set "google_client_secret", options[:client_secret]
+        end
+
+        if has_refresh_token?
+          refresh_access_token!
+        elsif respond_to?(:ask)
+          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!
+          Datapimp.config.set "google_refresh_token", auth_client.refresh_token
+          Datapimp.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(Datapimp.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?
+        (Datapimp.config.google_client_id.to_s.length > 0 && Datapimp.config.google_client_secret.to_s.length > 0)
+      end
+
+      def get_application_keys
+        unless Datapimp.config.google_client_id.to_s.length > 0
+          google_client_id = ask("What is the Google Client ID?", String)
+          Datapimp.config.set "google_client_id", google_client_id
+        end
+
+        unless Datapimp.config.google_client_secret.to_s.length > 0
+          google_client_secret = ask("What is the Google Client Secret?", String)
+          Datapimp.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 #Datapimp.config.google_client_id
+        auth.client_secret = client_secret #Datapimp.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
+        Datapimp.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!
+          Datapimp.config.set "google_access_token", auth_client.access_token
+        end
+      end
+
+    end
+  end
+end