gooddata 0.2.0

data/lib/gooddata/commands/profile.rb

@@ -0,0 +1,9 @@
+module GoodData::Command
+  class Profile < Base
+    def show
+      connect
+      pp GoodData.profile.to_json
+    end
+    alias :index :show
+  end
+end

data/lib/gooddata/commands/projects.rb

@@ -0,0 +1,51 @@
+module GoodData
+  module Command
+    class Projects < Base
+      def list
+        connect
+        Project.all.each do |project|
+          puts "%s  %s" % [project.uri, project.title]
+        end
+      end
+      alias :index :list
+
+      def create
+        connect
+
+        title = ask "Project name"
+        summary = ask "Project summary"
+        template = ask "Project template", :default => ''
+
+        project = Project.create :title => title, :summary => summary, :template => template
+
+        puts "Project '#{project.title}' with id #{project.uri} created successfully!"
+      end
+
+      def show
+        id = args.shift rescue nil
+        raise(CommandFailed, "Specify the project key you wish to show.") if id.nil?
+        connect
+        pp Project[id].to_json
+      end
+
+      def delete
+        raise(CommandFailed, "Specify the project key(s) for the project(s) you wish to delete.") if args.size == 0
+        connect
+        while args.size > 0
+          id = args.shift
+          project = Project[id]
+          ask "Do you want to delete the project '#{project.title}' with id #{project.uri}", :answers => %w(y n) do |answer|
+            case answer
+            when 'y' then
+              puts "Deleting #{project.title}..."
+              project.delete
+              puts "Project '#{project.title}' with id #{project.uri} deleted successfully!"
+            when 'n' then
+              puts "Aborting..."
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/commands/version.rb

@@ -0,0 +1,7 @@
+module GoodData::Command
+  class Version < Base
+    def index
+      puts GoodData.gem_version_string
+    end
+  end
+end

data/lib/gooddata/connection.rb

@@ -0,0 +1,220 @@
+require 'json/pure'
+require 'net/ftptls'
+
+# silence the parenthesis warning in rest-client 1.6.1
+old_verbose, $VERBOSE = $VERBOSE, nil ; require 'rest-client' ; $VERBOSE = old_verbose
+
+module GoodData
+
+  # = GoodData HTTP wrapper
+  #
+  # Provides a convenient HTTP wrapper for talking with the GoodData API.
+  #
+  # Remember that the connection is shared amongst the entire application.
+  # Therefore you can't be logged in to more than _one_ GoodData account.
+  # per session. Simultaneous connections to multiple GoodData accounts is not
+  # supported at this time.
+  #
+  # The GoodData API is a RESTful API that communicates using JSON. This wrapper
+  # makes sure that the session is stored between requests and that the JSON is
+  # parsed both when sending and receiving.
+  #
+  # == Usage
+  #
+  # Before a connection can be made to the GoodData API, you have to supply the user
+  # credentials using the set_credentials method:
+  #
+  #   Connection.new(username, password).set_credentials(username, password)
+  #
+  # To send a HTTP request use either the get, post or delete methods documented below.
+  #
+  class Connection
+
+    DEFAULT_URL = 'https://secure.gooddata.com'
+    LOGIN_PATH = '/gdc/account/login'
+    TOKEN_PATH = '/gdc/account/token'
+
+    # Set the GoodData account credentials.
+    #
+    # This have to be performed before any calls to the API.
+    #
+    # === Parameters
+    #
+    # * +username+ - The GoodData account username
+    # * +password+ - The GoodData account password
+    def initialize(username, password, url = nil)
+      @status   = :not_connected
+      @username = username
+      @password = password
+      @url      = url || DEFAULT_URL
+    end
+
+    # Returns the user JSON object of the currently logged in GoodData user account.
+    def user
+      ensure_connection
+      @user
+    end
+
+    # Performs a HTTP GET request.
+    #
+    # Retuns the JSON response formatted as a Hash object.
+    #
+    # === Parameters
+    #
+    # * +path+ - The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    #
+    # === Examples
+    #
+    #   Connection.new(username, password).get '/gdc/projects'
+    def get(path, options = {})
+      GoodData.logger.debug "GET #{path}"
+      ensure_connection
+      process_response(options) { @server[path].get cookies }
+    end
+
+    # Performs a HTTP POST request.
+    #
+    # Retuns the JSON response formatted as a Hash object.
+    #
+    # === Parameters
+    #
+    # * +path+ - The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    # * +data+ - The payload data in the format of a Hash object
+    #
+    # === Examples
+    #
+    #   Connection.new(username, password).post '/gdc/projects', { ... }
+    def post(path, data, options = {})
+      payload = data.to_json
+      GoodData.logger.debug "POST #{path}, payload: #{payload}"
+      ensure_connection
+      process_response(options) { @server[path].post payload, cookies }
+    end
+
+    # Performs a HTTP DELETE request.
+    #
+    # Retuns the JSON response formatted as a Hash object.
+    #
+    # === Parameters
+    #
+    # * +path+ - The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    #
+    # === Examples
+    #
+    #   Connection.new(username, password).delete '/gdc/project/1'
+    def delete(path)
+      GoodData.logger.debug "DELETE #{path}"
+      ensure_connection
+      process_response { @server[path].delete cookies }
+    end
+
+    # Get the cookies associated with the current connection.
+    def cookies
+      @cookies ||= { :cookies => {} }
+    end
+
+    # Set the cookies used when communicating with the GoodData API.
+    def merge_cookies!(cookies)
+      self.cookies
+      @cookies[:cookies].merge! cookies
+    end
+
+    # Returns true if a connection have been established to the GoodData API
+    # and the login was successful.
+    def logged_in?
+      @status == :logged_in
+    end
+
+    # The connection will automatically be established once it's needed, which it
+    # usually is when either the user, get, post or delete method is called. If you
+    # want to force a connection (or a re-connect) you can use this method.
+    def connect!
+      connect
+    end
+
+    # Uploads a file to GoodData server via FTPS
+    def upload(file, dir = nil)
+      Net::FTPTLS.open('secure-di.gooddata.com', @username, @password) do |ftp|
+        ftp.passive = true
+        if dir then
+          begin ; ftp.mkdir dir ; rescue ; ensure ; ftp.chdir dir ; end
+        end
+        ftp.binary = true
+        ftp.put file
+      end
+    end
+
+    private
+
+    def ensure_connection
+      connect if @status == :not_connected
+    end
+
+    def connect
+      # GoodData.logger.info "Connecting to GoodData..."
+      @status = :connecting
+      authenticate
+    end
+
+    def authenticate
+      credentials = {
+        'postUserLogin' => {
+          'login' => @username,
+          'password' => @password,
+          'remember' => 1
+        }
+      }
+
+      @server = RestClient::Resource.new @url, :headers => {
+        :content_type => :json,
+        :accept => [ :json, :zip ],
+        :user_agent => GoodData.gem_version_string
+      }
+
+      GoodData.logger.debug "Logging in..."
+      @user = post(LOGIN_PATH, credentials, :dont_reauth => true)['userLogin']
+      refresh_token :dont_reauth => true # avoid infinite loop if refresh_token fails with 401
+
+      @status = :logged_in
+    end
+
+    def process_response(options = {})
+      begin
+        begin
+          response = yield
+        rescue RestClient::Unauthorized
+          raise $! if options[:dont_reauth]
+          refresh_token
+          response = yield
+        end
+        merge_cookies! response.cookies
+        content_type = response.headers[:content_type]
+        if content_type == "application/json" then
+          result = response.to_str == '""' ? {} : JSON.parse(response.to_str)
+          GoodData.logger.debug "Response: #{result.inspect}"
+        elsif content_type == "application/zip" then
+          result = response
+          GoodData.logger.debug "Response: a zipped stream"
+        elsif response.headers[:content_length].to_s == '0'
+          result = nil
+        else
+          raise "Unsupported response content type '%s':\n%s" % [ content_type, response.to_str[0..127] ]
+        end
+        result
+      rescue RestClient::Exception => e
+        GoodData.logger.debug "Response: #{e.response}"
+        raise $!
+      end
+    end
+
+    def refresh_token(options = {})
+      GoodData.logger.debug "Getting authentication token..."
+      begin
+        get TOKEN_PATH, :dont_reauth => true # avoid infinite loop GET fails with 401
+      rescue RestClient::Unauthorized
+        raise $! if options[:dont_reauth]
+        authenticate
+      end
+    end
+  end
+end

data/lib/gooddata/extract.rb

@@ -0,0 +1,13 @@
+require 'csv'
+
+module GoodData::Extract  
+  class CsvFile
+    def initialize(file)
+      @file = file
+    end
+
+    def read(&block)
+      CSV.open @file, 'r', &block
+    end
+  end
+end

data/lib/gooddata/helpers.rb

@@ -0,0 +1,18 @@
+module GoodData::Helpers
+  def home_directory
+    running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+  end
+
+  def running_on_windows?
+    RUBY_PLATFORM =~ /mswin32|mingw32/
+  end
+
+  def running_on_a_mac?
+    RUBY_PLATFORM =~ /-darwin\d/
+  end
+
+  def error(msg)
+    STDERR.puts(msg)
+    exit 1
+  end
+end

data/lib/gooddata/model.rb

@@ -0,0 +1,558 @@
+require 'iconv'
+require 'fastercsv'
+
+##
+# Module containing classes that counter-part GoodData server-side meta-data
+# elements, including the server-side data model.
+#
+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'
+    FACT_PREFIX = 'fact'
+    DATE_FACT_PREFIX = 'dt'
+    TIME_FACT_PREFIX = 'tm.dt'
+    TIME_ATTRIBUTE_PREFIX = 'attr.time'
+    FACT_FOLDER_PREFIX = 'ffld'
+
+    class << self
+      def add_dataset(title, columns, project = nil)
+        add_schema Schema.new('columns' => columns, 'title' => title), project
+      end
+
+      def add_schema(schema, project = nil)
+        unless schema.is_a?(Schema) || 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
+        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
+    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}.#{Model::to_id(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
+
+      def self.load(file)
+        Schema.new JSON.load(open(file))
+      end
+
+      def initialize(config, title = nil)
+        @fields = []
+        config['title'] = title unless config['title']
+        raise 'Schema name not specified' unless config['title']
+        self.title = config['title']
+        self.config = config
+      end
+
+      def config=(config)
+        labels = []
+        config['columns'].each do |c|
+          add_attribute c if c['type'] == 'ATTRIBUTE'
+          add_fact c if c['type'] == 'FACT'
+          add_date c if c['type'] == 'DATE'
+          set_connection_point c if c['type'] == 'CONNECTION_POINT'
+          labels.push c if c['type'] == 'LABEL'
+        end
+        @connection_point = RecordsOf.new(nil, self) unless @connection_point
+      end
+
+      def title=(title)
+        @name = title
+        @title = title
+      end
+
+      def type_prefix ; 'dataset' ; end
+
+      def attributes; @attributes ||= {} ; end
+      def facts; @facts ||= {} ; end
+      def folders; @folders ||= {}; end
+
+      ##
+      # Underlying fact table name
+      #
+      def table
+        @table ||= FACT_COLUMN_PREFIX + Model::to_id(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
+        maql = "# Create the '#{self.title}' data set\n"
+        maql += "CREATE DATASET {#{self.identifier}} VISUAL (TITLE \"#{self.title}\");\n\n"
+        [ attributes, facts, { 1 => @connection_point } ].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
+        folders_maql = "# Create folders\n"
+        folders.keys.each { |folder| folders_maql += folder.to_maql_create }
+        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)
+        path = path.path if path.respond_to? :path
+        project = GoodData.project unless project
+
+        # create a temporary zip file
+        dir = Dir.mktmpdir
+        Zip::ZipFile.open("#{dir}/upload.zip", Zip::ZipFile::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) }
+          zip.get_output_stream('data.csv') do |f|
+            FasterCSV.foreach(path) { |row| f.puts row.to_csv }
+          end
+        end
+
+        # upload it
+        GoodData.connection.upload "#{dir}/upload.zip", File.basename(dir)
+        FileUtils.rm_rf dir
+
+        # kick the load
+        pull = { 'pullIntegration' => File.basename(dir) }
+        link = project.md.links('etl')['pull']
+        GoodData.post link, pull
+      end
+
+      # Generates the SLI manifest describing the data loading
+      #
+      def to_manifest
+        {
+          'dataSetSLIManifest' => {
+            'parts'   => fields.map { |f| f.to_manifest_part },
+            'dataSet' => self.identifier,
+            'file'    => 'data.csv', # should be configurable
+            'csvParams' => {
+              'quoteChar'     => '"',
+              'escapeChar'    => '"',
+              'separatorChar' => ',',
+              'endOfLine'     => "\n"
+            }
+          }
+        }
+      end
+
+      private
+
+      def add_attribute(column)
+        attribute = Attribute.new column, self
+        @fields << attribute
+        add_to_hash(self.attributes, attribute)
+        folders[AttributeFolder.new(attribute.folder)] = 1 if attribute.folder
+      end
+
+      def add_fact(column)
+        fact = Fact.new column, self
+        @fields << fact
+        add_to_hash(self.facts, fact)
+        folders[FactFolder.new(fact.folder)] = 1 if fact.folder
+      end
+
+      def add_date(column)
+        date = DateColumn.new column, self
+        date.parts.values.each { |p| @fields << p }
+        date.facts.each { |f| add_to_hash(self.facts, f) }
+        date.attributes.each { |a| add_to_hash(self.attributes, a) }
+        @fields << date
+      end
+
+      def set_connection_point(column)
+        @connection_point = RecordsOf.new column, self
+        @fields << @connection_point
+      end
+
+      def add_to_hash(hash, obj); hash[obj.identifier] = obj; 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)
+        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']
+        @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}.#{Model::to_id @schema.title}.#{Model::to_id name}"
+      end
+
+      def to_maql_drop
+        "DROP {#{self.identifier}};\n"
+      end
+
+      def visual
+        visual = super
+        visual += ", FOLDER {#{folder_prefix}.#{Model::to_id(folder)}}" if folder
+        visual
+      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
+
+      def type_prefix ; ATTRIBUTE_PREFIX ; end
+      def folder_prefix; ATTRIBUTE_FOLDER_PREFIX; end
+
+      def initialize(hash, schema)
+        super hash, schema
+        @primary_label = Label.new hash, self, schema
+      end
+
+      def table
+        @table ||= "d_" + Model::to_id(@schema.name) + "_" + Model::to_id(name)
+      end
+
+      def key ; "#{Model::to_id(@name)}#{FK_SUFFIX}" ; end
+
+      def to_maql_create
+        "CREATE ATTRIBUTE {#{identifier}} VISUAL (#{visual})" \
+               + " AS KEYS {#{table}.#{Model::FIELD_PK}} FULLSET;\n" \
+               + @primary_label.to_maql_create
+      end
+
+      def to_manifest_part
+        {
+          'referenceKey' => 1,
+          'populates' => [ @primary_label.identifier ],
+          'mode' => 'FULL',
+          'columnName' => name
+        }
+      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
+      def type_prefix ; 'label' ; end
+
+      def initialize(hash, attribute, schema)
+        super hash, schema
+        @attribute = attribute
+      end
+
+      def to_maql_create
+        "ALTER ATTRIBUTE {#{@attribute.identifier}} ADD LABELS {#{identifier}}" \
+              + " VISUAL (TITLE #{title.inspect}) AS {#{column}};\n"
+      end
+
+      def to_manifest_part
+        {
+          'populates'  => [ identifier ],
+          'mode'       => 'FULL',
+          'columnName' => name
+        }
+      end
+
+      def column
+        "#{@attribute.table}.#{LABEL_COLUMN_PREFIX}#{Model::to_id 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 RecordsOf < Attribute
+      def initialize(column, schema)
+        if column then
+          super
+        else
+          @name = 'id'
+          @title = "Records of #{schema.name}"
+          @folder = nil
+          @schema = schema
+        end
+      end
+
+      def table
+        @table ||= "f_" + Model::to_id(@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 + Model::to_id(name)
+      end
+
+      def to_maql_create
+        "CREATE FACT {#{self.identifier}} VISUAL (#{visual})" \
+               + " AS {#{column}};\n"
+      end
+
+      def to_manifest_part
+        {
+          'populates'  => [ identifier ],
+          'mode'       => 'FULL',
+          'columnName' => column
+        }
+      end
+    end
+
+    ##
+    # Reference to another data set
+    #
+    class Reference
+      def initialize(column, schema)
+        @name       = column['name']
+        @reference  = column['reference']
+        @schema_ref = column['schema_ref']
+        @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}.#{Model::to_id @schema_ref.title}.#{Model::to_id @reference}"
+      end
+
+      def key ; "#{Model::to_id @name}_id" ; end
+
+      def label_column
+        @column ||= "#{@schema.table}.#{LABEL_COLUMN_PREFIX Model::to_id(reference)}"
+      end
+
+      def to_maql_create
+        "ALTER ATTRIBUTE {#{self.identifier} ADD KEYS {#{@schema.table}.#{key}}"
+      end
+
+      def to_maql_drop
+        "ALTER ATTRIBUTE {#{self.identifier} DROP KEYS {#{@schema.table}.#{key}}"
+      end
+
+      def to_manifest_part
+        {
+          'populates'  => [ identifier ],
+          'mode'       => 'FULL',
+          'columnName' => label_column
+        }
+      end
+    end
+
+    ##
+    # Fact representation of a date.
+    #
+    class DateFact < Fact
+      def column_prefix ; DATE_COLUMN_PREFIX ; end
+      def type_prefix ; DATE_FACT_PREFIX ; end
+    end
+
+    ##
+    # Date as a reference to a date dimension
+    #
+    class DateReference < Reference
+
+    end
+
+    ##
+    # Date field that's not connected to a date dimension
+    #
+    class DateAttribute < Attribute
+      def key ; "#{DATE_COLUMN_PREFIX}#{super}" ; 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
+      attr_reader :parts, :facts, :attributes
+
+      def initialize(column, schema)
+        @parts = {} ; @facts = [] ; @attributes = []
+
+        @facts << @parts[:date_fact] = DateFact.new(column, schema)
+        if column['schemaReference'] then
+          @parts[:date_ref] = DateReference.new column, schema
+        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['schemaReference'] 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
+    end
+
+    ##
+    # Base class for GoodData attribute and fact folder abstractions
+    #
+    class Folder < MdObject
+      def initialize(title)
+        @title = title
+        @name = title
+      end
+
+      def to_maql_create
+        "CREATE FOLDER {#{type_prefix}.#{Model::to_id(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
+  end
+end