gooddata 0.5.16 → 0.6.0.pre2

data/lib/gooddata/extract.rb

@@ -10,4 +10,4 @@ module GoodData::Extract
       CSV.open @file, 'r', &block
     end
   end
-end
+end

data/lib/gooddata/goodzilla/goodzilla.rb

@@ -0,0 +1,40 @@
+module GoodData::SmallGoodZilla
+  
+  def self.get_facts(a_maql_string)
+    a_maql_string.scan(/#\"([^\"]+)\"/).flatten
+  end
+
+  def self.get_attributes(a_maql_string)
+    a_maql_string.scan(/@\"([^\"]+)\"/).flatten
+  end
+
+  def self.get_metrics(a_maql_string)
+    a_maql_string.scan(/\?"([^\"]+)\"/).flatten
+  end
+
+  def self.interpolate(values, dictionaries)
+    {
+      :facts => interpolate_values(values[:facts], dictionaries[:facts]),
+      :attributes => interpolate_values(values[:attributes], dictionaries[:attributes]),
+      :metrics => interpolate_values(values[:metrics], dictionaries[:metrics])
+    }
+  end
+
+  def self.interpolate_values(keys, values)
+    x = values.values_at(*keys)
+    keys.zip(x)
+  end
+
+  def self.interpolate_metric(metric, dictionary)
+    interpolated = interpolate({
+      :facts => GoodData::SmallGoodZilla.get_facts(metric),
+      :attributes => GoodData::SmallGoodZilla.get_attributes(metric),
+      :metrics => GoodData::SmallGoodZilla.get_metrics(metric)
+    }, dictionary)
+    metric = interpolated[:facts].reduce(metric) {|memo, item| memo.sub("#\"#{item[0]}\"", "[#{item[1]}]")}
+    metric = interpolated[:attributes].reduce(metric) {|memo, item| memo.sub("@\"#{item[0]}\"", "[#{item[1]}]")}
+    metric = interpolated[:metrics].reduce(metric) {|memo, item| memo.sub("?\"#{item[0]}\"", "[#{item[1]}]")}
+    metric
+  end
+
+end

data/lib/gooddata/model.rb

@@ -1,4 +1,4 @@
-require 'iconv'
+require 'open-uri'
 
 ##
 # Module containing classes that counter-part GoodData server-side meta-data
@@ -32,30 +32,303 @@ module GoodData
 
     SKIP_FIELD = false
 
-    BEGINNING_OF_TIMES = Date.parse('1/1/1900')
-
     class << self
-      def add_dataset(title, columns, project = nil)
-        add_schema Schema.new('columns' => columns, 'title' => title), project
+      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.is_a?(Schema) || schema.is_a?(String) then
+        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.is_a? Schema
+        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 to_id(str)
-        Iconv.iconv('ascii//ignore//translit', 'utf-8', str) \
-                .to_s.gsub(/[^\w\d_]/, '').gsub(/^[\d_]*/, '').downcase
+    end
+
+    class ProjectBuilder
+
+      attr_reader :title, :datasets, :reports, :metrics, :uploads, :users, :assert_report, :date_dimensions
+
+      class << self
+        
+        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={})
+        @date_dimensions << {:urn => options[:urn], :name => name, :title => options[:title]}
+      end
+
+      def add_dataset(name, &block)
+        builder = GoodData::Model::SchemaBuilder.new(name)
+        block.call(builder)
+        @datasets << builder.to_hash
+      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 = JSON.parse(open(file).read, :symbolize_names => true)
+        @metrics = @metrics + new_metrics
       end
+
+      def load_datasets(file)
+        new_metrics = JSON.parse(open(file).read, :symbolize_names => 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
+        JSON.pretty_generate(to_hash)
+      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
+
     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 :title, :name
+
+      def initialize(name=nil)
+        @name = name
+        @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_schema
+        Schema.new(to_hash)
+      end
+
+      def to_json
+        JSON.pretty_generate(to_hash)
+      end
+
+      def to_hash
+        h = {
+          :name => @name,
+          :columns => @columns
+        }
+        h.has_key?(:title) ? h.merge({:title => h[:title]}) : h
+      end
+    end
+
+    class ProjectCreator
+      
+      class << self
+        def migrate(options={})
+
+          spec = options[:spec] || fail("You need to provide spec for migration")
+          spec = spec.to_hash
+          project = options[:project]
+          token = options[:token] || fail("You need to specify token for project creation")
+          new_project = GoodData::Project.create(:title => spec[:title], :auth_token => token)
+
+          begin
+            GoodData.with_project(new_project) do |p|
+              migrate_date_dimensions(p, spec[:date_dimensions])
+              migrate_datasets(p, spec[:datasets])
+              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)
+          spec.each do |ds|
+            project.add_dataset(GoodData::Model::Schema.new(ds))
+          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)
+          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
+
+        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
 
@@ -72,7 +345,7 @@ module GoodData
       # non-Latin character and then dropping non-alphanumerical characters.
       #
       def identifier
-        @identifier ||= "#{self.type_prefix}.#{Model::to_id(name)}"
+        @identifier ||= "#{self.type_prefix}.#{name}"
       end
     end
 
@@ -82,13 +355,14 @@ module GoodData
     # model abstractions.
     #
     class Schema < MdObject
-      attr_reader :fields, :attributes, :facts, :folders, :references, :labels
+      attr_reader :fields, :attributes, :facts, :folders, :references, :labels, :name, :title
 
       def self.load(file)
         Schema.new JSON.load(open(file))
       end
 
-      def initialize(config, title = nil)
+      def initialize(config, name = nil)
+        super()
         @fields = []
         @attributes = {}
         @facts = {}
@@ -99,64 +373,45 @@ module GoodData
         @references = {}
         @labels = []
 
-        config['title'] = title unless config['title']
-        raise 'Schema name not specified' unless config['title']
-        self.title = config['title']
+        config[:name] = name unless config[:name]
+        config[:title] = config[:title] || config[:name].humanize
+        fail 'Schema name not specified' unless config[:name]
+        self.name = config[:name]
+        self.title = config[:title]
         self.config = config
       end
 
-      def transform_header(headers)
-        result = fields.reduce([]) do |memo, f|
-          val = f.to_csv_header(headers)
-          memo << val unless val === SKIP_FIELD
-          memo
-        end
-        result.flatten
-      end
-
-      def transform_row(headers, row)
-        result = fields.reduce([]) do |memo, f|
-          val = f.to_csv_data(headers, row)
-          memo << val unless val === SKIP_FIELD
-          memo
-        end
-        result.flatten
-      end
-
       def config=(config)
-        config['columns'].each do |c|
-          case c['type']
-          when 'ATTRIBUTE'
+        config[:columns].each do |c|
+          case c[:type].to_s
+          when "attribute"
             add_attribute c
-          when 'FACT'
+          when "fact"
             add_fact c
-          when 'DATE'
+          when "date"
             add_date c
-          when 'CONNECTION_POINT'
+          when "anchor"
             set_connection_point c
-          when 'LABEL'
+          when "label"
             add_label c
-          when 'REFERENCE'
+          when "reference"
             add_reference c
           else
-            fail "Unexpected type #{c['type']} in #{c.inspect}"
+            fail "Unexpected type #{c[:type]} in #{c.inspect}"
           end
         end
         @connection_point = RecordsOf.new(nil, self) unless @connection_point
       end
 
-      def title=(title)
-        @name = title
-        @title = title
+      def type_prefix
+        'dataset'
       end
 
-      def type_prefix ; 'dataset' ; end
-
       ##
       # Underlying fact table name
       #
       def table
-        @table ||= FACT_COLUMN_PREFIX + Model::to_id(name)
+        @table ||= FACT_COLUMN_PREFIX + name
       end
 
       ##
@@ -199,27 +454,39 @@ module GoodData
         folders_maql + "\n" + maql + "SYNCHRONIZE {#{identifier}};\n"
       end
 
-      # Load given file into a data set described by the given schema
-      #
       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, project, mode)
+          end
+        else
+          upload_data(path, project, mode)
+        end
+      end
+
+      # Load given file into a data set described by the given schema
+      def upload_data(path, project = nil, mode = "FULL")
         path = path.path if path.respond_to? :path
-        header = nil
+
+        inline_data = path.is_a?(String) ? false : true
+
         project = GoodData.project unless project
 
         # create a temporary zip file
         dir = Dir.mktmpdir
-        Zip::ZipFile.open("#{dir}/upload.zip", Zip::ZipFile::CREATE) do |zip|
+        Zip::File.open("#{dir}/upload.zip", Zip::File::CREATE) do |zip|
           # TODO make sure schema columns match CSV column names
           zip.get_output_stream('upload_info.json') { |f| f.puts JSON.pretty_generate(to_manifest(mode)) }
-          zip.get_output_stream('data.csv') do |f|
-            FasterCSV.foreach(path, :headers => true, :return_headers => true) do |row|
-              output = if row.header_row?
-                transform_header(row)
-              else
-                transform_row(header, row)
+          if inline_data
+            zip.get_output_stream('data.csv') do |f|
+              path.each do |row|
+                f.puts row.to_csv
               end
-              f.puts output.to_csv
             end
+          else
+            zip.add('data.csv', path)
           end
         end
 
@@ -234,6 +501,7 @@ module GoodData
         while (GoodData.get(task["pullTask"]["uri"])["taskStatus"] === "RUNNING" || GoodData.get(task["pullTask"]["uri"])["taskStatus"] === "PREPARED") do
           sleep 30
         end
+        fail "Load Failed" if (GoodData.get(task["pullTask"]["uri"])["taskStatus"] == "ERROR")
         puts "Done loading"
       end
 
@@ -322,10 +590,11 @@ module GoodData
       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
-        @name    = hash['name'] || raise("Data set fields must have their names defined")
-        @title   = hash['title'] || hash['name']
-        @folder  = hash['folder']
+        @name    = hash[:name] || raise("Data set fields must have their names defined")
+        @title   = hash[:title] || hash[:name].humanize
+        @folder  = hash[:folder]
         @schema  = schema
       end
 
@@ -334,7 +603,7 @@ module GoodData
       # non-Latin character and then dropping non-alphanumerical characters.
       #
       def identifier
-        @identifier ||= "#{self.type_prefix}.#{Model::to_id @schema.title}.#{Model::to_id name}"
+        @identifier ||= "#{self.type_prefix}.#{@schema.name}.#{name}"
       end
 
       def to_maql_drop
@@ -343,7 +612,7 @@ module GoodData
 
       def visual
         visual = super
-        visual += ", FOLDER {#{folder_prefix}.#{Model::to_id(folder)}}" if folder
+        visual += ", FOLDER {#{folder_prefix}.#{(folder)}}" if folder
         visual
       end
 
@@ -380,10 +649,10 @@ module GoodData
       end
 
       def table
-        @table ||= "d_" + Model::to_id(@schema.name) + "_" + Model::to_id(name)
+        @table ||= "d_" + @schema.name + "_" + name
       end
 
-      def key ; "#{Model::to_id(@name)}#{FK_SUFFIX}" ; end
+      def key ; "#{@name}#{FK_SUFFIX}" ; end
 
       def to_maql_create
         maql = "CREATE ATTRIBUTE {#{identifier}} VISUAL (#{visual})" \
@@ -413,7 +682,7 @@ module GoodData
       # def initialize(hash, schema)
       def initialize(hash, attribute, schema)
         super hash, schema
-        @attribute = attribute || schema.fields.find {|field| field.name === hash["reference"]}
+        @attribute = attribute || schema.fields.find {|field| field.name === hash[:reference]}
       end
 
       def to_maql_create
@@ -431,7 +700,7 @@ module GoodData
       end
 
       def column
-        "#{@attribute.table}.#{LABEL_COLUMN_PREFIX}#{Model::to_id name}"
+        "#{@attribute.table}.#{LABEL_COLUMN_PREFIX}#{name}"
       end
 
       alias :inspect_orig :inspect
@@ -457,7 +726,7 @@ module GoodData
       end
 
       def table
-        @table ||= "f_" + Model::to_id(@schema.name)
+        @table ||= "f_" + @schema.name
       end
 
       def to_maql_create
@@ -484,7 +753,7 @@ module GoodData
       end
 
       def column
-        @column ||= table + '.' + column_prefix + Model::to_id(name)
+        @column ||= table + '.' + column_prefix + name
       end
 
       def to_maql_create
@@ -508,10 +777,9 @@ module GoodData
       def initialize(column, schema)
         super column, schema
         # pp column
-
-        @name       = column['name']
-        @reference  = column['reference']
-        @schema_ref = column['schema_reference']
+        @name       = column[:name]
+        @reference  = column[:reference]
+        @schema_ref = column[:dataset]
         @schema     = schema
       end
 
@@ -521,13 +789,13 @@ module GoodData
       # from the reference key.
       #
       def identifier
-        @identifier ||= "#{ATTRIBUTE_PREFIX}.#{Model::to_id @schema_ref}.#{Model::to_id @reference}"
+        @identifier ||= "#{ATTRIBUTE_PREFIX}.#{@schema_ref}.#{@reference}"
       end
 
-      def key ; "#{Model::to_id @name}_id" ; end
+      def key ; "#{@name}_id" ; end
 
       def label_column
-        "#{LABEL_PREFIX}.#{Model::to_id @schema_ref}.#{Model::to_id @reference}"
+        "#{LABEL_PREFIX}.#{@schema_ref}.#{@reference}"
       end
 
       def to_maql_create
@@ -551,40 +819,40 @@ module GoodData
     ##
     # Fact representation of a date.
     #
-    class DateFact < Fact
-
-      attr_accessor :format, :output_format
-
-      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')
-      end
-
-      def column_prefix ; DATE_COLUMN_PREFIX ; end
-      def type_prefix ; DATE_FACT_PREFIX ; end
-
-      def to_csv_header(row)
-        "#{name}_fact"
-      end
-
-      def to_csv_data(headers, row)
-        val = row[name]
-        val.nil?() ? nil : (Date.strptime(val, format) - BEGINNING_OF_TIMES).to_i
-        rescue ArgumentError
-          raise "Value \"#{val}\" for column \"#{name}\" did not match the format: #{format}. " +
-            "Perhaps you need to add or change the \"format\" key in the data set configuration."
-      end
-
-      def to_manifest_part(mode)
-        {
-          'populates'  => [ identifier ],
-          'mode'       => mode,
-          'columnName' => "#{name}_fact"
-        }
-      end
-
-    end
+    # class DateFact < Fact
+    # 
+    #   attr_accessor :format, :output_format
+    # 
+    #   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')
+    #   end
+    # 
+    #   def column_prefix ; DATE_COLUMN_PREFIX ; end
+    #   def type_prefix ; DATE_FACT_PREFIX ; end
+    # 
+    #   def to_csv_header(row)
+    #     "#{name}_fact"
+    #   end
+    # 
+    #   def to_csv_data(headers, row)
+    #     val = row[name]
+    #     val.nil?() ? nil : (Date.strptime(val, format) - BEGINNING_OF_TIMES).to_i
+    #     rescue ArgumentError
+    #       raise "Value \"#{val}\" for column \"#{name}\" did not match the format: #{format}. " +
+    #         "Perhaps you need to add or change the \"format\" key in the data set configuration."
+    #   end
+    # 
+    #   def to_manifest_part(mode)
+    #     {
+    #       'populates'  => [ identifier ],
+    #       'mode'       => mode,
+    #       'columnName' => "#{name}_fact"
+    #     }
+    #   end
+    # 
+    # end
 
     ##
     # Date as a reference to a date dimension
@@ -595,13 +863,13 @@ module GoodData
 
       def initialize(column, schema)
         super column, schema
-        @output_format = column["format"] || '("dd/MM/yyyy")'
+        @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"
+        @urn = column[:urn] || "URN:GOODDATA:DATE"
       end
 
       def identifier
-        @identifier ||= "#{Model::to_id @schema_ref}.#{DATE_ATTRIBUTE}"
+        @identifier ||= "#{@schema_ref}.#{DATE_ATTRIBUTE}"
       end
 
       def to_manifest_part(mode)
@@ -614,14 +882,14 @@ module GoodData
         }
       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
+      # 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
 
@@ -677,22 +945,22 @@ module GoodData
         super column, schema
         @parts = {} ; @facts = [] ; @attributes = []; @references = []
 
-        @facts << @parts[:date_fact] = DateFact.new(column, schema)
-        if column['schema_reference'] then
+        # @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
+        # 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
@@ -727,7 +995,7 @@ module GoodData
       end
 
       def to_maql_create
-        "CREATE FOLDER {#{type_prefix}.#{Model::to_id(name)}}" \
+        "CREATE FOLDER {#{type_prefix}.#{name}}" \
             + " VISUAL (#{visual}) TYPE #{type};\n"
       end
     end
@@ -750,13 +1018,25 @@ module GoodData
 
     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:chefs_warehouse_fiscal:date
+        # urn = "urn:chefs_warehouse_fiscal:date"
+        # title = "title"
+        # name = "name"
+
         maql = ""
-        maql += "INCLUDE TEMPLATE \"#{urn}\" MODIFY (IDENTIFIER \"#{name}\", TITLE \"#{title || name}\");"
+        maql += "INCLUDE TEMPLATE \"#{@urn}\" MODIFY (IDENTIFIER \"#{@name}\", TITLE \"#{@title}\");"
         maql
       end
+
     end
 
   end
-end
+end