gooddata 0.6.7 → 0.6.8

data/lib/gooddata/commands/user.rb

@@ -1,10 +1,10 @@
 # encoding: UTF-8
 
-require_relative '../core/core'
-
 require 'highline/import'
 require 'multi_json'
 
+require_relative '../core/core'
+
 module GoodData
   module Command
     class User
@@ -24,8 +24,10 @@ module GoodData
           roles
         end
 
-        def show
-          GoodData.profile.to_json
+        def show(opts = { client: GoodData.connection })
+          client = opts[:client]
+          fail ArgumentError, 'No :client specified' if client.nil?
+          pp client.user.json
         end
       end
     end

data/lib/gooddata/connection.rb

@@ -1,8 +1,8 @@
 # encoding: UTF-8
 
-require_relative 'core/connection'
 require_relative 'core/logging'
-require_relative 'core/threaded'
+
+require_relative 'rest/rest'
 
 module GoodData
   class << self
@@ -10,9 +10,12 @@ module GoodData
     #
     # @see GoodData.connect
     def connection
-      threaded[:connection] || fail('Please authenticate with GoodData.connect first')
+      # TODO: Remove this after successful rest-factory transition
+      Rest::Client.connection # || fail('Please authenticate with GoodData.connect first')
     end
 
+    alias_method :client, :connection
+
     # Connect to the GoodData API
     #
     # @param options
@@ -20,57 +23,20 @@ module GoodData
     # @param third_options
     #
     def connect(options = nil, second_options = nil, third_options = {})
-      GoodData.logger.debug 'GoodData#connect'
-      threaded[:connection] = if options.is_a? Hash
-                                fail 'You have to provide login and password' if (options[:login].nil? || options[:login].empty?) && (options[:password].nil? || options[:password].empty?)
-                                Connection.new(options[:login], options[:password], options)
-                                conn = Connection.new(options[:login], options[:password], options)
-                                GoodData.project = options[:project] if options[:project]
-                                conn
-                              elsif options.is_a?(String) && second_options.is_a?(String)
-                                fail 'You have to provide login and password' if (options.nil? || options.empty?) && (second_options.nil? || second_options.empty?)
-                                Connection.new(options, second_options, third_options)
-                              elsif options.nil? && second_options.nil?
-                                p = GoodData::Command::Auth.read_credentials
-                                Connection.new(p[:login] || p[:username], p[:password], p)
-                              end
-      threaded[:connection]
+      Rest::Client.connect(options, second_options, third_options)
     end
 
     # Disconnect (logout) if logged in
     def disconnect
-      GoodData.logger.debug 'GoodData#disconnect'
-
-      if threaded[:connection]
-        threaded[:connection].disconnect
-        threaded[:connection] = nil
-      end
-    end
-
-    # Hepler for starting with SST easier
-    #
-    # @param token SST token
-    # @param options Options get routed to connect eventually so everything that you can use there should be possible to use here.
-    #
-    def connect_with_sst(token, options = {})
-      create_authenticated_connection(options.merge(:cookies => { 'GDCAuthSST' => token }))
-    end
-
-    # This method is aimed at creating an authenticated connection in case you do not hae pass/login but you have SST
-    #
-    # @param options :server => optional GD server uri, If nil it secure will be used. :cookies => you can specify a hash of cookies
-    #
-    def create_authenticated_connection(options = {})
-      connect(options)
-      server_cookies = options[:cookies]
-      connection.merge_cookies!(server_cookies)
-      connection.status = :logged_in
-      connection
+      Rest::Client.disconnect
     end
 
     def with_connection(options = nil, second_options = nil, third_options = {}, &bl)
       connection = connect(options, second_options, third_options)
       bl.call(connection)
+    rescue Exception => e # rubocop:disable RescueException
+        puts e.message
+        raise e
     ensure
       disconnect
     end

data/lib/gooddata/core/logging.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 
 require_relative 'nil_logger'
-require_relative 'threaded'
 
 module GoodData
   class << self

data/lib/gooddata/core/project.rb

@@ -1,15 +1,7 @@
 # encoding: UTF-8
 
-require_relative 'threaded'
-
 module GoodData
-  # Assigns global/default GoodData project
-  def project=(project)
-    GoodData.project = project
-    GoodData.project
-  end
-
-  alias_method :use, :project=
+  @project = nil
 
   class << self
     # Sets the active project
@@ -31,40 +23,48 @@ module GoodData
     #
     #     # Select project using indexer on GoodData::Project class
     #     GoodData.project = Project['afawtv356b6usdfsdf34vt']
-    #
-    def project=(project)
+    # Assigns global/default GoodData project
+    def project=(project, opts = { :client => GoodData.connection })
       if project.is_a? Project
-        threaded[:project] = project
+        @project = project
       elsif project.nil?
-        threaded[:project] = nil
+        @project = nil
       else
-        threaded[:project] = Project[project]
+        @project = Project[project, opts]
       end
+      @project
     end
 
     alias_method :use, :project=
 
+    attr_reader :project
+
     # Returns the active project
     #
-    def project
-      threaded[:project]
-    end
+    # def project
+    #   threaded[:project]
+    # end
 
     # Perform block in context of another project than currently set
     #
     # @param project Project to use
     # @param bl Block to be performed
-    def with_project(project, &bl)
+    def with_project(project, opts = { :client => GoodData.connection }, &bl)
       fail 'You have to specify a project when using with_project' if project.nil? || (project.is_a?(String) && project.empty?)
+      fail 'You have to specify block' unless bl
       old_project = GoodData.project
+
       begin
-        GoodData.use(project)
-        bl.call(GoodData.project)
+        GoodData.use(project, opts)
+        res = bl.call(GoodData.project)
       rescue RestClient::ResourceNotFound
-        raise(GoodData::ProjectNotFound, 'Project was not found')
-      ensure
         GoodData.project = old_project
+        raise(GoodData::ProjectNotFound, 'Project was not found')
       end
+
+      GoodData.project = old_project
+
+      res
     end
   end
 end

data/lib/gooddata/core/rest.rb

@@ -1,7 +1,5 @@
 # encoding: UTF-8
 
-require_relative 'connection'
-
 module GoodData
   DEFAULT_SLEEP_INTERVAL = 10
 
@@ -67,7 +65,7 @@ module GoodData
     end
 
     def upload_to_user_webdav(file, options = {})
-      u = URI(connection.options[:webdav_server] || GoodData.project.links['uploads'])
+      u = URI(GoodData.project.links['uploads'])
       url = URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
       connection.upload(file, options.merge(
         :directory => options[:directory],
@@ -76,7 +74,7 @@ module GoodData
     end
 
     def get_project_webdav_path(file, options = {})
-      u = URI(connection.options[:webdav_server] || GoodData.project.links['uploads'])
+      u = URI(GoodData.project.links['uploads'])
       URI.join(u.to_s.chomp(u.path.to_s), '/project-uploads/', "#{GoodData.project.pid}/")
     end
 
@@ -88,7 +86,7 @@ module GoodData
     end
 
     def get_user_webdav_path(file, options = {})
-      u = URI(connection.options[:webdav_server] || GoodData.project.links['uploads'])
+      u = URI(GoodData.project.links['uploads'])
       URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
     end
 
@@ -134,13 +132,16 @@ module GoodData
     # @param options [Hash] Options
     # @return [Hash] Result of polling
     def poll_on_response(link, options = {}, &bl)
+      client = options[:client]
+      fail ArgumentError, 'No :client specified' if client.nil?
+
       sleep_interval = options[:sleep_interval] || DEFAULT_SLEEP_INTERVAL
-      response = GoodData.get(link)
+      response = get(link)
       while bl.call(response)
         sleep sleep_interval
-        GoodData.connection.retryable(:tries => 3, :on => RestClient::InternalServerError) do
+        client.retryable(:tries => 3, :on => RestClient::InternalServerError) do
           sleep sleep_interval
-          response = GoodData.get(link)
+          response = get(link)
         end
       end
       response

data/lib/gooddata/core/user.rb

@@ -1,20 +1,9 @@
 # encoding: UTF-8
 
-require_relative 'connection'
-require_relative 'threaded'
-
 require_relative '../models/profile'
 
 module GoodData
   class << self
-    # Attempts to log in
-    #
-    # @return [Boolean] True if logged in else false
-    def test_login
-      connection.connect!
-      connection.logged_in?
-    end
-
     # Gets currently logged user
     #
     # @return [GoodData::Profile] User Profile

data/lib/gooddata/exceptions/project_not_found.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+require 'restclient/exceptions'
 
 module GoodData
   # Project Not Found

data/lib/gooddata/extensions/enumerable.rb

@@ -9,4 +9,14 @@ module Enumerable
       a
     end
   end
+
+  def pmapcat(initial = [], &block)
+    intermediate = pmap(&block)
+    intermediate.reduce(initial) do |a, e|
+      e.each do |x|
+        a << x
+      end
+      a
+    end
+  end
 end

data/lib/gooddata/extensions/hash.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+class Hash
+  # Return a hash that includes everything but the given keys. This is useful for
+  # limiting a set of parameters to everything but a few known toggles:
+  #
+  #   @person.update_attributes(params[:person].except(:admin))
+  #
+  # If the receiver responds to +convert_key+, the method is called on each of the
+  # arguments. This allows +except+ to play nice with hashes with indifferent access
+  # for instance:
+  #
+  #   {:a => 1}.with_indifferent_access.except(:a)  # => {}
+  #   {:a => 1}.with_indifferent_access.except("a") # => {}
+  #
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end

data/lib/gooddata/goodzilla/goodzilla.rb

@@ -38,12 +38,12 @@ module GoodData
       }
     end
 
-    def self.interpolate_ids(*ids)
+    def self.interpolate_ids(options, *ids)
       ids = ids.flatten
       if ids.empty?
         []
       else
-        res = GoodData::MdObject.identifier_to_uri(*ids)
+        res = GoodData::MdObject.identifier_to_uri(options, *ids)
         fail 'Not all of the identifiers were resolved' if Array(res).size != ids.size
         res
       end
@@ -54,7 +54,7 @@ module GoodData
       keys.zip(x)
     end
 
-    def self.interpolate_metric(metric, dictionary)
+    def self.interpolate_metric(metric, dictionary, options = { :client => GoodData.connection, :project => GoodData.project })
       interpolated = interpolate({
                                    :facts => GoodData::SmallGoodZilla.get_facts(metric),
                                    :attributes => GoodData::SmallGoodZilla.get_attributes(metric),
@@ -62,7 +62,7 @@ module GoodData
                                  }, dictionary)
 
       ids = GoodData::SmallGoodZilla.get_ids(metric)
-      interpolated_ids = ids.zip(Array(interpolate_ids(ids)))
+      interpolated_ids = ids.zip(Array(interpolate_ids(options, ids)))
 
       metric = interpolated[:facts].reduce(metric) { |a, e| a.sub("#\"#{e[0]}\"", "[#{e[1]}]") }
       metric = interpolated[:attributes].reduce(metric) { |a, e| a.sub("@\"#{e[0]}\"", "[#{e[1]}]") }

data/lib/gooddata/helper/class_helper.rb

@@ -0,0 +1 @@
+# encoding: utf-8

data/lib/gooddata/helper/helpers.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+require 'pathname'
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  require_relative file
+end

data/lib/gooddata/helpers/auth_helpers.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'multi_json'
+
+require_relative 'global_helpers'
+
+module GoodData
+  module Helpers
+    module AuthHelper
+      class << self
+        # Get path of .gooddata config
+        def credentials_file
+          "#{Helpers.home_directory}/.gooddata"
+        end
+
+        # Read credentials
+        def read_credentials(credentials_file_path = credentials_file)
+          if File.exist?(credentials_file_path)
+            config = File.read(credentials_file_path)
+            MultiJson.load(config, :symbolize_keys => true)
+          else
+            {}
+          end
+        end
+
+        # Writes credentials
+        def write_credentials(credentials, credentials_file_path = credentials_file)
+          File.open(credentials_file_path, 'w', 0600) do |f|
+            f.puts MultiJson.encode(credentials, :pretty => true)
+          end
+          credentials
+        end
+
+        def remove_credentials_file(credentials_file_path = credentials_file)
+          FileUtils.rm_f(credentials_file_path)
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/author.rb

@@ -8,7 +8,7 @@ module GoodData
       # @return [GoodData::Profile] Project Role author
       def author
         url = meta['author']
-        tmp = GoodData.get url
+        tmp = client.get url
         GoodData::Profile.new(tmp)
       end
     end

data/lib/gooddata/mixins/contributor.rb

@@ -8,7 +8,7 @@ module GoodData
       # @return [GoodData::Profile] Project Role Contributor
       def contributor
         url = meta['contributor']
-        tmp = GoodData.get url
+        tmp = client.get url
         GoodData::Profile.new(tmp)
       end
     end

data/lib/gooddata/mixins/data_property_reader.rb

@@ -1,5 +1,7 @@
 # encoding: UTF-8
 
+require_relative 'data_getter'
+
 module GoodData
   module Mixin
     module DataPropertyReader

data/lib/gooddata/mixins/data_property_writer.rb

@@ -1,5 +1,7 @@
 # encoding: UTF-8
 
+require_relative 'data_getter'
+
 module GoodData
   module Mixin
     module DataPropertyWriter