gooddata 0.2.0

data/lib/gooddata/models/links.rb

@@ -0,0 +1,42 @@
+module GoodData
+  class Links
+    attr_reader :data
+
+    def initialize(items)
+      @data = {}
+      items.values[0]['links'].each do |item|
+        category = item['category']
+        if @data[category] then
+          if @data[category]['category'] == category then
+            @data[category] = { @data[category]['identifier'] => @data[category] }
+          end
+          @data[category][item['identifier']] = item
+        else
+          @data[category] = item
+        end
+      end
+    end
+
+    def links(category, identifier = nil)
+      return Links.new(GoodData.get(self[category])) unless identifier
+      Links.new GoodData.get(get(category, identifier))
+    end
+
+    def [](category)
+      return @data[category]['link'] if @data[category] && @data[category]['link']
+      @data[category]
+    end
+
+    def is_unique?(category)
+      @data[category]['link'].is_a? String
+    end
+
+    def is_ambiguous?(category)
+      !is_unique?(category)
+    end
+
+    def get(category, identifier)
+      self[category][identifier]
+    end
+  end
+end

data/lib/gooddata/models/metadata.rb

@@ -0,0 +1,82 @@
+require 'gooddata/model'
+
+module GoodData
+  class MdObject
+    MD_OBJ_CTG = 'obj'
+    IDENTIFIERS_CFG = 'instance-identifiers'
+
+    class << self
+      def [](id)
+        raise "Cannot search for nil #{self.class}" unless id
+        if id.is_a? Integer or id =~ /^\d+$/
+          uri = "#{GoodData.project.md.link(MD_OBJ_CTG)}/#{id}"
+        elsif id !~ /\//
+          uri = identifier_to_uri id
+        elsif id =~ /^\//
+          uri = id
+        else
+          raise "Unexpected object id format: expected numeric ID, identifier with no slashes or an URI starting with a slash"
+        end
+        self.new((GoodData.get uri).values[0])
+      end
+
+      private
+
+      def identifier_to_uri(id)
+        raise NoProjectError.new "Connect to a project before searching for an object" unless GoodData.project
+        uri      = GoodData.project.md[IDENTIFIERS_CFG]
+        response = GoodData.post uri, { 'identifierToUri' => [id ] }
+        response['identifiers'][0]['uri']
+      end
+    end
+
+    def initialize(json)
+      @json = json
+    end
+
+    def delete
+      raise "Project '#{title}' with id #{uri} is already deleted" if state == :deleted
+      GoodData.delete @json['links']['self']
+    end
+
+    def uri
+      meta['uri']
+    end
+
+    def identifier
+      meta['identifier']
+    end
+
+    def title
+      meta['title']
+    end
+
+    def meta
+      @json['meta']
+    end
+
+    def content
+      @json['content']
+    end
+
+    def project
+      @project ||= Project[uri.gsub(/\/obj\/\d+$/, '')]
+    end
+  end
+
+  class DataSet < MdObject
+    SLI_CTG = 'singleloadinterface'
+    DS_SLI_CTG = 'dataset-singleloadinterface'
+
+    def sli_enabled?
+      content['mode'] == 'SLI'
+    end
+
+    def sli
+      raise NoProjectError.new "Connect to a project before searching for an object" unless GoodData.project
+      slis = GoodData.project.md.links(Model::LDM_CTG).links(SLI_CTG)[DS_SLI_CTG]
+      uri = slis[identifier]['link']
+      MdObject[uri]
+    end
+  end
+end

data/lib/gooddata/models/profile.rb

@@ -0,0 +1,32 @@
+module GoodData
+  class Profile
+    private_class_method :new
+    attr_reader :user
+
+    class << self
+      def load
+        # GoodData.logger.info "Loading user profile..."
+        Profile.send 'new'
+      end
+    end
+
+    def projects
+      @json['accountSetting']['links']['projects']
+    end
+
+    def to_json
+      @json
+    end
+
+    def [](key)
+      @json['accountSetting'][key]
+    end
+
+    private
+
+    def initialize
+      @json = GoodData.get GoodData.connection.user['profile']
+      @user = @json['accountSetting']['firstName'] + " " + @json['accountSetting']['lastName']
+    end
+  end
+end

data/lib/gooddata/models/project.rb

@@ -0,0 +1,136 @@
+require 'zip/zip'
+require 'fileutils'
+
+module GoodData
+  class NoProjectError < RuntimeError ; end
+
+  class Project
+    USERSPROJECTS_PATH = '/gdc/account/profile/%s/projects'
+    PROJECTS_PATH = '/gdc/projects'
+    PROJECT_PATH = '/gdc/projects/%s'
+    SLIS_PATH = '/ldm/singleloadinterface'
+
+    attr_accessor :connection
+
+    class << self
+      # Returns an array of all projects accessible by
+      # current user
+      def all
+        json = GoodData.get GoodData.profile.projects
+        json['projects'].map do |project|
+          Project.new project['project']
+        end
+      end
+
+      # Returns a Project object identified by given string
+      # The following identifiers are accepted
+      #  - /gdc/md/<id>
+      #  - /gdc/projects/<id>
+      #  - <id>
+      #
+      def [](id)
+        if id.to_s !~ /^(\/gdc\/(projects|md)\/)?[a-zA-Z\d]+$/
+          raise ArgumentError.new("wrong type of argument. Should be either project ID or path")
+        end
+
+        id = id.match(/[a-zA-Z\d]+$/)[0] if id =~ /\//
+
+        response = GoodData.get PROJECT_PATH % id
+        Project.new response['project']
+      end
+
+      # Create a project from a given attributes
+      # Expected keys:
+      # - :title (mandatory)
+      # - :summary
+      # - :template (default /projects/blank)
+      #
+      def create(attributes)
+        GoodData.logger.info "Creating project #{attributes[:title]}"
+
+        json = {
+          'meta' => {
+            'title' => attributes[:title],
+            'summary' => attributes[:summary]
+          },
+          'content' => {
+            # 'state' => 'ENABLED',
+            'guidedNavigation' => 1
+          }
+        }
+
+        json['meta']['projectTemplate'] = attributes[:template] if attributes[:template] && !attributes[:template].empty?
+        project = Project.new json
+        project.save
+        project
+      end
+    end
+
+    def initialize(json)
+      @json = json
+    end
+
+    def save
+      response = GoodData.post PROJECTS_PATH, { 'project' => @json }
+      if uri == nil
+        response = GoodData.get response['uri']
+        @json = response['project']
+      end
+    end
+
+    def delete
+      raise "Project '#{title}' with id #{uri} is already deleted" if state == :deleted
+      GoodData.delete @json['links']['self']
+    end
+
+    def uri
+      @json['links']['self'] if @json['links'] && @json['links']['self']
+    end
+
+    def title
+      @json['meta']['title'] if @json['meta']
+    end
+
+    def state
+      @json['content']['state'].downcase.to_sym if @json['content'] && @json['content']['state']
+    end
+
+    def md
+      @md ||= Links.new GoodData.get(@json['links']['metadata'])
+    end
+
+    # Creates a data set within the project
+    #
+    # == Usage
+    # p.add_dataset 'Test', [ { 'name' => 'a1', 'type' => 'ATTRIBUTE' ... } ... ]
+    # p.add_dataset 'title' => 'Test', 'columns' => [ { 'name' => 'a1', 'type' => 'ATTRIBUTE' ... } ... ]
+    #
+    def add_dataset(schema, columns = nil)
+      schema = { 'title' => schema, 'columns' => columns } if columns
+      schema = Model::Schema.new schema if schema.is_a? Hash
+      raise ArgumentError.new("Required either schema object or title plus columns array") unless schema.is_a? Model::Schema
+      Model.add_schema schema, self
+    end
+
+    def upload(file, schema)
+      schema.upload file, self
+    end
+
+    def slis
+      link = "#{@json['links']['metadata']}#{SLIS_PATH}"
+      Metadata.new GoodData.get(link)
+    end
+
+    def datasets
+      datasets_uri  = "#{md['data']}/sets"
+      response      = GoodData.get datasets_uri
+      response['dataSetsInfo']['sets'].map do |ds|
+        DataSet.new ds
+      end
+    end
+
+    def to_json
+      @json
+    end
+  end
+end

data/lib/gooddata/version.rb

@@ -0,0 +1,3 @@
+module GoodData
+  VERSION = "0.1.0"
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'gooddata'
+
+class Test::Unit::TestCase
+end

data/test/test_commands.rb

@@ -0,0 +1,85 @@
+require 'logger'
+require 'tempfile'
+
+require 'helper'
+require 'gooddata/command'
+
+GoodData.logger = Logger.new(STDOUT)
+
+class TestRestApiBasic < Test::Unit::TestCase
+  context "datasets command" do
+    SAMPLE_DATASET_CONFIG = {
+      "columns" => [
+        {
+          "type"  => "CONNECTION_POINT",
+          "name"  => "A1",
+          "title" =>"A1"
+        },
+        {
+          "type"  => "ATTRIBUTE",
+          "name"  => "A2",
+          "title" => "A2",
+          "folder"=> "Test"
+        },
+        {
+          "type"  => "FACT",
+          "name"  => "F2",
+          "title" => "F2 \"asdasd\"",
+          "folder"=> "Test"
+        }
+      ],
+      "title" => "Test"
+    }
+
+    should "list datasets" do
+      GoodData::Command.run "datasets", [ "--project", "FoodMartDemo" ]
+    end
+
+    should "apply a dataset model" do
+      GoodData::Command.connect
+      project = GoodData::Project.create \
+        :title => "gooddata-ruby TestRestApi #{Time.new.to_i}", :template => '/projectTemplates/empty/1'
+
+      Tempfile.open 'gdrb-test-' do |file|
+        file.puts SAMPLE_DATASET_CONFIG.to_json
+        file.close
+        GoodData::Command.run "datasets:apply", [ "--project", project.uri, file.path ]
+      end
+      project.delete
+    end
+  end
+
+  context "projects command" do
+    should "list projects" do
+      GoodData::Command.run "projects", []
+    end
+  end
+
+  context "api command" do
+    should "perform a test login" do
+      GoodData::Command.run "api:test", []
+    end
+
+    should "get FoodMartDemo metadata" do
+      GoodData::Command.run "api:get", [ '/gdc/md/FoodMartDemo' ]
+    end
+  end
+
+  context "profile command" do
+    should "show my GoodData profile" do
+      GoodData::Command.run "profile", []
+    end
+  end
+
+  context "help command" do
+    should "print help screen" do
+      GoodData::Command.run "help", []
+    end
+  end
+
+  context "version command" do
+    should "print version" do
+      GoodData::Command.run "version", []
+    end
+  end
+end

data/test/test_guessing.rb

@@ -0,0 +1,46 @@
+require 'helper'
+require 'gooddata/command'
+
+class TestGuesser < Test::Unit::TestCase
+  should "order LDM types as follows: cp, fact, date, attribute" do
+    assert_equal [ :connection_point, :fact, :date, :attribute ], \
+                 GoodData::Command::Guesser::sort_types([ :fact, :attribute, :connection_point, :date ])
+    assert_equal [ :fact ], GoodData::Command::Guesser::sort_types([ :fact ])
+    assert_equal [], GoodData::Command::Guesser::sort_types([])
+  end
+
+  should "guess facts, dates and connection points from a simple CSV" do
+    csv = [
+      [ 'cp', 'a1', 'a2', 'd1', 'd2', 'f'],
+      [ '1', 'one', 'huh', '2001-01-02', nil, '-1' ],
+      [ '2', 'two', 'blah', nil, '1970-10-23', '2.3' ],
+      [ '3', 'three', 'bleh', '0000-00-00', nil, '-3.14159'],
+      [ '4', 'one', 'huh', '2010-02-28 08:12:34', '1970-10-23', nil ]
+    ]
+    fields = GoodData::Command::Guesser.new(csv).guess(csv.size + 10)
+
+    assert_kind_of Hash, fields, "guesser should return a Hash"
+    fields.each do |field, info|
+      assert_kind_of Array, info, "guess for '%s' is not an Array" % field
+    end
+
+    type_msg_fmt = 'checking guessed types of "%s"'
+
+    assert_equal GoodData::Command::Guesser::sort_types([
+        :connection_point, :fact, :attribute
+      ]), fields['cp'], type_msg_fmt % 'cp'
+
+    assert_equal [ :attribute ], fields['a1'], type_msg_fmt % 'a1'
+    assert_equal [ :attribute ], fields['a2'], type_msg_fmt % 'a2'
+
+    assert_equal GoodData::Command::Guesser::sort_types([
+        :attribute, :connection_point, :date
+      ]), fields['d1'], type_msg_fmt % 'd1'
+    assert_equal GoodData::Command::Guesser::sort_types([
+        :attribute, :date
+      ]), fields['d2'], type_msg_fmt % 'd2'
+    assert_equal GoodData::Command::Guesser::sort_types([
+        :attribute, :connection_point, :fact
+      ]), fields['f'], type_msg_fmt % 'f'
+  end
+end

data/test/test_model.rb

@@ -0,0 +1,63 @@
+require 'logger'
+
+require 'helper'
+require 'gooddata/model'
+require 'gooddata/command'
+
+GoodData.logger = Logger.new(STDOUT)
+
+class TestModel < Test::Unit::TestCase
+  COLUMNS = [
+      { 'type' => 'CONNECTION_POINT', 'name' => 'cp', 'title' => 'CP', 'folder' => 'test' },
+      { 'type' => 'ATTRIBUTE', 'name' => 'a1', 'title' => 'A1', 'folder' => 'test' },
+      { 'type' => 'ATTRIBUTE', 'name' => 'a2', 'title' => 'A2', 'folder' => 'test' },
+      { 'type' => 'DATE', 'name' => 'event', 'title' => 'Event', 'folder' => 'test' },
+      { 'type' => 'FACT', 'name' => 'f1', 'title' => 'F1', 'folder' => 'test' },
+      { 'type' => 'FACT', 'name' => 'f2', 'title' => 'F2', 'folder' => 'test' },
+    ]
+  SCHEMA = GoodData::Model::Schema.new 'title' => 'test', 'columns' => COLUMNS
+
+  context "GoodData model tools" do
+    # Initialize a GoodData connection using the credential
+    # stored in ~/.gooddata
+    setup do
+      GoodData::Command::connect
+    end
+
+    should "generate identifiers star  ting with letters and without ugly characters" do
+      assert_equal 'fact.test.blah', GoodData::Model::Fact.new({ 'name' => 'blah' }, SCHEMA).identifier
+      assert_equal 'attr.test.blah', GoodData::Model::Attribute.new({ 'name' => '1_2_3 blah' }, SCHEMA).identifier
+      assert_equal 'dim.blaz', GoodData::Model::AttributeFolder.new(' b*ĺ*á#ž$').identifier
+    end
+
+    should "create a simple model in a sandbox project using Model.add_dataset" do
+      project = GoodData::Project.create :title => "gooddata-ruby test #{Time.new.to_i}"
+      GoodData.use project
+      objects = GoodData::Model.add_dataset 'Mrkev', COLUMNS
+
+      uris = objects['uris']
+      assert_equal "#{project.md['obj']}/1", uris[0]
+      # fetch last object (temporary objects can be placed at the begining of the list)
+      GoodData.get uris[uris.length - 1]
+
+      # created model should define SLI interface on the 'Mrkev' data set
+      # TODO move this into a standalone test covering gooddata/metadata.rb
+      ds = GoodData::DataSet['dataset.mrkev']
+      assert_not_nil ds
+
+      # clean-up
+      project.delete
+    end
+
+    should "create a simple model in a sandbox project using project.model.add_dataset" do
+      project = GoodData::Project.create :title => "gooddata-ruby test #{Time.new.to_i}"
+      objects = project.add_dataset 'Mrkev', COLUMNS
+
+      uris = objects['uris']
+      assert_equal "#{project.md['obj']}/1", uris[0]
+      # fetch last object (temporary objects can be placed at the begining of the list)
+      GoodData.get uris[uris.length - 1]
+      project.delete
+    end
+  end
+end