gooddata 0.6.11 → 0.6.12

data/lib/gooddata/core/logging.rb

@@ -5,6 +5,7 @@ require_relative 'nil_logger'
 module GoodData
   class << self
     attr_writer :logger
+    attr_writer :stats
 
     # Turn logging on
     #
@@ -43,5 +44,17 @@ module GoodData
     def logger
       @logger ||= NilLogger.new
     end
+
+    def stats_on
+      @stats = true
+    end
+
+    def stats_on? # rubocop:disable Style/TrivialAccessors
+      @stats
+    end
+
+    def stats_off
+      @stats = false
+    end
   end
 end

data/lib/gooddata/core/rest.rb

@@ -27,7 +27,7 @@ module GoodData
     #
     # ### Examples
     #
-    #     GoodData.post '/gdc/projects', { ... }
+    #     client.post '/gdc/projects', { ... }
     #
     def post(path, data = {}, options = {})
       connection.post path, data, options
@@ -44,7 +44,7 @@ module GoodData
     #
     # ### Examples
     #
-    #     GoodData.put '/gdc/projects', { ... }
+    #     client.put '/gdc/projects', { ... }
     #
     def put(path, data, options = {})
       connection.put path, data, options
@@ -64,8 +64,12 @@ module GoodData
       connection.delete path, options
     end
 
-    def upload_to_user_webdav(file, options = {})
-      u = URI(GoodData.project.links['uploads'])
+    # Upload to user directory
+    # @return [String]
+    def upload_to_user_webdav(file, options = { :project => GoodData.project })
+      options = merge_options(options)
+      project = options[:project]
+      u = URI(project.links['uploads'])
       url = URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
 
       connection.upload(file, options.merge(
@@ -73,28 +77,40 @@ module GoodData
       ))
     end
 
-    def get_project_webdav_path(_file, _options = {})
-      u = URI(GoodData.project.links['uploads'])
-      URI.join(u.to_s.chomp(u.path.to_s), '/project-uploads/', "#{GoodData.project.pid}/")
+    # Get WebDav directory for project data
+    # @return [String]
+    def get_project_webdav_path(file, options = { :project => GoodData.project })
+      options = merge_options(options)
+      project = options[:project]
+      project.get_project_webdav_path(file)
     end
 
-    def upload_to_project_webdav(file, options = {})
+    # Upload to project directory
+    def upload_to_project_webdav(file, options = { :project => GoodData.project })
+      options = merge_options(options)
       webdav_filename = File.basename(file)
       url = get_project_webdav_path(webdav_filename, options)
       connection.upload(file, options.merge(:staging_url => url))
     end
 
-    def download_from_project_webdav(file, where, options = {})
+    # Download from project directory
+    def download_from_project_webdav(file, where, options = { :project => GoodData.project })
+      options = merge_options(options)
       url = get_project_webdav_path(file, options)
       connection.download(file, where, options.merge(:staging_url => url))
     end
 
-    def get_user_webdav_path(_file, _options = {})
-      u = URI(GoodData.project.links['uploads'])
-      URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
+    # Get WebDav directory for user data
+    # @return [String]
+    def get_user_webdav_path(file, options = { :project => GoodData.project })
+      options = merge_options(options)
+      project = options[:project]
+      project.get_user_webdav_path(file)
     end
 
-    def download_from_user_webdav(file, where, options = {})
+    # Download from user directory
+    def download_from_user_webdav(file, where, options = { :project => GoodData.project })
+      options = merge_options(options)
       url = get_user_webdav_path(file, options)
       connection.download(file, where, options.merge(:staging_url => url))
     end
@@ -114,7 +130,7 @@ module GoodData
       response = GoodData.get(link, :process => false)
       while response.code == code
         sleep sleep_interval
-        GoodData::Rest::Client.retryable(:tries => 3, :on => RestClient::InternalServerError) do
+        GoodData::Rest::Client.retryable(:tries => 3, :refresh_token => proc { connection.refresh_token }) do
           sleep sleep_interval
           response = GoodData.get(link, :process => false)
         end
@@ -129,7 +145,7 @@ module GoodData
     # Generalizaton of poller. Since we have quite a variation of how async proceses are handled
     # this is a helper that should help you with resources where the information about "Are we done"
     # is inside the response. It expects the URI as an input where it can poll and a block that should
-    # return either true -> 'meaning we are done' or false -> meaning sleep and repeat. It returns the
+    # return either false -> 'meaning we are done' or true -> meaning sleep and repeat. It returns the
     # value of last poll. In majority of cases these are the data that you need
     #
     # @param link [String] Link for polling
@@ -143,12 +159,20 @@ module GoodData
       response = get(link)
       while bl.call(response)
         sleep sleep_interval
-        GoodData::Rest::Client.retryable(:tries => 3, :on => RestClient::InternalServerError) do
+        GoodData::Rest::Client.retryable(:tries => 3, :refresh_token => proc { client.connection.refresh_token }) do
           sleep sleep_interval
           response = get(link)
         end
       end
       response
     end
+
+    private
+
+    def merge_options(opts)
+      {
+        :project => GoodData.project
+      }.merge(opts)
+    end
   end
 end

data/lib/gooddata/exceptions/user_in_different_domain.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module GoodData
+  class UserInDifferentDomainError < RuntimeError
+    DEFAULT_MSG = 'User is already in different domain'
+
+    def initialize(msg = DEFAULT_MSG)
+      super(msg)
+    end
+  end
+end

data/lib/gooddata/extensions/enumerable.rb

@@ -24,4 +24,12 @@ module Enumerable
     intermediate = pmap(&block)
     zip(intermediate).select { |x| x[1] }.map(&:first)
   end
+
+  def rjust(n, x)
+    Array.new([0, n - length].max, x) + self
+  end
+
+  def ljust(n, x)
+    dup.fill(x, length...n)
+  end
 end

data/lib/gooddata/goodzilla/goodzilla.rb

@@ -2,6 +2,8 @@
 
 module GoodData
   module SmallGoodZilla
+    PARSE_MAQL_OBJECT_REGEXP = /\[([^\]]+)\]/
+
     # Get IDs from MAQL string
     # @param a_maql_string Input MAQL string
     # @return [Array<String>] List of IDS
@@ -30,6 +32,28 @@ module GoodData
       a_maql_string.scan(/\?"([^\"]+)\"/).flatten
     end
 
+    # Pretty prints the MAQL expression. This basically means it finds out names of objects and elements and print their values instead of URIs
+    # @param expression [String] Expression to be beautified
+    # @return [String] Pretty printed MAQL expression
+    def self.pretty_print(expression, opts = { client: GoodData.connection, project: GoodData.project })
+      temp = expression.dup
+      pairs = expression.scan(PARSE_MAQL_OBJECT_REGEXP).pmap do |uri|
+        uri = uri.first
+        if uri =~ /elements/
+          [uri, Attribute.find_element_value(uri, opts)]
+        else
+          [uri, GoodData::MdObject[uri, opts].title]
+        end
+      end
+
+      pairs.each do |el|
+        uri = el[0]
+        obj = el[1]
+        temp.sub!(uri, obj)
+      end
+      temp
+    end
+
     def self.interpolate(values, dictionaries)
       {
         :facts => interpolate_values(values[:facts], dictionaries[:facts]),

data/lib/gooddata/helpers/global_helpers.rb

@@ -6,16 +6,91 @@ require 'pathname'
 module GoodData
   module Helpers
     class << self
-      def home_directory
-        running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
-      end
+      # A helper which allows you to diff two lists of objects. The objects
+      # can be arbitrary objects as long as they respond to to_hash because
+      # the diff is eventually done on hashes. It allows you to specify
+      # several options to allow you to limit on what the sameness test is done
+      #
+      # @param [Array<Object>] old_list List of objects that serves as a base for comparison
+      # @param [Array<Object>] new_list List of objects that is compared agianst the old_list
+      # @return [Hash] A structure that contains the result of the comparison. There are
+      # four keys.
+      # :added contains the list that are in new_list but were not in the old_list
+      # :added contains the list that are in old_list but were not in the new_list
+      # :same contains objects that are in both lists and they are the same
+      # :changed contains list of objects that changed along ith original, the new one
+      # and the list of changes
+      def diff(old_list, new_list, options = {})
+        old_list = old_list.map(&:to_hash)
+        new_list = new_list.map(&:to_hash)
 
-      def running_on_windows?
-        RUBY_PLATFORM =~ /mswin32|mingw32/
+        fields = options[:fields]
+        lookup_key = options[:key]
+
+        old_lookup = Hash[old_list.map { |v| [v[lookup_key], v] }]
+
+        res = {
+          :added => [],
+          :removed => [],
+          :changed => [],
+          :same => []
+        }
+
+        new_list.each do |new_obj|
+          old_obj = old_lookup[new_obj[lookup_key]]
+          if old_obj.nil?
+            res[:added] << new_obj
+            next
+          end
+
+          if fields
+            sliced_old_obj = old_obj.slice(*fields)
+            sliced_new_obj = new_obj.slice(*fields)
+          else
+            sliced_old_obj = old_obj
+            sliced_new_obj = new_obj
+          end
+          if sliced_old_obj != sliced_new_obj
+            difference = sliced_new_obj.to_a - sliced_old_obj.to_a
+            differences = Hash[*difference.mapcat { |x| x }]
+            res[:changed] << {
+              old_obj: old_obj,
+              new_obj: new_obj,
+              diff: differences
+            }
+          else
+            res[:same] << old_obj
+          end
+        end
+
+        new_lookup = Hash[new_list.map { |v| [v[lookup_key], v] }]
+        old_list.each do |old_obj|
+          new_obj = new_lookup[old_obj[lookup_key]]
+          if new_obj.nil?
+            res[:removed] << old_obj
+            next
+          end
+        end
+
+        res
       end
 
-      def running_on_a_mac?
-        RUBY_PLATFORM =~ /-darwin\d/
+      def create_lookup(collection, on)
+        lookup = {}
+        if on.is_a?(Array)
+          collection.each do |e|
+            key = e.values_at(*on)
+            lookup[key] = [] unless lookup.key?(key)
+            lookup[key] << e
+          end
+        else
+          collection.each do |e|
+            key = e[on]
+            lookup[key] = [] unless lookup.key?(key)
+            lookup[key] << e
+          end
+        end
+        lookup
       end
 
       ENCODED_PARAMS_KEY = :gd_encoded_params
@@ -94,6 +169,10 @@ module GoodData
         end
       end
 
+      def home_directory
+        running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+      end
+
       def hash_dfs(thing, &block)
         if !thing.is_a?(Hash) && !thing.is_a?(Array) # rubocop:disable Style/GuardClause
         elsif thing.is_a?(Array)
@@ -109,14 +188,49 @@ module GoodData
       end
 
       # TODO: Implement without using ActiveSupport
-      def sanitize_string(str, filter = /[^a-z_]/, replacement = '')
-        str = ActiveSupport::Inflector.transliterate(str).downcase
-        str.gsub(filter, replacement)
+      def humanize(str)
+        ActiveSupport::Inflector.humanize(str)
+      end
+
+      def join(master, slave, on, on2, options = {})
+        full_outer = options[:full_outer]
+
+        lookup = create_lookup(slave, on2)
+        marked_lookup = {}
+        results = master.reduce([]) do |a, line|
+          matching_values = lookup[line.values_at(*on)] || []
+          marked_lookup[line.values_at(*on)] = 1
+          if matching_values.empty?
+            a << line.to_hash
+          else
+            matching_values.each do |matching_value|
+              a << matching_value.to_hash.merge(line.to_hash)
+            end
+          end
+          a
+        end
+
+        if full_outer
+          (lookup.keys - marked_lookup.keys).each do |key|
+            puts lookup[key]
+            results << lookup[key].first.to_hash
+          end
+        end
+        results
+      end
+
+      def running_on_windows?
+        RUBY_PLATFORM =~ /mswin32|mingw32/
+      end
+
+      def running_on_a_mac?
+        RUBY_PLATFORM =~ /-darwin\d/
       end
 
       # TODO: Implement without using ActiveSupport
-      def humanize(str)
-        ActiveSupport::Inflector.humanize(str)
+      def sanitize_string(str, filter = /[^a-z_]/, replacement = '')
+        str = ActiveSupport::Inflector.transliterate(str).downcase
+        str.gsub(filter, replacement)
       end
 
       def underline(x)

data/lib/gooddata/mixins/author.rb

@@ -3,13 +3,19 @@
 module GoodData
   module Mixin
     module Author
-      # Gets Project Role Author
+      # Gets author of an object
       #
-      # @return [GoodData::Profile] Project Role author
+      # @return [GoodData::Profile] object author
       def author
-        url = meta['author']
-        tmp = client.get url
-        GoodData::Profile.new(tmp)
+        tmp = client.get(author_uri)
+        client.create(GoodData::Profile, tmp, project: project)
+      end
+
+      # Gets author URI of an object
+      #
+      # @return [String] object author URI
+      def author_uri
+        meta['author']
       end
     end
   end

data/lib/gooddata/mixins/is_dimension.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module IsDimension
+      # Returns true if the object is a dimension false otherwise
+      # @return [Boolean]
+      def dimension?
+        true
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_object_indexer.rb

@@ -37,7 +37,23 @@ module GoodData
         # new(GoodData.get uri) unless uri.nil?
         if uri # rubocop:disable Style/GuardClause
           raw = client.get(uri)
-          client.create(self, raw, client: client, project: project)
+          md_class = self
+          case raw.keys.first
+          when 'attribute'
+            md_class = GoodData::Attribute
+          when 'metric'
+            md_class = GoodData::Metric
+          when 'projectDashboard'
+            md_class = GoodData::Dashboard
+          when 'report'
+            md_class = GoodData::Report
+          when 'reportDefinition'
+            md_class = GoodData::ReportDefinition
+          else
+            md_class = self
+          end
+
+          client.create(md_class, raw, client: client, project: project)
         end
       end
 

data/lib/gooddata/mixins/md_object_query.rb

@@ -45,10 +45,18 @@ module GoodData
         if key.nil?
           result
         elsif key.respond_to?(:category)
-          result.select { |item| item['category'] == key.category }
+          result = result.select { |item| item['category'] == key.category }
         else
-          result.select { |item| item['category'] == key }
+          result = result.select { |item| item['category'] == key }
         end
+
+        if opts[:full]
+          result = result.map do |res|
+            GoodData::MdObject[res['link'], :client => c, :project => opts[:project]]
+          end
+        end
+
+        result
       end
 
       # Checks for dependency