gooddata 0.6.10 → 0.6.11

data/lib/gooddata/models/empty_result.rb

@@ -24,15 +24,15 @@ module GoodData
     alias_method :to_table, :table
     alias_method :without_column_headers, :table
 
-    def ==(other)
+    def ==(_other)
       false
     end
 
-    def diff(otherDataResult)
+    def diff(_otherDataResult)
       ['empty']
     end
 
-    def [](index, options = {})
+    def [](index, _options = {})
       to_table[index]
     end
 
@@ -46,11 +46,11 @@ module GoodData
       table[index]
     end
 
-    def include_row?(row = nil)
+    def include_row?(_row = nil)
       false
     end
 
-    def include_column?(row = nil)
+    def include_column?(_row = nil)
       false
     end
   end

data/lib/gooddata/models/execution.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+require_relative '../rest/resource'
+require_relative '../extensions/hash'
+
+module GoodData
+  class Execution < Rest::Resource
+    attr_reader :dirty, :json
+
+    alias_method :data, :json
+    alias_method :raw_data, :json
+    alias_method :to_hash, :json
+
+    # Initializes object instance from raw wire JSON
+    #
+    # @param json Json used for initialization
+    def initialize(json)
+      super
+      @json = json
+    end
+
+    # Timestamp when execution was created
+    def created
+      Time.parse(json['execution']['createdTime'])
+    end
+
+    # Data for execution
+    def data
+      @client.get(json['execution']['data'])
+    end
+
+    # Has execution failed?
+    def error?
+      status == :error
+    end
+
+    # Timestamp when execution was finished
+    def finished
+      Time.parse(json['execution']['endTime'])
+    end
+
+    # Log for execution
+    def log
+      @client.get(json['execution']['log'])
+    end
+
+    # Is execution ok?
+    def ok?
+      status == :ok
+    end
+
+    # Timestamp when execution was started
+    def started
+      Time.parse(json['execution']['startTime'])
+    end
+
+    # Status of execution
+    def status
+      json['execution']['status'].downcase.to_sym
+    end
+
+    # Returns URL
+    #
+    # @return [String] Schedule URL
+    def uri
+      @json['execution']['links']['self'] if @json && @json['execution'] && @json['execution']['links']
+    end
+
+    # Compares two executions - based on their URI
+    def ==(other)
+      other.respond_to?(:uri) && other.uri == uri && other.respond_to?(:to_hash) && other.to_hash == to_hash
+    end
+  end
+end

data/lib/gooddata/models/execution_detail.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+require_relative '../rest/resource'
+require_relative '../extensions/hash'
+
+module GoodData
+  class ExecutionDetail < Rest::Resource
+    attr_reader :dirty, :json
+
+    alias_method :data, :json
+    alias_method :raw_data, :json
+    alias_method :to_hash, :json
+
+    # Initializes object instance from raw wire JSON
+    #
+    # @param json Json used for initialization
+    def initialize(json)
+      super
+      @json = json
+    end
+
+    # Timestamp when execution was created
+    def created
+      Time.parse(json['executionDetail']['created'])
+    end
+
+    # Timestamp when execution was finished
+    def finished
+      Time.parse(json['executionDetail']['finished'])
+    end
+
+    # Log for execution
+    def log
+      @client.get(json['executionDetail']['links']['log'])
+    end
+
+    # Filename of log
+    def log_filename
+      @client.get(json['executionDetail']['logFileName'])
+    end
+
+    # Is execution ok?
+    def ok?
+      status.downcase == 'ok'
+    end
+
+    # Timestamp when execution was started
+    def started
+      Time.parse(json['executionDetail']['started'])
+    end
+
+    # Status of execution
+    def status
+      json['executionDetail']['status']
+    end
+
+    # Timestamp when execution was updated
+    def updated
+      Time.parse(json['executionDetail']['updated'])
+    end
+
+    # Returns URL
+    #
+    # @return [String] Schedule URL
+    def uri
+      @json['executionDetail']['links']['self'] if @json && @json['executionDetail'] && @json['executionDetail']['links']
+    end
+
+    # Compares two executions - based on their URI
+    def ==(other)
+      other.respond_to?(:uri) && other.uri == uri && other.respond_to?(:to_hash) && other.to_hash == to_hash
+    end
+  end
+end

data/lib/gooddata/models/membership.rb

@@ -194,7 +194,7 @@ module GoodData
       res = []
 
       tmp = client.get @json['user']['links']['invitations']
-      tmp['invitations'].each do |invitation|
+      tmp['invitations'].each do |_invitation|
         # TODO: Something is missing here
       end
 

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

@@ -56,12 +56,12 @@ module GoodData
     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)
+      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
-        Metric.xcreate("SELECT #{a_type.to_s.upcase}(![#{identifier}], ![#{an_attribute.identifier}])", :title => a_title, :client => client, :project => project)
+        project.create_metric("SELECT #{a_type.to_s.upcase}([#{uri}], [#{an_attribute.uri}])", title: a_title, extended_notation: false)
       else
-        Metric.xcreate("SELECT #{a_type.to_s.upcase}(![#{identifier}])", :title => a_title, :client => client, :project => project)
+        project.create_metric("SELECT #{a_type.to_s.upcase}([#{uri}])", title: a_title, extended_notation: false)
       end
     end
 
@@ -80,9 +80,7 @@ module GoodData
     # @option options [Number] :limit limits the number of values to certain number. Default is 100
     # @return [Array]
     def values
-      results = labels.map do |label|
-        label.values
-      end
+      results = labels.map(&:values)
       results.first.zip(*results[1..-1])
     end
 

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

@@ -11,6 +11,8 @@ module GoodData
   class Dashboard < GoodData::MdObject
     root_key :projectDashboard
 
+    include GoodData::Mixin::Lockable
+
     class << self
       # Method intended to get all objects of that type in a specified project
       #

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

@@ -32,9 +32,9 @@ module GoodData
     # @return [GoodData::Metric]
     def create_metric(options = { :type => :sum })
       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)
+      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)
       a_title = options[:title] || "#{a_type} of #{title}"
-      Metric.xcreate("SELECT #{a_type.to_s.upcase}(![#{identifier}])", :title => a_title, :client => client, :project => project)
+      project.create_metric("SELECT #{a_type.to_s.upcase}([#{uri}])", title: a_title, extended_notation: false)
     end
   end
 end

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

@@ -10,6 +10,8 @@ module GoodData
   class Metric < MdObject
     attr_reader :json
 
+    include GoodData::Mixin::Lockable
+
     alias_method :to_hash, :json
 
     include GoodData::Mixin::RestResource
@@ -28,7 +30,7 @@ module GoodData
       end
 
       def xcreate(metric, options = { :client => GoodData.connection, :project => GoodData.project })
-        create(metric, options.merge(:extended_notation => true))
+        create(metric, { extended_notation: true }.merge(options))
       end
 
       def create(metric, options = { :client => GoodData.connection, :project => GoodData.project })
@@ -47,6 +49,7 @@ module GoodData
           title = options[:title]
           summary = options[:summary]
         else
+          metric ||= options
           title = metric[:title] || options[:title]
           summary = metric[:summary] || options[:summary]
           expression = metric[:expression] || options[:expression] || fail('Metric has to have its expression defined')

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

@@ -7,6 +7,8 @@ module GoodData
   class Report < GoodData::MdObject
     root_key :report
 
+    include GoodData::Mixin::Lockable
+
     class << self
       # Method intended to get all objects of that type in a specified project
       #
@@ -63,51 +65,33 @@ module GoodData
       self
     end
 
-    def results
-      content['results']
-    end
-
+    # Gets a report definitions (versions) of this report as objects.
+    #
+    # @return [Array<GoodData::ReportDefinition>] Returns list of report definitions. Oldest comes first
     def definitions
       content['definitions'].pmap { |uri| project.report_definitions(uri) }
     end
 
+    # Gets list of uris of report definitions (versions) of this report.
+    #
+    # @return [Array<String>] Returns list of report definitions' uris. Oldest comes first
     def definition_uris
       content['definitions']
     end
 
-    def latest_report_definition_uri
-      definition_uris.last
-    end
-
-    def latest_report_definition
-      project.report_definitions(latest_report_definition_uri)
-    end
-
-    def remove_definition(definition)
-      def_uri = is_a?(GoodData::ReportDefinition) ? definition.uri : definition
-      content['definitions'] = definition_uris.reject { |x| x == def_uri }
-      self
-    end
-
-    # TODO: Cover with test. You would probably need something that will be able to create a report easily from a definition
-    def remove_definition_but_latest
-      to_remove = definition_uris - [latest_report_definition_uri]
-      to_remove.each do |uri|
-        remove_definition(uri)
-      end
-      self
-    end
-
-    def purge_report_of_unused_definitions!
-      full_list = definition_uris
-      remove_definition_but_latest
-      purged_list = definition_uris
-      to_remove = full_list - purged_list
-      save
-      to_remove.each { |uri| client.delete(uri) }
+    # Deletes report along with its report definitions.
+    #
+    # @return [GoodData::Report] Returns self
+    def delete
+      defs = definitions
+      super
+      defs.peach(&:delete)
       self
     end
 
+    # Computes the report and returns the result. If it is not computable returns nil.
+    #
+    # @return [GoodData::DataResult] Returns the result
     def execute
       fail 'You have to save the report before executing. If you do not want to do that please use GoodData::ReportDefinition' unless saved?
       result = client.post '/gdc/xtab2/executor3', 'report_req' => { 'report' => uri }
@@ -124,21 +108,87 @@ module GoodData
       end
     end
 
+    # Returns true if you can export and object
+    #
+    # @return [Boolean] Returns whether the report is exportable
     def exportable?
       true
     end
 
+    # Returns binary data of the exported report in a given format. The format can be
+    # either 'csv', 'xls', 'xlsx' or 'pdf'.
+    #
+    # @return [String] Returns data
     def export(format)
       result = GoodData.post('/gdc/xtab2/executor3', 'report_req' => { 'report' => uri })
       result1 = GoodData.post('/gdc/exporter/executor', :result_req => { :format => format, :result => result })
       GoodData.poll_on_code(result1['uri'], process: false)
     end
 
+    # Returns the newest (current version) report definition uri
+    #
+    # @return [String] Returns uri of the newest report defintion
+    def latest_report_definition_uri
+      definition_uris.last
+    end
+
+    # Returns the newest (current version) report definition as an object
+    #
+    # @return [GoodData::ReportDefinition] Returns the newest report defintion
+    def latest_report_definition
+      project.report_definitions(latest_report_definition_uri)
+    end
+
+    # Returns the newest (current version) report definition uri
+    #
+    # @return [String] Returns uri of the newest report defintion
+    def purge_report_of_unused_definitions!
+      full_list = definition_uris
+      remove_definition_but_latest
+      purged_list = definition_uris
+      to_remove = full_list - purged_list
+      save
+      to_remove.each { |uri| client.delete(uri) }
+      self
+    end
+
+    # Removes definition from the report. The definition to remove can be passed in any form that is accepted by
+    # GoodData::ReportDefintion[]
+    #
+    # @param definition [String | GoodData::ReportDefinition] Report defintion to remove
+    # @return [GoodData::Report] Returns report with removed definition
+    def remove_definition(definition)
+      a_def = GoodData::ReportDefinition(definition, project: project, client: client)
+      def_uri = a_def.uri
+      content['definitions'] = definition_uris.reject { |x| x == def_uri }
+      self
+    end
+
+    # TODO: Cover with test. You would probably need something that will be able to create a report easily from a definition
+    # Removes all definitions but the latest from the report. This is useful for cleaning up before you create
+    # a template out of a project.
+    #
+    # @return [GoodData::Report] Returns report with removed definitions
+    def remove_definition_but_latest
+      to_remove = definition_uris - [latest_report_definition_uri]
+      to_remove.each do |uri|
+        remove_definition(uri)
+      end
+      self
+    end
+
+    # Replaces all occurences of something with something else. This is just a convenience method. The
+    # real work is done under the hood in report definition. This is just deferring to those
+    #
+    # @param what [Object] What you would like to have changed
+    # @param for_what [Object] What you would like to have changed this for
+    # @return [GoodData::Report] Returns report with removed definition
     def replace(what, for_what)
       new_defs = definitions.map do |rep_def|
         rep_def.replace(what, for_what)
       end
       new_defs.pmap(&:save)
+      self
     end
   end
 end

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

@@ -72,7 +72,10 @@ module GoodData
             fail "Object given by id \"#{item}\" could not be found" if x.nil?
             case x.raw_data.keys.first.to_s
             when 'attribute'
-              GoodData::Attribute.new(x.json).display_forms.first
+              attr = GoodData::Attribute.new(x.json)
+              attr.client = client
+              attr.project = opts[:project]
+              attr.display_forms.first
             when 'attributeDisplayForm'
               GoodData::Label.new(x.json)
             when 'metric'
@@ -117,11 +120,11 @@ module GoodData
 
         metrics = (left + top).select { |item| item.respond_to?(:metric?) && item.metric? }
 
-        unsaved_metrics = metrics.reject { |i| i.saved? }
+        unsaved_metrics = metrics.reject(&:saved?)
         unsaved_metrics.each { |m| m.title = 'Untitled metric' unless m.title }
 
         begin
-          unsaved_metrics.each { |m| m.save }
+          unsaved_metrics.each(&:save)
           rd = GoodData::ReportDefinition.create(options)
           data_result(execute_inline(rd, options), options)
         ensure
@@ -131,13 +134,7 @@ module GoodData
 
       def execute_inline(rd, opts = { :client => GoodData.connection, :project => GoodData.project })
         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?
+        project = opts[:project]
 
         rd = rd.respond_to?(:json) ? rd.json : rd
         data = {
@@ -191,7 +188,7 @@ module GoodData
 
         # TODO: Put somewhere for i18n
         fail_msg = 'All metrics in report definition must be saved'
-        fail fail_msg unless (left + top).all? { |i| i.saved? }
+        fail fail_msg unless (left + top).all?(&:saved?)
 
         pars = {
           'reportDefinition' => {
@@ -231,7 +228,16 @@ module GoodData
     end
 
     def attributes
-      labels.map { |label| label.attribute }
+      labels.map(&:attribute)
+    end
+
+    # Removes the color mapping from report definition
+    #
+    # @return [GoodData::ReportDefinition] Returns self
+    def reset_color_mapping!
+      global_chart_options = GoodData::Helpers.get_path(content, %w(chart styles global))
+      global_chart_options['colorMapping'] = [] if global_chart_options
+      self
     end
 
     def labels
@@ -247,16 +253,21 @@ module GoodData
     end
 
     def execute(opts = { :client => GoodData.connection, :project => GoodData.project })
-      opts = {
-        :client => client,
-        :project => project
-      }
+      client = opts[:client]
+      fail ArgumentError, 'No :client specified' if client.nil?
+
+      p = opts[:project]
+      fail ArgumentError, 'No :project specified' if p.nil?
+
+      project = client.projects(p)
+      fail ArgumentError, 'Wrong :project specified' if project.nil?
 
+      opts = { client: client, project: project }
       result = if saved?
                  pars = {
                    'report_req' => { 'reportDefinition' => uri }
                  }
-                 client.post '/gdc/xtab2/executor', pars
+                 client.post '/gdc/xtab2/executor3', pars
                else
                  ReportDefinition.execute_inline(self, opts)
                end

data/lib/gooddata/models/metadata.rb

@@ -39,7 +39,7 @@ module GoodData
     end
 
     def delete
-      if saved?
+      if saved? # rubocop:disable Style/GuardClause
         client.delete(uri)
         meta.delete('uri')
         # ["uri"] = nil

data/lib/gooddata/models/model.rb

@@ -120,7 +120,7 @@ module GoodData
           body['taskStatus'] == 'RUNNING' || body['taskStatus'] == 'PREPARED'
         end
 
-        if res['taskStatus'] == 'ERROR'
+        if res['taskStatus'] == 'ERROR' # rubocop:disable Style/GuardClause
           s = StringIO.new
           client.download_from_user_webdav(File.basename(dir) + '/upload_status.json', s)
           js = MultiJson.load(s.string)