gooddata 0.6.18 → 0.6.19

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

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+require_relative 'schema_blueprint'
+
+module GoodData
+  module Model
+    class DateDimension < GoodData::Model::SchemaBlueprint
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+require_relative 'blueprint_field'
+
+module GoodData
+  module Model
+    class FactBlueprintField < BlueprintField
+      # Returns gd_data_type
+      #
+      # @return [String] returns gd_data_type of the fact
+      def gd_data_type
+        data[:gd_data_type] || Model::DEFAULT_FACT_DATATYPE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+require_relative 'blueprint_field'
+
+module GoodData
+  module Model
+    class LabelBlueprintField < BlueprintField
+      # Returns the attribute this label is referencing to
+      #
+      # @return [AttributeBlueprintField] the object representing attribute in the blueprint
+      def attribute
+        dataset_blueprint.attribute_for_label(self)
+      end
+
+      # Returns gd_data_type
+      #
+      # @return [String] returns gd_data_type of the label
+      def gd_data_type
+        data[:gd_data_type] || Model::DEFAULT_ATTRIBUTE_DATATYPE
+      end
+
+      # Returns gd_data_type
+      #
+      # @return [String] returns gd_type of the label
+      def gd_type
+        data[:gd_type] || Model::DEFAULT_TYPE
+      end
+
+      # Validates the fields in the label
+      #
+      # @return [Array] returns list of the errors represented by hash structures
+      def validate
+        validate_presence_of(:id, :reference).map do |e|
+          { type: :error, message: "Field \"#{e}\" is not defined or empty for label \"#{id}\"" }
+        end
+      end
+    end
+  end
+end

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

@@ -29,14 +29,27 @@ module GoodData
         end
       end
 
+      # Removes column from from the blueprint
+      #
+      # @param project [Hash | GoodData::Model::ProjectBlueprint] Project blueprint
+      # @param dataset [Hash | GoodData::Model::DatasetBlueprint] Dataset blueprint
+      # @param column_id [String] Column id
+      # @return [Hash | GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def self.remove_column!(project, dataset, column_id)
+        dataset = find_dataset(project, dataset)
+        col = dataset[:columns].find { |c| c[:id] == column_id }
+        dataset[:columns].delete(col)
+        project
+      end
+
       # Removes dataset from blueprint. Dataset can be given as either a name
       # or a DatasetBlueprint or a Hash representation.
       #
-      # @param project [Hash] Project blueprint
+      # @param project [Hash | GoodData::Model::ProjectBlueprint] Project blueprint
       # @param dataset_name [GoodData::Model::DatasetBlueprint | String | Hash] Dataset to be removed
-      # @return [Hash] project with removed dataset
-      def self.remove_dataset(project, dataset_name)
-        dataset = dataset_name.is_a?(String) ? find_dataset(project, dataset_name) : dataset_name
+      # @return [Hash] new project with removed dataset
+      def self.remove_dataset(project, dataset_id)
+        dataset = dataset_id.is_a?(String) ? find_dataset(project, dataset_id) : dataset_name
         index = project[:datasets].index(dataset)
         dupped_project = project.deep_dup
         dupped_project[:datasets].delete_at(index)
@@ -47,11 +60,12 @@ module GoodData
       # or a DatasetBlueprint or a Hash representation. This version mutates
       # the dataset in place
       #
-      # @param project [Hash] Project blueprint
+      # @param project [Hash | GoodData::Model::ProjectBlueprint] Project blueprint
       # @param dataset_name [GoodData::Model::DatasetBlueprint | String | Hash] Dataset to be removed
       # @return [Hash] project with removed dataset
-      def self.remove_dataset!(project, dataset_name)
-        dataset = dataset_name.is_a?(String) ? find_dataset(project, dataset_name) : dataset_name
+      def self.remove_dataset!(project, dataset_id)
+        project = project.to_hash
+        dataset = dataset_id.is_a?(String) ? find_dataset(project, dataset_id) : dataset_id
         index = project[:datasets].index(dataset)
         project[:datasets].delete_at(index)
         project
@@ -63,11 +77,12 @@ module GoodData
       # @param project [GoodData::Model::ProjectBlueprint | Hash] Project blueprint
       # @param options [Hash] options
       # @return [Array<Hash>]
-      def self.datasets(project, options = {})
+      def self.datasets(project_blueprint, options = {})
+        project_blueprint = project_blueprint.to_hash
         include_date_dimensions = options[:include_date_dimensions] || options[:dd]
-        ds = (project.to_hash[:datasets] || [])
+        ds = (project_blueprint.to_hash[:datasets] || [])
         if include_date_dimensions
-          ds + date_dimensions(project)
+          ds + date_dimensions(project_blueprint)
         else
           ds
         end
@@ -78,8 +93,8 @@ module GoodData
       # @param project [GoodData::Model::ProjectBlueprint | Hash] Project blueprint
       # @param name [GoodData::Model::DatasetBlueprint | String | Hash] Dataset
       # @return [Boolean]
-      def self.dataset?(project, name)
-        find_dataset(project, name)
+      def self.dataset?(project, name, options = {})
+        find_dataset(project, name, options)
         true
       rescue
         false
@@ -91,16 +106,11 @@ module GoodData
       # @param obj [GoodData::Model::DatasetBlueprint | String | Hash] Dataset
       # @param options [Hash] options
       # @return [GoodData::Model::DatasetBlueprint]
-      def self.find_dataset(project, obj, options = {})
-        include_date_dimensions = options[:include_date_dimensions] || options[:dd]
+      def self.find_dataset(project_blueprint, obj, options = {})
         return obj.to_hash if DatasetBlueprint.dataset_blueprint?(obj)
-        all_datasets = if include_date_dimensions
-                         datasets(project) + date_dimensions(project)
-                       else
-                         datasets(project)
-                       end
-        name = obj.respond_to?(:key?) ? obj[:name] : obj
-        ds = all_datasets.find { |d| d[:name] == name }
+        all_datasets = datasets(project_blueprint, options)
+        name = obj.respond_to?(:to_hash) ? obj.to_hash[:id] : obj
+        ds = all_datasets.find { |d| d[:id] == name }
         fail "Dataset #{name} could not be found" if ds.nil?
         ds
       end
@@ -109,8 +119,9 @@ module GoodData
       #
       # @param project [GoodData::Model::ProjectBlueprint | Hash] Project blueprint
       # @return [Array<Hash>]
-      def self.date_dimensions(project)
-        project.to_hash[:date_dimensions] || []
+      def self.date_dimensions(project_blueprint)
+        project_blueprint.to_hash[:date_dimensions] || []
+        # dims.map {|dim| DateDimension.new(dim, project_blueprint)}
       end
 
       # Returns true if a date dimension of a given name exists in a bleuprint
@@ -132,8 +143,8 @@ module GoodData
       # @param name [string] Date dimension
       # @return [Hash]
       def self.find_date_dimension(project, name)
-        ds = date_dimensions(project).find { |d| d[:name] == name }
-        fail "Date dimension #{name} could not be found" if ds.nil?
+        ds = date_dimensions(project).find { |d| d[:id] == name }
+        fail "Date dimension #{name} could not be found" unless ds
         ds
       end
 
@@ -145,6 +156,10 @@ module GoodData
         datasets(project).mapcat { |d| DatasetBlueprint.fields(d) }
       end
 
+      # Changes the dataset through a builder. You provide a block and an istance of
+      # GoodData::Model::ProjectBuilder is passed in as the only parameter
+      #
+      # @return [GoodData::Model::ProjectBlueprint] returns changed project blueprint
       def change(&block)
         builder = ProjectBuilder.create_from_data(self)
         block.call(builder)
@@ -157,34 +172,132 @@ module GoodData
       #
       # @param options [Hash] options
       # @return [Array<GoodData::Model::DatasetBlueprint>]
-      def datasets(options = {})
-        ProjectBlueprint.datasets(to_hash, options).map { |d| DatasetBlueprint.new(d) }
+      def datasets(id = :all, options = {})
+        id = id.respond_to?(:id) ? id.id : id
+        dss = ProjectBlueprint.datasets(self, options).map do |d|
+          case d[:type]
+          when :date_dimension
+            DateDimension.new(d, self)
+          when :dataset
+            DatasetBlueprint.new(d, self)
+          end
+        end
+        id == :all ? dss : dss.find { |d| d.id == id }
       end
 
+      # Adds dataset to the blueprint
+      #
+      # @param a_dataset [Hash | GoodData::Model::SchemaBlueprint] dataset to be added
+      # @param index [Integer] number specifying at which position the new dataset should be added. If not specified it is added at the end
+      # @return [GoodData::Model::ProjectBlueprint] returns project blueprint
       def add_dataset!(a_dataset, index = nil)
         if index.nil? || index > datasets.length
           data[:datasets] << a_dataset.to_hash
         else
           data[:datasets].insert(index, a_dataset.to_hash)
         end
+        self
       end
 
-      # Removes dataset from blueprint. Dataset can be given as either a name
-      # or a DatasetBlueprint or a Hash representation.
+      def add_date_dimension!(a_dimension, index = nil)
+        dim = a_dimension.to_hash
+        if index.nil? || index > date_dimensions.length
+          data[:date_dimensions] << dim
+        else
+          data[:date_dimensions].insert(index, dim)
+        end
+        self
+      end
+
+      # Adds column to particular dataset in the blueprint
       #
-      # @param dataset_name [GoodData::Model::DatasetBlueprint | String | Hash] Dataset to be removed
-      # @return [Hash] project with removed dataset
-      def remove_dataset(dataset_name)
-        ProjectBlueprint.remove_dataset(to_hash, dataset_name)
+      # @param dataset [Hash | GoodData::Model::SchemaBlueprint] dataset to be added
+      # @param column_definition [Hash] Column definition to be added
+      # @return [GoodData::Model::ProjectBlueprint] returns project blueprint
+      def add_column!(dataset, column_definition)
+        ds = ProjectBlueprint.find_dataset(to_hash, dataset)
+        ds[:columns] << column_definition
+        self
       end
 
-      # Removes dataset from blueprint. Dataset can be given as either a name
-      # or a DatasetBlueprint or a Hash representation.
+      # Removes column to particular dataset in the blueprint
       #
-      # @param dataset_name [GoodData::Model::DatasetBlueprint | String | Hash] Dataset to be removed
-      # @return [Hash] project with removed dataset
-      def remove_dataset!(dataset_name)
-        ProjectBlueprint.remove_dataset!(to_hash, dataset_name)
+      # @param dataset [Hash | GoodData::Model::SchemaBlueprint] dataset to be added
+      # @param id [String] id of the column to be removed
+      # @return [GoodData::Model::ProjectBlueprint] returns project blueprint
+      def remove_column!(dataset, id)
+        ProjectBlueprint.remove_column!(to_hash, dataset, id)
+        self
+      end
+
+      # Moves column to particular dataset in the blueprint. It currently supports moving
+      # of attributes and facts only. The rest of the fields probably does not make sense
+      # In case of attribute it moves its labels as well.
+      #
+      # @param id [GoodData::Model::BlueprintField] column to be moved
+      # @param from_dataset [Hash | GoodData::Model::SchemaBlueprint] dataset from which the field should be moved
+      # @param to_dataset [Hash | GoodData::Model::SchemaBlueprint] dataset to which the field should be moved
+      # @return [GoodData::Model::ProjectBlueprint] returns project blueprint
+      def move!(col, from_dataset, to_dataset)
+        from_dataset = find_dataset(from_dataset)
+        to_dataset = find_dataset(to_dataset)
+        column = if col.is_a?(String)
+                   from_dataset.find_column_by_id(col)
+                 else
+                   from_dataset.find_column(col)
+                 end
+        fail "Column #{col} cannot be found in dataset #{from_dataset.id}" unless column
+        stuff = case column.type
+                when :attribute
+                  [column] + column.labels
+                when :fact
+                  [column]
+                when :reference
+                  [column]
+                else
+                  fail 'Duplicate does not support moving #{col.type} type of field'
+                end
+        stuff = stuff.map(&:data)
+        stuff.each { |c| remove_column!(from_dataset, c[:id]) }
+        stuff.each { |c| add_column!(to_dataset, c) }
+        self
+      end
+
+      def duplicate!(col, from_dataset, to_dataset)
+        from_dataset = find_dataset(from_dataset)
+        to_dataset = find_dataset(to_dataset)
+        column = if col.is_a?(String)
+                   from_dataset.find_column_by_id(col)
+                 else
+                   from_dataset.find_column(col)
+                 end
+        fail "Column #{col} cannot be found in dataset #{from_dataset.id}" unless column
+        stuff = case column.type
+                when :attribute
+                  [column] + column.labels
+                when :fact
+                  [column]
+                when :reference
+                  [column]
+                else
+                  fail 'Duplicate does not support moving #{col.type} type of field'
+                end
+        stuff.map(&:data).each { |c| add_column!(to_dataset, c) }
+        self
+      end
+
+      # Returns list of attributes from all the datasets in a blueprint
+      #
+      # @return [Array<Hash>]
+      def attributes
+        datasets.reduce([]) { |a, e| a.concat(e.attributes) }
+      end
+
+      # Returns list of attributes and anchors from all the datasets in a blueprint
+      #
+      # @return [Array<Hash>]
+      def attributes_and_anchors
+        datasets.mapcat(&:attributes_and_anchors)
       end
 
       # Is this a project blueprint?
@@ -198,15 +311,48 @@ module GoodData
       #
       # @return [Array<Hash>]
       def date_dimensions
-        ProjectBlueprint.date_dimensions(to_hash)
+        ProjectBlueprint.date_dimensions(self).map { |dd| GoodData::Model::DateDimension.new(dd, self) }
       end
 
       # Returns true if a dataset contains a particular dataset false otherwise
       #
       # @param name [GoodData::Model::DatasetBlueprint | String | Hash] Dataset
       # @return [Boolean]
-      def dataset?(name)
-        ProjectBlueprint.dataset?(to_hash, name)
+      def dataset?(name, options = {})
+        ProjectBlueprint.dataset?(to_hash, name, options)
+      end
+
+      # Returns SLI manifest for one dataset. This is used by our API to allow
+      # loading data. The method is on project blueprint because you need
+      # acces to whole project to be able to generate references
+      #
+      # @param dataset [GoodData::Model::DatasetBlueprint | Hash | String] Dataset
+      # @param mode [String] Method of loading. FULL or INCREMENTAL
+      # @return [Array<Hash>] a title
+      def dataset_to_manifest(dataset, mode = 'FULL')
+        ToManifest.dataset_to_manifest(self, dataset, mode)
+      end
+
+      # Duplicated blueprint
+      #
+      # @param a_blueprint [GoodData::Model::DatasetBlueprint] Dataset blueprint to be merged
+      # @return [GoodData::Model::DatasetBlueprint]
+      def dup
+        ProjectBlueprint.new(data.deep_dup)
+      end
+
+      # Returns list of facts from all the datasets in a blueprint
+      #
+      # @return [Array<Hash>]
+      def facts
+        datasets.mapcat(&:facts)
+      end
+
+      # Returns list of fields from all the datasets in a blueprint
+      #
+      # @return [Array<Hash>]
+      def fields
+        datasets.flat_map(&:fields)
       end
 
       # Returns dataset specified. It can check even for a date dimension
@@ -215,7 +361,9 @@ module GoodData
       # @param options [Hash] options
       # @return [GoodData::Model::DatasetBlueprint]
       def find_dataset(name, options = {})
-        DatasetBlueprint.new(ProjectBlueprint.find_dataset(to_hash, name, options))
+        ds = datasets(name, options)
+        fail "Dataset \"#{name}\" could not be found" unless ds
+        ds
       end
 
       # Returns a dataset of a given name. If a dataset is not found it throws an exeception
@@ -227,6 +375,15 @@ module GoodData
         DatasetBlueprint.new(ds)
       end
 
+      # Return list of datasets that are centers of the stars in datamart.
+      # This means these datasets are not referenced by anybody else
+      # In a good blueprint design these should be fact tables
+      #
+      # @return [Array<Hash>]
+      def find_star_centers
+        datasets.select { |d| d.referenced_by.empty? }
+      end
+
       # Constructor
       #
       # @param init_data [ProjectBlueprint | Hash] Blueprint or a blueprint definition. If passed a hash it is used as data for new instance. If there is a ProjectBlueprint passed it is duplicated and a new instance is created.
@@ -239,65 +396,20 @@ module GoodData
                     else
                       init_data
                     end
-        @data = some_data.deep_dup
-      end
-
-      # Validate the blueprint in particular if all references reference existing datasets and valid fields inside them.
-      #
-      # @return [Array] array of errors
-      def validate_references
-        if datasets.count == 1
-          []
-        else
-          x = datasets.reduce([]) { |a, e| e.anchor? ? a << [e.name] : a } + date_dimensions.map { |y| [y[:name]] }
-          refs = datasets.reduce([]) do |a, e|
-            a.concat(e.references)
-          end
-          refs.reduce([]) do |a, e|
-            x.include?([e[:dataset]]) ? a : a.concat([e])
+        @data = some_data.deep_dup.symbolize_keys
+        (@data[:datasets] || []).each do |d|
+          d[:type] = d[:type].to_sym
+          d[:columns].each do |c|
+            c[:type] = c[:type].to_sym
           end
         end
-      end
-
-      # Validate the blueprint and all its datasets return array of errors that are found.
-      #
-      # @return [Array] array of errors
-      def validate
-        refs_errors = validate_references
-        labels_errors = datasets.reduce([]) { |a, e| a.concat(e.validate) }
-        refs_errors.concat(labels_errors)
-      end
-
-      # Validate the blueprint and all its datasets and return true if model is valid. False otherwise.
-      #
-      # @return [Boolean] is model valid?
-      def valid?
-        validate.empty?
-      end
-
-      # Returns list of datasets which are referenced by given dataset. This can be
-      # optionally switched to return even date dimensions
-      #
-      # @param project [GoodData::Model::DatasetBlueprint | Hash | String] Dataset blueprint
-      # @return [Array<Hash>]
-      def referenced_by(dataset)
-        find_dataset(dataset, include_date_dimensions: true).references.map do |ref|
-          find_dataset(ref[:dataset], include_date_dimensions: true)
+        (@data[:date_dimensions] || []).each do |d|
+          d[:type] = d[:type].to_sym
         end
       end
 
-      # Returns list of attributes from all the datasets in a blueprint
-      #
-      # @return [Array<Hash>]
-      def attributes
-        datasets.reduce([]) { |a, e| a.concat(e.attributes) }
-      end
-
-      # Returns list of attributes and anchors from all the datasets in a blueprint
-      #
-      # @return [Array<Hash>]
-      def attributes_and_anchors
-        datasets.mapcat(&:attributes_and_anchors)
+      def id
+        data[:id]
       end
 
       # Returns list of labels from all the datasets in a blueprint
@@ -307,36 +419,6 @@ module GoodData
         datasets.mapcat(&:labels)
       end
 
-      # Returns list of facts from all the datasets in a blueprint
-      #
-      # @return [Array<Hash>]
-      def facts
-        datasets.mapcat(&:facts)
-      end
-
-      # Returns list of fields from all the datasets in a blueprint
-      #
-      # @return [Array<Hash>]
-      def fields
-        ProjectBlueprint.fields(to_hash)
-      end
-
-      # Returns list of attributes that can break facts in a given dataset.
-      # This basically means that it is giving you all attributes from the
-      # datasets that are references by given dataset. Currently does not
-      # work transitively
-      #
-      # @param project [GoodData::Model::DatasetBlueprint | Hash | String] Dataset blueprint
-      # @return [Array<Hash>]
-      def can_break(dataset)
-        dataset = find_dataset(dataset) if dataset.is_a?(String)
-        (referenced_by(dataset) + [dataset]).mapcat do |ds|
-          ds.attributes_and_anchors.map do |attr|
-            [ds, attr]
-          end
-        end
-      end
-
       # Experimental but a basis for automatic check of health of a project
       #
       # @param project [GoodData::Model::DatasetBlueprint | Hash | String] Dataset blueprint
@@ -380,16 +462,61 @@ module GoodData
         errors
       end
 
-      # Return list of datasets that are centers of the stars in datamart.
-      # This means these datasets are not referenced by anybody else
-      # In a good blueprint design these should be fact tables
+      # Merging two blueprints. The self blueprint is changed in place
       #
+      # @param a_blueprint [GoodData::Model::DatasetBlueprint] Dataset blueprint to be merged
+      # @return [GoodData::Model::ProjectBlueprint]
+      def merge!(a_blueprint)
+        temp_blueprint = merge(a_blueprint)
+        @data = temp_blueprint.data
+        self
+      end
+
+      # Returns list of datasets which are referenced by given dataset. This can be
+      # optionally switched to return even date dimensions
+      #
+      # @param project [GoodData::Model::DatasetBlueprint | Hash | String] Dataset blueprint
       # @return [Array<Hash>]
-      def find_star_centers
-        referenced = datasets.mapcat { |d| referenced_by(d) }
-        referenced.flatten!
-        res = datasets.map(&:to_hash) - referenced.map(&:to_hash)
-        res.map { |d| DatasetBlueprint.new(d) }
+      def referenced_by(dataset)
+        find_dataset(dataset, include_date_dimensions: true).referencing
+      end
+
+      def referencing(dataset)
+        datasets(:all, include_date_dimensions: true)
+          .flat_map(&:references)
+          .select { |r| r.dataset == dataset }
+          .map(&:dataset_blueprint)
+      end
+
+      # Removes dataset from blueprint. Dataset can be given as either a name
+      # or a DatasetBlueprint or a Hash representation.
+      #
+      # @param dataset_name [GoodData::Model::DatasetBlueprint | String | Hash] Dataset to be removed
+      # @return [Hash] project with removed dataset
+      def remove_dataset(dataset_name)
+        ProjectBlueprint.remove_dataset(to_hash, dataset_name)
+        self
+      end
+
+      # Removes dataset from blueprint. Dataset can be given as either a name
+      # or a DatasetBlueprint or a Hash representation.
+      #
+      # @param dataset_name [GoodData::Model::DatasetBlueprint | String | Hash] Dataset to be removed
+      # @return [Hash] project with removed dataset
+      def remove_dataset!(dataset_id)
+        ProjectBlueprint.remove_dataset!(to_hash, dataset_id)
+        self
+      end
+
+      # Removes all the labels from the anchor. This is a typical operation that people want to
+      # perform on fact tables
+      #
+      # @return [GoodData::Model::ProjectBlueprint] Returns changed blueprint
+      def strip_anchor!(dataset)
+        from_dataset = find_dataset(dataset)
+        stuff = dataset.anchor.labels.map(&:data)
+        stuff.each { |column| remove_column!(from_dataset, column[:id]) }
+        self
       end
 
       # Returns some reports that might get you started. They are just simple
@@ -405,8 +532,7 @@ module GoodData
             star, metrics = e
             metrics.each(&:save)
             reports_stubs = metrics.map do |m|
-              breaks = can_break(star).map { |ds, aM| ds.identifier_for(aM) }
-              # [breaks.sample((breaks.length/10.0).ceil), m]
+              breaks = broken_by(star).map { |ds, aM| ds.identifier_for(aM) }
               [breaks, m]
             end
             a.concat(reports_stubs)
@@ -435,13 +561,41 @@ module GoodData
         stars.zip(metrics)
       end
 
-      # Merging two blueprints. The self blueprint is changed in place
-      #
-      # @param a_blueprint [GoodData::Model::DatasetBlueprint] Dataset blueprint to be merged
-      # @return [GoodData::Model::ProjectBlueprint]
-      def merge!(a_blueprint)
-        temp_blueprint = merge(a_blueprint)
-        @data = temp_blueprint.data
+      def to_blueprint
+        self
+      end
+
+      def refactor_split_df(dataset)
+        fail ValidationError unless valid?
+        o = find_dataset(dataset)
+        new_dataset = GoodData::Model::DatasetBlueprint.new({ type: :dataset, id: "#{o.id}_dim", columns: [] }, self)
+        new_dataset.change do |d|
+          d.add_anchor('vymysli_id')
+          d.add_label('label.vymysli_id', reference: 'vymysli_id')
+        end
+        nb = merge(new_dataset.to_blueprint)
+        o.attributes.each { |a| nb.move!(a, o, new_dataset.id) }
+        old = nb.find_dataset(dataset)
+        old.attributes.each do |a|
+          remove_column!(old, a)
+        end
+        old.change do |d|
+          d.add_reference(new_dataset.id)
+        end
+        nb
+      end
+
+      def refactor_split_facts(dataset, column_names, new_dataset_title)
+        fail ValidationError unless valid?
+        change do |p|
+          p.add_dataset(new_dataset_title) do |d|
+            d.add_anchor("#{new_dataset_title}.id")
+          end
+        end
+        dataset_to_refactor = find_dataset(dataset)
+        new_dataset = find_dataset(new_dataset_title)
+        column_names.each { |c| move!(c, dataset_to_refactor, new_dataset) }
+        dataset_to_refactor.references.each { |ref| duplicate!(ref, dataset_to_refactor, new_dataset) }
         self
       end
 
@@ -454,32 +608,48 @@ module GoodData
         temp_blueprint = dup
         return temp_blueprint unless a_blueprint
         a_blueprint.datasets.each do |dataset|
-          if temp_blueprint.dataset?(dataset.name)
-            local_dataset = temp_blueprint.find_dataset(dataset.name)
+          if temp_blueprint.dataset?(dataset.id)
+            local_dataset = temp_blueprint.find_dataset(dataset.id)
             index = temp_blueprint.datasets.index(local_dataset)
             local_dataset.merge!(dataset)
-            temp_blueprint.remove_dataset!(local_dataset.name)
+            temp_blueprint.remove_dataset!(local_dataset.id)
             temp_blueprint.add_dataset!(local_dataset, index)
           else
             temp_blueprint.add_dataset!(dataset.dup)
           end
         end
+        a_blueprint.date_dimensions.each do |dd|
+          if temp_blueprint.dataset?(dd.id, dd: true)
+            local_dim = temp_blueprint.find_dataset(dd.id, dd: true)
+            fail "Unable to merge date dimensions #{dd.id} with defintion #{dd.data} with #{local_dim.data}" unless local_dim.data == dd.data
+          else
+            temp_blueprint.add_date_dimension!(dd.dup)
+          end
+        end
         temp_blueprint
       end
 
-      # Duplicated blueprint
+      # Helper for storing the project blueprint into a file as JSON.
       #
-      # @param a_blueprint [GoodData::Model::DatasetBlueprint] Dataset blueprint to be merged
-      # @return [GoodData::Model::DatasetBlueprint]
-      def dup
-        ProjectBlueprint.new(data.deep_dup)
+      # @param filename [String] Name of the file where the blueprint should be stored
+      def store_to_file(filename)
+        File.open(filename, 'w') do |f|
+          f << JSON.pretty_generate(to_hash)
+        end
       end
 
       # Returns title of a dataset. If not present it is generated from the name
       #
       # @return [String] a title
       def title
-        Model.title(to_hash)
+        Model.title(to_hash) if to_hash[:title]
+      end
+
+      # Returns title of a dataset. If not present it is generated from the name
+      #
+      # @return [String] a title
+      def title=(a_title)
+        @data[:title] = a_title
       end
 
       # Returns Wire representation. This is used by our API to generate and
@@ -487,6 +657,7 @@ module GoodData
       #
       # @return [Hash] a title
       def to_wire
+        validate
         ToWire.to_wire(data)
       end
 
@@ -495,20 +666,10 @@ module GoodData
       #
       # @return [Array<Hash>] a title
       def to_manifest
+        validate
         ToManifest.to_manifest(to_hash)
       end
 
-      # Returns SLI manifest for one dataset. This is used by our API to allow
-      # loading data. The method is on project blueprint because you need
-      # acces to whole project to be able to generate references
-      #
-      # @param dataset [GoodData::Model::DatasetBlueprint | Hash | String] Dataset
-      # @param mode [String] Method of loading. FULL or INCREMENTAL
-      # @return [Array<Hash>] a title
-      def dataset_to_manifest(dataset, mode = 'FULL')
-        ToManifest.dataset_to_manifest(self, dataset, mode)
-      end
-
       # Returns hash representation of blueprint
       #
       # @return [Hash] a title
@@ -516,12 +677,49 @@ module GoodData
         @data
       end
 
-      def ==(other)
-        to_hash == other.to_hash
+      # Validate the blueprint in particular if all references reference existing datasets and valid fields inside them.
+      #
+      # @return [Array] array of errors
+      def validate_references
+        stuff = datasets(:all, include_date_dimensions: true).flat_map(&:references).select do |ref|
+          begin
+            ref.dataset
+            false
+          rescue RuntimeError
+            true
+          end
+        end
+        stuff.map { |r| { type: :bad_reference, reference: r.data, referencing_dataset: r.data[:dataset] } }
+      end
+
+      # Validate the blueprint and all its datasets return array of errors that are found.
+      #
+      # @return [Array] array of errors
+      def validate
+        errors = []
+        errors.concat validate_references
+        errors.concat datasets.reduce([]) { |a, e| a.concat(e.validate) }
+        errors.concat datasets.reduce([]) { |a, e| a.concat(e.validate_gd_data_type_errors) }
+        errors
+      rescue
+        raise GoodData::ValidationError
+      end
+
+      # Validate the blueprint and all its datasets and return true if model is valid. False otherwise.
+      #
+      # @return [Boolean] is model valid?
+      def valid?
+        validate.empty?
       end
 
-      def eql?(other)
-        to_hash == other.to_hash
+      def ==(other)
+        # to_hash == other.to_hash
+        return false unless id == other.id
+        return false unless title == other.title
+        left = to_hash[:datasets].map { |d| d[:columns].to_set }.to_set
+        right = other.to_hash[:datasets].map { |d| d[:columns].to_set }.to_set
+        return false unless left == right
+        true
       end
     end
   end