gooddata 0.6.0 → 0.6.2

data/lib/gooddata/models/metadata/report.rb

@@ -0,0 +1,115 @@
+# encoding: UTF-8
+
+require_relative '../metadata'
+require_relative 'metadata'
+
+module GoodData
+  class Report < GoodData::MdObject
+    root_key :report
+
+    class << self
+      def [](id, options = {})
+        if id == :all
+          fail 'You have to specify a project ID' if GoodData.project.nil?
+          uri = GoodData.project.md['query'] + '/reports/'
+          GoodData.get(uri)['query']['entries']
+        else
+          super
+        end
+      end
+
+      def create(options = {})
+        title = options[:title]
+        summary = options[:summary] || ''
+        rd = options[:rd] || ReportDefinition.create(:top => options[:top], :left => options[:left])
+        rd.save
+
+        report = {
+          'report' => {
+            'content' => {
+              'domains' => [],
+              'definitions' => [rd.uri]
+            },
+            'meta' => {
+              'tags' => '',
+              'deprecated' => '0',
+              'summary' => summary,
+              'title' => title
+            }
+          }
+        }
+        # TODO: write test for report definitions with explicit identifiers
+        report['report']['meta']['identifier'] = options[:identifier] if options[:identifier]
+        Report.new report
+      end
+    end
+
+    def results
+      content['results']
+    end
+
+    def definitions
+      content['definitions']
+    end
+
+    def latest_report_definition_uri
+      definitions.last
+    end
+
+    def latest_report_definition
+      GoodData::MdObject[latest_report_definition_uri]
+    end
+
+    def remove_definition(definition)
+      def_uri = is_a?(GoodData::ReportDefinition) ? definition.uri : definition
+      content['definitions'] = definitions.reject { |x| x == def_uri }
+      self
+    end
+
+    # TODO: Cover with test. You would probably need something that will be able to create a report easily from a definition
+    def remove_definition_but_latest
+      to_remove = definitions - [latest_report_definition_uri]
+      to_remove.each do |uri|
+        remove_definition(uri)
+      end
+      self
+    end
+
+    def purge_report_of_unused_definitions!
+      full_list = definitions
+      remove_definition_but_latest
+      purged_list = definitions
+      to_remove = full_list - purged_list
+      save
+      to_remove.each { |uri| GoodData.delete(uri) }
+      self
+    end
+
+    def execute
+      fail 'You have to save the report before executing. If you do not want to do that please use GoodData::ReportDefinition' unless saved?
+      result = GoodData.post '/gdc/xtab2/executor3', 'report_req' => { 'report' => uri }
+      data_result_uri = result['execResult']['dataResult']
+      result = GoodData.get data_result_uri
+      while result['taskState'] && result['taskState']['status'] == 'WAIT'
+        sleep 10
+        result = GoodData.get data_result_uri
+      end
+      ReportDataResult.new(GoodData.get data_result_uri)
+    end
+
+    def exportable?
+      true
+    end
+
+    def export(format)
+      result = GoodData.post('/gdc/xtab2/executor3', 'report_req' => { 'report' => uri })
+      result1 = GoodData.post('/gdc/exporter/executor', :result_req => { :format => format, :result => result })
+      png = GoodData.get(result1['uri'], :process => false)
+      while png.code == 202
+        sleep(1)
+        png = GoodData.get(result1['uri'], :process => false)
+      end
+      png
+    end
+  end
+end

data/lib/gooddata/models/{report_definition.rb → metadata/report_definition.rb}

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 
+require_relative '../metadata'
 require_relative 'metadata'
 
 # GoodData Module
@@ -10,7 +11,7 @@ module GoodData
     root_key :reportDefinition
 
     class << self
-      def [](id)
+      def [](id, options = {})
         if id == :all
           uri = GoodData.project.md['query'] + '/reportdefinition/'
           result = GoodData.get(uri)
@@ -22,7 +23,7 @@ module GoodData
 
       def create_metrics_part(left, top)
         stuff = Array(left) + Array(top)
-        stuff.select { |item| item.respond_to?(:is_metric?) }.map do |metric|
+        stuff.select { |item| item.respond_to?(:metric?) && item.metric? }.map do |metric|
           create_metric_part(metric)
         end
       end
@@ -47,14 +48,14 @@ module GoodData
       def create_part(stuff)
         stuff = Array(stuff)
         parts = stuff.reduce([]) do |memo, item|
-          if item.respond_to?(:is_metric?)
+          if item.respond_to?(:metric?) && item.metric?
             memo
           else
             memo << create_attribute_part(item)
           end
           memo
         end
-        if stuff.any? { |item| item.respond_to?(:is_metric?) }
+        if stuff.any? { |item| item.respond_to?(:metric?) && item.metric? }
           parts << 'metricGroup'
         end
         parts
@@ -62,7 +63,7 @@ module GoodData
 
       def find(stuff)
         stuff.map do |item|
-          if item.respond_to?(:is_attribute?)
+          if item.respond_to?(:attribute?) && item.attribute?
             item.display_forms.first
           elsif item.is_a?(String)
             x = GoodData::MdObject.get_by_id(item)
@@ -112,7 +113,7 @@ module GoodData
         left = Array(options[:left])
         top = Array(options[:top])
 
-        metrics = (left + top).select { |item| item.respond_to?(:is_metric?) }
+        metrics = (left + top).select { |item| item.respond_to?(:metric?) && item.metric? }
 
         unsaved_metrics = metrics.reject { |i| i.saved? }
         unsaved_metrics.each { |m| m.title = 'Untitled metric' unless m.title }
@@ -120,7 +121,7 @@ module GoodData
         begin
           unsaved_metrics.each { |m| m.save }
           rd = GoodData::ReportDefinition.create(options)
-          get_data_result(execute_inline(rd))
+          data_result(execute_inline(rd))
         ensure
           unsaved_metrics.each { |m| m.delete if m && m.saved? }
         end
@@ -140,7 +141,11 @@ module GoodData
         GoodData.post(uri, data)
       end
 
-      def get_data_result(result)
+      # TODO: refactor the method. It should be instance method
+      # Method used for getting a data_result from a wire representation of
+      # @param result [Hash, Object] Wire data from JSON
+      # @return [GoodData::ReportDataResult]
+      def data_result(result)
         data_result_uri = result['execResult']['dataResult']
         result = GoodData.get data_result_uri
 
@@ -186,6 +191,8 @@ module GoodData
             }
           }
         }
+        # TODO: write test for report definitions with explicit identifiers
+        pars['reportDefinition']['meta']['identifier'] = options[:identifier] if options[:identifier]
 
         ReportDefinition.new(pars)
       end
@@ -204,8 +211,7 @@ module GoodData
                else
                  ReportDefinition.execute_inline(self)
                end
-
-      get_data_result(result)
+      ReportDefinition.data_result(result)
     end
   end
 end

data/lib/gooddata/models/metadata/schema.rb

@@ -0,0 +1,227 @@
+# encoding: UTF-8
+
+require_relative '../../helpers'
+
+require_relative '../attributes/anchor'
+require_relative '../columns/columns'
+require_relative '../md_object'
+
+module GoodData
+  module Model
+    ##
+    # Server-side representation of a local data set; includes connection point,
+    # attributes and labels, facts, folders and corresponding pieces of physical
+    # model abstractions.
+    #
+    class Schema < MdObject
+      attr_reader :fields, :attributes, :facts, :folders, :references, :labels, :name, :title, :anchor
+
+      def self.load(file)
+        Schema.new JSON.load(open(file))
+      end
+
+      def initialize(a_config, a_name = 'Default Name', a_title = 'Default Title')
+        super()
+        @fields = []
+        @attributes = []
+        @facts = []
+        @folders = {
+          :facts => {},
+          :attributes => {}
+        }
+        @references = []
+        @labels = []
+
+        a_config[:name] = a_name unless a_config[:name]
+        a_config[:title] = a_config[:name] unless a_config[:title]
+        a_config[:title] = a_title unless a_config[:title]
+        a_config[:title] = a_config[:title].humanize
+
+        fail 'Schema name not specified' unless a_config[:name]
+        @name = a_config[:name]
+        @title = a_config[:title]
+        self.config = (a_config)
+      end
+
+      def config=(config)
+        config[:columns].each do |c|
+          case c[:type].to_s
+          when 'attribute'
+            add_attribute c
+          when 'fact'
+            add_fact c
+          when 'date'
+            add_date c
+          when 'anchor'
+            set_anchor c
+          when 'label'
+            add_label c
+          when 'reference'
+            add_reference c
+          else
+            fail "Unexpected type #{c[:type]} in #{c.inspect}"
+          end
+        end
+        @anchor = Anchor.new(nil, self) unless @anchor
+      end
+
+      def type_prefix
+        'dataset'
+      end
+
+      ##
+      # Underlying fact table name
+      #
+      def table
+        @table ||= FACT_COLUMN_PREFIX + name
+      end
+
+      ##
+      # Generates MAQL DDL script to drop this data set and included pieces
+      #
+      def to_maql_drop
+        maql = ''
+        [attributes, facts].each do |obj|
+          maql += obj.to_maql_drop
+        end
+        maql += "DROP {#{identifier}};\n"
+      end
+
+      ##
+      # Generates MAQL DDL script to create this data set and included pieces
+      #
+      def to_maql_create
+        # TODO: Use template (.erb)
+        maql = "# Create the '#{title}' data set\n"
+        maql += "CREATE DATASET {#{identifier}} VISUAL (TITLE \"#{title}\");\n\n"
+        [attributes, facts, { 1 => @anchor }].each do |objects|
+          objects.values.each do |obj|
+            maql += "# Create '#{obj.title}' and add it to the '#{title}' data set.\n"
+            maql += obj.to_maql_create
+            maql += "ALTER DATASET {#{identifier}} ADD {#{obj.identifier}};\n\n"
+          end
+        end
+
+        labels.each do |label|
+          maql += "# Creating Labels\n"
+          maql += label.to_maql_create
+        end
+
+        references.values.each do |ref|
+          maql += "# Creating references\n"
+          maql += ref.to_maql_create
+        end
+
+        folders_maql = "# Create folders\n"
+        (folders[:attributes].values + folders[:facts].values).each { |folder| folders_maql += folder.to_maql_create }
+        folders_maql + "\n" + maql + "SYNCHRONIZE {#{identifier}};\n"
+      end
+
+      def upload(path, project = nil, mode = 'FULL')
+        if path =~ URI.regexp
+          Tempfile.open('remote_file') do |temp|
+            temp << open(path).read
+            temp.flush
+            upload_data(temp, mode)
+          end
+        else
+          upload_data(path, mode)
+        end
+      end
+
+      def upload_data(path, mode)
+        GoodData::Model.upload_data(path, to_manifest(mode))
+      end
+
+      # Generates the SLI manifest describing the data loading
+      #
+      def to_manifest(mode = 'FULL')
+        {
+          'dataSetSLIManifest' => {
+            'parts' => fields.reduce([]) do |memo, f|
+              val = f.to_manifest_part(mode)
+              memo << val unless val.nil?
+              memo
+            end,
+            'dataSet' => identifier,
+            'file' => 'data.csv', # should be configurable
+            'csvParams' => {
+              'quoteChar' => '"',
+              'escapeChar' => '"',
+              'separatorChar' => ',',
+              'endOfLine' => "\n"
+            }
+          }
+        }
+      end
+
+      def to_wire_model
+        {
+          'dataset' => {
+            'identifier' => identifier,
+            'title' => title,
+            'anchor' => @anchor.to_wire_model,
+            'facts' => facts.map { |f| f.to_wire_model },
+            'attributes' => attributes.map { |a| a.to_wire_model },
+            'references' => references.map { |r| r.is_a?(DateReference) ? r.schema_ref : type_prefix + '.' + r.schema_ref }
+            } }
+      end
+
+      private
+
+      def add_attribute(column)
+        attribute = Attribute.new column, self
+        fields << attribute
+        attributes << attribute
+        add_attribute_folder(attribute.folder)
+        # folders[AttributeFolder.new(attribute.folder)] = 1 if attribute.folder
+      end
+
+      def add_attribute_folder(name)
+        return if name.nil?
+        return if folders[:attributes].key?(name)
+        folders[:attributes][name] = AttributeFolder.new(name)
+      end
+
+      def add_fact(column)
+        fact = Fact.new column, self
+        fields << fact
+        facts << fact
+        add_fact_folder(fact.folder)
+        # folders[FactFolder.new(fact.folder)] = 1 if fact.folder
+      end
+
+      def add_fact_folder(name)
+        return if name.nil?
+        return if folders[:facts].key?(name)
+        folders[:facts][name] = FactFolder.new(name)
+      end
+
+      def add_label(column)
+        label = Label.new(column, nil, self)
+        labels << label
+        fields << label
+      end
+
+      def add_reference(column)
+        reference = Reference.new(column, self)
+        fields << reference
+        references << reference
+      end
+
+      def add_date(column)
+        date = DateColumn.new column, self
+        @fields << date
+        date.parts.values.each { |p| @fields << p }
+        date.facts.each { |f| facts << f }
+        date.attributes.each { |a| attributes << a }
+        date.references.each { |r| references << r }
+      end
+
+      def set_anchor(column) # rubocop:disable AccessorMethodName
+        @anchor = Anchor.new column, self
+        @fields << @anchor
+      end
+    end
+  end
+end

data/lib/gooddata/models/model.rb

@@ -1,9 +1,23 @@
 # encoding: UTF-8
 
-require_relative '../helpers'
-
+require_relative '../core/connection'
+require_relative '../core/rest'
+
+require_relative 'attributes/attributes'
+require_relative 'columns/columns'
+require_relative 'facts/facts'
+require_relative 'folders/folders'
+require_relative 'metadata/metadata'
+require_relative 'references/references'
+
+require_relative 'links'
+require_relative 'module_constants'
+require_relative 'metadata/schema'
+
+require 'fileutils'
+require 'multi_json'
 require 'open-uri'
-require 'active_support/all'
+require 'zip'
 
 ##
 # Module containing classes that counter-part GoodData server-side meta-data
@@ -11,49 +25,25 @@ require 'active_support/all'
 #
 module GoodData
   module Model
-    # GoodData REST API categories
-    LDM_CTG = 'ldm'
-    LDM_MANAGE_CTG = 'ldm-manage'
-
-    # Model naming conventions
-    FIELD_PK = 'id'
-    FK_SUFFIX = '_id'
-    FACT_COLUMN_PREFIX = 'f_'
-    DATE_COLUMN_PREFIX = 'dt_'
-    TIME_COLUMN_PREFIX = 'tm_'
-    LABEL_COLUMN_PREFIX = 'nm_'
-    ATTRIBUTE_FOLDER_PREFIX = 'dim'
-    ATTRIBUTE_PREFIX = 'attr'
-    LABEL_PREFIX = 'label'
-    FACT_PREFIX = 'fact'
-    DATE_FACT_PREFIX = 'dt'
-    DATE_ATTRIBUTE = 'date'
-    DATE_ATTRIBUTE_DEFAULT_DISPLAY_FORM = 'mdyy'
-    TIME_FACT_PREFIX = 'tm.dt'
-    TIME_ATTRIBUTE_PREFIX = 'attr.time'
-    FACT_FOLDER_PREFIX = 'ffld'
-
-    SKIP_FIELD = false
-
     class << self
-      def add_dataset(name, columns, project = nil)
-        Schema.new('columns' => columns, 'name' => name)
-        add_schema(schema, project)
-      end
+      # def add_dataset(name, columns, project = nil)
+      #   Schema.new('columns' => columns, 'name' => name)
+      #   add_schema(schema, project)
+      # end
 
-      def add_schema(schema, project = nil)
-        unless schema.respond_to?(:to_maql_create) || schema.is_a?(String) then
-          raise ArgumentError.new("Schema object or schema file path expected, got '#{schema}'")
-        end
-        schema = Schema.load(schema) unless schema.respond_to?(:to_maql_create)
-        project = GoodData.project unless project
-        ldm_links = GoodData.get project.md[LDM_CTG]
-        ldm_uri = Links.new(ldm_links)[LDM_MANAGE_CTG]
-        GoodData.post ldm_uri, {'manage' => {'maql' => schema.to_maql_create}}
-      end
+      # def add_schema(schema, project = nil)
+      #   unless schema.respond_to?(:to_maql_create) || schema.is_a?(String)
+      #     fail(ArgumentError, "Schema object or schema file path expected, got '#{schema}'")
+      #   end
+      #   schema = Schema.load(schema) unless schema.respond_to?(:to_maql_create)
+      #   project = GoodData.project unless project
+      #   ldm_links = GoodData.get project.md[LDM_CTG]
+      #   ldm_uri = Links.new(ldm_links)[LDM_MANAGE_CTG]
+      #   GoodData.post ldm_uri, 'manage' => { 'maql' => schema.to_maql_create }
+      # end
 
       # Load given file into a data set described by the given schema
-      def upload_data(path, manifest, options={})
+      def upload_data(path, manifest, options = {})
         project = options[:project] || GoodData.project
         # mode = options[:mode] || "FULL"
         path = path.path if path.respond_to? :path
@@ -63,7 +53,7 @@ module GoodData
         dir = Dir.mktmpdir
         begin
           Zip::File.open("#{dir}/upload.zip", Zip::File::CREATE) do |zip|
-            # TODO make sure schema columns match CSV column names
+            # TODO: make sure schema columns match CSV column names
             zip.get_output_stream('upload_info.json') { |f| f.puts JSON.pretty_generate(manifest) }
             if inline_data
               zip.get_output_stream('data.csv') do |f|
@@ -83,10 +73,11 @@ module GoodData
         end
 
         # kick the load
-        pull = {'pullIntegration' => File.basename(dir)}
+        pull = { 'pullIntegration' => File.basename(dir) }
         link = project.md.links('etl')['pull']
         task = GoodData.post link, pull
-        while GoodData.get(task['pullTask']['uri'])['taskStatus'] === 'RUNNING' || GoodData.get(task['pullTask']['uri'])['taskStatus'] === 'PREPARED'
+        # TODO: Refactor the task status out
+        while GoodData.get(task['pullTask']['uri'])['taskStatus'] == 'RUNNING' || GoodData.get(task['pullTask']['uri'])['taskStatus'] == 'PREPARED'
           sleep 30
         end
         if GoodData.get(task['pullTask']['uri'])['taskStatus'] == 'ERROR'
@@ -103,1302 +94,10 @@ module GoodData
         d = Marshal.load(Marshal.dump(a_schema_blueprint))
         d[:columns] = d[:columns] + b_schema_blueprint[:columns]
         d[:columns].uniq!
-        columns_that_failed_to_merge = d[:columns].group_by { |x| x[:name] }.map { |k, v| [k, v.count] }.find_all { |x| x[1] > 1 }
+        columns_that_failed_to_merge = d[:columns].group_by { |x| x[:name] }.map { |k, v| [k, v.count] }.select { |x| x[1] > 1 }
         fail "Columns #{columns_that_failed_to_merge} failed to merge. When merging columns with the same name they have to be identical." unless columns_that_failed_to_merge.empty?
         d
       end
     end
-
-    class ProjectBlueprint
-      attr_accessor :data
-
-      def self.from_json(spec)
-        if spec.is_a?(String)
-          ProjectBlueprint.new(MultiJson.load(File.read(spec), :symbolize_keys => true))
-        else
-          ProjectBlueprint.new(spec)
-        end
-      end
-
-      def change(&block)
-        builder = ProjectBuilder.create_from_data(self)
-        block.call(builder)
-        builder
-        @data = builder.to_hash
-        self
-      end
-
-      def datasets
-        data[:datasets].map { |d| SchemaBlueprint.new(d) }
-      end
-
-      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
-      end
-
-      def remove_dataset(dataset_name)
-        x = data[:datasets].find { |d| d[:name] == dataset_name }
-        index = data[:datasets].index(x)
-        data[:datasets].delete_at(index)
-      end
-
-      def date_dimensions
-        data[:date_dimensions]
-      end
-
-      def get_dataset(name)
-        ds = data[:datasets].find { |d| d[:name] == name }
-        SchemaBlueprint.new(ds) unless ds.nil?
-      end
-
-      def initialize(init_data)
-        @data = init_data
-      end
-
-      def model_validate
-        if datasets.count == 1
-          []
-        else
-          x = datasets.reduce([]) { |memo, schema| schema.has_anchor? ? memo << [schema.name, schema.anchor[:name]] : memo }
-          refs = datasets.reduce([]) do |memo, dataset|
-            memo.concat(dataset.references)
-          end
-          refs.reduce([]) do |memo, ref|
-            x.include?([ref[:dataset], ref[:reference]]) ? memo : memo.concat([ref])
-          end
-        end
-      end
-
-      def model_valid?
-        errors = model_validate
-        errors.empty? ? true : false
-      end
-
-      def merge!(a_blueprint)
-        temp_blueprint = dup
-        a_blueprint.datasets.each do |dataset|
-          local_dataset = temp_blueprint.get_dataset(dataset.name)
-          if local_dataset.nil?
-            temp_blueprint.add_dataset(dataset.dup)
-          else
-            index = temp_blueprint.datasets.index(local_dataset)
-            local_dataset.merge!(dataset)
-            temp_blueprint.remove_dataset(local_dataset.name)
-            temp_blueprint.add_dataset(local_dataset, index)
-          end
-        end
-        @data = temp_blueprint.data
-        self
-      end
-
-      def dup
-        deep_copy = Marshal.load(Marshal.dump(data))
-        ProjectBlueprint.new(deep_copy)
-      end
-
-      def title
-        data[:title]
-      end
-
-      def to_wire_model
-        {
-          'diffRequest' => {
-            'targetModel' => {
-              'projectModel' => {
-                'datasets' => datasets.map { |d| d.to_wire_model },
-                'dateDimensions' => date_dimensions.map { |d|
-                  {
-                    'dateDimension' => {
-                      'name' => d[:name],
-                      'title' => d[:title] || d[:name].humanize
-                    }
-                  } }
-              }}}}
-      end
-
-      def to_hash
-        @data
-      end
-    end
-
-    class SchemaBlueprint
-      attr_accessor :data
-
-      def change(&block)
-        builder = SchemaBuilder.create_from_data(self)
-        block.call(builder)
-        builder
-        @data = builder.to_hash
-        self
-      end
-
-      def initialize(init_data)
-        @data = init_data
-      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)
-      end
-
-      def merge!(a_blueprint)
-        new_blueprint = GoodData::Model.merge_dataset_columns(self, a_blueprint)
-        @data = new_blueprint
-        self
-      end
-
-      def name
-        data[:name]
-      end
-
-      def title
-        data[:title]
-      end
-
-      def to_hash
-        data
-      end
-
-      def columns
-        data[:columns]
-      end
-
-      def has_anchor?
-        columns.any? { |c| c[:type].to_s == 'anchor' }
-      end
-
-      def anchor
-        find_column_by_type(:anchor, :first)
-      end
-
-      def references
-        find_column_by_type(:reference)
-      end
-
-      def attributes
-        find_column_by_type(:attribute)
-      end
-
-      def facts
-        find_column_by_type(:fact)
-      end
-
-      def find_column_by_type(type, all=:all)
-        type = type.to_s
-        if all == :all
-          columns.find_all { |c| c[:type].to_s == type }
-        else
-          columns.find { |c| c[:type].to_s == type }
-        end
-      end
-
-      def find_column_by_name(type, all=:all)
-        type = type.to_s
-        if all == :all
-          columns.find_all { |c| c[:name].to_s == type }
-        else
-          columns.find { |c| c[:name].to_s == type }
-        end
-      end
-
-      def to_schema
-        Schema.new(to_hash)
-      end
-
-      def to_manifest
-        to_schema.to_manifest
-      end
-
-      def pretty_print(printer)
-        printer.text "Schema <#{object_id}>:\n"
-        printer.text " Name: #{name}\n"
-        printer.text " Columns: \n"
-        printer.text columns.map { |c| "  #{c[:name]}: #{c[:type]}" }.join("\n")
-      end
-
-      def dup
-        deep_copy = Marshal.load(Marshal.dump(data))
-        SchemaBlueprint.new(deep_copy)
-      end
-
-      def to_wire_model
-        to_schema.to_wire_model
-      end
-
-      def ==(other)
-        to_hash == other.to_hash
-      end
-    end
-
-    class ProjectBuilder
-      attr_reader :title, :datasets, :reports, :metrics, :uploads, :users, :assert_report, :date_dimensions
-
-      class << self
-        def create_from_data(blueprint, title = 'Title')
-          pb = ProjectBuilder.new(title)
-          pb.data = blueprint.to_hash
-          pb
-        end
-
-        def create(title, options={}, &block)
-          pb = ProjectBuilder.new(title)
-          block.call(pb)
-          pb
-        end
-      end
-
-      def initialize(title)
-        @title = title
-        @datasets = []
-        @reports = []
-        @assert_tests = []
-        @metrics = []
-        @uploads = []
-        @users = []
-        @dashboards = []
-        @date_dimensions = []
-      end
-
-      def add_date_dimension(name, options = {})
-        dimension = {
-          urn: options[:urn],
-          name: name,
-          title: options[:title]
-        }
-
-        @date_dimensions << dimension
-      end
-
-      def add_dataset(name, &block)
-        builder = GoodData::Model::SchemaBuilder.new(name)
-        block.call(builder)
-        if @datasets.any? { |item| item[:name] == name }
-          ds = @datasets.find { |item| item[:name] == name }
-          index = @datasets.index(ds)
-          stuff = GoodData::Model.merge_dataset_columns(ds, builder.to_hash)
-          @datasets.delete_at(index)
-          @datasets.insert(index, stuff)
-        else
-          @datasets << builder.to_hash
-        end
-      end
-
-      def add_report(title, options={})
-        @reports << {:title => title}.merge(options)
-      end
-
-      def add_metric(title, options={})
-        @metrics << {:title => title}.merge(options)
-      end
-
-      def add_dashboard(title, &block)
-        db = DashboardBuilder.new(title)
-        block.call(db)
-        @dashboards << db.to_hash
-      end
-
-      def load_metrics(file)
-        new_metrics = MultiJson.load(open(file).read, :symbolize_keys => true)
-        @metrics = @metrics + new_metrics
-      end
-
-      def load_datasets(file)
-        new_metrics = MultiJson.load(open(file).read, :symbolize_keys => true)
-        @datasets = @datasets + new_metrics
-      end
-
-      def assert_report(report, result)
-        @assert_tests << {:report => report, :result => result}
-      end
-
-      def upload(data, options={})
-        mode = options[:mode] || 'FULL'
-        dataset = options[:dataset]
-        @uploads << {
-          :source => data,
-          :mode => mode,
-          :dataset => dataset
-        }
-      end
-
-      def add_users(users)
-        @users << users
-      end
-
-      def to_json(options={})
-        eliminate_empty = options[:eliminate_empty] || false
-
-        if eliminate_empty
-          JSON.pretty_generate(to_hash.reject { |k, v| v.is_a?(Enumerable) && v.empty? })
-        else
-          JSON.pretty_generate(to_hash)
-        end
-      end
-
-      def to_hash
-        {
-          :title => @title,
-          :datasets => @datasets,
-          :uploads => @uploads,
-          :dashboards => @dashboards,
-          :metrics => @metrics,
-          :reports => @reports,
-          :users => @users,
-          :assert_tests => @assert_tests,
-          :date_dimensions => @date_dimensions
-        }
-      end
-
-      def get_dataset(name)
-        datasets.find { |d| d.name == name }
-      end
-    end
-
-    class DashboardBuilder
-      def initialize(title)
-        @title = title
-        @tabs = []
-      end
-
-      def add_tab(tab, &block)
-        tb = TabBuilder.new(tab)
-        block.call(tb)
-        @tabs << tb
-        tb
-      end
-
-      def to_hash
-        {
-          :name => @name,
-          :tabs => @tabs.map { |tab| tab.to_hash }
-        }
-      end
-    end
-
-    class TabBuilder
-      def initialize(title)
-        @title = title
-        @stuff = []
-      end
-
-      def add_report(options={})
-        @stuff << {:type => :report}.merge(options)
-      end
-
-      def to_hash
-        {
-          :title => @title,
-          :items => @stuff
-        }
-      end
-    end
-
-    class SchemaBuilder
-      attr_accessor :data
-
-      class << self
-        def create_from_data(blueprint)
-          sc = SchemaBuilder.new
-          sc.data = blueprint.to_hash
-          sc
-        end
-      end
-
-      def initialize(name=nil)
-        @data = {
-          :name => name,
-          :columns => []
-        }
-      end
-
-      def name
-        data[:name]
-      end
-
-      def columns
-        data[:columns]
-      end
-
-      def add_column(column_def)
-        columns.push(column_def)
-        self
-      end
-
-      def add_anchor(name, options={})
-        add_column({:type => :anchor, :name => name}.merge(options))
-        self
-      end
-
-      def add_attribute(name, options={})
-        add_column({:type => :attribute, :name => name}.merge(options))
-        self
-      end
-
-      def add_fact(name, options={})
-        add_column({:type => :fact, :name => name}.merge(options))
-        self
-      end
-
-      def add_label(name, options={})
-        add_column({:type => :label, :name => name}.merge(options))
-        self
-      end
-
-      def add_date(name, options={})
-        add_column({:type => :date, :name => name}.merge(options))
-      end
-
-      def add_reference(name, options={})
-        add_column({:type => :reference, :name => name}.merge(options))
-      end
-
-      def to_json
-        JSON.pretty_generate(to_hash)
-      end
-
-      def to_hash
-        data
-      end
-
-      def to_schema
-        Schema.new(to_hash)
-      end
-    end
-
-    class ProjectCreator
-      class << self
-        def migrate(options={})
-          spec = options[:spec] || fail('You need to provide spec for migration')
-          spec = spec.to_hash
-
-          token = options[:token]
-          project = options[:project] || GoodData::Project.create(:title => spec[:title], :auth_token => token)
-          fail('You need to specify token for project creation') if token.nil? && project.nil?
-
-          begin
-            GoodData.with_project(project) do |p|
-              # migrate_date_dimensions(p, spec[:date_dimensions] || [])
-              migrate_datasets(p, spec)
-              load(p, spec)
-              migrate_metrics(p, spec[:metrics] || [])
-              migrate_reports(p, spec[:reports] || [])
-              migrate_dashboards(p, spec[:dashboards] || [])
-              migrate_users(p, spec[:users] || [])
-              execute_tests(p, spec[:assert_tests] || [])
-              p
-            end
-          end
-        end
-
-        def migrate_date_dimensions(project, spec)
-          spec.each do |dd|
-            Model.add_schema(DateDimension.new(dd), project)
-          end
-        end
-
-        def migrate_datasets(project, spec)
-          bp = ProjectBlueprint.new(spec)
-          # 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)
-          link = result['asyncTask']['link']['poll']
-          response = GoodData.get(link, :process => false)
-          # pp response
-          while response.code != 200
-            sleep 1
-            GoodData.connection.retryable(:tries => 3, :on => RestClient::InternalServerError) do
-              sleep 1
-              response = GoodData.get(link, :process => false)
-              # pp response
-            end
-          end
-          response = GoodData.get(link)
-          ldm_links = GoodData.get project.md[LDM_CTG]
-          ldm_uri = Links.new(ldm_links)[LDM_MANAGE_CTG]
-          chunks = response['projectModelDiff']['updateScripts'].find_all { |script| script['updateScript']['preserveData'] == true && script['updateScript']['cascadeDrops'] == false }.map { |x| x['updateScript']['maqlDdlChunks'] }.flatten
-          chunks.each do |chunk|
-            GoodData.post ldm_uri, {'manage' => {'maql' => chunk}}
-          end
-
-          bp.datasets.each do |ds|
-            schema = ds.to_schema
-            GoodData::ProjectMetadata["manifest_#{schema.name}"] = schema.to_manifest.to_json
-          end
-        end
-
-        def migrate_reports(project, spec)
-          spec.each do |report|
-            project.add_report(report)
-          end
-        end
-
-        def migrate_dashboards(project, spec)
-          spec.each do |dash|
-            project.add_dashboard(dash)
-          end
-        end
-
-        def migrate_metrics(project, spec)
-          spec.each do |metric|
-            project.add_metric(metric)
-          end
-        end
-
-        def migrate_users(project, spec)
-          spec.each do |user|
-            puts "Would migrate user #{user}"
-            # project.add_user(user)
-          end
-        end
-
-        def load(project, spec)
-          if spec.has_key?(:uploads)
-            spec[:uploads].each do |load|
-              schema = GoodData::Model::Schema.new(spec[:datasets].detect { |d| d[:name] == load[:dataset] })
-              project.upload(load[:source], schema, load[:mode])
-            end
-          end
-        end
-
-        def execute_tests(project, spec)
-          spec.each do |assert|
-            result = GoodData::ReportDefinition.execute(assert[:report])
-            fail "Test did not pass. Got #{result.table.inspect}, expected #{assert[:result].inspect}" if result.table != assert[:result]
-          end
-        end
-      end
-    end
-
-    class MdObject
-      attr_accessor :name, :title
-
-      def visual
-        "TITLE \"#{title_esc}\""
-      end
-
-      def title_esc
-        title.gsub(/"/, "\\\"")
-      end
-
-      ##
-      # Generates an identifier from the object name by transliterating
-      # non-Latin character and then dropping non-alphanumerical characters.
-      #
-      def identifier
-        @identifier ||= "#{self.type_prefix}.#{name}"
-      end
-    end
-
-    ##
-    # Server-side representation of a local data set; includes connection point,
-    # attributes and labels, facts, folders and corresponding pieces of physical
-    # model abstractions.
-    #
-    class Schema < MdObject
-      attr_reader :fields, :attributes, :facts, :folders, :references, :labels, :name, :title, :anchor
-
-      def self.load(file)
-        Schema.new JSON.load(open(file))
-      end
-
-      def initialize(config, name = 'Default Name', title = 'Default Title')
-        super()
-        @fields = []
-        @attributes = []
-        @facts = []
-        @folders = {
-          :facts => {},
-          :attributes => {}
-        }
-        @references = []
-        @labels = []
-
-        config[:name] = name unless config[:name]
-        config[:title] = config[:name] unless config[:title]
-        config[:title] = title unless config[:title]
-        config[:title] = config[:title].humanize
-
-        fail 'Schema name not specified' unless config[:name]
-        self.name = config[:name]
-        self.title = config[:title]
-        self.config = config
-      end
-
-      def config=(config)
-        config[:columns].each do |c|
-          case c[:type].to_s
-          when 'attribute'
-            add_attribute c
-          when 'fact'
-            add_fact c
-          when 'date'
-            add_date c
-          when 'anchor'
-            set_anchor c
-          when 'label'
-            add_label c
-          when 'reference'
-            add_reference c
-          else
-            fail "Unexpected type #{c[:type]} in #{c.inspect}"
-          end
-        end
-        @anchor = Anchor.new(nil, self) unless @anchor
-      end
-
-      def type_prefix
-        'dataset'
-      end
-
-      ##
-      # Underlying fact table name
-      #
-      def table
-        @table ||= FACT_COLUMN_PREFIX + name
-      end
-
-      ##
-      # Generates MAQL DDL script to drop this data set and included pieces
-      #
-      def to_maql_drop
-        maql = ''
-        [attributes, facts].each do |obj|
-          maql += obj.to_maql_drop
-        end
-        maql += "DROP {#{self.identifier}};\n"
-      end
-
-      ##
-      # Generates MAQL DDL script to create this data set and included pieces
-      #
-      def to_maql_create
-        # TODO: Use template (.erb)
-        maql = "# Create the '#{self.title}' data set\n"
-        maql += "CREATE DATASET {#{self.identifier}} VISUAL (TITLE \"#{self.title}\");\n\n"
-        [attributes, facts, {1 => @anchor}].each do |objects|
-          objects.values.each do |obj|
-            maql += "# Create '#{obj.title}' and add it to the '#{self.title}' data set.\n"
-            maql += obj.to_maql_create
-            maql += "ALTER DATASET {#{self.identifier}} ADD {#{obj.identifier}};\n\n"
-          end
-        end
-
-        labels.each do |label|
-          maql += "# Creating Labels\n"
-          maql += label.to_maql_create
-        end
-
-        references.values.each do |ref|
-          maql += "# Creating references\n"
-          maql += ref.to_maql_create
-        end
-
-        folders_maql = "# Create folders\n"
-        (folders[:attributes].values + folders[:facts].values).each { |folder| folders_maql += folder.to_maql_create }
-        folders_maql + "\n" + maql + "SYNCHRONIZE {#{identifier}};\n"
-      end
-
-      def upload(path, project = nil, mode = 'FULL')
-        if path =~ URI::regexp
-          Tempfile.open('remote_file') do |temp|
-            temp << open(path).read
-            temp.flush
-            upload_data(temp, mode)
-          end
-        else
-          upload_data(path, mode)
-        end
-      end
-
-      def upload_data(path, mode)
-        GoodData::Model.upload_data(path, to_manifest(mode))
-      end
-
-      # Generates the SLI manifest describing the data loading
-      # 
-      def to_manifest(mode = 'FULL')
-        {
-          'dataSetSLIManifest' => {
-            'parts' => fields.reduce([]) { |memo, f| val = f.to_manifest_part(mode); memo << val unless val.nil?; memo },
-            'dataSet' => self.identifier,
-            'file' => 'data.csv', # should be configurable
-            'csvParams' => {
-              'quoteChar' => '"',
-              'escapeChar' => '"',
-              'separatorChar' => ',',
-              'endOfLine' => "\n"
-            }
-          }
-        }
-      end
-
-      def to_wire_model
-        {
-          'dataset' => {
-            'identifier' => identifier,
-            'title' => title,
-            'anchor' => @anchor.to_wire_model,
-            'facts' => facts.map { |f| f.to_wire_model },
-            'attributes' => attributes.map { |a| a.to_wire_model },
-            'references' => references.map { |r| r.is_a?(DateReference) ? r.schema_ref : type_prefix + '.' + r.schema_ref }}
-        }
-      end
-
-      private
-
-      def add_attribute(column)
-        attribute = Attribute.new column, self
-        fields << attribute
-        attributes << attribute
-        add_attribute_folder(attribute.folder)
-        # folders[AttributeFolder.new(attribute.folder)] = 1 if attribute.folder
-      end
-
-      def add_attribute_folder(name)
-        return if name.nil?
-        return if folders[:attributes].has_key?(name)
-        folders[:attributes][name] = AttributeFolder.new(name)
-      end
-
-      def add_fact(column)
-        fact = Fact.new column, self
-        fields << fact
-        facts << fact
-        add_fact_folder(fact.folder)
-        # folders[FactFolder.new(fact.folder)] = 1 if fact.folder
-      end
-
-      def add_fact_folder(name)
-        return if name.nil?
-        return if folders[:facts].has_key?(name)
-        folders[:facts][name] = FactFolder.new(name)
-      end
-
-      def add_label(column)
-        label = Label.new(column, nil, self)
-        labels << label
-        fields << label
-      end
-
-      def add_reference(column)
-        reference = Reference.new(column, self)
-        fields << reference
-        references << reference
-      end
-
-      def add_date(column)
-        date = DateColumn.new column, self
-        @fields << date
-        date.parts.values.each { |p| @fields << p }
-        date.facts.each { |f| facts << f }
-        date.attributes.each { |a| attributes << a }
-        date.references.each { |r| references << r }
-      end
-
-      def set_anchor(column)
-        @anchor = Anchor.new column, self
-        @fields << @anchor
-      end
-    end
-
-    ##
-    # This is a base class for server-side LDM elements such as attributes, labels and
-    # facts
-    #
-    class Column < MdObject
-      attr_accessor :folder, :name, :title, :schema
-
-      def initialize(hash, schema)
-        super()
-        raise ArgumentError.new("Schema must be provided, got #{schema.class}") unless schema.is_a? Schema
-        raise('Data set fields must have their names defined') if hash[:name].nil?
-
-        @name = hash[:name]
-        @title = hash[:title] || hash[:name].humanize
-        @folder = hash[:folder]
-        @schema = schema
-      end
-
-      ##
-      # Generates an identifier from the object name by transliterating
-      # non-Latin character and then dropping non-alphanumerical characters.
-      #
-      def identifier
-        @identifier ||= "#{self.type_prefix}.#{@schema.name}.#{name}"
-      end
-
-      def to_maql_drop
-        "DROP {#{self.identifier}};\n"
-      end
-
-      def visual
-        visual = super
-        visual += ", FOLDER {#{folder_prefix}.#{(folder)}}" if folder
-        visual
-      end
-
-      def to_csv_header(row)
-        name
-      end
-
-      def to_csv_data(headers, row)
-        row[name]
-      end
-
-
-      # Overriden to prevent long strings caused by the @schema attribute
-      #
-      def inspect
-        to_s.sub(/>$/, " @title=#{@title.inspect}, @name=#{@name.inspect}, @folder=#{@folder.inspect}," \
-                       " @schema=#{@schema.to_s.sub(/>$/, ' @title=' + @schema.name.inspect + '>')}" \
-                       ">")
-      end
-    end
-
-    ##
-    # GoodData attribute abstraction
-    #
-    class Attribute < Column
-      attr_reader :primary_label, :labels
-
-      def type_prefix;
-        ATTRIBUTE_PREFIX;
-      end
-
-      def folder_prefix;
-        ATTRIBUTE_FOLDER_PREFIX;
-      end
-
-      def initialize(hash, schema)
-        super hash, schema
-        @labels = []
-        @primary_label = Label.new hash, self, schema
-      end
-
-      def table
-        @table ||= 'd_' + @schema.name + '_' + name
-      end
-
-      def key;
-        "#{@name}#{FK_SUFFIX}";
-      end
-
-      def to_maql_create
-        maql = "CREATE ATTRIBUTE {#{identifier}} VISUAL (#{visual})" \
-               + " AS KEYS {#{table}.#{Model::FIELD_PK}} FULLSET;\n"
-        maql += @primary_label.to_maql_create if @primary_label
-        maql
-      end
-
-      def to_manifest_part(mode)
-        {
-          'referenceKey' => 1,
-          'populates' => [@primary_label.identifier],
-          'mode' => mode,
-          'columnName' => name
-        }
-      end
-
-      def to_wire_model
-        {
-          'attribute' => {
-            'identifier' => identifier,
-            'title' => title,
-            'labels' => labels.map do |l|
-              {
-                'label' => {
-                  'identifier' => l.identifier,
-                  'title' => l.title,
-                  'type' => 'GDC.text'
-                }
-              }
-            end
-          }
-        }
-      end
-    end
-
-    ##
-    # GoodData display form abstraction. Represents a default representation
-    # of an attribute column or an additional representation defined in a LABEL
-    # field
-    #
-    class Label < Column
-      attr_accessor :attribute
-
-      def type_prefix;
-        'label';
-      end
-
-      # def initialize(hash, schema)
-      def initialize(hash, attribute, schema)
-        super hash, schema
-        attribute = attribute.nil? ? schema.fields.find { |field| field.name === hash[:reference] } : attribute
-        @attribute = attribute
-        attribute.labels << self
-      end
-
-      def to_maql_create
-        '# LABEL FROM LABEL'
-        "ALTER ATTRIBUTE {#{@attribute.identifier}} ADD LABELS {#{identifier}}" \
-              + " VISUAL (TITLE #{title.inspect}) AS {#{column}};\n"
-      end
-
-      def to_manifest_part(mode)
-        {
-          'populates' => [identifier],
-          'mode' => mode,
-          'columnName' => name
-        }
-      end
-
-      def column
-        "#{@attribute.table}.#{LABEL_COLUMN_PREFIX}#{name}"
-      end
-
-      alias :inspect_orig :inspect
-
-      def inspect
-        inspect_orig.sub(/>$/, " @attribute=#{@attribute.to_s.sub(/>$/, " @name=#{@attribute.name}")}>")
-      end
-    end
-
-    ##
-    # A GoodData attribute that represents a data set's connection point or a data set
-    # without a connection point
-    #
-    class Anchor < Attribute
-      def initialize(column, schema)
-        if column then
-          super
-        else
-          super({:type => 'anchor', :name => 'id'}, schema)
-          @labels = []
-          @primary_label = nil
-        end
-      end
-
-      def table
-        @table ||= 'f_' + @schema.name
-      end
-
-      def to_maql_create
-        maql = super
-        maql += "\n# Connect '#{self.title}' to all attributes of this data set\n"
-        @schema.attributes.values.each do |c|
-          maql += "ALTER ATTRIBUTE {#{c.identifier}} ADD KEYS " \
-                + "{#{table}.#{c.key}};\n"
-        end
-        maql
-      end
-    end
-
-    ##
-    # GoodData fact abstraction
-    #
-    class Fact < Column
-      def type_prefix;
-        FACT_PREFIX;
-      end
-
-      def column_prefix;
-        FACT_COLUMN_PREFIX;
-      end
-
-      def folder_prefix;
-        FACT_FOLDER_PREFIX;
-      end
-
-      def table
-        @schema.table
-      end
-
-      def column
-        @column ||= table + '.' + column_prefix + name
-      end
-
-      def to_maql_create
-        "CREATE FACT {#{self.identifier}} VISUAL (#{visual})" \
-               + " AS {#{column}};\n"
-      end
-
-      def to_manifest_part(mode)
-        {
-          'populates' => [identifier],
-          'mode' => mode,
-          'columnName' => name
-        }
-      end
-
-      def to_wire_model
-        {
-          'fact' => {
-            'identifier' => identifier,
-            'title' => title
-          }
-        }
-      end
-    end
-
-    ##
-    # Reference to another data set
-    #
-    class Reference < Column
-      attr_accessor :reference, :schema_ref
-
-      def initialize(column, schema)
-        super column, schema
-        # pp column
-        @name = column[:name]
-        @reference = column[:reference]
-        @schema_ref = column[:dataset]
-        @schema = schema
-      end
-
-      ##
-      # Generates an identifier of the referencing attribute using the
-      # schema name derived from schemaReference and column name derived
-      # from the reference key.
-      #
-      def identifier
-        @identifier ||= "#{ATTRIBUTE_PREFIX}.#{@schema_ref}.#{@reference}"
-      end
-
-      def key;
-        "#{@name}_id";
-      end
-
-      def label_column
-        "#{LABEL_PREFIX}.#{@schema_ref}.#{@reference}"
-      end
-
-      def to_maql_create
-        "ALTER ATTRIBUTE {#{self.identifier}} ADD KEYS {#{@schema.table}.#{key}};\n"
-      end
-
-      def to_maql_drop
-        "ALTER ATTRIBUTE {#{self.identifier} DROP KEYS {#{@schema.table}.#{key}};\n"
-      end
-
-      def to_manifest_part(mode)
-        {
-          'populates' => [label_column],
-          'mode' => mode,
-          'columnName' => name,
-          'referenceKey' => 1
-        }
-      end
-    end
-
-    ##
-    # Date as a reference to a date dimension
-    #
-    class DateReference < Reference
-      attr_accessor :format, :output_format, :urn
-
-      def initialize(column, schema)
-        super column, schema
-        @output_format = column['format'] || 'dd/MM/yyyy'
-        @format = @output_format.gsub('yyyy', '%Y').gsub('MM', '%m').gsub('dd', '%d')
-        @urn = column[:urn] || 'URN:GOODDATA:DATE'
-      end
-
-      def identifier
-        @identifier ||= "#{@schema_ref}.#{DATE_ATTRIBUTE}"
-      end
-
-      def to_manifest_part(mode)
-        {
-          'populates' => ["#{identifier}.#{DATE_ATTRIBUTE_DEFAULT_DISPLAY_FORM}"],
-          'mode' => mode,
-          'constraints' => {'date' => output_format},
-          'columnName' => name,
-          'referenceKey' => 1
-        }
-      end
-
-      # def to_maql_create
-      #   # urn:chefs_warehouse_fiscal:date
-      #   super_maql = super
-      #   maql = ""
-      #   # maql = "# Include date dimensions\n"
-      #   # maql += "INCLUDE TEMPLATE \"#{urn}\" MODIFY (IDENTIFIER \"#{name}\", TITLE \"#{title || name}\");\n"
-      #   maql += super_maql
-      # end
-    end
-
-    ##
-    # Date field that's not connected to a date dimension
-    #
-    class DateAttribute < Attribute
-      def key;
-        "#{DATE_COLUMN_PREFIX}#{super}";
-      end
-
-      def to_manifest_part(mode)
-        {
-          'populates' => ['label.stuff.mmddyy'],
-          'format' => 'unknown',
-          'mode' => mode,
-          'referenceKey' => 1
-        }
-      end
-    end
-
-    ##
-    # Fact representation of a time of a day
-    #
-    class TimeFact < Fact
-      def column_prefix;
-        TIME_COLUMN_PREFIX;
-      end
-
-      def type_prefix;
-        TIME_FACT_PREFIX;
-      end
-    end
-
-    ##
-    # Time as a reference to a time-of-a-day dimension
-    #
-    class TimeReference < Reference
-    end
-
-    ##
-    # Time field that's not connected to a time-of-a-day dimension
-    #
-    class TimeAttribute < Attribute
-      def type_prefix;
-        TIME_ATTRIBUTE_PREFIX;
-      end
-
-      def key;
-        "#{TIME_COLUMN_PREFIX}#{super}";
-      end
-
-      def table;
-        @table ||= "#{super}_tm";
-      end
-    end
-
-    ##
-    # Date column. A container holding the following
-    # parts: date fact, a date reference or attribute and an optional time component
-    # that contains a time fact and a time reference or attribute.
-    #
-    class DateColumn < Column
-      attr_reader :parts, :facts, :attributes, :references
-
-      def initialize(column, schema)
-        super column, schema
-        @parts = {}; @facts = []; @attributes = []; @references = []
-
-        # @facts << @parts[:date_fact] = DateFact.new(column, schema)
-        if column[:dataset] then
-          @parts[:date_ref] = DateReference.new column, schema
-          @references << @parts[:date_ref]
-        else
-          @attributes << @parts[:date_attr] = DateAttribute.new(column, schema)
-        end
-        # if column['datetime'] then
-        #   puts "*** datetime"
-        #   @facts << @parts[:time_fact] = TimeFact.new(column, schema)
-        #   if column['schema_reference'] then
-        #     @parts[:time_ref] = TimeReference.new column, schema
-        #   else
-        #     @attributes << @parts[:time_attr] = TimeAttribute.new(column, schema)
-        #   end
-        # end
-      end
-
-      def to_maql_create
-        @parts.values.map { |v| v.to_maql_create }.join "\n"
-      end
-
-      def to_maql_drop
-        @parts.values.map { |v| v.to_maql_drop }.join "\n"
-      end
-
-      def to_csv_header(row)
-        SKIP_FIELD
-      end
-
-      def to_csv_data(headers, row)
-        SKIP_FIELD
-      end
-
-      def to_manifest_part(mode)
-        nil
-      end
-    end
-
-    ##
-    # Base class for GoodData attribute and fact folder abstractions
-    #
-    class Folder < MdObject
-      def initialize(title)
-        # TODO: should a super be here?
-        # how to deal with name vs title?
-        @title = title
-        @name = GoodData::Helpers.sanitize_string(title)
-      end
-
-      def to_maql_create
-        "CREATE FOLDER {#{type_prefix}.#{name}}" \
-            + " VISUAL (#{visual}) TYPE #{type};\n"
-      end
-    end
-
-    ##
-    # GoodData attribute folder abstraction
-    #
-    class AttributeFolder < Folder
-      def type;
-        'ATTRIBUTE'
-      end
-
-      def type_prefix;
-        'dim'
-      end
-    end
-
-    ##
-    # GoodData fact folder abstraction
-    #
-    class FactFolder < Folder
-      def type;
-        'FACT'
-      end
-
-      def type_prefix;
-        'ffld'
-      end
-    end
-
-    class DateDimension < MdObject
-      def initialize(spec={})
-        super()
-        @name = spec[:name]
-        @title = spec[:title] || @name
-        @urn = spec[:urn] || 'URN:GOODDATA:DATE'
-      end
-
-      def to_maql_create
-        # urn = "urn:chefs_warehouse_fiscal:date"
-        # title = "title"
-        # name = "name"
-
-        maql = ''
-        maql += "INCLUDE TEMPLATE \"#{@urn}\" MODIFY (IDENTIFIER \"#{@name}\", TITLE \"#{@title}\");"
-        maql
-      end
-    end
   end
-end
+end