gooddata 0.6.3 → 0.6.4

data/lib/gooddata/models/metadata.rb

@@ -38,7 +38,10 @@ module GoodData
       # @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 = {})
-        fail "Cannot search for nil #{self.class}" unless id
+        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 GoodData.project
+        return all(options) if id == :all
+        return id if id.is_a?(MdObject)
         uri = if id.is_a?(Integer) || id =~ /^\d+$/
                 "#{GoodData.project.md[MD_OBJ_CTG]}/#{id}"
               elsif id !~ /\//
@@ -51,8 +54,13 @@ module GoodData
         new(GoodData.get uri) unless uri.nil?
       end
 
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = {})
-        self[:all, options]
+        fail NotImplementedError, 'Method should be implemented in subclass. Currently there is no way hoe to get all metadata objects on API.'
       end
 
       def find_by_tag(tag)
@@ -92,18 +100,42 @@ module GoodData
         if response['identifiers'].empty?
           nil
         else
-          ids = response['identifiers'].map { |x| x['uri'] }
-          ids.count == 1 ? ids.first : ids
+          identifiers = response['identifiers']
+          ids_lookup = identifiers.reduce({}) do |a, e|
+            a[e['identifier']] = e['uri']
+            a
+          end
+          uris = ids.map { |x| ids_lookup[x] }
+          uris.count == 1 ? uris.first : uris
         end
       end
 
       alias_method :id_to_uri, :identifier_to_uri
 
       alias_method :get_by_id, :[]
+
+      private
+
+      # Method intended to be called by individual classes in their all
+      # implementations. It abstracts the way interacting with query resources.
+      # It either returns the array of hashes from query. If asked it also
+      # goes and brings the full objects. Due to performance reasons
+      # :full => false is the default. This will most likely change
+      #
+      # @param query_obj_type [String] string used in URI to distinguish different query resources for different objects
+      # @param klass [Class] A class used for instantiating the returned data
+      # @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 = {})
+        fail(NoProjectError, 'Connect to a project before searching for an object') unless GoodData.project
+        query_result = GoodData.get(GoodData.project.md['query'] + "/#{query_obj_type}/")['query']['entries']
+        options[:full] ? query_result.map { |item| klass[item['link']] } : query_result
+      end
     end
 
     metadata_property_reader :uri, :identifier, :title, :summary, :tags, :deprecated, :category
-    metadata_property_writer :tags, :summary, :title
+    metadata_property_writer :tags, :summary, :title, :identifier
 
     def root_key
       raw_data.keys.first
@@ -237,8 +269,21 @@ module GoodData
       self
     end
 
+    # Saves an object with a different name
+    #
+    # @param new_title [String] New title. If not provided one is provided
+    # @return [GoodData::MdObject] MdObject that has been saved as
+    def save_as(new_title = "Clone of #{title}")
+      dupped = Marshal.load(Marshal.dump(raw_data))
+      dupped[root_key]['meta'].delete('uri')
+      dupped[root_key]['meta'].delete('identifier')
+      dupped[root_key]['meta']['title'] = new_title
+      x = self.class.new(dupped)
+      x.save
+    end
+
     def ==(other)
-      other.uri == uri && other.respond_to?(:to_hash) && other.to_hash == to_hash
+      other.respond_to?(:uri) && other.uri == uri && other.respond_to?(:to_hash) && other.to_hash == to_hash
     end
 
     def validate
@@ -249,19 +294,31 @@ module GoodData
       false
     end
 
-    # TODO: generate fill for other subtypes
+    # Returns true if the object is a fact false otherwise
+    # @return [Boolean]
     def fact?
       false
     end
 
+    # Returns true if the object is an attribute false otherwise
+    # @return [Boolean]
     def attribute?
       false
     end
 
+    # Returns true if the object is a metric false otherwise
+    # @return [Boolean]
     def metric?
       false
     end
 
+    # Returns true if the object is a label false otherwise
+    # @return [Boolean]
+    def label?
+      false
+    end
+    alias_method :display_form?, :label?
+
     private
 
     def dependency(uri, key = nil)

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

@@ -9,44 +9,56 @@ module GoodData
     ATTRIBUTE_BASE_AGGREGATIONS = [:count]
 
     class << self
-      def [](id, options = {})
-        if id == :all
-          attrs = GoodData.get(GoodData.project.md['query'] + '/attributes/')['query']['entries']
-          options[:full] ? attrs.map { |a| Attribute[a['link']] } : attrs
-        else
-          super
-        end
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = {})
+        query('attributes', 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
+      #
+      # @param uri [String] Uri of the element. in the form of /gdc/md/PID/obj/OBJ_ID/elements?id=21
+      # @return [String] Textual representation of a particular attribute element
       def find_element_value(uri)
         matches = uri.match(/(.*)\/elements\?id=(\d+)$/)
-        Attribute[matches[1]].primary_label.find_element_value(matches[2].to_i)
+        Attribute[matches[1]].primary_label.find_element_value(uri)
       end
     end
 
+    # Returns the labels of an attribute
+    # @return [Array<GoodData::Label>]
     def display_forms
-      content['displayForms'].map { |df| GoodData::DisplayForm[df['meta']['uri']] }
+      content['displayForms'].map { |df| GoodData::Label[df['meta']['uri']] }
     end
     alias_method :labels, :display_forms
 
     # Returns the first display form which is the primary one
-    # @return [GoodData::DisplayForm] Primary label
+    # @return [GoodData::Label] Primary label
     def primary_display_form
       labels.first
     end
     alias_method :primary_label, :primary_display_form
 
+    # Returns true if the object is an attribute false otherwise
+    # @return [Boolean]
     def attribute?
       true
     end
 
+    # Creates the basic count metric with the attribute used. If you need to compute the attribute on a different dataset you can specify that in params. The metric created is not saved.
+    # @param [Hash] options the options to pass to the value list
+    # @option options [Symbol] :type type of aggregation function.
+    # @option options [Symbol] :attribute Use this attribute if you need to express different dataset for performing the computation on. It basically serves for creating metrics like SELECT COUNT(User, Opportunity).
+    # @return [GoodData::Metric]
     def create_metric(options = {})
       an_attribute = options[:attribute]
       a_type = options[:type] || :count
       fail "Suggested aggreagtion function (#{a_type}) does not exist for base metric created out of attribute. You can use only one of #{ATTRIBUTE_BASE_AGGREGATIONS.map { |x| ":" + x.to_s }.join(',')}" unless ATTRIBUTE_BASE_AGGREGATIONS.include?(a_type)
       a_title = options[:title] || "#{a_type} of #{title}"
       if an_attribute
-        an_attribute = Attribute[an_attribute] if an_attribute.is_a?(String)
         Metric.xcreate(:expression => "SELECT #{a_type.to_s.upcase}(![#{identifier}], ![#{an_attribute.identifier}])", :title => a_title)
       else
         Metric.xcreate(:expression => "SELECT #{a_type.to_s.upcase}(![#{identifier}])", :title => a_title)
@@ -57,7 +69,7 @@ module GoodData
     # @param [Object] element_id Element identifier either Number or a uri as a String
     # @return [Array] list of values for certain element. Returned in the same order as is the order of labels
     def values_for(element_id)
-      element_id = element_id.is_a?(String) ? element_id.match(/\?id=(\d)/)[1] : element_id
+      # element_id = element_id.is_a?(String) ? element_id.match(/\?id=(\d)/)[1] : element_id
       labels.map do |label|
         label.find_element_value(element_id)
       end
@@ -74,6 +86,9 @@ module GoodData
       results.first.zip(*results[1..-1])
     end
 
+    # Allows to search in attribute labels by name. It uses the string as a basis for regexp and tries to match either a title or an identifier. Returns first match.
+    # @param name [String] name used as a basis for regular expression
+    # @return [GoodData::Label]
     def label_by_name(name)
       labels.find { |label| label.title.downcase =~ /#{name}/ || label.identifier.downcase =~ /#{name}/ }
     end

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

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 
 require_relative '../md_object'
-require_relative '../../helpers'
+require_relative '../../helpers/helpers'
 
 module GoodData
   module Model

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

@@ -12,12 +12,13 @@ module GoodData
     root_key :projectDashboard
 
     class << self
-      def [](id, options = {})
-        if id == :all
-          GoodData.get(GoodData.project.md['query'] + '/projectdashboards/')['query']['entries']
-        else
-          super
-        end
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = {})
+        query('projectdashboards', Dashboard, options)
       end
 
       def create_report_tab(tab)

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

@@ -4,14 +4,14 @@ require_relative '../metadata'
 require_relative 'metadata'
 
 module GoodData
-  class DisplayForm < GoodData::MdObject
+  class Label < GoodData::MdObject
     root_key :attributeDisplayForm
 
     # Finds an attribute element URI for given value. This URI can be used by find_element_value to find the original value again
     # @param [String] value value of an label you are looking for
     # @return [String]
     def find_value_uri(value)
-      value = CGI.escapeHTML(value)
+      value = CGI.escape(value)
       results = GoodData.post("#{uri}/validElements?limit=30&offset=0&order=asc&filter=#{value}", {})
       items = results['validElements']['items']
       if items.empty?
@@ -57,5 +57,20 @@ module GoodData
     def attribute
       GoodData::Attribute[content['formOf']]
     end
+
+    # Returns true if the object is an attribute false otherwise
+    # @return [Boolean]
+    def label?
+      true
+    end
+    alias_method :display_form?, :label?
+
+    # Gives an attribute url of current label. Useful for mass actions when it does not introduce HTTP call.
+    # @return [GoodData::Attibute]
+    def attribute_uri
+      content['formOf']
+    end
   end
 end
+
+GoodData::DisplayForm = GoodData::Label

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

@@ -12,20 +12,26 @@ module GoodData
     FACT_BASE_AGGREGATIONS = [:sum, :min, :max, :avg, :median]
 
     class << self
-      def [](id, options = {})
-        if id == :all
-          facts = GoodData.get(GoodData.project.md['query'] + '/facts/')['query']['entries']
-          options[:full] ? facts.map { |f| Fact[f['link']] } : facts
-        else
-          super
-        end
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = {})
+        query('facts', Fact, options)
       end
     end
 
+    # Returns true if the object is a fact false otherwise
+    # @return [Boolean]
     def fact?
       true
     end
 
+    # Creates the basic count metric with the fact used. The metric created is not saved.
+    # @param [Hash] options the options to pass to the value list
+    # @option options [Symbol] :type type of aggregation function. Default is :sum
+    # @return [GoodData::Metric]
     def create_metric(options = {})
       a_type = options[:type] || :sum
       fail "Suggested aggreagtion function (#{a_type}) does not exist for base metric created out of fact. You can use only one of #{FACT_BASE_AGGREGATIONS.map { |x| ":" + x.to_s }.join(',')}" unless FACT_BASE_AGGREGATIONS.include?(a_type)

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

@@ -12,13 +12,13 @@ module GoodData
     PARSE_MAQL_OBJECT_REGEXP = /\[([^\]]+)\]/
 
     class << self
-      def [](id, options = {})
-        if id == :all
-          metrics = GoodData.get(GoodData.project.md['query'] + '/metrics/')['query']['entries']
-          options[:full] ? metrics.map { |m| Metric[m['link']] } : metrics
-        else
-          super
-        end
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = {})
+        query('metrics', Metric, options)
       end
 
       def xcreate(options)
@@ -137,7 +137,7 @@ module GoodData
     end
 
     # Checks that the expression contains certain element of an attribute. The value is looked up through given label.
-    # @param [GoodData::DisplayForm] label Label though which the value is looked up
+    # @param [GoodData::Label] label Label though which the value is looked up
     # @param [String] value Value that will be looked up through the label.
     # @return [Boolean]
     def contain_value?(label, value)
@@ -157,7 +157,7 @@ module GoodData
     end
 
     # Method used for replacing attribute element values. Looks up certain value of a label in the MAQL expression and exchanges it for a different value of the same label.
-    # @param [GoodData::DisplayForm] label Label through which the value and for_value are resolved
+    # @param [GoodData::Label] label Label through which the value and for_value are resolved
     # @param [String] value value that is going to be replaced
     # @param [String] for_value value that is going to be the new one
     # @return [GoodData::Metric]

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

@@ -8,14 +8,13 @@ module GoodData
     root_key :report
 
     class << self
-      def [](id, options = {})
-        if id == :all
-          fail 'You have to specify a project ID' if GoodData.project.nil?
-          uri = GoodData.project.md['query'] + '/reports/'
-          GoodData.get(uri)['query']['entries']
-        else
-          super
-        end
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = {})
+        query('reports', Report, options)
       end
 
       def create(options = {})

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

@@ -11,14 +11,13 @@ module GoodData
     root_key :reportDefinition
 
     class << self
-      def [](id, options = {})
-        if id == :all
-          uri = GoodData.project.md['query'] + '/reportdefinition/'
-          result = GoodData.get(uri)
-          result['query']['entries']
-        else
-          super
-        end
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @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 = {})
+        query('reportdefinition', ReportDefinition, options)
       end
 
       def create_metrics_part(left, top)
@@ -72,7 +71,7 @@ module GoodData
             when 'attribute'
               GoodData::Attribute.new(x.raw_data).display_forms.first
             when 'attributeDisplayForm'
-              GoodData::DisplayForm.new(x.raw_data)
+              GoodData::Label.new(x.raw_data)
             when 'metric'
               GoodData::Metric.new(x.raw_data)
             end
@@ -91,7 +90,7 @@ module GoodData
             when 'attribute'
               GoodData::Attribute.get_by_id(item[:id]).display_forms.first
             when 'label'
-              GoodData::DisplayForm.get_by_id(item[:id])
+              GoodData::Label.get_by_id(item[:id])
           end
           elsif item.is_a?(Hash) && (item.keys.include?(:identifier))
             case item[:type].to_s
@@ -101,7 +100,7 @@ module GoodData
               result = GoodData::Attribute.get_by_id(item[:identifier])
               result.display_forms.first
             when 'label'
-              GoodData::DisplayForm.get_by_id(item[:identifier])
+              GoodData::Label.get_by_id(item[:identifier])
             end
           else
             item

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

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require_relative '../../helpers'
+require_relative '../../helpers/helpers'
 
 require_relative '../attributes/anchor'
 require_relative '../columns/columns'

data/lib/gooddata/models/model.rb

@@ -91,7 +91,7 @@ module GoodData
       def merge_dataset_columns(a_schema_blueprint, b_schema_blueprint)
         a_schema_blueprint = a_schema_blueprint.to_hash
         b_schema_blueprint = b_schema_blueprint.to_hash
-        d = Marshal.load(Marshal.dump(a_schema_blueprint))
+        d = a_schema_blueprint.deep_dup
         d[:columns] = d[:columns] + b_schema_blueprint[:columns]
         d[:columns].uniq!
         columns_that_failed_to_merge = d[:columns].group_by { |x| x[:name] }.map { |k, v| [k, v.count] }.select { |x| x[1] > 1 }

data/lib/gooddata/models/process.rb

@@ -42,41 +42,54 @@ module GoodData
         end
       end
 
-      def upload_package(dir, files_to_exclude)
-        Tempfile.open('deploy-graph-archive') do |temp|
-          Zip::OutputStream.open(temp.path) do |zio|
-            FileUtils.cd(dir) do
-
-              files_to_pack = Dir.glob('./**/*').reject { |f| files_to_exclude.include?(Pathname(dir) + f) }
-              files_to_pack.each do |item|
-                # puts "including #{item}" if verbose
-                unless File.directory?(item)
-                  zio.put_next_entry(item)
-                  zio.print IO.read(item)
+      def upload_package(path, files_to_exclude)
+        if !path.directory?
+          GoodData.upload_to_user_webdav(path)
+          path
+        else
+          Tempfile.open('deploy-graph-archive') do |temp|
+            Zip::OutputStream.open(temp.path) do |zio|
+              FileUtils.cd(path) do
+
+                files_to_pack = Dir.glob('./**/*').reject { |f| files_to_exclude.include?(Pathname(path) + f) }
+                files_to_pack.each do |item|
+                  # puts "including #{item}" if verbose
+                  unless File.directory?(item)
+                    zio.put_next_entry(item)
+                    zio.print IO.read(item)
+                  end
                 end
               end
             end
+            GoodData.upload_to_user_webdav(temp.path)
+            temp.path
           end
-          GoodData.upload_to_user_webdav(temp.path)
-          temp
         end
       end
 
-      def deploy(dir, options = {})
-        dir = Pathname(dir) || fail('Directory is not specified')
-        fail "\"#{dir}\" is not a directory" unless dir.directory?
-        files_to_exclude = options[:files_to_exclude].map { |p| Pathname(p) }
+      # Deploy a new process or redeploy existing one.
+      #
+      # @param path [String] Path to ZIP archive or to a directory containing files that should be ZIPed
+      # @option options [String] :files_to_exclude
+      # @option options [String] :process_id ('nobody') From address
+      # @option options [String] :type ('GRAPH') Type of process - GRAPH or RUBY
+      # @option options [String] :name Readable name of the process
+      # @option options [String] :process_id ID of a process to be redeployed (do not set if you want to create a new process)
+      # @option options [Boolean] :verbose (false) Switch on verbose mode for detailed logging
+      def deploy(path, options = {})
+        path = Pathname(path) || fail('Path is not specified')
+        files_to_exclude = options[:files_to_exclude].nil? ? [] : options[:files_to_exclude].map { |p| Pathname(p) }
         process_id = options[:process_id]
 
         type = options[:type] || 'GRAPH'
         deploy_name = options[:name]
         verbose = options[:verbose] || false
-        puts HighLine.color("Deploying #{dir}", HighLine::BOLD) if verbose
-        deployed_path = Process.upload_package(dir, files_to_exclude)
+        puts HighLine.color("Deploying #{path}", HighLine::BOLD) if verbose
+        deployed_path = Process.upload_package(path, files_to_exclude)
         data = {
           :process => {
             :name => deploy_name,
-            :path => "/uploads/#{File.basename(deployed_path.path)}",
+            :path => "/uploads/#{File.basename(deployed_path)}",
             :type => type
           }
         }
@@ -86,7 +99,7 @@ module GoodData
                 GoodData.put("/gdc/projects/#{GoodData.project.pid}/dataload/processes/#{process_id}", data)
               end
         process = Process.new(res)
-        puts HighLine.color("Deploy DONE #{dir}", HighLine::GREEN) if verbose
+        puts HighLine.color("Deploy DONE #{path}", HighLine::GREEN) if verbose
         process
       end
     end
@@ -99,10 +112,16 @@ module GoodData
       GoodData.delete(uri)
     end
 
-    def deploy(dir, options = {})
-      process = Process.upload(dir, options.merge(:process_id => process_id))
-      puts HighLine.color("Deploy DONE #{dir}", HighLine::GREEN) if verbose
-      process
+    # Redeploy existing process.
+    #
+    # @param path [String] Path to ZIP archive or to a directory containing files that should be ZIPed
+    # @option options [String] :files_to_exclude
+    # @option options [String] :process_id ('nobody') From address
+    # @option options [String] :type ('GRAPH') Type of process - GRAPH or RUBY
+    # @option options [String] :name Readable name of the process
+    # @option options [Boolean] :verbose (false) Switch on verbose mode for detailed logging
+    def deploy(path, options = {})
+      Process.deploy(path, options.merge(:process_id => process_id))
     end
 
     def process