gooddata 0.6.19 → 0.6.20

data/lib/gooddata/helpers/data_helper.rb

@@ -11,7 +11,7 @@ module GoodData
 
       def initialize(opts = {})
         opts = opts.is_a?(String) ? { type: :staging, path: opts } : opts
-        opts = opts.symbolize_keys
+        opts = GoodData::Helpers.symbolize_keys(opts)
         @source = opts[:type]
         @options = opts
         @realized = false

data/lib/gooddata/helpers/global_helpers.rb

@@ -1,12 +1,16 @@
 # encoding: UTF-8
 
-require 'active_support/all'
 require 'pathname'
+require 'hashie'
 
 require_relative 'global_helpers_params'
 
 module GoodData
   module Helpers
+    class DeepMergeableHash < Hash
+      include Hashie::Extensions::DeepMerge
+    end
+
     class << self
       def error(msg)
         STDERR.puts(msg)
@@ -51,9 +55,11 @@ module GoodData
         end
       end
 
-      # TODO: Implement without using ActiveSupport
-      def humanize(str)
-        ActiveSupport::Inflector.humanize(str)
+      def titleize(str)
+        titleized = str.gsub(/[\.|_](.)/) { |x| x.upcase }
+        titleized = titleized.gsub('_', ' ')
+        titleized[0] = titleized[0].upcase
+        titleized
       end
 
       def join(master, slave, on, on2, options = {})
@@ -91,41 +97,102 @@ module GoodData
         RUBY_PLATFORM =~ /-darwin\d/
       end
 
-      # TODO: Implement without using ActiveSupport
-      def sanitize_string(str, filter = /[^a-z_]/, replacement = '')
-        str = ActiveSupport::Inflector.transliterate(str).downcase
-        str.gsub(filter, replacement)
-      end
-
       def underline(x)
         '=' * x.size
       end
 
-      # Recurscively changes the string keys of a hash to symbols.
-      #
-      # @param h [Hash] Data structure to change
-      # @return [Hash] Hash with symbolized keys
-      def symbolize_keys_deep!(h)
-        if Hash == h
-          Hash[
-            h.map do |k, v|
-              [k.respond_to?(:to_sym) ? k.to_sym : k, symbolize_keys_deep!(v)]
-            end
-          ]
-        else
-          h
+      def transform_keys!(an_object)
+        return enum_for(:transform_keys!) unless block_given?
+        an_object.keys.each do |key|
+          an_object[yield(key)] = delete(key)
         end
+        an_object
       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
-          ]
+      def symbolize_keys!(an_object)
+        transform_keys!(an_object) do |key|
+          begin
+            key.to_sym
+          rescue
+            key
+          end
+        end
+      end
+
+      def symbolize_keys(an_object)
+        transform_keys(an_object) do |key|
+          begin
+            key.to_sym
+          rescue
+            key
+          end
+        end
+      end
+
+      def transform_keys(an_object)
+        return enum_for(:transform_keys) unless block_given?
+        result = an_object.class.new
+        an_object.each_key do |key|
+          result[yield(key)] = an_object[key]
+        end
+        result
+      end
+
+      def deep_symbolize_keys(an_object)
+        deep_transform_keys(an_object) do |key|
+          begin
+            key.to_sym
+          rescue
+            key
+          end
+        end
+      end
+
+      def stringify_keys(an_object)
+        transform_keys(an_object) { |key| key.to_s }
+      end
+
+      def deep_stringify_keys(an_object)
+        deep_transform_keys(an_object) { |key| key.to_s }
+      end
+
+      def deep_transform_keys(an_object, &block)
+        _deep_transform_keys_in_object(an_object, &block)
+      end
+
+      def _deep_transform_keys_in_object(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+          end
+        when Array
+          object.map { |e| _deep_transform_keys_in_object(e, &block) }
         else
-          h
+          object
+        end
+      end
+
+      def deep_dup(an_object)
+        case an_object
+        when Array
+          an_object.map { |it| GoodData::Helpers.deep_dup(it) }
+        when Hash
+          an_object.each_with_object(an_object.dup) do |(key, value), hash|
+            hash[GoodData::Helpers.deep_dup(key)] = GoodData::Helpers.deep_dup(value)
+          end
+        when Object
+          an_object.duplicable? ? an_object.dup : an_object
+        end
+      end
+
+      def undot(params)
+        # for each key-value config given
+        params.map do |k, v|
+          # dot notation to hash
+          k.split('__').reverse.reduce(v) do |memo, obj|
+            GoodData::Helper.DeepMergeableHash[{ obj => memo }]
+          end
         end
       end
     end

data/lib/gooddata/mixins/md_finders.rb

@@ -11,11 +11,11 @@ module GoodData
       def find_first_by_identifier(identifier, options = { :client => GoodData.connection, :project => GoodData.project })
         all = self[:all, options.merge(full: false)]
         item = if identifier.is_a?(Regexp)
-                 all.find { |r| r['identifier'] =~ identifier }
+                 all.find { |r| r.identifier =~ identifier }
                else
-                 all.find { |r| r['identifier'] == identifier }
+                 all.find { |r| r.identifier == identifier }
                end
-        self[item['link'], options] unless item.nil?
+        self[item.uri, options] unless item.nil?
       end
 
       # Finds a specific type of the object by identifier. Returns all matches. Returns full object.
@@ -24,13 +24,13 @@ module GoodData
       # @param title [Regexp] regular expression that has to match
       # @return [Array<GoodData::MdObject>] Array of MdObject
       def find_by_identifier(identifier, options = { :client => GoodData.connection, :project => GoodData.project })
-        all = self[:all, options.merge(full: false)]
+        all = self[:all, options]
         items = if identifier.is_a?(Regexp)
-                  all.select { |r| r['title'] =~ identifier }
+                  all.select { |r| r.title =~ identifier }
                 else
-                  all.select { |r| r['title'] == identifier }
+                  all.select { |r| r.title == identifier }
                 end
-        items.pmap { |item| self[item['link'], options] unless item.nil? }
+        items.pmap { |item| self[item.uri, options] unless item.nil? }
       end
 
       def find_by_tag(tag, opts = { :client => GoodData.connection, :project => GoodData.project })
@@ -51,13 +51,13 @@ module GoodData
       # @param title [Regexp] regular expression that has to match
       # @return [Array<GoodData::MdObject>] Array of MdObject
       def find_first_by_title(title, options = { :client => GoodData.connection, :project => GoodData.project })
-        all = self[:all, options.merge(full: false)]
+        all = self[:all, options]
         item = if title.is_a?(Regexp)
-                 all.find { |r| r['title'] =~ title }
+                 all.find { |r| r.title =~ title }
                else
-                 all.find { |r| r['title'] == title }
+                 all.find { |r| r.title == title }
                end
-        self[item['link'], options] unless item.nil?
+        self[item.uri, options] unless item.nil?
       end
 
       # Finds a specific type of the object by title. Returns all matches. Returns full object.
@@ -66,13 +66,13 @@ module GoodData
       # @param title [Regexp] regular expression that has to match
       # @return [Array<GoodData::MdObject>] Array of MdObject
       def find_by_title(title, options = { :client => GoodData.connection, :project => GoodData.project })
-        all = self[:all, options.merge(full: false)]
+        all = self[:all, options]
         items = if title.is_a?(Regexp)
-                  all.select { |r| r['title'] =~ title }
+                  all.select { |r| r.title =~ title }
                 else
-                  all.select { |r| r['title'] == title }
+                  all.select { |r| r.title == title }
                 end
-        items.pmap { |item| self[item['link'], options] unless item.nil? }
+        items.pmap { |item| self[item.uri, options] unless item.nil? }
       end
     end
   end

data/lib/gooddata/mixins/md_object_query.rb

@@ -33,8 +33,18 @@ module GoodData
         project = GoodData::Project[p, options]
         fail ArgumentError, 'Wrong :project specified' if project.nil?
 
-        query_result = client.get(project.md['query'] + "/#{query_obj_type}/")['query']['entries']
-        options[:full] == false ? query_result : query_result.pmap { |item| klass[item['link'], options] }
+        offset = 0
+        page_limit = 50
+        Enumerator.new do |y|
+          loop do
+            result = client.get(project.md['objects'] + '/query', params: { category: query_obj_type, limit: page_limit, offset: offset })
+            result['objects']['items'].each do |item|
+              y << (klass ? client.create(klass, item, project: project) : item)
+            end
+            break if result['objects']['paging']['count'] < page_limit
+            offset += page_limit
+          end
+        end
       end
 
       def dependency(uri, key = nil, opts = { :client => GoodData.connection })

data/lib/gooddata/models/blueprint/blueprint_field.rb

@@ -10,7 +10,7 @@ module GoodData
       end
 
       def initialize(data, dataset)
-        @data = data.symbolize_keys
+        @data = GoodData::Helpers.symbolize_keys(data)
         @data[:type] = @data[:type].to_sym
         @dataset_blueprint = dataset
       end
@@ -39,7 +39,7 @@ module GoodData
       end
 
       def title
-        @data[:title] || @data[:id].titleize
+        @data[:title] || GoodData::Helpers.titleize(@data[:id])
       end
 
       # Validates the fields in the field

data/lib/gooddata/models/blueprint/dataset_blueprint.rb

@@ -243,7 +243,7 @@ module GoodData
       #
       # @return [GoodData::Model::DatasetBlueprint] matching fields
       def dup
-        DatasetBlueprint.new(data.deep_dup, project_blueprint)
+        DatasetBlueprint.new(GoodData::Helpers.deep_dup(data), project_blueprint)
       end
 
       # Returns facts of a dataset
@@ -367,7 +367,7 @@ module GoodData
         identifiers = facts.map { |f| identifier_for(f) }
         identifiers.zip(facts).map do |id, fact|
           Metric.xcreate(
-            :title => fact[:name].titleize,
+            :title => GoodData::Helpers.titleize(fact[:name]),
             :expression => "SELECT SUM(![#{id}])")
         end
       end

data/lib/gooddata/models/blueprint/project_blueprint.rb

@@ -51,7 +51,7 @@ module GoodData
       def self.remove_dataset(project, dataset_id)
         dataset = dataset_id.is_a?(String) ? find_dataset(project, dataset_id) : dataset_name
         index = project[:datasets].index(dataset)
-        dupped_project = project.deep_dup
+        dupped_project = GoodData::Helpers.deep_dup(project)
         dupped_project[:datasets].delete_at(index)
         dupped_project
       end
@@ -338,7 +338,7 @@ module GoodData
       # @param a_blueprint [GoodData::Model::DatasetBlueprint] Dataset blueprint to be merged
       # @return [GoodData::Model::DatasetBlueprint]
       def dup
-        ProjectBlueprint.new(data.deep_dup)
+        ProjectBlueprint.new(GoodData::Helpers.deep_dup(data))
       end
 
       # Returns list of facts from all the datasets in a blueprint
@@ -396,7 +396,7 @@ module GoodData
                     else
                       init_data
                     end
-        @data = some_data.deep_dup.symbolize_keys
+        @data = GoodData::Helpers.symbolize_keys(GoodData::Helpers.deep_dup(some_data))
         (@data[:datasets] || []).each do |d|
           d[:type] = d[:type].to_sym
           d[:columns].each do |c|

data/lib/gooddata/models/blueprint/schema_blueprint.rb

@@ -122,7 +122,7 @@ module GoodData
       #
       # @return [String]
       def title
-        data[:title] || data[:id].titleize
+        data[:title] || GoodData::Helpers.titleize(data[:id])
       end
 
       # Validates the blueprint and returns true if model is valid. False otherwise.

data/lib/gooddata/models/datawarehouse.rb

@@ -17,6 +17,7 @@ module GoodData
         c = client(opts)
         fail ArgumentError, 'No :client specified' if c.nil?
 
+        opts = { :auth_token => Helpers::AuthHelper.read_token }.merge(opts)
         auth_token = opts[:auth_token] || opts[:token]
         fail ArgumentError, 'You have to provide your token for creating projects as :auth_token parameter' if auth_token.nil? || auth_token.empty?
 

data/lib/gooddata/models/domain.rb

@@ -183,26 +183,23 @@ module GoodData
       # @option opts [Number] :limit From address
       # TODO: Review opts[:limit] functionality
       def users(domain, id = :all, opts = {})
-        c = client(opts)
-        domain = c.domain(domain)
+        client = client(opts)
+        domain = client.domain(domain)
         if id == :all
           GoodData.logger.warn("Retrieving all users from domain #{domain.name}")
-          result = []
-          page_limit = opts[:page_limit] || 1000
-          limit = opts[:limit] || Float::INFINITY
-          offset = opts[:offset] || 0
-          uri = "#{domain.uri}/users?offset=#{offset}&limit=#{page_limit}"
-          loop do
-            tmp = client(opts).get(uri)
-            tmp['accountSettings']['items'].each do |account|
-              result << client(opts).create(GoodData::Profile, account)
+          Enumerator.new do |y|
+            page_limit = opts[:page_limit] || 1000
+            offset = opts[:offset] || 0
+            loop do
+              tmp = client(opts).get("#{domain.uri}/users", params: { offset: offset, limit: page_limit })
+              tmp['accountSettings']['items'].each do |user_data|
+                user = client.create(GoodData::Profile, user_data)
+                y << user
+              end
+              break if tmp['accountSettings']['items'].count < page_limit
+              offset += page_limit
             end
-            break if result.length >= limit
-
-            uri = tmp['accountSettings']['paging']['next']
-            break unless uri
           end
-          result
         else
           find_user_by_login(domain, id)
         end

data/lib/gooddata/models/from_wire.rb

@@ -1,7 +1,5 @@
 # encoding: UTF-8
 
-require_relative 'from_wire_parse'
-
 module GoodData
   module Model
     module FromWire

data/lib/gooddata/models/membership.rb

@@ -381,7 +381,7 @@ module GoodData
     end
 
     def to_hash
-      tmp = content.merge(meta).merge('uri' => uri).symbolize_keys
+      tmp = GoodData::Helpers.symbolize_keys(content.merge(meta).merge('uri' => uri))
       [
         [:userRoles, :role],
         [:companyName, :company_name],

data/lib/gooddata/models/metadata/attribute.rb

@@ -21,7 +21,7 @@ module GoodData
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
       def all(options = { :client => GoodData.connection, :project => GoodData.project })
-        query('attributes', Attribute, options)
+        query('attribute', Attribute, options)
       end
 
       # Finds the value of an atribute and gives you the textual form for the label that is acquired by calling primary_label method

data/lib/gooddata/models/metadata/dashboard.rb

@@ -20,7 +20,7 @@ module GoodData
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
       def all(options = { :client => GoodData.connection, :project => GoodData.project })
-        query('projectdashboards', Dashboard, options)
+        query('projectDashboard', Dashboard, options)
       end
 
       def create_report_tab(tab)

data/lib/gooddata/models/metadata/dataset.rb

@@ -13,7 +13,7 @@ module GoodData
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
       def all(options = { :client => GoodData.connection, :project => GoodData.project })
-        query('datasets', Dataset, options)
+        query('dataSet', Dataset, options)
       end
     end
 

data/lib/gooddata/models/metadata/dimension.rb

@@ -17,7 +17,7 @@ module GoodData
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
       def all(options = { :client => GoodData.connection, :project => GoodData.project })
-        query('dimensions', Dimension, options)
+        query('dimension', Dimension, options)
       end
 
       # Returns a Project object identified by given string

data/lib/gooddata/models/metadata/fact.rb

@@ -22,7 +22,7 @@ module GoodData
       # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
       # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
       def all(options = { :client => GoodData.connection, :project => GoodData.project })
-        query('facts', Fact, options)
+        query('fact', Fact, options)
       end
     end