gooddata 0.6.7 → 0.6.8

data/lib/gooddata/cli/commands/role_cmd.rb

@@ -1,28 +0,0 @@
-# encoding: UTF-8
-
-require 'pp'
-
-require_relative '../shared'
-require_relative '../../commands/role'
-
-GoodData::CLI.module_eval do
-  desc 'Basic Role Management'
-  arg_name 'list'
-  command :role do |c|
-    c.desc 'List roles'
-    c.command :list do |list|
-      list.action do |global_options, options, args|
-        opts = options.merge(global_options)
-        GoodData.connect(opts)
-
-        pid = global_options[:project_id]
-        fail 'Project ID has to be provided' if pid.nil? || pid.empty?
-
-        role_list = GoodData::Command::Role.list(pid)
-        role_list.each do |k, v|
-          puts [k, v[:uri]].join(',')
-        end
-      end
-    end
-  end
-end

data/lib/gooddata/core/connection.rb

@@ -1,392 +0,0 @@
-# encoding: UTF-8
-
-require 'multi_json'
-require 'rest-client'
-
-require_relative '../version'
-
-module GoodData
-  # # GoodData HTTP wrapper
-  #
-  # Provides a convenient HTTP wrapper for talking with the GoodData API.
-  #
-  # Remember that the connection is shared amongst the entire application.
-  # Therefore you can't be logged in to more than _one_ GoodData account.
-  # per session. Simultaneous connections to multiple GoodData accounts is not
-  # supported at this time.
-  #
-  # The GoodData API is a RESTful API that communicates using JSON. This wrapper
-  # makes sure that the session is stored between requests and that the JSON is
-  # parsed both when sending and receiving.
-  #
-  # ## Usage
-  #
-  # Before a connection can be made to the GoodData API, you have to supply the user credentials like this:
-  #
-  #   Connection.new(username, password)
-  #
-  # To send a HTTP request use either the get, post or delete methods documented below.
-  #
-  class Connection
-    DEFAULT_URL = 'https://secure.gooddata.com'
-    LOGIN_PATH = '/gdc/account/login'
-    TOKEN_PATH = '/gdc/account/token'
-
-    attr_reader(:auth_token, :url)
-    attr_accessor :status, :options
-
-    # Options:
-    # * :tries - Number of retries to perform. Defaults to 1.
-    # * :on - The Exception on which a retry will be performed. Defaults to Exception, which retries on any Exception.
-    #
-    # ### Example
-    #
-    #     retryable(:tries => 1, :on => OpenURI::HTTPError) do
-    #       # your code here
-    #     end
-    #
-    def retryable(options = {}, &block)
-      opts = { :tries => 1, :on => Exception }.merge(options)
-
-      retry_exception, retries = opts[:on], opts[:tries]
-
-      begin
-        return yield
-      rescue retry_exception
-        retry if (retries -= 1) > 0
-      end
-
-      yield
-    end
-
-    # Set the GoodData account credentials.
-    #
-    # This have to be performed before any calls to the API.
-    #
-    # @param username The GoodData account username
-    # @param password The GoodData account password
-    #
-    def initialize(username, password, options = {})
-      @status = :not_connected
-      @username = username
-      @password = password
-      @url = options[:server] || DEFAULT_URL
-      @auth_token = options[:gdc_temporary_token]
-      @options = options
-
-      @headers = options[:headers] || {}
-
-      default_headers = {
-        :content_type => :json,
-        :accept => [:json, :zip],
-        :user_agent => GoodData.gem_version_string
-      }
-      default_headers.merge! @headers
-
-      @server = RestClient::Resource.new @url,
-                                         :timeout => @options[:timeout],
-                                         :headers => default_headers
-
-      @server = create_server_connection(@url, @options)
-    end
-
-    # Returns the user JSON object of the currently logged in GoodData user account.
-    def user
-      ensure_connection
-      @user
-    end
-
-    # Performs a HTTP GET request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    #
-    # ### Examples
-    #
-    #     Connection.new(username, password).get '/gdc/projects'
-    #
-    def get(path, options = {})
-      GoodData.logger.debug "GET #{@server}#{path}"
-      ensure_connection
-      b = proc { @server[path].get cookies }
-      process_response(options, &b)
-    end
-
-    # Performs a HTTP POST request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    # @param data The payload data in the format of a Hash object
-    #
-    # ### Examples
-    #
-    #     Connection.new(username, password).post '/gdc/projects', { ... }
-    #
-    def post(path, data, options = {})
-      GoodData.logger.debug("POST #{@server}#{path}, payload: #{scrub_params(data, [:password, :login, :authorizationToken])}")
-      ensure_connection
-      payload = data.is_a?(Hash) ? data.to_json : data
-      b = proc { @server[path].post payload, cookies }
-      process_response(options, &b)
-    end
-
-    # Performs a HTTP PUT request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    # @param data The payload data in the format of a Hash object
-    #
-    # ### Examples
-    #
-    #     Connection.new(username, password).put '/gdc/projects', { ... }
-    #
-    def put(path, data, options = {})
-      payload = data.is_a?(Hash) ? data.to_json : data
-      GoodData.logger.debug "PUT #{@server}#{path}, payload: #{payload}"
-      ensure_connection
-      b = proc { @server[path].put payload, cookies }
-      process_response(options, &b)
-    end
-
-    # Performs a HTTP DELETE request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    #
-    # ### Examples
-    #
-    #     Connection.new(username, password).delete '/gdc/project/1'
-    #
-    def delete(path, options = {})
-      GoodData.logger.debug "DELETE #{@server}#{path}"
-      ensure_connection
-      b = proc { @server[path].delete cookies }
-      process_response(options, &b)
-    end
-
-    # Get the cookies associated with the current connection.
-    def cookies
-      @cookies ||= { :cookies => {} }
-    end
-
-    # Set the cookies used when communicating with the GoodData API.
-    def merge_cookies!(cookies)
-      self.cookies
-      @cookies[:cookies].merge! cookies
-    end
-
-    # Returns true if a connection have been established to the GoodData API
-    # and the login was successful.
-    def logged_in?
-      @status == :logged_in
-    end
-
-    def url=(url = nil)
-      @url = url || DEFAULT_URL
-      @server = create_server_connection(@url, @options)
-    end
-
-    # The connection will automatically be established once it's needed, which it
-    # usually is when either the user, get, post or delete method is called. If you
-    # want to force a connection (or a re-connect) you can use this method.
-    def connect!
-      connect
-    end
-
-    # Uploads a file to GoodData server
-    # /uploads/ resources are special in that they use a different
-    # host and a basic authentication.
-    def upload(file, options = {})
-      ensure_connection
-
-      dir = options[:directory] || ''
-      staging_uri = options[:staging_url].to_s
-      url = dir.empty? ? staging_uri : URI.join(staging_uri, "#{dir}/").to_s
-
-      # Make a directory, if needed
-      unless dir.empty?
-        method = :get
-        GoodData.logger.debug "#{method}: #{url}"
-        begin
-          # first check if it does exits
-          RestClient::Request.execute({
-            :method => method,
-            :url => url,
-            :timeout => @options[:timeout],
-            :headers => {
-              :user_agent => GoodData.gem_version_string
-              }
-            }.merge(cookies)
-          )
-        rescue RestClient::Exception => e
-          if e.http_code == 404
-            method = :mkcol
-            GoodData.logger.debug "#{method}: #{url}"
-            RestClient::Request.execute({
-              :method => method,
-              :url => url,
-              :timeout => @options[:timeout],
-              :headers => {
-                :user_agent => GoodData.gem_version_string
-              }
-            }.merge(cookies))
-          end
-        end
-      end
-
-      payload = options[:stream] ? 'file' : File.read(file)
-      filename = options[:filename] || options[:stream] ? 'randome-filename.txt' : File.basename(file)
-
-      # Upload the file
-      # puts "uploading the file #{URI.join(url, filename).to_s}"
-      req = RestClient::Request.new(
-        :method => :put,
-        :url => URI.join(url, filename).to_s,
-        :timeout => @options[:timeout],
-        :headers => {
-          :user_agent => GoodData.gem_version_string
-        },
-        :payload => payload,
-        :raw_response => true,
-        :user => @username,
-        :password => @password
-      )
-      # .merge(cookies))
-      req.execute
-      true
-    end
-
-    def download(what, where, options = {})
-      staging_uri = options[:staging_url].to_s
-      url = staging_uri + what
-      req = RestClient::Request.new(
-        :method => 'GET',
-        :url => url,
-        :user => @username,
-        :password => @password)
-
-      if where.is_a?(String)
-        File.open(where, 'w') do |f|
-          req.execute do |chunk, x, y|
-            f.write chunk
-          end
-        end
-      else
-        # Assume it is a IO stream
-        req.execute do |chunk, x, y|
-          where.write chunk
-        end
-      end
-    end
-
-    def connected?
-      @status == :logged_in
-    end
-
-    def disconnect
-      if connected? && GoodData.connection.user['state']
-        GoodData.delete(GoodData.connection.user['state'])
-        @status = :not_connected
-      end
-    end
-
-    private
-
-    def create_server_connection(url, options)
-      RestClient::Resource.new url,
-                               :timeout => options[:timeout],
-                               :headers => {
-                                 :content_type => :json,
-                                 :accept => [:json, :zip],
-                                 :user_agent => GoodData.gem_version_string
-                               }
-    end
-
-    def ensure_connection
-      connect if @status == :not_connected
-    end
-
-    def connect
-      GoodData.logger.info 'Connecting to GoodData...'
-      @status = :connecting
-      authenticate
-    end
-
-    def authenticate
-      credentials = {
-        'postUserLogin' => {
-          'login' => @username,
-          'password' => @password,
-          'remember' => 1
-        }
-      }
-      GoodData.logger.debug 'Logging in...'
-      @user = post(LOGIN_PATH, credentials, :dont_reauth => true)['userLogin']
-      refresh_token :dont_reauth => true # avoid infinite loop if refresh_token fails with 401
-
-      @status = :logged_in
-    end
-
-    def process_response(options = {}, &block)
-      begin
-        response = block.call
-      rescue RestClient::Unauthorized
-        raise $ERROR_INFO if options[:dont_reauth]
-        refresh_token
-        response = block.call
-      end
-      merge_cookies! response.cookies
-      content_type = response.headers[:content_type]
-      return response if options[:process] == false
-
-      if content_type == 'application/json' || content_type == 'application/json;charset=UTF-8'
-        result = response.to_str == '""' ? {} : MultiJson.load(response.to_str)
-        GoodData.logger.debug "Response: #{result.inspect}"
-      elsif ['text/plain;charset=UTF-8', 'text/plain; charset=UTF-8', 'text/plain'].include?(content_type)
-        result = response
-        GoodData.logger.debug 'Response: plain text'
-      elsif content_type == 'application/zip'
-        result = response
-        GoodData.logger.debug 'Response: a zipped stream'
-      elsif response.headers[:content_length].to_s == '0'
-        result = nil
-        GoodData.logger.debug 'Response: Empty response possibly 204'
-      elsif response.code == 204
-        result = nil
-        GoodData.logger.debug 'Response: 204 no content'
-      else
-        fail "Unsupported response content type '%s':\n%s" % [content_type, response.to_str[0..127]]
-      end
-      result
-    rescue RestClient::Exception => e
-      GoodData.logger.debug "Response: #{e.response}"
-      raise $ERROR_INFO
-    end
-
-    def refresh_token(options = {})
-      GoodData.logger.debug 'Getting authentication token...'
-      begin
-        get TOKEN_PATH, :dont_reauth => true # avoid infinite loop GET fails with 401
-      rescue RestClient::Unauthorized
-        raise $ERROR_INFO if options[:dont_reauth]
-        authenticate
-      end
-    end
-
-    def scrub_params(params, keys)
-      keys = keys.reduce([]) { |a, e| a.concat([e.to_s, e.to_sym]) }
-
-      new_params = params.deep_dup
-      GoodData::Helpers.hash_dfs(new_params) do |k, key|
-        keys.each do |key_to_scrub|
-          k[key_to_scrub] = ('*' * k[key_to_scrub].length) if k && k.key?(key_to_scrub) && k[key_to_scrub]
-        end
-      end
-      new_params
-    end
-  end
-end

data/lib/gooddata/core/threaded.rb

@@ -1,14 +0,0 @@
-# encoding: UTF-8
-
-module GoodData
-  module Threaded
-    # Used internally for thread safety
-    def threaded
-      Thread.current[:goooddata] ||= {}
-    end
-  end
-
-  class << self
-    include Threaded
-  end
-end

data/lib/gooddata/models/md_object.rb

@@ -1,25 +0,0 @@
-# encoding: UTF-8
-
-module GoodData
-  module Model
-    class MdObject
-      attr_accessor :name, :title
-
-      def visual
-        "TITLE \"#{title_esc}\""
-      end
-
-      def title_esc
-        title.gsub(/"/, "\\\"")
-      end
-
-      ##
-      # Generates an identifier from the object name by transliterating
-      # non-Latin character and then dropping non-alphanumerical characters.
-      #
-      def identifier
-        @identifier ||= "#{type_prefix}.#{name}"
-      end
-    end
-  end
-end