gooddata 0.6.16 → 0.6.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40814e8c9d7deee9ac0eca814a3ac3c635f1ede3
-  data.tar.gz: fe14bb4f38e410de2e7abc9624e5f3aba6c39e6f
+  metadata.gz: 0bbc18e2feb9dc7d8f7b2fcadfd4e26474b666d0
+  data.tar.gz: 0020310a69543fcea52bd5d0bee0ddbe25bae3ff
 SHA512:
-  metadata.gz: f4128f12fab224bc8a5814fe0dcee35c385c2652defe34afb331562a65332b7f4fdd9199b7bb4c653eebdff39d6dd21950482e10fb1b51c5e81664072c490035
-  data.tar.gz: 731f9c3dab1e859777931f44362e4e50c2bc79fa562a4172ad2d53c658d9b3f309ff2000fb36a9090bdecd09be5240d76d3344316d60b281803bcc3d4e90373e
+  metadata.gz: dc66e78d316ee699b2374f1885a8cd6736addd8040931400e7fab8c287327a322828480fbd0d25a5ebaea343c8b810e926afa174b2f39239d1aec0e9f504114a
+  data.tar.gz: 388b87c526902279fd6c01b5739f478e3d8d4787179e3062ae495caa0809ad58d47b3edaee21230425f373d5ab056097e20214b568038da7cdd07053f981b3c8

data/.rubocop.yml

@@ -4,6 +4,9 @@ AbcSize:
 ClassLength:
   Enabled: false
 
+ModuleLength:
+  Enabled: false
+
 CyclomaticComplexity:
   Enabled: false
 
@@ -29,4 +32,4 @@ MethodLength:
   Enabled: false
 
 PerceivedComplexity:
-  Enabled: false
+  Enabled: false

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

@@ -130,7 +130,7 @@ GoodData::CLI.module_eval do
       show.action do |global_options, options, _args|
         opts = options.merge(global_options)
         client = GoodData.connect(opts)
-        spec, _ = GoodData::Command::Project.get_spec_and_project_id('.')
+        spec = GoodData::Command::Project.get_spec_and_project_id('.')[0]
         new_project = GoodData::Command::Project.build(opts.merge(spec: spec, client: client))
         puts "Project was created. New project PID is #{new_project.pid}, URI is #{new_project.uri}."
       end

data/lib/gooddata/core/logging.rb

@@ -14,7 +14,7 @@ module GoodData
     #     GoodData.logging_on
     #
     def logging_on
-      GoodData.logger = Logger.new(STDOUT) if logger.is_a? NilLogger
+      @logger = default_logger if logger.is_a? NilLogger
     end
 
     # Turn logging on
@@ -24,15 +24,15 @@ module GoodData
     #     GoodData.logging_off
     #
     def logging_off
-      GoodData.logger = NilLogger.new
+      @logger = NilLogger.new
     end
 
     def logging_on?
-      !GoodData.logger.instance_of?(NilLogger)
+      !@logger.instance_of?(NilLogger)
     end
 
     # Returns the logger instance. The default implementation
-    # does not log anything
+    # is a logger to stdout on INFO level
     # For some serious logging, set the logger instance using
     # the logger= method
     #
@@ -42,7 +42,7 @@ module GoodData
     #     GoodData.logger = Logger.new(STDOUT)
     #
     def logger
-      @logger ||= NilLogger.new
+      @logger ||= default_logger
     end
 
     def stats_on
@@ -56,5 +56,15 @@ module GoodData
     def stats_off
       @stats = false
     end
+
+    private
+
+    # The default logger - stdout and INFO level
+    #
+    def default_logger
+      log = Logger.new(STDOUT)
+      log.level = Logger::INFO
+      log
+    end
   end
 end

data/lib/gooddata/core/rest.rb

@@ -1,8 +1,6 @@
 # encoding: UTF-8
 
 module GoodData
-  DEFAULT_SLEEP_INTERVAL = 10
-
   class << self
     # Performs a HTTP GET request.
     #
@@ -122,21 +120,9 @@ module GoodData
     # @param options [Hash] Options
     # @return [Hash] Result of polling
     def poll_on_code(link, options = {})
-      code = options[:code] || 202
-      sleep_interval = options[:sleep_interval] || DEFAULT_SLEEP_INTERVAL
-      response = GoodData.get(link, :process => false)
-      while response.code == code
-        sleep sleep_interval
-        GoodData::Rest::Client.retryable(:tries => 3, :refresh_token => proc { connection.refresh_token }) do
-          sleep sleep_interval
-          response = GoodData.get(link, :process => false)
-        end
-      end
-      if options[:process] == false
-        response
-      else
-        GoodData.get(link)
-      end
+      client = options[:client]
+      fail ArgumentError, 'No :client specified' if client.nil?
+      client.poll_on_code(link, options)
     end
 
     # Generalizaton of poller. Since we have quite a variation of how async proceses are handled
@@ -151,17 +137,7 @@ module GoodData
     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 = get(link)
-      while bl.call(response)
-        sleep sleep_interval
-        GoodData::Rest::Client.retryable(:tries => 3, :refresh_token => proc { client.connection.refresh_token }) do
-          sleep sleep_interval
-          response = get(link)
-        end
-      end
-      response
+      client.poll_on_response(link, options, &bl)
     end
 
     private

data/lib/gooddata/helpers/global_helpers.rb

@@ -3,147 +3,11 @@
 require 'active_support/all'
 require 'pathname'
 
+require_relative 'global_helpers_params'
+
 module GoodData
   module Helpers
     class << self
-      # 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)
-
-        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 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
-      ENCODED_HIDDEN_PARAMS_KEY = :gd_encoded_hidden_params
-
-      # Encodes parameters for passing them to GD execution platform.
-      # Core types are kept and complex types (arrays, structures, etc) are JSON encoded into key hash "gd_encoded_params" or "gd_encoded_hidden_params", depending on the 'hidden' method param.
-      # The two different keys are used because the params and hidden params are merged by the platform and if we use the same key, the param would be overwritten.
-      #
-      # Core types are following:
-      # - Boolean (true, false)
-      # - Fixnum
-      # - Float
-      # - Nil
-      # - String
-      #
-      # @param [Hash] params Parameters to be encoded
-      # @return [Hash] Encoded parameters
-      def encode_params(params, hidden = false)
-        res = {}
-        nested = {}
-        core_types = [FalseClass, Fixnum, Float, NilClass, TrueClass, String]
-        params.each do |k, v|
-          if core_types.include?(v.class)
-            res[k] = v
-          else
-            nested[k] = v
-          end
-        end
-        key = hidden ? ENCODED_HIDDEN_PARAMS_KEY : ENCODED_PARAMS_KEY
-        res[key] = nested.to_json unless nested.empty?
-        res
-      end
-
-      # Decodes params as they came from the platform
-      # The "data" key is supposed to be json and it's parsed - if this
-      def decode_params(params)
-        key = ENCODED_PARAMS_KEY.to_s
-        hidden_key = ENCODED_HIDDEN_PARAMS_KEY.to_s
-        data_params = params[key] || '{}'
-        hidden_data_params = params[hidden_key] || '{}'
-
-        begin
-          parsed_data_params = JSON.parse(data_params)
-          parsed_hidden_data_params = JSON.parse(hidden_data_params)
-        rescue JSON::ParserError => e
-          raise e.class, "Error reading json from '#{key}' or '#{hidden_key}' in params #{params}\n #{e.message}"
-        end
-        params.delete(key)
-        params.delete(hidden_key)
-        params.merge(parsed_data_params).merge(parsed_hidden_data_params)
-      end
-
       def error(msg)
         STDERR.puts(msg)
         exit 1
@@ -252,6 +116,18 @@ module GoodData
           h
         end
       end
+
+      def stringify_keys_deep!(h)
+        if Hash == h.class
+          Hash[
+            h.map do |k, v|
+              [k.respond_to?(:to_s) ? k.to_s : k, stringify_keys_deep!(v)]
+            end
+          ]
+        else
+          h
+        end
+      end
     end
   end
 end

data/lib/gooddata/helpers/global_helpers_params.rb

@@ -0,0 +1,145 @@
+# encoding: UTF-8
+
+module GoodData
+  module Helpers
+    class << self
+      ENCODED_PARAMS_KEY = :gd_encoded_params
+      ENCODED_HIDDEN_PARAMS_KEY = :gd_encoded_hidden_params
+
+      # Encodes parameters for passing them to GD execution platform.
+      # Core types are kept and complex types (arrays, structures, etc) are JSON encoded into key hash "gd_encoded_params" or "gd_encoded_hidden_params", depending on the 'hidden' method param.
+      # The two different keys are used because the params and hidden params are merged by the platform and if we use the same key, the param would be overwritten.
+      #
+      # Core types are following:
+      # - Boolean (true, false)
+      # - Fixnum
+      # - Float
+      # - Nil
+      # - String
+      #
+      # @param [Hash] params Parameters to be encoded
+      # @return [Hash] Encoded parameters
+      def encode_params(params, hidden = false)
+        res = {}
+        nested = {}
+        core_types = [FalseClass, Fixnum, Float, NilClass, TrueClass, String]
+        params.each do |k, v|
+          if core_types.include?(v.class)
+            res[k] = v
+          else
+            nested[k] = v
+          end
+        end
+        key = hidden ? ENCODED_HIDDEN_PARAMS_KEY : ENCODED_PARAMS_KEY
+        res[key] = nested.to_json unless nested.empty?
+        res
+      end
+
+      # Decodes params as they came from the platform
+      # The "data" key is supposed to be json and it's parsed - if this
+      def decode_params(params)
+        key = ENCODED_PARAMS_KEY.to_s
+        hidden_key = ENCODED_HIDDEN_PARAMS_KEY.to_s
+        data_params = params[key] || '{}'
+        hidden_data_params = params[hidden_key] || '{}'
+
+        begin
+          parsed_data_params = JSON.parse(data_params)
+          parsed_hidden_data_params = JSON.parse(hidden_data_params)
+        rescue JSON::ParserError => e
+          raise e.class, "Error reading json from '#{key}' or '#{hidden_key}' in params #{params}\n #{e.message}"
+        end
+        params.delete(key)
+        params.delete(hidden_key)
+        params.merge(parsed_data_params).merge(parsed_hidden_data_params)
+      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)
+
+        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 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
+    end
+  end
+end