gooddata 0.6.18 → 0.6.19

data/lib/gooddata/models/{to_wire.rb → blueprint/to_wire.rb}

@@ -12,17 +12,7 @@ module GoodData
       # @param dataset [Hash] Dataset blueprint hash represenation
       # @return [Hash] Manifest for a particular reference
       def self.anchor_to_wire(_project, dataset)
-        if DatasetBlueprint.anchor(dataset)
-          attribute_to_wire(dataset, DatasetBlueprint.anchor(dataset))
-        else
-          {
-            attribute: {
-              identifier: GoodData::Model.identifier_for(dataset, type: :anchor_no_label),
-              title: "Records of #{ GoodData::Model.title(dataset) }",
-              folder: dataset[:folder] || GoodData::Model.title(dataset)
-            }
-          }
-        end
+        attribute_to_wire(dataset, DatasetBlueprint.anchor(dataset))
       end
 
       # Converts atttribute to wire format.
@@ -42,28 +32,26 @@ module GoodData
       # @param attribute [Hash] Attribute
       # @return [Hash] Manifest for a particular reference
       def self.attribute_to_wire(dataset, attribute)
-        default_label = DatasetBlueprint.default_label_for_attribute(dataset, attribute)
-        label = default_label[:type].to_sym == :label ? default_label : default_label.merge(type: :primary_label)
-        payload = {
-          attribute: {
-            identifier: GoodData::Model.identifier_for(dataset, attribute),
-            title: GoodData::Model.title(attribute),
-            folder: attribute[:folder] || dataset[:folder] || GoodData::Model.title(dataset),
-            labels: ([attribute.merge(type: :primary_label)] + DatasetBlueprint.labels_for_attribute(dataset, attribute)).map do |l|
-              {
-                label: {
-                  identifier: GoodData::Model.identifier_for(dataset, l, attribute),
-                  title: GoodData::Model.title(l),
-                  type: l[:gd_type],
-                  dataType: l[:gd_data_type]
-                }
-              }
-            end,
-            defaultLabel: GoodData::Model.identifier_for(dataset, label, attribute)
+        ls = DatasetBlueprint.labels_for_attribute(dataset, attribute)
+        labels = ls.map do |l|
+          {
+            label: {
+              identifier: l[:id],
+              title: GoodData::Model.title(l),
+              type: l[:gd_type] || Model::DEFAULT_TYPE,
+              dataType: GoodData::Model.normalize_gd_data_type(l[:gd_data_type]) || Model::DEFAULT_ATTRIBUTE_DATATYPE
+            }
           }
-        }
-        payload.tap do |p|
-          p[:attribute][:description] = GoodData::Model.description(attribute) if GoodData::Model.description(attribute)
+        end
+        {}.tap do |a|
+          a[:attribute] = {}
+          a[:attribute][:identifier] = attribute[:id]
+          a[:attribute][:title] = Model.title(attribute)
+          a[:attribute][:folder] = attribute[:folder] || dataset[:folder] || GoodData::Model.title(dataset)
+          a[:attribute][:labels] = labels unless labels.empty?
+          a[:attribute][:description] = GoodData::Model.description(attribute) if GoodData::Model.description(attribute)
+          default = ls.find { |l| l[:default_label] }
+          a[:attribute][:defaultLabel] = (default && default[:id]) || ls.first[:id] unless ls.empty?
         end
       end
 
@@ -75,7 +63,7 @@ module GoodData
       def self.dataset_to_wire(project, dataset)
         {
           dataset: {
-            identifier: GoodData::Model.identifier_for(dataset),
+            identifier: dataset[:id],
             title: GoodData::Model.title(dataset),
             anchor: anchor_to_wire(project, dataset),
             attributes: attributes_to_wire(project, dataset),
@@ -90,13 +78,13 @@ module GoodData
       # @param project [Hash] Project blueprint hash represenation
       # @param dataset [Hash] Dataset blueprint hash represenation
       # @return [Hash] Manifest for a particular reference
-      def self.date_dimensions_to_wire(_project, dataset)
-        {
-          dateDimension: {
-            name: dataset[:name],
-            title: GoodData::Model.title(dataset)
-          }
-        }
+      def self.date_dimension_to_wire(_project, dataset)
+        payload = {}.tap do |dd|
+          dd[:name] = dataset[:id]
+          dd[:urn] = dataset[:urn] if dataset[:urn]
+          dd[:title] = GoodData::Model.title(dataset)
+        end
+        { dateDimension: payload }
       end
 
       # Converts fact to wire format.
@@ -107,10 +95,10 @@ module GoodData
       def self.fact_to_wire(dataset, fact)
         payload = {
           fact: {
-            identifier: GoodData::Model.identifier_for(dataset, fact),
+            identifier: fact[:id],
             title: GoodData::Model.title(fact),
             folder: fact[:folder] || dataset[:folder] || GoodData::Model.title(dataset),
-            dataType: fact[:gd_data_type] || DEFAULT_FACT_DATATYPE
+            dataType: GoodData::Model.normalize_gd_data_type(fact[:gd_data_type]) || DEFAULT_FACT_DATATYPE
           }
         }
         payload.tap do |p|
@@ -123,16 +111,9 @@ module GoodData
       # @param fact [Hash] Project blueprint hash represenation
       # @param dataset [Hash] Dataset blueprint hash represenation
       # @return [Hash] Manifest for a particular reference
-      def self.references_to_wire(project, dataset)
+      def self.references_to_wire(_project, dataset)
         DatasetBlueprint.references(dataset).map do |r|
-          if ProjectBlueprint.date_dimension?(project, r[:dataset])
-            ProjectBlueprint.find_date_dimension(project, r[:dataset])[:name]
-          elsif ProjectBlueprint.dataset?(project, r[:dataset])
-            ds = ProjectBlueprint.find_dataset(project, r[:dataset])
-            'dataset.' + ds[:name]
-          else
-            fail 'This dataset does not exist'
-          end
+          r[:dataset]
         end
       end
 
@@ -148,7 +129,7 @@ module GoodData
             targetModel: {
               projectModel: {
                 datasets: (what[:datasets] || []).map { |d| dataset_to_wire(what, d) },
-                dateDimensions: (what[:date_dimensions] || []).map { |d| date_dimensions_to_wire(what, d) }
+                dateDimensions: (what[:date_dimensions] || []).map { |d| date_dimension_to_wire(what, d) }
               }
             }
           }

data/lib/gooddata/models/datawarehouse.rb

@@ -17,7 +17,7 @@ module GoodData
         c = client(opts)
         fail ArgumentError, 'No :client specified' if c.nil?
 
-        auth_token = opts[:auth_token]
+        auth_token = opts[:auth_token] || opts[:token]
         fail ArgumentError, 'You have to provide your token for creating projects as :auth_token parameter' if auth_token.nil? || auth_token.empty?
 
         title = opts[:title]
@@ -34,7 +34,7 @@ module GoodData
         res = c.post(CREATE_URL, json)
 
         # wait until the instance is created
-        final_res = c.poll_on_response(res['asyncTask']['links']['poll'], :sleep_interval => 3) do |r|
+        final_res = c.poll_on_response(res['asyncTask']['links']['poll'], opts.merge(sleep_interval: 3)) do |r|
           r['asyncTask']['links']['instance'].nil?
         end
 

data/lib/gooddata/models/domain.rb

@@ -97,6 +97,7 @@ module GoodData
       end
 
       def update_user(user_data, options = { client: GoodData.connection })
+        user_data = user_data.to_hash if user_data.is_a?(GoodData::Profile)
         client = client(options)
         user_data = user_data.to_hash
         # generated_pass = rand(10E10).to_s
@@ -189,7 +190,7 @@ module GoodData
           result = []
           page_limit = opts[:page_limit] || 1000
           limit = opts[:limit] || Float::INFINITY
-          offset = opts[:offset]
+          offset = opts[:offset] || 0
           uri = "#{domain.uri}/users?offset=#{offset}&limit=#{page_limit}"
           loop do
             tmp = client(opts).get(uri)
@@ -250,7 +251,7 @@ module GoodData
     # Example
     #
     # GoodData.connect 'tomas.korcak@gooddata.com' 'your-password'
-    # domain = GoodData::Domain['gooddata-tomas-korcak']
+    # domain = project.domain('domain-name')
     # domain.add_user 'joe.doe@example', 'sup3rS3cr3tP4ssW0rtH'
     #
     def add_user(data, opts = {})

data/lib/gooddata/models/execution.rb

@@ -89,8 +89,8 @@ module GoodData
     # Wait for execution result, status different than RUNNING or SCHEDULED
     #
     # @return [GoodData::Execution] Execution result
-    def wait_for_result
-      res = client.poll_on_response(uri) do |body|
+    def wait_for_result(options = {})
+      res = client.poll_on_response(uri, options) do |body|
         body['execution'] && (body['execution']['status'] == 'RUNNING' || body['execution']['status'] == 'SCHEDULED')
       end
       @json = res

data/lib/gooddata/models/execution_detail.rb

@@ -24,6 +24,11 @@ module GoodData
       Time.parse(json['executionDetail']['created'])
     end
 
+    # Has execution failed?
+    def error?
+      status == :error
+    end
+
     # Timestamp when execution was finished
     def finished
       Time.parse(json['executionDetail']['finished'])
@@ -41,7 +46,7 @@ module GoodData
 
     # Is execution ok?
     def ok?
-      status.downcase == 'ok'
+      status == :ok
     end
 
     # Timestamp when execution was started
@@ -51,7 +56,7 @@ module GoodData
 
     # Status of execution
     def status
-      json['executionDetail']['status']
+      json['executionDetail']['status'].downcase.to_sym
     end
 
     # Timestamp when execution was updated

data/lib/gooddata/models/from_wire.rb

@@ -7,92 +7,84 @@ module GoodData
     module FromWire
       # Converts dataset from wire format into an internal blueprint representation
       #
-      # @param stuff [Hash] Whatever comes from wire
+      # @param dataset [Hash] Whatever comes from wire
       # @return [Hash] Manifest for a particular reference
-      def self.dataset_from_wire(stuff)
+      def self.dataset_from_wire(dataset)
         {}.tap do |d|
+          id = dataset['dataset']['identifier']
+
           d[:type] = :dataset
-          d[:title] = stuff['dataset']['title'] if stuff['dataset']['title'] != stuff['dataset']['identifier'].split('.').last.titleize
-          d[:name] = stuff['dataset']['identifier'].split('.').last
-          d[:columns] = (parse_anchor(stuff) + parse_attributes(stuff) + parse_facts(stuff) + parse_references(stuff))
+          d[:title] = dataset['dataset']['title']
+          d[:id] = id
+          d[:columns] = (parse_anchor(dataset) + parse_attributes(dataset) + parse_facts(dataset) + parse_references(dataset))
         end
       end
 
       # Entry method for converting information about project mode from wire
       # format into an internal blueprint representation
       #
-      # @param stuff [Hash] Whatever comes from wire
+      # @param wire_model [Hash] Whatever comes from wire
       # @return [GoodData::Model::ProjectBlueprint] Manifest for a particular reference
-      def self.from_wire(stuff)
-        model = stuff['projectModelView']['model']['projectModel']
+      def self.from_wire(wire_model)
+        model = wire_model['projectModelView']['model']['projectModel']
         datasets = model['datasets'] || []
         dims = model['dateDimensions'] || []
+
         ProjectBlueprint.new(
           datasets: datasets.map { |ds| dataset_from_wire(ds) },
           date_dimensions: dims.map { |dd| parse_date_dimensions(dd) }
         )
       end
 
-      # Converts anchor from wire format into an internal blueprint representation
+      # Converts attrbutes from wire format into an internal blueprint representation
       #
       # @param stuff [Hash] Whatever comes from wire
       # @return [Hash] Manifest for a particular reference
-      def self.parse_anchor(stuff)
-        attribute = stuff['dataset']['anchor']['attribute']
-        if !attribute.key?('labels')
-          []
-        else
-          labels = attribute['labels'] || []
-          default_label = attribute['defaultLabel']
-          primary_label_name = attribute['identifier'].split('.').last
-          dataset_name = attribute['identifier'].split('.')[1]
-          primary_label_identifier = GoodData::Model.identifier_for({ name: dataset_name }, type: :primary_label, name: primary_label_name)
-          primary_labels, regular_labels = labels.partition { |x| x['label']['identifier'] == primary_label_identifier }
-          dl = primary_labels.map do |label|
-            parse_label(attribute, label, 'anchor', default_label)
-          end
-          rl = regular_labels.map do |label|
-            parse_label(attribute, label, 'label', default_label)
-          end
-          dl + rl
+      def self.parse_attributes(stuff)
+        dataset = stuff['dataset']
+        attributes = dataset['attributes'] || []
+        attributes.mapcat do |a|
+          parse_attribute(a['attribute'])
         end
       end
 
-      # Converts attrbutes from wire format into an internal blueprint representation
+      # Converts anchor from wire format into an internal blueprint representation
       #
       # @param stuff [Hash] Whatever comes from wire
       # @return [Hash] Manifest for a particular reference
-      def self.parse_attributes(stuff)
-        dataset = stuff['dataset']
-        attributes = dataset['attributes'] || []
-        attributes.mapcat do |a|
-          attribute = a['attribute']
-          labels = attribute['labels'] || []
-          default_label = attribute['defaultLabel']
-          primary_label_name = attribute['identifier'].split('.').last
-          dataset_name = attribute['identifier'].split('.')[1]
-          primary_label_identifier = GoodData::Model.identifier_for({ name: dataset_name }, type: :primary_label, name: primary_label_name)
-          primary_labels, regular_labels = labels.partition { |x| x['label']['identifier'] == primary_label_identifier }
-          dl = primary_labels.map do |label|
-            parse_label(attribute, label, 'attribute', default_label)
-          end
-          rl = regular_labels.map do |label|
-            parse_label(attribute, label, 'label', default_label)
-          end
-          dl + rl
+      def self.parse_anchor(stuff)
+        anchor = stuff['dataset']['anchor']['attribute']
+        parse_attribute(anchor, :anchor)
+      end
+
+      def self.parse_attribute(attribute, type = :attribute)
+        labels = attribute['labels'] || []
+        default_label_id = attribute['defaultLabel']
+        default_label = labels.find { |l| l['label']['identifier'] == default_label_id } || labels.first
+        regular_labels = labels - [default_label]
+        pl = default_label.nil? ? [] : [parse_label(attribute, default_label, :default_label)]
+        rl = regular_labels.map do |label|
+          parse_label(attribute, label, :label)
+        end
+        attribute = {}.tap do |a|
+          a[:type] = type
+          a[:id] = attribute['identifier']
+          a[:title] = attribute['title']
+          a[:description] = attribute['description']
+          a[:folder] = attribute['folder']
         end
+        [attribute] + pl + rl
       end
 
       # Converts date dimensions from wire format into an internal blueprint representation
       #
       # @param stuff [Hash] Whatever comes from wire
       # @return [Hash] Manifest for a particular reference
-      def self.parse_date_dimensions(stuff)
+      def self.parse_date_dimensions(date_dim)
         {}.tap do |d|
           d[:type] = :date_dimension
-          # d[:urn] = :date_dimension
-          d[:name] = stuff['dateDimension']['name']
-          d[:title] = stuff['dateDimension']['title'] if stuff['dateDimension']['title'] != d[:name].titleize
+          d[:id] = date_dim['dateDimension']['name']
+          d[:title] = date_dim['dateDimension']['title']
         end
       end
 
@@ -105,11 +97,11 @@ module GoodData
         facts.map do |fact|
           {}.tap do |f|
             f[:type] = fact['fact']['identifier'] =~ /^dt\./ ? :date_fact : :fact
-            f[:name] = fact['fact']['identifier'].split('.').last
-            f[:title] = fact['fact']['title'] if fact['fact']['title'] != fact['fact']['identifier'].split('.').last.titleize
+            f[:id] = fact['fact']['identifier']
+            f[:title] = fact['fact']['title']
             f[:description] = fact['fact']['description'] if fact['fact']['description']
-            f[:folder] = fact['fact']['folder'] if fact['fact']['folder']
-            f[:gd_data_type] = fact['fact']['dataType'] if fact['fact'].key?('dataType')
+            f[:folder] = fact['fact']['folder']
+            f[:gd_data_type] = fact['fact']['dataType'] || GoodData::Model::DEFAULT_FACT_DATATYPE
           end
         end
       end
@@ -118,38 +110,35 @@ module GoodData
       #
       # @param stuff [Hash] Whatever comes from wire
       # @return [Hash] Manifest for a particular reference
-      def self.parse_label(attribute, label, type, default_label = nil)
+      def self.parse_label(attribute, label, type)
         {}.tap do |l|
-          l[:type] = type
-          l[:reference] = attribute['identifier'].split('.').last if type == 'label'
-          l[:name] = label['label']['identifier'].split('.').last
-          l[:title] = label['label']['title'] if label['label']['title'] != label['label']['identifier'].split('.').last.titleize
-          l[:description] = attribute['description'] if %w(attribute anchor).include?(type) && attribute['description']
-          l[:folder] = attribute['folder'] if attribute['folder'] && (type == 'attribute' || type == 'anchor')
-          l[:gd_data_type] = label['label']['dataType'] if label['label'].key?('dataType')
-          l[:gd_type] = label['label']['type'] if label['label'].key?('type')
-          l[:default_label] = true if default_label == label['label']['identifier']
+          l[:type] = :label
+          l[:id] = label['label']['identifier']
+          l[:reference] = attribute['identifier']
+          l[:title] = label['label']['title']
+          l[:gd_data_type] = label['label']['dataType'] || GoodData::Model::DEFAULT_ATTRIBUTE_DATATYPE
+          l[:gd_type] = label['label']['type'] || GoodData::Model::DEFAULT_TYPE
+          l[:default_label] = true if type == :default_label
         end
       end
 
       # Converts label from wire format into an internal blueprint representation
       #
-      # @param stuff [Hash] Whatever comes from wire
+      # @param dataset [Hash] Whatever comes from wire
+      # @param anchor_hash [Hash] dataset id -> anchor id hash
       # @return [Hash] Manifest for a particular reference
-      def self.parse_references(stuff)
-        references = stuff['dataset']['references'] || []
+      def self.parse_references(dataset)
+        references = dataset['dataset']['references'] || []
         references.map do |ref|
           if ref =~ /^dataset\./
             {
               :type => :reference,
-              :name => ref.gsub(/^dataset\./, ''),
-              :dataset => ref.gsub(/^dataset\./, '')
+              :dataset => ref
             }
           else
             {
               :type => :date,
-              :name => ref.gsub(/^dataset\./, ''),
-              :dataset => ref.gsub(/^dataset\./, '')
+              :dataset => ref
             }
           end
         end

data/lib/gooddata/models/from_wire_parse.rb

@@ -1,125 +1,125 @@
-# encoding: UTF-8
-
-module GoodData
-  module Model
-    module FromWire
-      # Converts anchor from wire format into an internal blueprint representation
-      #
-      # @param stuff [Hash] Whatever comes from wire
-      # @return [Hash] Manifest for a particular reference
-      def self.parse_anchor(stuff)
-        attribute = stuff['dataset']['anchor']['attribute']
-        if !attribute.key?('labels')
-          []
-        else
-          labels = attribute['labels'] || []
-          default_label = attribute['defaultLabel']
-          primary_label_name = attribute['identifier'].split('.').last
-          dataset_name = attribute['identifier'].split('.')[1]
-          primary_label_identifier = GoodData::Model.identifier_for({ name: dataset_name }, type: :primary_label, name: primary_label_name)
-          primary_labels, regular_labels = labels.partition { |x| x['label']['identifier'] == primary_label_identifier }
-          dl = primary_labels.map do |label|
-            parse_label(attribute, label, 'anchor', default_label)
-          end
-          rl = regular_labels.map do |label|
-            parse_label(attribute, label, 'label', default_label)
-          end
-          dl + rl
-        end
-      end
-
-      # Converts attrbutes from wire format into an internal blueprint representation
-      #
-      # @param stuff [Hash] Whatever comes from wire
-      # @return [Hash] Manifest for a particular reference
-      def self.parse_attributes(stuff)
-        dataset = stuff['dataset']
-        attributes = dataset['attributes'] || []
-        attributes.mapcat do |a|
-          attribute = a['attribute']
-          labels = attribute['labels'] || []
-          default_label = attribute['defaultLabel']
-          primary_label_name = attribute['identifier'].split('.').last
-          dataset_name = attribute['identifier'].split('.')[1]
-          primary_label_identifier = GoodData::Model.identifier_for({ name: dataset_name }, type: :primary_label, name: primary_label_name)
-          primary_labels, regular_labels = labels.partition { |x| x['label']['identifier'] == primary_label_identifier }
-          dl = primary_labels.map do |label|
-            parse_label(attribute, label, 'attribute', default_label)
-          end
-          rl = regular_labels.map do |label|
-            parse_label(attribute, label, 'label', default_label)
-          end
-          dl + rl
-        end
-      end
-
-      # Converts date dimensions from wire format into an internal blueprint representation
-      #
-      # @param stuff [Hash] Whatever comes from wire
-      # @return [Hash] Manifest for a particular reference
-      def self.parse_date_dimensions(stuff)
-        {}.tap do |d|
-          d[:type] = :date_dimension
-          # d[:urn] = :date_dimension
-          d[:name] = stuff['dateDimension']['name']
-          d[:title] = stuff['dateDimension']['title'] if stuff['dateDimension']['title'] != d[:name].titleize
-        end
-      end
-
-      # Converts facts from wire format into an internal blueprint representation
-      #
-      # @param stuff [Hash] Whatever comes from wire
-      # @return [Hash] Manifest for a particular reference
-      def self.parse_facts(stuff)
-        facts = stuff['dataset']['facts'] || []
-        facts.map do |fact|
-          {}.tap do |f|
-            f[:type] = fact['fact']['identifier'] =~ /^dt\./ ? :date_fact : :fact
-            f[:name] = fact['fact']['identifier'].split('.').last
-            f[:title] = fact['fact']['title'] if fact['fact']['title'] != fact['fact']['identifier'].split('.').last.titleize
-            f[:gd_data_type] = fact['fact']['dataType'] if fact['fact'].key?('dataType')
-          end
-        end
-      end
-
-      # Converts label from wire format into an internal blueprint representation
-      #
-      # @param stuff [Hash] Whatever comes from wire
-      # @return [Hash] Manifest for a particular reference
-      def self.parse_label(attribute, label, type, default_label = nil)
-        {}.tap do |l|
-          l[:type] = type
-          l[:reference] = attribute['identifier'].split('.').last if type == 'label'
-          l[:name] = label['label']['identifier'].split('.').last
-          l[:title] = label['label']['title'] if label['label']['title'] != label['label']['identifier'].split('.').last.titleize
-          l[:gd_data_type] = label['label']['dataType'] if label['label'].key?('dataType')
-          l[:gd_type] = label['label']['type'] if label['label'].key?('type')
-          l[:default_label] = true if default_label == label['label']['identifier']
-        end
-      end
-
-      # Converts label from wire format into an internal blueprint representation
-      #
-      # @param stuff [Hash] Whatever comes from wire
-      # @return [Hash] Manifest for a particular reference
-      def self.parse_references(stuff)
-        references = stuff['dataset']['references'] || []
-        references.map do |ref|
-          if ref =~ /^dataset\./
-            {
-              :type => :reference,
-              :name => ref.gsub(/^dataset\./, ''),
-              :dataset => ref.gsub(/^dataset\./, '')
-            }
-          else
-            {
-              :type => :date,
-              :name => ref.gsub(/^dataset\./, ''),
-              :dataset => ref.gsub(/^dataset\./, '')
-            }
-          end
-        end
-      end
-    end
-  end
-end
+# # encoding: UTF-8
+#
+# module GoodData
+#   module Model
+#     module FromWire
+#       # Converts anchor from wire format into an internal blueprint representation
+#       #
+#       # @param stuff [Hash] Whatever comes from wire
+#       # @return [Hash] Manifest for a particular reference
+#       def self.parse_anchor(stuff)
+#         attribute = stuff['dataset']['anchor']['attribute']
+#         if !attribute.key?('labels')
+#           []
+#         else
+#           labels = attribute['labels'] || []
+#           default_label = attribute['defaultLabel']
+#           primary_label_name = attribute['identifier'].split('.').last
+#           dataset_name = attribute['identifier'].split('.')[1]
+#           primary_label_identifier = GoodData::Model.identifier_for({ name: dataset_name }, type: :primary_label, name: primary_label_name)
+#           primary_labels, regular_labels = labels.partition { |x| x['label']['identifier'] == primary_label_identifier }
+#           dl = primary_labels.map do |label|
+#             parse_label(attribute, label, 'anchor', default_label)
+#           end
+#           rl = regular_labels.map do |label|
+#             parse_label(attribute, label, 'label', default_label)
+#           end
+#           dl + rl
+#         end
+#       end
+#
+#       # Converts attrbutes from wire format into an internal blueprint representation
+#       #
+#       # @param stuff [Hash] Whatever comes from wire
+#       # @return [Hash] Manifest for a particular reference
+#       def self.parse_attributes(stuff)
+#         dataset = stuff['dataset']
+#         attributes = dataset['attributes'] || []
+#         attributes.mapcat do |a|
+#           attribute = a['attribute']
+#           labels = attribute['labels'] || []
+#           default_label = attribute['defaultLabel']
+#           primary_label_name = attribute['identifier'].split('.').last
+#           dataset_name = attribute['identifier'].split('.')[1]
+#           primary_label_identifier = GoodData::Model.identifier_for({ name: dataset_name }, type: :primary_label, name: primary_label_name)
+#           primary_labels, regular_labels = labels.partition { |x| x['label']['identifier'] == primary_label_identifier }
+#           dl = primary_labels.map do |label|
+#             parse_label(attribute, label, 'attribute', default_label)
+#           end
+#           rl = regular_labels.map do |label|
+#             parse_label(attribute, label, 'label', default_label)
+#           end
+#           dl + rl
+#         end
+#       end
+#
+#       # Converts date dimensions from wire format into an internal blueprint representation
+#       #
+#       # @param stuff [Hash] Whatever comes from wire
+#       # @return [Hash] Manifest for a particular reference
+#       def self.parse_date_dimensions(stuff)
+#         {}.tap do |d|
+#           d[:type] = :date_dimension
+#           # d[:urn] = :date_dimension
+#           d[:name] = stuff['dateDimension']['name']
+#           d[:title] = stuff['dateDimension']['title'] if stuff['dateDimension']['title'] != d[:name].titleize
+#         end
+#       end
+#
+#       # Converts facts from wire format into an internal blueprint representation
+#       #
+#       # @param stuff [Hash] Whatever comes from wire
+#       # @return [Hash] Manifest for a particular reference
+#       def self.parse_facts(stuff)
+#         facts = stuff['dataset']['facts'] || []
+#         facts.map do |fact|
+#           {}.tap do |f|
+#             f[:type] = fact['fact']['identifier'] =~ /^dt\./ ? :date_fact : :fact
+#             f[:name] = fact['fact']['identifier'].split('.').last
+#             f[:title] = fact['fact']['title'] if fact['fact']['title'] != fact['fact']['identifier'].split('.').last.titleize
+#             f[:gd_data_type] = fact['fact']['dataType'] if fact['fact'].key?('dataType')
+#           end
+#         end
+#       end
+#
+#       # Converts label from wire format into an internal blueprint representation
+#       #
+#       # @param stuff [Hash] Whatever comes from wire
+#       # @return [Hash] Manifest for a particular reference
+#       def self.parse_label(attribute, label, type, default_label = nil)
+#         {}.tap do |l|
+#           l[:type] = type
+#           l[:reference] = attribute['identifier'].split('.').last if type == 'label'
+#           l[:name] = label['label']['identifier'].split('.').last
+#           l[:title] = label['label']['title'] if label['label']['title'] != label['label']['identifier'].split('.').last.titleize
+#           l[:gd_data_type] = label['label']['dataType'] if label['label'].key?('dataType')
+#           l[:gd_type] = label['label']['type'] if label['label'].key?('type')
+#           l[:default_label] = true if default_label == label['label']['identifier']
+#         end
+#       end
+#
+#       # Converts label from wire format into an internal blueprint representation
+#       #
+#       # @param stuff [Hash] Whatever comes from wire
+#       # @return [Hash] Manifest for a particular reference
+#       def self.parse_references(stuff)
+#         references = stuff['dataset']['references'] || []
+#         references.map do |ref|
+#           if ref =~ /^dataset\./
+#             {
+#               :type => :reference,
+#               :name => ref.gsub(/^dataset\./, ''),
+#               :dataset => ref.gsub(/^dataset\./, '')
+#             }
+#           else
+#             {
+#               :type => :date,
+#               :name => ref.gsub(/^dataset\./, ''),
+#               :dataset => ref.gsub(/^dataset\./, '')
+#             }
+#           end
+#         end
+#       end
+#     end
+#   end
+# end