gooddata 0.6.4 → 0.6.5

data/lib/gooddata/models/project_creator.rb

@@ -46,7 +46,7 @@ module GoodData
           # schema = Schema.load(schema) unless schema.respond_to?(:to_maql_create)
           # project = GoodData.project unless project
           uri = "/gdc/projects/#{GoodData.project.pid}/model/diff"
-          result = GoodData.post(uri, bp.to_wire_model)
+          result = GoodData.post(uri, bp.to_wire)
           link = result['asyncTask']['link']['poll']
           response = GoodData.get(link, :process => false)
           # pp response
@@ -75,9 +75,10 @@ module GoodData
 
           end
 
-          bp.datasets.each do |ds|
-            schema = ds.to_schema
-            GoodData::ProjectMetadata["manifest_#{schema.name}"] = schema.to_manifest.to_json
+          bp.datasets.zip(GoodData::Model::ToManifest.to_manifest(bp.to_hash)).each do |ds|
+            dataset = ds[0]
+            manifest = ds[1]
+            GoodData::ProjectMetadata["manifest_#{dataset.name}"] = manifest.to_json
           end
         end
 

data/lib/gooddata/models/project_role.rb

@@ -2,78 +2,39 @@
 
 require_relative 'profile'
 
+require_relative '../mixins/mixins'
+
 module GoodData
   class ProjectRole
-    def initialize(json)
-      @json = json
-    end
+    attr_accessor :json
 
-    # Gets Project Role Identifier
-    #
-    # @return [string] Project Role
-    def identifier
-      @json['projectRole']['meta']['identifier']
-    end
+    include GoodData::Mixin::RestGetters
 
-    # Gets Project Role Author
-    #
-    # @return [GoodData::Profile] Project Role author
-    def author
-      url = @json['projectRole']['meta']['author']
-      tmp = GoodData.get url
-      GoodData::Profile.new(tmp)
+    class << self
+      include GoodData::Mixin::RestResource
     end
 
-    # Gets Project Role Contributor
-    #
-    # @return [GoodData::Profile] Project Role Contributor
-    def contributor
-      url = @json['projectRole']['meta']['contributor']
-      tmp = GoodData.get url
-      GoodData::Profile.new(tmp)
-    end
+    ProjectRole.root_key :projectRole
 
-    # Gets DateTime time when created
-    #
-    # @return [DateTime] Date time of creation
-    def created
-      DateTime.parse(@json['projectRole']['meta']['created'])
-    end
+    include GoodData::Mixin::RootKeyGetter
+    include GoodData::Mixin::Author
+    include GoodData::Mixin::Contributor
+    include GoodData::Mixin::Timestamps
 
-    # Gets Project Role Permissions
-    #
-    # @return [string] Project Role
-    def permissions
-      @json['projectRole']['permissions']
-    end
-
-    # Gets Project Role Title
-    #
-    # @return [string] Project Role Title
-    def title
-      @json['projectRole']['meta']['title']
+    def initialize(json)
+      @json = json
     end
 
-    # Gets Project Role Summary
-    #
-    # @return [string] Project Role Summary
-    def summary
-      @json['projectRole']['meta']['summary']
-    end
+    ProjectRole.data_property_reader :permissions
 
-    # Gets DateTime time when updated
-    #
-    # @return [DateTime] Date time of last update
-    def updated
-      DateTime.parse(@json['projectRole']['meta']['updated'])
-    end
+    ProjectRole.metadata_property_reader :identifier, :title, :summary
 
     # Gets Users with this Role
     #
     # @return [Array<GoodData::Profile>] List of users
     def users
       res = []
-      url = @json['projectRole']['links']['roleUsers']
+      url = data['links']['roleUsers']
       tmp = GoodData.get url
       tmp['associatedUsers']['users'].each do |user_url|
         user = GoodData.get user_url
@@ -88,5 +49,9 @@ module GoodData
     def uri
       @json['projectRole']['links']['roleUsers'].split('/')[0...-1].join('/')
     end
+
+    def ==(other)
+      uri == other.uri
+    end
   end
 end

data/lib/gooddata/models/schema_blueprint.rb

@@ -6,147 +6,332 @@ module GoodData
   module Model
     class DatasetBlueprint
       attr_accessor :data
+      # Checks if a dataset has an anchor.
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Boolean] returns true if dataset has an anchor
+      def self.anchor?(dataset)
+        columns(dataset).any? { |c| c[:type].to_s == 'anchor' }
+      end
 
-      def change(&block)
-        builder = SchemaBuilder.create_from_data(self)
-        block.call(builder)
-        @data = builder.to_hash
-        self
+      # Returns anchor of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Hash] returns the anchor or nil
+      def self.anchor(dataset)
+        find_column_by_type(dataset, :anchor, :first)
       end
 
-      def initialize(init_data)
-        @data = init_data
+      # Returns attributes of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def self.attributes(dataset)
+        find_column_by_type(dataset, :attribute, :all)
       end
 
-      def upload(source, options = {})
-        project = options[:project] || GoodData.project
-        fail 'You have to specify a project into which you want to load.' if project.nil?
-        mode = options[:load] || 'FULL'
-        project.upload(source, to_schema, mode)
+      # Returns all labels that is referenced by a label
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the labels or an empty array
+      def self.attribute_for_label(dataset, label)
+        find_column_by_type(dataset, [:attribute, :anchor], :all).find { |a| label[:reference] == a[:name] }
       end
 
-      def merge!(a_blueprint)
-        new_blueprint = GoodData::Model.merge_dataset_columns(self, a_blueprint)
-        @data = new_blueprint
-        self
+      # Returns all the fields of a dataset. This means facts, attributes, references
+      #
+      # @param ds [Hash] Dataset blueprint
+      # @return [Boolean]
+      def self.columns(ds)
+        ds[:columns] || []
       end
+      singleton_class.send(:alias_method, :fields, :columns)
 
-      def name
-        data[:name]
+      # Tells you if the object is a dataset. It consumes both Hash represenation
+      # or the GoodData::Model::DatasetBlueprint
+      #
+      # @param ds [Object] Value to be tested
+      # @return [Boolean]
+      def self.dataset_blueprint?(ds)
+        if ds.is_a?(DatasetBlueprint)
+          true
+        elsif ds.respond_to?(:[]) && ds.is_a?(Hash) && ds[:type].to_sym == :dataset
+          true
+        else
+          false
+        end
       end
 
-      def title
-        data[:title] || name.titleize
+      # Returns date facts of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def self.date_facts(dataset)
+        find_column_by_type(dataset, :date_fact, :all)
       end
 
-      def to_hash
-        data
+      # Returns label that is marked as default for a particular attribtue.
+      # This does not necessarily need to be the first one. This is a default label
+      # in terms of what is displayed on the UI
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the labels or an empty array
+      def self.default_label_for_attribute(dataset, attribute)
+        default_label = labels_for_attribute(dataset, attribute).find { |l| l[:default_label] == true }
+        default_label || attribute
       end
 
-      def columns
-        data[:columns]
+      # Returns facts of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def self.facts(dataset)
+        find_column_by_type(dataset, [:fact, :date_fact], :all)
       end
 
-      def anchor?
-        columns.any? { |c| c[:type].to_s == 'anchor' }
+      # Finds a specific column given a name
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @param name [String] Name of a field
+      # @param all [Symbol] if :all is passed all mathching objects are returned
+      # Otherwise only the first one is
+      # @return [Array<Hash>] matching fields
+      def self.find_column_by_name(dataset, name, all = nil)
+        if all == :all
+          columns(dataset).select { |c| c[:name].to_s == name }
+        else
+          columns(dataset).find { |c| c[:name].to_s == name }
+        end
+      end
+
+      # Returns all the fields of a specified type. You can specify more types
+      # as an array if you need more than one type.
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @param type [String | Symbol | Array[Symmbol] | Array[String]] Type or types you would like to get
+      # @param all [Symbol] if :all is passed
+      # as third parameter it return all object otherwise it returns the first one
+      # @return [Array<Hash>] matching fields
+      def self.find_column_by_type(dataset, type, all = nil)
+        types = if type.is_a?(Enumerable)
+                  type
+                else
+                  [type]
+                end
+        if all == :all
+          columns(dataset).select { |c| types.any? { |t| t.to_s == c[:type].to_s } }
+        else
+          columns(dataset).find { |c| types.any? { |t| t.to_s == c[:type].to_s } }
+        end
       end
 
+      # Returns labels facts of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the label or an empty array
+      def self.labels(dataset)
+        find_column_by_type(dataset, :label, :all)
+      end
+
+      # Returns labels for a particular attribute
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @param attribute [Hash] Attribute
+      # @return [Array<Hash>] returns the labels or an empty array
+      def self.labels_for_attribute(dataset, attribute)
+        labels(dataset).select { |l| l[:reference] == attribute[:name] }
+      end
+
+      # Returns references of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the references or an empty array
+      def self.references(dataset)
+        find_column_by_type(dataset, [:reference, :date], :all)
+      end
+
+      # Returns anchor of a dataset
+      #
+      # @return [Hash] returns the anchor or nil
       def anchor
         find_column_by_type(:anchor, :first)
       end
 
-      def references
-        find_column_by_type(:reference)
+      # Checks if a dataset has an anchor.
+      #
+      # @return [Boolean] returns true if dataset has an anchor
+      def anchor?
+        columns.any? { |c| c[:type].to_s == 'anchor' }
       end
 
+      # Returns attributes of a dataset
+      #
+      # @return [Array<Hash>] returns the attribute or an empty array
       def attributes
-        find_column_by_type(:attribute)
+        DatasetBlueprint.attributes(to_hash)
       end
 
-      def facts
-        find_column_by_type(:fact)
+      def attributes_and_anchors
+        anchor? ? attributes + [anchor] : attributes
       end
 
-      def labels
-        find_column_by_type(:label)
+      # Changes the dataset through a builder. You provide a block with an istance of
+      # GoodData::Model::SchemaBuilder and you
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the labels or an empty array
+      def change(&block)
+        builder = SchemaBuilder.create_from_data(self)
+        block.call(builder)
+        @data = builder.to_hash
+        self
       end
 
-      def attributes_and_anchors
-        anchor? ? attributes + [anchor] : attributes
+      # Returns all the fields of a dataset. This means facts, attributes, references
+      #
+      # @return [Boolean]
+      def columns
+        DatasetBlueprint.columns(to_hash)
       end
+      alias_method :fields, :columns
 
-      def find_column_by_type(type, all = :all)
-        type = type.to_s
-        if all == :all
-          columns.select { |c| c[:type].to_s == type }
-        else
-          columns.find { |c| c[:type].to_s == type }
-        end
+      # Creates a metric which counts numnber of lines in dataset. Works for both
+      # datasets with or without anchor
+      #
+      # @return [Boolean]
+      def count
+        id = if anchor?
+               GoodData::Model.identifier_for(to_hash, anchor)
+             else
+               GoodData::Model.identifier_for(to_hash, type: :anchor_no_label)
+             end
+        # binding.pry
+        attribute = GoodData::Attribute[id]
+        attribute.create_metric.execute
       end
 
-      def find_column_by_name(type, all = :all)
-        type = type.to_s
-        if all == :all
-          columns.select { |c| c[:name].to_s == type }
-        else
-          columns.find { |c| c[:name].to_s == type }
-        end
+      # Returns date facts of a dataset
+      #
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def date_facts
+        DatasetBlueprint.date_facts(to_hash)
       end
 
-      def suggest_metrics
-        identifiers = facts.map { |f| identifier_for(f) }
-        identifiers.zip(facts).map do |id, fact|
-          Metric.xcreate(
-            :title => fact[:name].titleize,
-            :expression => "SELECT SUM(![#{id}])")
-        end
+      # Duplicates the DatasetBlueprint. It is done as a deep duplicate
+      #
+      # @return [GoodData::Model::DatasetBlueprint] matching fields
+      def dup
+        DatasetBlueprint.new(data.deep_dup)
       end
 
-      def to_schema
-        Schema.new(to_hash)
+      # Compares two blueprints. This is done by comapring the hash represenatation.
+      # It has to be exacty identical including the order of the columns
+      #
+      # @param name [GoodData::Model::DatasetBlueprint] Name of a field
+      # @return [Boolean] matching fields
+      def eql?(other)
+        to_hash == other.to_hash
       end
 
-      def to_manifest
-        to_schema.to_manifest
+      # Returns facts of a dataset
+      #
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def facts
+        DatasetBlueprint.facts(to_hash)
       end
 
-      def pretty_print(printer)
-        printer.text "Schema <#{object_id}>:\n"
-        printer.text " Name: #{name}\n"
-        printer.text " Columns: \n"
-        printer.text columns.map do |c|
-          "  #{c[:name]}: #{c[:type]}"
-        end.join("\n")
+      # Finds a specific column given a name
+      #
+      # @param name [String] Name of a field
+      # @param all [Symbol] if :all is passed all mathching objects are returned
+      # Otherwise only the first one is
+      # @return [Array<Hash>] matching fields
+      def find_column_by_name(type, all = :all)
+        DatasetBlueprint.find_column_by_name(to_hash, type, all)
       end
 
-      def dup
-        DatasetBlueprint.new(data.deep_dup)
+      # Returns all the fields of a specified type. You can specify more types
+      # as an array if you need more than one type.
+      #
+      # @param type [String | Symbol | Array[Symmbol] | Array[String]] Type or types you would like to get
+      # @param all [Symbol] if :all is passed
+      # as third parameter it return all object otherwise it returns the first one
+      # @return [Array<Hash>] matching fields
+      def find_column_by_type(type, all = nil)
+        DatasetBlueprint.find_column_by_type(to_hash, type, all)
       end
 
-      def to_wire_model
-        to_schema.to_wire_model
+      # Creates a DatasetBlueprint
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [DatasetBlueprint] returns the labels or an empty array
+      def initialize(init_data)
+        @data = init_data
       end
 
-      def ==(other)
-        to_hash == other.to_hash
+      # Returns labels facts of a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the label or an empty array
+      def labels
+        DatasetBlueprint.labels(to_hash)
       end
 
-      def eql?(other)
-        to_hash == other.to_hash
+      # Merges two schemas together. This method changes the blueprint
+      # in place. If you would prefer the method that generates a new blueprint
+      # use merge method
+      #
+      # @param a_blueprint [GoodData::Model::DatasetBlueprint] Dataset blueprint to be merged
+      # @return [GoodData::Model::DatasetBlueprint] returns itself changed
+      def merge!(a_blueprint)
+        new_blueprint = GoodData::Model.merge_dataset_columns(self, a_blueprint)
+        @data = new_blueprint
+        self
+      end
+
+      # Returns name of the dataset
+      #
+      # @return [String]
+      def name
+        data[:name]
       end
 
-      def identifier_for(column)
-        column = find_column_by_name(column) if column.is_a?(String)
-        case column[:type].to_sym
-        when :attribute
-          "attr.#{name}.#{column[:name]}"
-        when :anchor
-          "attr.#{name}.#{column[:name]}"
-        when :fact
-          "fact.#{name}.#{column[:name]}"
+      # Returns references of a dataset
+      #
+      # @return [Array<Hash>] returns the references or an empty array
+      def references
+        DatasetBlueprint.references(to_hash)
+      end
+
+      # Method for suggest a couple of metrics that might get you started
+      # Idea is that we will provide couple of strategies. Currently the metrics
+      # are created in the random way but they should work.
+      #
+      # @return [Array<GoodData::Metric>] matching fields
+      def suggest_metrics
+        identifiers = facts.map { |f| identifier_for(f) }
+        identifiers.zip(facts).map do |id, fact|
+          Metric.xcreate(
+            :title => fact[:name].titleize,
+            :expression => "SELECT SUM(![#{id}])")
         end
       end
 
+      # Returns title of the dataset. If it is not set up. It is generated for you
+      # based on the name which is titleized
+      #
+      # @return [String]
+      def title
+        data[:title] || name.titleize
+      end
+
+      # Returns hash representation which is much better suited for processing
+      #
+      # @return [Hash]
+      def to_hash
+        data
+      end
+
       # Validate the blueprint return array of errors that are found.
       #
       # @return [Array] array of errors
@@ -170,6 +355,24 @@ module GoodData
           find_column_by_name(label[:reference]).empty?
         end
       end
+
+      # Helper methods to decide wheather the dataset is considered wide.
+      # Currently the wider datasets have both performance and usability
+      # penalty
+      #
+      # @return [Boolean] matching fields
+      def wide?
+        fields.count > 32
+      end
+
+      # Compares two blueprints. This is done by comapring the hash represenatation.
+      # It has to be exacty identical including the order of the columns
+      #
+      # @param name [GoodData::Model::DatasetBlueprint] Name of a field
+      # @return [Boolean] matching fields
+      def ==(other)
+        to_hash == other.to_hash
+      end
     end
   end
 end