gooddata 0.6.20 → 0.6.22

data/lib/gooddata/models/project_creator.rb

@@ -1,4 +1,8 @@
 # encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 require_relative 'project'
 require_relative 'blueprint/project_blueprint'
@@ -60,7 +64,7 @@ module GoodData
 
           response = client.get(link)
 
-          chunks = pick_correct_chunks(response['projectModelDiff']['updateScripts'])
+          chunks = pick_correct_chunks(response['projectModelDiff']['updateScripts'], opts)
           if !chunks.nil? && !dry_run
             chunks['updateScript']['maqlDdlChunks'].each do |chunk|
               result = project.execute_maql(chunk)
@@ -88,6 +92,8 @@ module GoodData
           end
         end
 
+        alias_method :migrate_measures, :migrate_metrics
+
         def load(project, spec)
           if spec.key?(:uploads) # rubocop:disable Style/GuardClause
             spec[:uploads].each do |load|
@@ -104,18 +110,20 @@ module GoodData
           end
         end
 
-        def pick_correct_chunks(chunks)
+        def pick_correct_chunks(chunks, opts = {})
+          preference = opts[:preference] || {}
           # first is cascadeDrops, second is preserveData
           rules = [
-            [false, true],
-            [false, false],
-            [true, true],
-            [true, false]
+            { priority: 1, cascade_drops: false, preserve_data: true },
+            { priority: 2, cascade_drops: false, preserve_data: false },
+            { priority: 3, cascade_drops: true, preserve_data: true },
+            { priority: 4, cascade_drops: true, preserve_data: false }
           ]
-          stuff = chunks.select { |chunk| chunk['updateScript']['maqlDdlChunks'] }
-          rules.reduce(nil) do |a, e|
-            a || stuff.find { |chunk| e[0] == chunk['updateScript']['cascadeDrops'] && e[1] == chunk['updateScript']['preserveData'] }
-          end
+          stuff = chunks.select { |chunk| chunk['updateScript']['maqlDdlChunks'] }.map { |chunk| { cascade_drops: chunk['updateScript']['cascadeDrops'], preserve_data: chunk['updateScript']['preserveData'], maql: chunk['updateScript']['maqlDdlChunks'], orig: chunk } }
+          results = GoodData::Helpers.join(rules, stuff, [:cascade_drops, :preserve_data], [:cascade_drops, :preserve_data], inner: true).sort_by { |l| l[:priority] }
+
+          pick = results.find { |r| r.values_at(:cascade_drops, :preserve_data) == preference.values_at(:cascade_drops, :preserve_data) } || results.first
+          pick[:orig] if pick
         end
       end
     end

data/lib/gooddata/models/project_metadata.rb

@@ -1,4 +1,8 @@
 # encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 module GoodData
   class ProjectMetadata

data/lib/gooddata/models/project_role.rb

@@ -1,4 +1,8 @@
 # encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 require 'pmap'
 

data/lib/gooddata/models/report_data_result.rb

@@ -1,176 +1,268 @@
 # encoding: UTF-8
-
-require_relative 'data_result.rb'
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
 
 module GoodData
-  class ReportDataResult < DataResult
-    # Row limit
-    ROW_LIMIT = 10_000_000
+  class ReportDataResult < Rest::Object
+    class << self
+      # Does all the needed parsing on the apyload coming from the API and returns an instance of ReportDataResult
+      #
+      # @param [Hash] data Data coming from the API
+      # @return [GoodData::ReportDataResult] Returns new report data result
+      def from_xtab(data, options = {})
+        client = options[:client]
+        project = options[:project]
+        top = top_headers(data)
+        left = left_headers(data)
+        jank = GoodData::Helpers.zeroes(rows(top), cols(left), nil)
+        d = data(data)
+        stuff = d.empty? ? GoodData::Helpers.zeroes(rows(left), cols(top), nil) : d
+
+        a = jank.zip(top).map { |x, y| x + y }
+        b = left.zip(stuff).map { |x, y| x + y }
+        result = a + b
+        client ? client.create(ReportDataResult, data: result, top: rows(top), left: cols(left), project: project) : ReportDataResult.new(data: result, top: rows(top), left: cols(left))
+      end
 
-    attr_reader :row_headers, :column_headers, :table, :headers_height, :headers_width
+      private
 
-    def initialize(data)
-      super
-      @row_headers = []
-      @column_headers = []
-      @table = []
+      def line(child)
+        children = child['children'] || []
+        return (child['first']..child['last']).to_a.map { [child['id']] } if children.empty?
+        children.flat_map { |c| line(c) }.map do |x|
+          child['id'].nil? ? x : [child['id']] + x
+        end
+      end
 
-      @row_headers, @headers_width = tabularize_rows
-      @column_headers, @headers_height = tabularize_columns
+      def root_line(root)
+        lookups = root['lookups']
+        header = line(root['tree'])
+        header.map { |l| l.each_with_index.map { |item, index| lookups[index][item] } }
+      end
+
+      def top_headers(data)
+        root = data['xtab_data']['columns']
+        root_line(root).transpose
+      end
+
+      def left_headers(data)
+        root = data['xtab_data']['rows']
+        root_line(root)
+      end
+
+      def cols(stuff)
+        stuff.first.count
+      end
+
+      def rows(stuff)
+        stuff.count
+      end
 
-      assemble_table
+      def data(data)
+        data['xtab_data']['data'].map { |row| row.map { |i| i ? BigDecimal(i) : i } }
+      end
     end
 
-    def without_column_headers
-      @table = table.transpose[headers_height, ROW_LIMIT].transpose
-      self
+    # Returns
+    #
+    # @param [Hash] opts Data for the report
+    # @option opts [Array<Array>] :data The data as a matrix. First rows then cols
+    # @option opts [Number] :top Number of rows that are representing the top header
+    # @option opts [Number] :left Number of cols that are representing the left header
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def initialize(opts)
+      @data = opts[:data]
+      @top_headers_rows_nums = opts[:top]
+      @left_headers_cols_nums = opts[:left]
     end
 
-    def to_data_table
-      table.transpose[headers_height, ROW_LIMIT].transpose[headers_width, ROW_LIMIT]
+    # Gives you new report result with top headers removed
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def without_top_headers
+      slice(@top_headers_rows_nums, 0)
     end
 
-    def each_line
-      to_table.each { |line| yield line }
+    # Gives you new report result with left headers removed
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result
+    def without_left_headers
+      slice(0, @left_headers_cols_nums)
     end
 
-    alias_method :each_row, :each_line
+    # Gives you left headers as an Array
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def left_headers
+      return nil if @left_headers_cols_nums == 0
+      top = @left_headers_cols_nums - 1
+      without_top_headers.slice(0, [0, top]).to_a
+    end
 
-    def each_column
-      table.each { |line| yield line }
+    # Gives you right headers as an Array
+    #
+    # @return [Array] Return top headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def top_headers
+      return nil if @top_headers_rows_nums == 0
+      top = @top_headers_rows_nums - 1
+      without_left_headers.slice([0, top], 0).to_a
     end
 
-    def to_a
-      table.to_a
+    # Gives you data as a new ReportDataResult
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def data
+      slice(@top_headers_rows_nums, @left_headers_cols_nums)
+    end
+
+    def each
+      to_a.each
     end
+    alias_method :each_line, :each
+    alias_method :each_row, :each
 
-    def to_table
-      table.transpose
+    def each_column
+      size.last.times.map do |i|
+        col = map { |row| row[i] }
+        yield(col)
+      end
     end
 
-    def [](index, _options = {})
-      to_table[index]
+    # Gives you data as a new ReportDataResult
+    #
+    # @return [Array] Return left headers as Array of Arrays. The notation is of a matrix. First rows then cols.
+    def to_a
+      @data
+    end
+    alias_method :to_table, :to_a
+
+    # Gives report as a table suitable for printing out
+    #
+    # @return [String]
+    def to_s(options = {})
+      with_indices = options[:index]
+
+      a = to_table.to_a
+      data = a.transpose
+      data.unshift((1..a.length).to_a) if with_indices
+      processed_data = data.each_with_index.map do |col, i|
+        col.unshift(i.zero? ? nil : i) if with_indices # inserts row labels #
+        w = col.map { |cell| cell.to_s.length }.max # w = "column width" #
+        col.each_with_index.map do |cell, j|
+          j.zero? ? cell.to_s.center(w) : cell.to_s.ljust(w)
+        end # alligns the column #
+      end
+      processed_data.transpose.map { |row| "[#{row.join(' | ')}]" }.unshift('').join("\n")
     end
 
+    # Allows to pick particular row inside the report result
+    #
+    # @return [Array] Returns a row of data
+    def [](index)
+      @data[index]
+    end
     alias_method :row, :[]
 
+    # Allows to pick particular column inside the report result
+    #
+    # @return [Array] Returns a column of data. The column is returned transposed
     def column(index)
-      table[index]
+      transpose[index]
     end
 
-    def include_row?(row)
-      to_table.include?(row)
+    # Is the report without any data? This can be caused by the fact that the filters are too restrictive or data are not loaded in
+    #
+    # @return [Array] Returns true if data result is empty
+    def empty?
+      row, cols = size
+      row == 0 && cols == 0
     end
 
-    def include_column?(row)
-      table.include?(row)
+    # Allows you to test if a report contains a row.
+    #
+    # @param [Array<String | Number>] row Row that you want to test. It is looking for the whole row. If the headers are getting in the way use #without_left_headers or #without_top_headers
+    # @return [Array] Returns true if data are inside a report
+    def include_row?(row)
+      @data.include?(row)
     end
 
-    def ==(other)
-      csv_table = to_table
-      len = csv_table.length
-      table = other.respond_to?(:to_table) ? other.to_table : other
-      return false if len != table.length
-      diff(other).empty? ? true : false
+    # Allows you to test if a report contains a column.
+    #
+    # @param [Array<String | Number>] row Row that you want to test. It is looking for the whole row. If the headers are getting in the way use #without_left_headers or #without_top_headers
+    # @return [Array] Returns true if data are inside a report
+    def include_column?(col)
+      transpose.include_row?(col)
     end
 
-    def diff(otherDataResult)
-      csv_table = to_table
-      other_table = otherDataResult.respond_to?(:to_table) ? otherDataResult.to_table : otherDataResult
-      differences = []
-
-      csv_table.each do |row|
-        differences << row unless other_table.find { |r| r == row }
-      end
-      differences
+    # Returns the size of the report
+    #
+    # @return [Array<Number>] The size of the report result as an array. First element is rows second is columns
+    def size
+      [@data.size, @data.empty? ? 0 : @data.first.size]
     end
 
-    def empty?
-      false
-    end
-
-    private
-
-    def each_level(table, level, children, lookup)
-      max_level = level + 1
-      children.each do |kid|
-        first = kid['first']
-        last = kid['last']
-        repetition = last - first + 1
-        repetition.times do |i|
-          table[first + i] ||= []
-          if kid['type'] == 'total'
-            table[first + i][level] = kid['id']
-          else
-            table[first + i][level] = lookup[level][kid['id'].to_s]
-          end
-        end
-        unless kid['children'].empty?
-          new_level = each_level(table, level + 1, kid['children'], lookup)
-          max_level = [max_level, new_level].max
-        end
-      end
-      max_level
+    # Transposes data and returns as new data result
+    #
+    # @return [GoodData::ReportDataResult] Returns new report data result with flipped columns and rows
+    def transpose
+      ReportDataResult.new(data: to_a.transpose, top: @left_headers_cols_nums, left: @top_headers_rows_nums)
     end
 
-    def tabularize_rows
-      rows = data['xtab_data']['rows']
-      kids = rows['tree']['children']
-
-      if kids.empty? || (kids.size == 1 && kids.first['type'] == 'metric')
-        headers = [[nil]]
-        size = 0
+    # Gives you report result with a subset of data starting at position rows, cols
+    #
+    # @param [Number] rows Position where you want to slice your row. Currently accepts only number
+    # @param [Number] cols Position where you want to slice your row. Currently accepts only number
+    # @return [GoodData::ReportDataResult] Returns new report data result sliced data
+    def slice(rows, cols)
+      rows = rows.is_a?(Enumerable) ? rows : [rows, size.first]
+      cols = cols.is_a?(Enumerable) ? cols : [cols, size.last]
+      new_data = @data[rows.first..rows.last].map { |col| col[cols.first..cols.last] }
+      if client
+        client.create(ReportDataResult, data: new_data, top: @top_headers_rows_nums - rows.first, left: @left_headers_cols_nums - cols.first, project: project)
       else
-        headers = []
-        size = each_level(headers, 0, rows['tree']['children'], rows['lookups'])
+        ReportDataResult.new(data: new_data, top: @top_headers_rows_nums - rows.first, left: @left_headers_cols_nums - cols.first, project: project)
       end
-      return headers, size # rubocop:disable RedundantReturn
     end
 
-    def tabularize_columns
-      columns = data['xtab_data']['columns']
-      kids = columns['tree']['children']
-
-      if kids.empty? || (kids.size == 1 && kids.first['type'] == 'metric')
-        headers = [[nil]]
-        size = 0
-      else
-        headers = []
-        size = each_level(headers, 0, columns['tree']['children'], columns['lookups'])
-      end
+    # Returns the size of the the data portion of report
+    #
+    # @return [Array<Number>] The size of the report result as an array. First element is rows second is columns
+    def data_size
+      data.size
+    end
 
-      return headers, size # rubocop:disable RedundantReturn
+    def ==(other)
+      return false if size != other.size
+      @data == other.to_a
     end
 
-    def assemble_table
-      #    puts "=== COLUMNS === #{column_headers.size}x#{headers_height}"
-      (column_headers.size).times do |i|
-        (headers_height).times do |j|
-          table[headers_width + i] ||= []
-          #        puts "[#{headers_width + i}][#{j}] #{column_headers[i][j]}"
-          table[headers_width + i][j] = column_headers[i][j]
-        end
-      end
+    def eq?(other)
+      self == other
+    end
 
-      #    puts "=== ROWS ==="
-      (row_headers.size).times do |i|
-        (headers_width).times do |j|
-          table[j] ||= []
-          #        puts "[#{j}][#{headers_height + i}] #{row_headers[i][j]}"
-          table[j][headers_height + i] = row_headers[i][j]
-        end
-      end
+    # Implements subtraction. Works only on reports that have same number of columns. Gives you columns that are not in other.
+    #
+    # @param [GoodData::ReportDataResult] other The other report result
+    # @return [Array<Array>] Returns rows that are not contained in other
+    def -(other)
+      fail 'Seems you are not using a data result as a parameter' unless other.respond_to?(:size)
+      message = 'Results do not have compatible sizes. Subtracting the dataresults works row wise so you have to have the same number of columns'
+      fail message if size.last != other.size.last
+      to_a - other.to_a
+    end
 
-      xtab_data = data['xtab_data']['data']
-      #    puts "=== DATA === #{column_headers.size}x#{row_headers.size}"
-      (column_headers.size).times do |i|
-        (row_headers.size).times do |j|
-          table[headers_width + i] ||= []
-          #        puts "[#{headers_width + i}, #{headers_height + j}] [#{i}][#{j}]=#{xtab_data[j][i]}"
-          val = xtab_data[j][i]
-          table[headers_width + i][headers_height + j] = val.nil? ? val : BigDecimal(val)
-        end
-      end
+    # Implements diff. Works only on reports that have same number of columns (because it uses #- behind the scene).
+    #
+    # @param [GoodData::ReportDataResult] other The other report result
+    # @return [Hash] Returns a hash that gives you the differences in the report results
+    def diff(other)
+      {
+        added: other - self,
+        removed: self - other,
+        same: @data & other.to_a
+      }
     end
   end
 end