gooddata 0.6.0.pre11 → 0.6.0

data/lib/gooddata/models/report_data_result.rb

@@ -1,9 +1,11 @@
-require File.join(File.dirname(__FILE__), "data_result.rb")
+# encoding: UTF-8
+
+require_relative 'data_result.rb'
 
 module GoodData
   class ReportDataResult < DataResult
-
-    ROW_LIMIT = 10000000
+    # Row limit
+    ROW_LIMIT = 10_000_000
 
     attr_reader :row_headers, :column_headers, :table, :headers_height, :headers_width
 
@@ -88,19 +90,19 @@ module GoodData
     def each_level(table, level, children, lookup)
       max_level = level + 1
       children.each do |kid|
-        first = kid["first"]
-        last = kid["last"]
+        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"]
+          if kid['type'] == 'total'
+            table[first + i][level] = kid['id']
           else
-            table[first + i][level] = lookup[level][kid["id"].to_s]
+            table[first + i][level] = lookup[level][kid['id'].to_s]
           end
         end
-        if (!kid["children"].empty?)
-          new_level = each_level(table, level+1, kid["children"], lookup)
+        if (!kid['children'].empty?)
+          new_level = each_level(table, level+1, kid['children'], lookup)
           max_level = [max_level, new_level].max
         end
       end
@@ -108,29 +110,30 @@ module GoodData
     end
 
     def tabularize_rows
-      rows = data["xtab_data"]["rows"]
-      kids = rows["tree"]["children"]
+      rows = data['xtab_data']['rows']
+      kids = rows['tree']['children']
 
       if kids.empty? || (kids.size == 1 && kids.first['type'] == 'metric')
         headers, size = [[nil]], 0
       else
         headers = []
-        size = each_level(headers, 0, rows["tree"]["children"], rows["lookups"])
+        size = each_level(headers, 0, rows['tree']['children'], rows['lookups'])
       end
-      return headers, size
+      return headers, size # rubocop:disable RedundantReturn
     end
 
     def tabularize_columns
-      columns = data["xtab_data"]["columns"]
-      kids = columns["tree"]["children"]
+      columns = data['xtab_data']['columns']
+      kids = columns['tree']['children']
 
       if kids.empty? || (kids.size == 1 && kids.first['type'] == 'metric')
         headers, size = [[nil]], 0
       else
         headers = []
-        size = each_level(headers, 0, columns["tree"]["children"], columns["lookups"])
+        size = each_level(headers, 0, columns['tree']['children'], columns['lookups'])
       end
-      return headers, size
+
+      return headers, size # rubocop:disable RedundantReturn
     end
 
     def assemble_table()
@@ -152,7 +155,7 @@ module GoodData
         end
       end
 
-      xtab_data = data["xtab_data"]["data"]
+      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|

data/lib/gooddata/models/report_definition.rb

@@ -1,40 +1,46 @@
-require File.join(File.dirname(__FILE__), "metadata")
+# encoding: UTF-8
 
-module GoodData
-  class ReportDefinition < GoodData::MdObject 
+require_relative 'metadata'
 
+# GoodData Module
+module GoodData
+  # Report Definition
+  # TODO: Add more doc ...
+  class ReportDefinition < GoodData::MdObject
     root_key :reportDefinition
 
     class << self
       def [](id)
         if id == :all
-          GoodData.get(GoodData.project.md['query'] + '/reportdefinition/')['query']['entries']
-        else 
+          uri = GoodData.project.md['query'] + '/reportdefinition/'
+          result = GoodData.get(uri)
+          result['query']['entries']
+        else
           super
         end
       end
 
       def create_metrics_part(left, top)
         stuff = Array(left) + Array(top)
-        stuff.find_all {|item| item.respond_to?(:is_metric?)}.map do |metric|
+        stuff.select { |item| item.respond_to?(:is_metric?) }.map do |metric|
           create_metric_part(metric)
         end
       end
 
       def create_metric_part(metric)
         {
-          "alias" => metric.title,
-          "uri" => metric.uri
+          'alias' => metric.title,
+          'uri' => metric.uri
         }
       end
 
       def create_attribute_part(attrib)
         {
-           "attribute" => {
-              "alias" => "",
-              "totals" => [],
-              "uri" => attrib.uri
-           }
+          'attribute' => {
+            'alias' => '',
+            'totals' => [],
+            'uri' => attrib.uri
+          }
         }
       end
 
@@ -48,8 +54,8 @@ module GoodData
           end
           memo
         end
-        if stuff.any? {|item| item.respond_to?(:is_metric?)}
-          parts << "metricGroup"
+        if stuff.any? { |item| item.respond_to?(:is_metric?) }
+          parts << 'metricGroup'
         end
         parts
       end
@@ -62,36 +68,38 @@ module GoodData
             x = GoodData::MdObject.get_by_id(item)
             fail "Object given by id \"#{item}\" could not be found" if x.nil?
             case x.raw_data.keys.first.to_s
-            when "attribute"
+            when 'attribute'
               GoodData::Attribute.new(x.raw_data).display_forms.first
-            when "attributeDisplayForm"
+            when 'attributeDisplayForm'
               GoodData::DisplayForm.new(x.raw_data)
-            when "metric"
+            when 'metric'
               GoodData::Metric.new(x.raw_data)
             end
           elsif item.is_a?(Hash) && item.keys.include?(:title)
             case item[:type].to_s
-            when "metric"
+            when 'metric'
               GoodData::Metric.find_first_by_title(item[:title])
-            when "attribute"
-              GoodData::Attribute.find_first_by_title(item[:title]).display_forms.first
+            when 'attribute'
+              result = GoodData::Attribute.find_first_by_title(item[:title])
+              result.display_forms.first
             end
           elsif item.is_a?(Hash) && (item.keys.include?(:id))
             case item[:type].to_s
-            when "metric"
+            when 'metric'
               GoodData::Metric.get_by_id(item[:id])
-            when "attribute"
+            when 'attribute'
               GoodData::Attribute.get_by_id(item[:id]).display_forms.first
-            when "label"
+            when 'label'
               GoodData::DisplayForm.get_by_id(item[:id])
-            end
+          end
           elsif item.is_a?(Hash) && (item.keys.include?(:identifier))
             case item[:type].to_s
-            when "metric"
+            when 'metric'
               GoodData::Metric.get_by_id(item[:identifier])
-            when "attribute"
-              GoodData::Attribute.get_by_id(item[:identifier]).display_forms.first
-            when "label"
+            when 'attribute'
+              result = GoodData::Attribute.get_by_id(item[:identifier])
+              result.display_forms.first
+            when 'label'
               GoodData::DisplayForm.get_by_id(item[:identifier])
             end
           else
@@ -100,91 +108,104 @@ module GoodData
         end
       end
 
-      def execute(options={})
+      def execute(options = {})
         left = Array(options[:left])
         top = Array(options[:top])
 
-        metrics = (left + top).find_all {|item| item.respond_to?(:is_metric?)}
+        metrics = (left + top).select { |item| item.respond_to?(:is_metric?) }
 
-        unsaved_metrics = metrics.reject {|i| i.saved?}
-        unsaved_metrics.each {|m| m.title = "Untitled metric" unless m.title}
+        unsaved_metrics = metrics.reject { |i| i.saved? }
+        unsaved_metrics.each { |m| m.title = 'Untitled metric' unless m.title }
 
         begin
-          unsaved_metrics.each {|m| m.save}
+          unsaved_metrics.each { |m| m.save }
           rd = GoodData::ReportDefinition.create(options)
           get_data_result(execute_inline(rd))
         ensure
-          unsaved_metrics.each {|m| m.delete if m &&  m.saved?}
+          unsaved_metrics.each { |m| m.delete if m && m.saved? }
         end
       end
 
       def execute_inline(rd)
         rd = rd.respond_to?(:raw_data) ? rd.raw_data : rd
         data = {
-          :report_req => {
-            :definitionContent => {
-              :content => rd,
-              :projectMetadata => GoodData::project.links["metadata"]}}}
-        GoodData.post("/gdc/app/projects/#{GoodData.project.pid}/execute", data)
+          report_req: {
+            definitionContent: {
+              content: rd,
+              projectMetadata: GoodData.project.links['metadata']
+            }
+          }
+        }
+        uri = "/gdc/app/projects/#{GoodData.project.pid}/execute"
+        GoodData.post(uri, data)
       end
 
       def get_data_result(result)
-        data_result_uri = result["execResult"]["dataResult"]
+        data_result_uri = result['execResult']['dataResult']
         result = GoodData.get data_result_uri
-        while result["taskState"] && result["taskState"]["status"] == "WAIT" do
-           sleep 10
-           result = GoodData.get data_result_uri
-         end
+
+        while result['taskState'] && result['taskState']['status'] == 'WAIT'
+          sleep 10
+          result = GoodData.get data_result_uri
+        end
+
         ReportDataResult.new(GoodData.get data_result_uri)
       end
 
-      def create(options={})
+      def create(options = {})
         left = Array(options[:left])
         top = Array(options[:top])
 
         left = ReportDefinition.find(left)
         top = ReportDefinition.find(top)
 
-        fail "All metrics in report definition must be saved" unless (left + top).all? {|i| i.saved?}
-
-        ReportDefinition.new({
-           "reportDefinition" => {
-              "content" => {
-                 "grid" => {
-                    "sort" => {
-                      "columns" => [],
-                      "rows" => []
-                      },
-                    "columnWidths" => [],
-                    "columns" => ReportDefinition.create_part(top),
-                    "metrics" => ReportDefinition.create_metrics_part(left, top),
-                    "rows" => ReportDefinition.create_part(left),
-                 },
-                 "format" => "grid",
-                 "filters" => []
+        # 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? }
+
+        pars = {
+          'reportDefinition' => {
+            'content' => {
+              'grid' => {
+                'sort' => {
+                  'columns' => [],
+                  'rows' => []
+                },
+                'columnWidths' => [],
+                'columns' => ReportDefinition.create_part(top),
+                'metrics' => ReportDefinition.create_metrics_part(left, top),
+                'rows' => ReportDefinition.create_part(left)
               },
-              "meta" => {
-                 "tags" => "",
-                 "summary" => "",
-                 "title" => "Untitled report definition"
-              }
-           }
-        })
+              'format' => 'grid',
+              'filters' => []
+            },
+            'meta' => {
+              'tags' => '',
+              'summary' => '',
+              'title' => 'Untitled report definition'
+            }
+          }
+        }
+
+        ReportDefinition.new(pars)
       end
     end
 
-    def metrics 
-      content["grid"]["metrics"].map {|i| GoodData::Metric[i["uri"]]}
+    def metrics
+      content['grid']['metrics'].map { |i| GoodData::Metric[i['uri']] }
     end
 
     def execute
       result = if saved?
-        GoodData.post '/gdc/xtab2/executor', {"report_req" => {"reportDefinition" => uri}}
-      else
-        ReportDefinition.execute_inline(self)
-      end
-      ReportDefinition::get_data_result(result)
+                 pars = {
+                   'report_req' => { 'reportDefinition' => uri }
+                 }
+                 GoodData.post '/gdc/xtab2/executor', pars
+               else
+                 ReportDefinition.execute_inline(self)
+               end
+
+      get_data_result(result)
     end
-
-  end    
-end
+  end
+end

data/lib/gooddata/version.rb

@@ -1,8 +1,10 @@
+# encoding: UTF-8
+
+# GoodData Module
 module GoodData
-  VERSION = "0.6.0.pre11"
+  VERSION = "0.6.0"
 
   class << self
-
     # Version
     def version
       VERSION
@@ -10,7 +12,7 @@ module GoodData
 
     # Identifier of gem version
     # @return Formatted gem version
-    def gem_version_string()
+    def gem_version_string
       "gooddata-gem/#{VERSION}"
     end
   end

data/lib/templates/bricks/brick.rb.erb

@@ -1,7 +1,7 @@
 class MyBrick < GoodData::Bricks::Brick
 
-  def call(params)
-    # do something here
-  end
+    def call(params)
+        # do something here
+    end
 
 end

data/lib/templates/bricks/main.rb.erb

@@ -1,4 +1,5 @@
-require 'gooddata/bricks'
-require './mybrick'
+require_relative '../../gooddata/bricks/bricks'
+
+require_relative './mybrick'
 
 GoodData::Bricks::Pipeline.prepare([LoggerMiddleware, BenchMiddleware, GoodDataMiddleware, MyBrick])

data/lib/templates/project/Goodfile.erb

@@ -1,4 +1,4 @@
 {
-  "model" : "./model/model.rb",
-  "project_id"   : ""
+"model" : "./model/model.rb",
+"project_id"   : ""
 }

data/lib/templates/project/model/model.rb.erb

@@ -1,25 +1,25 @@
-GoodData::Model::ProjectBuilder.create("<%= name %>") do |p|
-  p.add_date_dimension("committed_on")
+GoodData::Model::ProjectBuilder.create("           ") do |p|
+    p.add_date_dimension("committed_on")
 
-  p.add_dataset("repos") do |d|
-    d.add_anchor("id")
-    d.add_label("name", :reference => "id")
-  end
+    p.add_dataset("repos") do |d|
+        d.add_anchor("id")
+        d.add_label("name", :reference => "id")
+    end
 
-  p.add_dataset("devs") do |d|
-    d.add_anchor("id")
-    d.add_label("email", :reference => "id")
-  end
+    p.add_dataset("devs") do |d|
+        d.add_anchor("id")
+        d.add_label("email", :reference => "id")
+    end
 
-  p.add_dataset("commits") do |d|
-    d.add_fact("lines_changed")
-    d.add_date("committed_on", :dataset => "committed_on")
-    d.add_reference("dev_id", :dataset => 'devs', :reference => 'id')
-    d.add_reference("repo_id", :dataset => 'repos', :reference => 'id')
-  end
+    p.add_dataset("commits") do |d|
+        d.add_fact("lines_changed")
+        d.add_date("committed_on", :dataset => "committed_on")
+        d.add_reference("dev_id", :dataset => 'devs', :reference => 'id')
+        d.add_reference("repo_id", :dataset => 'repos', :reference => 'id')
+    end
 
-  p.upload("data/devs.csv", :dataset => 'devs')
-  p.upload("data/repos.csv", :dataset => 'repos')
-  p.upload("data/commits.csv", :dataset => 'commits')
+    p.upload("data/devs.csv", :dataset => 'devs')
+    p.upload("data/repos.csv", :dataset => 'repos')
+    p.upload("data/commits.csv", :dataset => 'commits')
 
 end