gooddata 0.6.18 → 0.6.19

data/lib/gooddata/models/blueprint/anchor_field.rb

@@ -0,0 +1,46 @@
+# encoding: UTF-8
+
+require_relative 'attribute_field'
+
+module GoodData
+  module Model
+    class AnchorBlueprintField < AttributeBlueprintField
+      # Returns true if it is an anchor
+      #
+      # @return [Boolean] returns true
+      def anchor?
+        true
+      end
+
+      # Removes all the labels from the anchor. This is a typical operation that people want to perform
+      #
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def strip!
+        dataset_blueprint.strip_anchor!
+      end
+
+      # Alias for strip!. Removes all the labels from the anchor. This is a typical operation that people want to perform
+      #
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def remove!
+        strip!
+      end
+
+      # Returns labels for anchor or empty array if there are none
+      #
+      # @return [Array<GoodData::Model::LabelBlueprintField>] Returns list of labels
+      def labels
+        dataset_blueprint.labels_for_attribute(self)
+      end
+
+      # Validates the field for presence of mandatory fields
+      #
+      # @return [Array<Hash>] Returns list of errors as hashes
+      def validate
+        validate_presence_of(:id).map do |e|
+          { type: :error, message: "Field \"#{e}\" is not defined or empty for anchor \"#{id}\"" }
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/models/blueprint/attribute_field.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+require_relative 'blueprint_field'
+
+module GoodData
+  module Model
+    class AttributeBlueprintField < BlueprintField
+      # Returns list of labels on the attribute. There has to be always at least one attribute
+      #
+      # @return [Array] returns list of the errors represented by hash structures
+      def labels
+        @dataset_blueprint.labels_for_attribute(self)
+      end
+
+      # Validates the fields in the attribute
+      #
+      # @return [Array] returns list of the errors represented by hash structures
+      def validate
+        validate_presence_of(:id).map do |e|
+          { type: :error, message: "Field \"#{e}\" is not defined or empty for attribute \"#{id}\"" }
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/models/blueprint/blueprint.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+
+require 'pathname'
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  require file
+end

data/lib/gooddata/models/blueprint/blueprint_field.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+
+module GoodData
+  module Model
+    class BlueprintField
+      attr_reader :dataset_blueprint, :data
+
+      def id
+        @data[:id]
+      end
+
+      def initialize(data, dataset)
+        @data = data.symbolize_keys
+        @data[:type] = @data[:type].to_sym
+        @dataset_blueprint = dataset
+      end
+
+      # Returns the md object in associated project or throws error if not present
+      #
+      # @return [GoodData::MdObject] md object that is represented in the blueprint
+      def in_project(project)
+        GoodData::MdObject[id, project: project, client: project.client]
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        if @data.key?(method_sym)
+          @data[method_sym]
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_sym, *arguments, &block)
+        if @data.key?(method_sym)
+          true
+        else
+          super
+        end
+      end
+
+      def title
+        @data[:title] || @data[:id].titleize
+      end
+
+      # Validates the fields in the field
+      #
+      # @return [Array] returns list of the errors represented by hash structures
+      def validate
+        []
+      end
+
+      def ==(other)
+        return false unless other.respond_to?(:data)
+        @data == other.data
+      end
+
+      private
+
+      def validate_presence_of(*fields)
+        fields.reduce([]) do |a, e|
+          data.key?(e) && !data[e].blank? ? a : a + [e]
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/models/{schema_blueprint.rb → blueprint/dataset_blueprint.rb}

@@ -1,11 +1,11 @@
 # encoding: UTF-8
 
 require_relative 'schema_builder'
+require_relative 'schema_blueprint'
 
 module GoodData
   module Model
-    class DatasetBlueprint
-      attr_accessor :data
+    class DatasetBlueprint < SchemaBlueprint
       # Checks if a dataset has an anchor.
       #
       # @param dataset [Hash] Dataset blueprint
@@ -19,7 +19,7 @@ module GoodData
       # @param dataset [Hash] Dataset blueprint
       # @return [Hash] returns the anchor or nil
       def self.anchor(dataset)
-        find_column_by_type(dataset, :anchor, :first)
+        find_column_by_type(dataset, :anchor)
       end
 
       # Returns attributes of a dataset
@@ -27,7 +27,15 @@ module GoodData
       # @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)
+        find_columns_by_type(dataset, :attribute, :all)
+      end
+
+      # Returns attributes and anchor defined on a dataset
+      #
+      # @param dataset [Hash] Dataset blueprint
+      # @return [Array<Hash>] returns the attributes
+      def self.attributes_and_anchors(dataset)
+        [anchor(dataset)] + attributes(dataset)
       end
 
       # Returns all labels that is referenced by a label
@@ -35,7 +43,7 @@ module GoodData
       # @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] }
+        find_columns_by_type(dataset, :attribute, :anchor).find { |a| label[:reference] == a[:id] }
       end
 
       # Returns all the fields of a dataset. This means facts, attributes, references
@@ -43,7 +51,7 @@ module GoodData
       # @param ds [Hash] Dataset blueprint
       # @return [Boolean]
       def self.columns(ds)
-        ds[:columns] || []
+        (ds.to_hash[:columns] || [])
       end
       singleton_class.send(:alias_method, :fields, :columns)
 
@@ -67,7 +75,7 @@ module GoodData
       # @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)
+        find_column_by_type(dataset, :date_fact)
       end
 
       # Returns label that is marked as default for a particular attribtue.
@@ -78,7 +86,7 @@ module GoodData
       # @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
+        default_label
       end
 
       # Returns facts of a dataset
@@ -86,7 +94,7 @@ module GoodData
       # @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)
+        find_columns_by_type(dataset, :fact, :date_fact)
       end
 
       # Finds a specific column given a name
@@ -96,33 +104,32 @@ module GoodData
       # @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)
+      def self.find_column_by_id(dataset, name, all = nil)
         if all == :all
-          columns(dataset).select { |c| c[:name].to_s == name }
+          columns(dataset).select { |c| c[:id].to_s == name }
         else
-          columns(dataset).find { |c| c[:name].to_s == name }
+          columns(dataset).find { |c| c[:id].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.
+      # Returns first field of a specified 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
+      # @param dataset [Hash | GoodData::Model::ProjectBlueprint] Dataset blueprint
+      # @param types [String | Symbol | Array[Symbol] | Array[String]] Type or types you would like to get
       # 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
+      def self.find_column_by_type(dataset, *types)
+        columns(dataset).find { |c| types.any? { |t| t.to_s == c[:type].to_s } }
+      end
+
+      # Returns all the fields of a specified type. You can specify more types
+      # if you need more than one type.
+      #
+      # @param dataset [Hash | GoodData::Model::ProjectBlueprint] Dataset blueprint
+      # @param types [String | Symbol | Array[Symmbol] | Array[String]] Type or types you would like to get
+      # @return [Array<Hash>] matching fields
+      def self.find_columns_by_type(dataset, *types)
+        columns(dataset).select { |c| types.any? { |t| t.to_s == c[:type].to_s } }
       end
 
       # Returns labels facts of a dataset
@@ -130,7 +137,7 @@ module GoodData
       # @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)
+        find_columns_by_type(dataset, :label)
       end
 
       # Returns labels for a particular attribute
@@ -139,7 +146,7 @@ module GoodData
       # @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] }
+        labels(dataset).select { |l| l[:reference] == attribute[:id] }
       end
 
       # Returns references of a dataset
@@ -147,39 +154,43 @@ module GoodData
       # @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)
+        find_columns_by_type(dataset, :reference, :date)
       end
 
       # Returns anchor of a dataset
       #
       # @return [Hash] returns the anchor or nil
       def anchor
-        find_column_by_type(:anchor, :first)
+        find_column_by_type(:anchor)
       end
 
       # 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' }
+        columns.any? { |c| c.type == :anchor }
       end
 
       # Returns attributes of a dataset
       #
       # @return [Array<Hash>] returns the attribute or an empty array
-      def attributes
-        DatasetBlueprint.attributes(to_hash)
+      def attributes(id = :all)
+        return id if id.is_a?(AttributeBlueprintField)
+        ats = find_columns_by_type(:attribute)
+        id == :all ? ats : ats.find { |a| a.id == id }
       end
 
+      # Returns attributes and anchor defined on a dataset
+      #
+      # @return [Array<GoodData::Model::DatasetBlueprint>] returns the attributes
       def attributes_and_anchors
-        anchor? ? attributes + [anchor] : attributes
+        attributes + [anchor]
       end
 
-      # Changes the dataset through a builder. You provide a block with an istance of
-      # GoodData::Model::SchemaBuilder and you
+      # Changes the dataset through a builder. You provide a block and an istance of
+      # GoodData::Model::SchemaBuilder is passed in as the only parameter
       #
-      # @param dataset [Hash] Dataset blueprint
-      # @return [Array<Hash>] returns the labels or an empty array
+      # @return [GoodData::Model::SchemaBlueprint] returns changed dataset blueprint
       def change(&block)
         builder = SchemaBuilder.create_from_data(self)
         block.call(builder)
@@ -187,11 +198,29 @@ module GoodData
         self
       end
 
-      # Returns all the fields of a dataset. This means facts, attributes, references
+      # Returns all the fields of a dataset. This means anchor, facts, attributes, references
+      # This method will cast them to correct types
       #
       # @return [Boolean]
       def columns
-        DatasetBlueprint.columns(to_hash)
+        DatasetBlueprint.columns(to_hash).map do |c|
+          case c[:type].to_sym
+          when :anchor
+            GoodData::Model::AnchorBlueprintField.new(c, self)
+          when :attribute
+            GoodData::Model::AttributeBlueprintField.new(c, self)
+          when :fact
+            GoodData::Model::FactBlueprintField.new(c, self)
+          when :label
+            GoodData::Model::LabelBlueprintField.new(c, self)
+          when :reference
+            GoodData::Model::ReferenceBlueprintField.new(c, self)
+          when :date
+            GoodData::Model::ReferenceBlueprintField.new(c, self)
+          else
+            GoodData::Model::BlueprintField.new(c, self)
+          end
+        end
       end
       alias_method :fields, :columns
 
@@ -200,87 +229,99 @@ module GoodData
       #
       # @return [Boolean]
       def count(project)
-        id = if anchor?
-               GoodData::Model.identifier_for(to_hash, anchor)
-             else
-               GoodData::Model.identifier_for(to_hash, type: :anchor_no_label)
-             end
-        attribute = project.attributes(id)
-        attribute.create_metric.execute
+        anchor.in_project(project).create_metric.execute
       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)
+        find_columns_by_type(:date_fact)
       end
 
       # Duplicates the DatasetBlueprint. It is done as a deep duplicate
       #
       # @return [GoodData::Model::DatasetBlueprint] matching fields
       def dup
-        DatasetBlueprint.new(data.deep_dup)
+        DatasetBlueprint.new(data.deep_dup, project_blueprint)
       end
 
-      # Compares two blueprints. This is done by comapring the hash represenatation.
-      # It has to be exacty identical including the order of the columns
+      # Returns facts of a dataset
       #
-      # @param name [GoodData::Model::DatasetBlueprint] Name of a field
-      # @return [Boolean] matching fields
-      def eql?(other)
-        to_hash == other.to_hash
+      # @return [Array<Hash>] returns the attribute or an empty array
+      def facts(id = :all)
+        return id if id.is_a?(FactBlueprintField)
+        fs = find_columns_by_type(:fact)
+        id == :all ? fs : fs.find { |a| a.id == id }
       end
 
-      # Returns facts of a dataset
+      # Finds a specific column given a col
       #
-      # @return [Array<Hash>] returns the attribute or an empty array
-      def facts
-        DatasetBlueprint.facts(to_hash)
+      # @param col [GoodData::Model::BlueprintField | Hash] Field
+      # @return [GoodData::Model::BlueprintField] matching fields
+      def find_column(col)
+        columns.find { |c| c == col }
       end
 
-      # Finds a specific column given a name
+      # Finds a specific column given an id
       #
-      # @param name [String] Name of a field
+      # @param id [String] Id 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)
+      def find_column_by_id(id)
+        id = id.respond_to?(:id) ? id.id : id
+        columns.find { |c| c.id == id }
       end
 
-      # Returns all the fields of a specified type. You can specify more types
-      # as an array if you need more than one type.
+      # Returns first field of a specified 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)
+      # @return [GoodData::Model::BlueprintField] returns matching field
+      def find_column_by_type(*types)
+        columns.find { |c| types.any? { |t| t.downcase.to_sym == c.type } }
       end
 
-      # Returns identifier for dataset
+      # Returns all the fields of a specified type. You can specify more types
+      # as an array if you need more than one type.
       #
-      # @return [String] identifier
-      def identifier
-        GoodData::Model.identifier_for(to_hash)
+      # @param type [String | Symbol | Array[Symmbol] | Array[String]] Type or types you would like to get
+      # as third parameter it return all object otherwise it returns the first one
+      # @return [Array<GoodData::Model::BlueprintField>] matching fields
+      def find_columns_by_type(*types)
+        columns.select { |c| types.any? { |t| t.downcase.to_sym == c.type } }
       end
 
       # Creates a DatasetBlueprint
       #
       # @param dataset [Hash] Dataset blueprint
       # @return [DatasetBlueprint] returns the labels or an empty array
-      def initialize(init_data)
-        @data = init_data
+      def initialize(init_data, blueprint)
+        super
+        @data[:type] = @data.key?('type') ? @data['type'].to_sym : @data[:type]
+        @data[:columns].each do |c|
+          c[:type] = c[:type].to_sym
+        end
       end
 
       # 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)
+      def labels(id = :all)
+        return id if id.is_a?(LabelBlueprintField)
+        labs = find_columns_by_type(:label)
+        id == :all ? labs : labs.find { |l| l.id == id }
+      end
+
+      def attribute_for_label(label)
+        l = labels(label)
+        attributes_and_anchors.find { |a| a.id == l.reference }
+      end
+
+      def labels_for_attribute(attribute)
+        a = attributes(attribute)
+        labels.select { |l| l.reference == a.id }
       end
 
       # Merges two schemas together. This method changes the blueprint
@@ -295,18 +336,26 @@ module GoodData
         self
       end
 
-      # Returns name of the dataset
-      #
-      # @return [String]
-      def name
-        data[:name]
-      end
-
       # Returns references of a dataset
       #
       # @return [Array<Hash>] returns the references or an empty array
       def references
-        DatasetBlueprint.references(to_hash)
+        find_columns_by_type(:reference, :date)
+      end
+
+      # Removes column from from the blueprint
+      #
+      # @param id [String] Id of the column to be removed
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def remove_column!(id)
+        @project_blueprint.remove_column!(self, id)
+      end
+
+      # Removes all the labels from the anchor. This is a typical operation that people want to perform
+      #
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def strip_anchor!
+        @project_blueprint.strip_anchor!(self)
       end
 
       # Method for suggest a couple of metrics that might get you started
@@ -323,43 +372,62 @@ module GoodData
         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
+      def to_blueprint
+        GoodData::Model::ProjectBlueprint.new(datasets: [to_hash])
+      end
+
+      # Validate the blueprint return array of errors that are found.
       #
-      # @return [String]
-      def title
-        data[:title] || name.titleize
+      # @return [Array] array of errors
+      def validate
+        errors = []
+        errors.concat(validate_more_anchors)
+        errors.concat(validate_some_anchors)
+        errors.concat(validate_label_references)
+        errors.concat(validate_gd_data_type_errors)
+        errors.concat(fields.flat_map(&:validate))
+        errors.concat(validate_attribute_has_one_label)
+        errors
       end
 
-      # Returns hash representation which is much better suited for processing
+      # Validate if the dataset has more than zero anchors defined.
       #
-      # @return [Hash]
-      def to_hash
-        data
+      # @return [Array] array of errors
+      def validate_some_anchors
+        find_columns_by_type(:anchor).count == 0 ? [{ type: :no_anchor, dataset: id }] : []
       end
 
-      # Validate the blueprint return array of errors that are found.
+      # Validate if the dataset does not have more than one anchor defined.
       #
       # @return [Array] array of errors
-      def validate
-        more_than_one_anchor = find_column_by_type(:anchor, :all).count > 1 ? [{ :anchor => 2 }] : []
-        validate_label_references.concat(more_than_one_anchor)
+      def validate_more_anchors
+        find_columns_by_type(:anchor).count > 1 ? [{ type: :more_than_on_anchor, dataset: id }] : []
       end
 
-      # Validate the blueprint and return true if model is valid. False otherwise.
+      # Validate if the attribute does have at least one label
       #
-      # @return [Boolean] is model valid?
-      def valid?
-        validate.empty?
+      # @return [Array] array of errors
+      def validate_attribute_has_one_label
+        find_columns_by_type(:attribute)
+          .select { |a| a.labels.empty? }
+          .map { |e| { type: :attribute_without_label, attribute: e.id } }
       end
 
       # Validate the that any labels are pointing to the existing attribute. If not returns the list of errors. Currently just violating labels.
       #
       # @return [Array] array of errors
       def validate_label_references
-        labels.select do |label|
-          find_column_by_name(label[:reference]).empty?
-        end
+        labels.select { |r| r.attribute.nil? }
+          .map { |er_ref| { type: :wrong_label_reference, label: er_ref.id, wrong_reference: er_ref.data[:reference] } }
+      end
+
+      # Validate the the used gd_data_types are one of the allowed types. The data types are checked on lables and facts.
+      #
+      # @return [Array] array of errors
+      def validate_gd_data_type_errors
+        (labels + facts)
+          .select { |x| x.gd_data_type && !GoodData::Model.check_gd_data_type(x.gd_data_type) }
+          .map { |e| { :error => :invalid_gd_data_type_specified, :column => e.id } }
       end
 
       # Helper methods to decide wheather the dataset is considered wide.
@@ -370,15 +438,6 @@ module GoodData
       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