gooddata 0.6.7 → 0.6.8

data/lib/gooddata/mixins/inspector.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+# See https://gist.github.com/ubermajestix/3644301
+
+module GoodData
+  module Mixin
+    # When an RSpec test like this fails,
+    #
+    #   @my_array.should == [@some_model, @some_model2]
+    #
+    # RSpec will call inspect on each of the objects to "help" you figure out
+    # what went wrong. Well, inspect will usually dump a TON OF SHIT and make trying
+    # to figure out why `@my_array` is not made up of `@some_model` and `@some_model2`.
+    #
+    # This little module and technique helps get around that. It will redefine `inspect`
+    # if you include it in your model object.
+    #
+    # You can define a whitelist of methods that inspect will dump.
+    # It will always provide `object_id` at a minimum.
+    #
+    # To use it, drop it in spec/support/inspector.rb and class_eval the models to
+    # override `inspect`.
+    module Inspector
+      def inspect
+        string = "#<#{self.class.name}:#{object_id} "
+        fields = self.class.inspector_fields.map { |field| "#{field}: #{send(field)}" }
+        string << fields.join(', ') << '>'
+      end
+
+      def self.inspected
+        @inspected ||= []
+      end
+
+      def self.included(source)
+        # $stdout.puts "Overriding inspect on #{source}"
+        inspected << source
+        source.class_eval do
+          def self.inspector(*fields)
+            @inspector_fields = *fields
+          end
+
+          def self.inspector_fields
+            @inspector_fields ||= []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_finders.rb

@@ -3,18 +3,26 @@
 module GoodData
   module Mixin
     module MdFinders
-      def find_by_tag(tag)
-        self[:all].select { |r| r['tags'].split(',').include?(tag) }
+      def find_by_tag(tag, opts = { :client => GoodData.connection, :project => GoodData.project })
+        c = client || opts[:client]
+
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError 'Wrong :project specified' if project.nil?
+
+        self[:all, client: c, project: project].select { |r| r.tags.split(',').include?(tag) }
       end
 
-      def find_first_by_title(title)
-        all = self[:all]
+      def find_first_by_title(title, options = { :client => GoodData.connection, :project => GoodData.project })
+        all = self[:all, options.merge(full: false)]
         item = if title.is_a?(Regexp)
                  all.find { |r| r['title'] =~ title }
                else
                  all.find { |r| r['title'] == title }
                end
-        self[item['link']] unless item.nil?
+        self[item['link'], options] unless item.nil?
       end
 
       # Finds a specific type of the object by title. Returns all matches. Returns full object.
@@ -22,14 +30,14 @@ module GoodData
       # @param title [String] title that has to match exactly
       # @param title [Regexp] regular expression that has to match
       # @return [Array<GoodData::MdObject>] Array of MdObject
-      def find_by_title(title)
-        all = self[:all]
+      def find_by_title(title, options = { :client => GoodData.connection, :project => GoodData.project })
+        all = self[:all, options.merge(full: false)]
         items = if title.is_a?(Regexp)
                   all.select { |r| r['title'] =~ title }
                 else
                   all.select { |r| r['title'] == title }
                 end
-        items.map { |item| self[item['link']] unless item.nil? }
+        items.pmap { |item| self[item['link'], options] unless item.nil? }
       end
     end
   end

data/lib/gooddata/mixins/md_id_to_uri.rb

@@ -6,10 +6,18 @@ module GoodData
       IDENTIFIERS_CFG = 'instance-identifiers'
 
       # TODO: Add test
-      def identifier_to_uri(*ids)
-        fail(NoProjectError, 'Connect to a project before searching for an object') unless GoodData.project
-        uri = GoodData.project.md[IDENTIFIERS_CFG]
-        response = GoodData.post uri, 'identifierToUri' => ids
+      def identifier_to_uri(opts = { :client => GoodData.connection, :project => GoodData.project }, *ids)
+        client = opts[:client]
+        fail ArgumentError, 'No :client specified' if client.nil?
+
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        uri = project.md[IDENTIFIERS_CFG]
+        response = client.post uri, 'identifierToUri' => ids
         if response['identifiers'].empty?
           nil
         else

data/lib/gooddata/mixins/md_object_indexer.rb

@@ -11,8 +11,15 @@ 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 [MdObject] if id is a String or number single object is returned
       # @return [Array] if :all was provided as an id, list of objects should be returned. Note that this is implemented only in the subclasses. MdObject does not support this since API has no means to return list of all types of objects
-      def [](id, options = {})
-        project = options[:project] || GoodData.project
+      def [](id, options = { :client => GoodData.connection, :project => GoodData.project })
+        client = options[:client]
+        fail ArgumentError, 'No :client specified' if client.nil?
+
+        p = options[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, :client => client]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
 
         fail "You have to provide an \"id\" to be searched for." unless id
         fail(NoProjectError, 'Connect to a project before searching for an object') unless project
@@ -21,13 +28,17 @@ module GoodData
         uri = if id.is_a?(Integer) || id =~ /^\d+$/
                 "#{project.md[MD_OBJ_CTG]}/#{id}"
               elsif id !~ /\//
-                identifier_to_uri id
+                identifier_to_uri options, id
               elsif id =~ /^\//
                 id
               else
                 fail 'Unexpected object id format: expected numeric ID, identifier with no slashes or an URI starting with a slash'
               end
-        new(GoodData.get uri) unless uri.nil?
+        # new(GoodData.get uri) unless uri.nil?
+        if uri
+          raw = client.get(uri)
+          client.create(self, raw, client: client, project: project)
+        end
       end
 
       alias_method :get_by_id, :[]

data/lib/gooddata/mixins/md_object_query.rb

@@ -8,8 +8,8 @@ module GoodData
       # @param options [Hash] the options hash
       # @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 = {})
-        fail NotImplementedError, 'Method should be implemented in subclass. Currently there is no way hoe to get all metadata objects on API.'
+      def all(options = { :client => GoodData.connection, :project => GoodData.project })
+        fail NotImplementedError, 'Method should be implemented in subclass. Currently there is no way how to get all metadata objects on API.'
       end
 
       # Method intended to be called by individual classes in their all
@@ -23,15 +23,25 @@ module GoodData
       # @param options [Hash] the options hash
       # @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 query(query_obj_type, klass, options = {})
-        project = options[:project] || GoodData.project
-        fail(NoProjectError, 'Connect to a project before searching for an object') unless project
-        query_result = GoodData.get(project.md['query'] + "/#{query_obj_type}/")['query']['entries']
-        options[:full] ? query_result.map { |item| klass[item['link']] } : query_result
+      def query(query_obj_type, klass, options = { :client => GoodData.connection, :project => GoodData.project })
+        client = options[:client]
+        fail ArgumentError, 'No :client specified' if client.nil?
+
+        p = options[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        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] }
       end
 
-      def dependency(uri, key = nil)
-        result = GoodData.get(uri)['entries']
+      def dependency(uri, key = nil, opts = { :client => GoodData.connection })
+        c = opts[:client]
+        fail ArgumentError, 'No :client specified' if c.nil?
+
+        result = c.get(uri)['entries']
         if key.nil?
           result
         elsif key.respond_to?(:category)
@@ -42,13 +52,13 @@ module GoodData
       end
 
       # Checks for dependency
-      def dependency?(type, uri, target_uri)
+      def dependency?(type, uri, target_uri, opts = { :client => GoodData.connection, :project => GoodData.project })
         uri = uri.respond_to?(:uri) ? uri.uri : uri
         objs = case type
                when :usedby
-                 usedby(uri)
+                 usedby(uri, nil, opts)
                when :using
-                 using(uri)
+                 using(uri, nil, opts)
                end
 
         target_uri = target_uri.respond_to?(:uri) ? target_uri.uri : target_uri
@@ -58,26 +68,38 @@ module GoodData
       end
 
       # Returns which objects uses this MD resource
-      def usedby(uri, key = nil, project = GoodData.project)
-        dependency("#{project.md['usedby2']}/#{obj_id(uri)}", key)
+      def usedby(uri, key = nil, opts = { :client => GoodData.connection, :project => GoodData.project })
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'No :project specified' if project.nil?
+
+        dependency("#{project.md['usedby2']}/#{obj_id(uri)}", key, opts)
       end
 
       alias_method :used_by, :usedby
 
       # Returns which objects this MD resource uses
-      def using(uri, key = nil)
-        dependency("#{GoodData.project.md['using2']}/#{obj_id(uri)}", key)
+      def using(uri, key = nil, opts = { :client => GoodData.connection, :project => GoodData.project })
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'No :project specified' if project.nil?
+
+        dependency("#{project.md['using2']}/#{obj_id(uri)}", key, opts)
       end
 
-      def usedby?(uri, target_uri)
-        dependency?(:usedby, uri, target_uri)
+      def usedby?(uri, target_uri, opts = { :client => GoodData.connection, :project => GoodData.project })
+        dependency?(:usedby, uri, target_uri, opts)
       end
 
       alias_method :used_by?, :usedby?
 
       # Checks if obj is using this MD resource
-      def using?(uri, target_uri)
-        dependency?(:using, uri, target_uri)
+      def using?(uri, target_uri, opts = { :client => GoodData.connection, :project => GoodData.project })
+        dependency?(:using, uri, target_uri, opts)
       end
     end
   end

data/lib/gooddata/mixins/md_relations.rb

@@ -3,36 +3,45 @@
 module GoodData
   module Mixin
     module MdRelations
-      def dependency(uri, key = nil)
-        GoodData::MdObject.dependency(uri, key)
+      def dependency(uri, key = nil, opts = { :client => client, :project => project })
+        GoodData::MdObject.dependency(uri, key, opts)
       end
 
       # Checks for dependency
-      def dependency?(type, obj)
-        GoodData::MdObject.dependency?(type, self, obj)
+      def dependency?(type, obj, opts = { :client => client, :project => project })
+        GoodData::MdObject.dependency?(type, self, obj, opts)
       end
 
       # Returns which objects uses this MD resource
-      def usedby(key = nil, project = GoodData.project)
-        dependency("#{project.md['usedby2']}/#{obj_id}", key)
+      def usedby(key = nil, opts = { :client => client, :project => project })
+        p = opts[:project]
+        fail ArgumentError, 'No :project specified' if p.nil?
+
+        project = GoodData::Project[p, opts]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        dependency("#{project.md['usedby2']}/#{obj_id}", key, opts)
       end
 
       alias_method :used_by, :usedby
 
       # Returns which objects this MD resource uses
-      def using(key = nil)
-        dependency("#{GoodData.project.md['using2']}/#{obj_id}", key)
+      def using(key = nil, opts = { :client => client, :project => project })
+        project = opts[:project]
+        fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+        dependency("#{project.md['using2']}/#{obj_id}", key, opts)
       end
 
-      def usedby?(obj)
-        GoodData::MdObject.used_by?(self, obj)
+      def usedby?(obj, opts = { :client => client, :project => project })
+        GoodData::MdObject.used_by?(self, obj, opts)
       end
 
       alias_method :used_by?, :usedby?
 
       # Checks if obj is using this MD resource
-      def using?(obj)
-        dependency?(:using, obj)
+      def using?(obj, opts = { :client => client, :project => project })
+        dependency?(:using, obj, opts)
       end
     end
   end

data/lib/gooddata/mixins/meta_getter.rb

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

data/lib/gooddata/mixins/meta_property_reader.rb

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

data/lib/gooddata/mixins/meta_property_writer.rb

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

data/lib/gooddata/mixins/rest_resource.rb

@@ -1,19 +1,41 @@
 # encoding: UTF-8
 
-require_relative 'root_key_setter'
-require_relative 'data_property_reader'
-require_relative 'data_property_writer'
-require_relative 'meta_property_reader'
-require_relative 'meta_property_reader'
+require_relative 'mixins'
 
 module GoodData
   module Mixin
     module RestResource
-      include GoodData::Mixin::RootKeySetter
-      include GoodData::Mixin::DataPropertyReader
-      include GoodData::Mixin::DataPropertyWriter
-      include GoodData::Mixin::MetaPropertyReader
-      include GoodData::Mixin::MetaPropertyWriter
+      def self.included(base)
+        # Core REST Object Stuff
+        base.extend GoodData::Mixin::RootKeySetter
+        base.send :include, GoodData::Mixin::RootKeyGetter
+        base.send :include, GoodData::Mixin::DataGetter
+        base.send :include, GoodData::Mixin::MetaGetter
+        base.send :include, GoodData::Mixin::ObjId
+        base.send :include, GoodData::Mixin::ContentGetter
+        base.send :include, GoodData::Mixin::Timestamps
+        base.send :include, GoodData::Mixin::Links
+
+        base.extend GoodData::Mixin::DataPropertyReader
+        base.extend GoodData::Mixin::DataPropertyWriter
+        base.extend GoodData::Mixin::MetaPropertyReader
+        base.extend GoodData::Mixin::MetaPropertyWriter
+
+        # MdObject Stuff
+        base.send :include, GoodData::Mixin::MdJson
+        base.send :include, GoodData::Mixin::NotAttribute
+        base.send :include, GoodData::Mixin::NotExportable
+        base.send :include, GoodData::Mixin::NotFact
+        base.send :include, GoodData::Mixin::NotMetric
+        base.send :include, GoodData::Mixin::NotLabel
+        base.send :include, GoodData::Mixin::MdRelations
+
+        base.extend GoodData::Mixin::MdObjId
+        base.extend GoodData::Mixin::MdObjectQuery
+        base.extend GoodData::Mixin::MdObjectIndexer
+        base.extend GoodData::Mixin::MdFinders
+        base.extend GoodData::Mixin::MdIdToUri
+      end
     end
   end
 end

data/lib/gooddata/mixins/root_key_getter.rb

@@ -4,7 +4,7 @@ module GoodData
   module Mixin
     module RootKeyGetter
       def root_key
-        raw_data.keys.first
+        json.keys.first
       end
     end
   end

data/lib/gooddata/models/data_result.rb

@@ -2,8 +2,10 @@
 
 require_relative '../extensions/big_decimal'
 
+require_relative '../rest/object'
+
 module GoodData
-  class DataResult
+  class DataResult < Rest::Object
     attr_reader :data
 
     def initialize(data)

data/lib/gooddata/models/domain.rb

@@ -1,9 +1,13 @@
 # encoding: UTF-8
 
+require 'cgi'
+
 require_relative 'profile'
 
+require_relative '../rest/object'
+
 module GoodData
-  class Domain
+  class Domain < GoodData::Rest::Object
     attr_reader :name
 
     USERS_OPTIONS = { :offset => 0, :limit => 1000 }
@@ -13,9 +17,10 @@ module GoodData
       #
       # @param domain_name [String] Domain name
       # @return [String] Domain object instance
-      def [](domain_name, options = {})
+      def [](domain_name, options = { :client => GoodData.connection })
+        c = client(options)
         fail "Using pseudo-id 'all' is not supported by GoodData::Domain" if domain_name.to_s == 'all'
-        GoodData::Domain.new(domain_name)
+        c.create(GoodData::Domain, domain_name)
       end
 
       # Adds user to domain
@@ -71,17 +76,20 @@ module GoodData
         tmp = opts[:timezone]
         data[:timezone] = tmp if tmp && !tmp.empty?
 
+        c = client(opts)
+
         # TODO: It will be nice if the API will return us user just newly created
         url = "/gdc/account/domains/#{opts[:domain]}/users"
-        response = GoodData.post(url, :accountSetting => data)
+        response = c.post(url, :accountSetting => data)
 
-        raw = GoodData.get response['uri']
+        url = response['uri']
+        raw = c.get url
 
         # TODO: Remove this hack when POST /gdc/account/domains/{domain-name}/users returns full profile
         raw['accountSetting']['links'] = {} unless raw['accountSetting']['links']
         raw['accountSetting']['links']['self'] = response['uri'] unless raw['accountSetting']['links']['self']
 
-        GoodData::Profile.new(raw)
+        c.create(GoodData::Profile, raw)
       end
 
       # Finds user in domain by login
@@ -89,12 +97,13 @@ module GoodData
       # @param domain [String] Domain name
       # @param login [String] User login
       # @return [GoodData::Profile] User profile
-      def find_user_by_login(domain, login)
-        url = "/gdc/account/domains/#{domain}/users?login=#{login}"
-        tmp = GoodData.get url
+      def find_user_by_login(domain, login, opts = {})
+        c = client(opts)
+        escaped_login = CGI.escape(login)
+        url = "/gdc/account/domains/#{domain}/users?login=#{escaped_login}"
+        tmp = c.get url
         items = tmp['accountSettings']['items'] if tmp['accountSettings']
-        return GoodData::Profile.new(items.first) if items && items.length > 0
-        nil
+        items && items.length > 0 ? c.factory.create(GoodData::Profile, items.first) : nil
       end
 
       # Returns list of users for domain specified
@@ -103,17 +112,16 @@ module GoodData
       # @option opts [Number] :offset The subject
       # @option opts [Number] :limit From address
       # TODO: Review opts[:limit] functionality
-      def users(domain, opts = USERS_OPTIONS)
+      def users(domain, opts = USERS_OPTIONS.merge(:client => GoodData.connection))
         result = []
 
-        options = USERS_OPTIONS.merge(opts)
-        offset = 0 || options[:offset]
-        uri = "/gdc/account/domains/#{domain}/users?offset=#{offset}&limit=#{options[:limit]}"
+        offset = 0 || opts[:offset]
+        uri = "/gdc/account/domains/#{domain}/users?offset=#{offset}&limit=#{opts[:limit]}"
         loop do
           break unless uri
-          tmp = GoodData.get(uri)
+          tmp = client(opts).get(uri)
           tmp['accountSettings']['items'].each do |account|
-            result << GoodData::Profile.new(account)
+            result << client(opts).create(GoodData::Profile, account)
           end
           uri = tmp['accountSettings']['paging']['next']
         end
@@ -125,7 +133,7 @@ module GoodData
       # @param [Array<GoodData::Membership>] list List of users
       # @param [String] default_domain_name Default domain name used when no specified in user
       # @return [Array<GoodData::User>] List of users created
-      def users_create(list, default_domain = nil)
+      def users_create(list, default_domain = nil, opts = { :client => GoodData.connection, :project => GoodData.project })
         default_domain_name = default_domain.respond_to?(:name) ? default_domain.name : default_domain
         domains = {}
         list.map do |user|
@@ -137,9 +145,10 @@ module GoodData
 
           # Get domain info from REST, add to cache
           if domain.nil?
+            d = GoodData::Domain[domain_name, opts]
             domain = {
-              :domain => GoodData::Domain[domain_name],
-              :users => GoodData::Domain[domain_name].users
+              :domain => d,
+              :users => d.users(opts)
             }
 
             domain[:users_map] = Hash[domain[:users].map { |u| [u.email, u] }]
@@ -170,7 +179,7 @@ module GoodData
             user_data[:authentication_modes] = tmp && !tmp.empty?
 
             # Add created user to cache
-            domain_user = domain[:domain].add_user(user_data)
+            domain_user = domain[:domain].add_user(opts.merge(user_data))
             domain[:users] << domain_user
             domain[:users_map][user.email] = domain_user
           end
@@ -222,7 +231,7 @@ module GoodData
     # pp domain.users
     #
     def users(opts = USERS_OPTIONS)
-      GoodData::Domain.users(name, opts)
+      GoodData::Domain.users(name, opts.merge(client: client))
     end
 
     def users_create(list)