gooddata 0.6.0 → 0.6.2

data/lib/gooddata/cli/commands/project_cmd.rb

@@ -1,32 +1,22 @@
 # encoding: UTF-8
 
+require 'pathname'
 require 'pp'
 
 require_relative '../shared'
-require_relative '../../commands/projects'
+require_relative '../../commands/project'
 
 GoodData::CLI.module_eval do
 
-  desc 'Manage your projects'
+  desc 'Manage your project'
   arg_name 'project_command'
   command :project do |c|
-
-    c.desc "Lists user's projects"
-    c.command :list do |list|
-      list.action do |global_options, options, args|
-        opts = options.merge(global_options)
-        GoodData.connect(opts)
-        list = GoodData::Command::Projects.list()
-        puts list.map { |p| [p.uri, p.title].join(',') }
-      end
-    end
-
     c.desc 'If you are in a gooddata project blueprint or if you provide a project id it will start an interactive session inside that project'
     c.command :jack_in do |jack|
       jack.action do |global_options, options, args|
         goodfile_path = GoodData::Helpers.find_goodfile(Pathname('.'))
 
-        spin_session = Proc.new do |goodfile, blueprint|
+        spin_session = proc do |goodfile, blueprint|
           project_id = global_options[:project_id] || goodfile[:project_id]
           fail "You have to provide 'project_id'. You can either provide it through -p flag or even better way is to fill it in in your Goodfile under key \"project_id\". If you just started a project you have to create it first. One way might be through \"gooddata project build\"" if project_id.nil? || project_id.empty?
 
@@ -37,11 +27,11 @@ GoodData::CLI.module_eval do
             GoodData.with_project(project_id) do |project|
               puts "Use 'exit' to quit the live session. Use 'q' to jump out of displaying a large output."
               binding.pry(:quiet => true,
-                          :prompt => [proc { |target_self, nest_level, pry|
+                          :prompt => [proc do |target_self, nest_level, pry|
                             'project_live_sesion: '
-                          }])
+                          end])
             end
-          rescue GoodData::ProjectNotFound => e
+          rescue GoodData::ProjectNotFound
             puts "Project with id \"#{project_id}\" could not be found. Make sure that the id you provided is correct."
           end
         end
@@ -50,7 +40,7 @@ GoodData::CLI.module_eval do
           goodfile = MultiJson.load(File.read(goodfile_path), :symbolize_keys => true)
           model_key = goodfile[:model]
           blueprint = GoodData::Model::ProjectBlueprint.new(eval(File.read(model_key)).to_hash) if File.exist?(model_key) && !File.directory?(model_key)
-          FileUtils::cd(goodfile_path.dirname) do
+          FileUtils.cd(goodfile_path.dirname) do
             spin_session.call(goodfile, blueprint)
           end
         else
@@ -59,6 +49,7 @@ GoodData::CLI.module_eval do
       end
     end
 
+    # TODO: Move away the ask methods. Provide params
     c.desc 'Create a gooddata project'
     c.command :create do |create|
       create.action do |global_options, options, args|
@@ -69,12 +60,12 @@ GoodData::CLI.module_eval do
 
         opts = options.merge(global_options)
         GoodData.connect(opts)
-        project = GoodData::Command::Projects.create({
-                                                       :title => title,
-                                                       :summary => summary,
-                                                       :template => template,
-                                                       :token => token
-                                                     })
+        project = GoodData::Command::Project.create(
+          :title => title,
+          :summary => summary,
+          :template => template,
+          :token => token
+        )
         puts "Project '#{project.title}' with id #{project.uri} created successfully!"
       end
     end
@@ -85,24 +76,69 @@ GoodData::CLI.module_eval do
         id = global_options[:project_id]
         opts = options.merge(global_options)
         GoodData.connect(opts)
-        GoodData::Command::Projects.delete(id)
+        GoodData::Command::Project.delete(id)
       end
     end
 
     c.desc 'Clones a project. Useful for testing'
     c.command :clone do |clone|
       clone.desc 'Name of the new project'
+
       clone.default_value nil
       clone.arg_name 'cloned_project_name'
-      clone.flag [:n, :name]
+      clone.flag [:t, :title]
+
+      clone.default_value false
+      clone.switch [:u, :users]
+
+      clone.default_value true
+      clone.switch [:d, :data]
 
       clone.action do |global_options, options, args|
+        opts = options.merge(global_options)
         id = global_options[:project_id]
-        name = options[:name]
-        token = options[:token]
+        token = opts[:token]
+
+        fail 'You have to provide a token for creating a project. Please use parameter --token' if token.nil? || token.empty?
+
+        GoodData.connect(opts)
+        GoodData::Command::Project.clone(id, opts)
+      end
+    end
+
+    c.desc 'Invites user to project'
+    c.command :invite do |store|
+      store.action do |global_options, options, args|
+        project_id = global_options[:project_id]
+        fail 'Project ID has to be provided' if project_id.nil? || project_id.empty?
+
+        email = args.first
+        fail 'Email of user to be invited has to be provided' if email.nil? || email.empty?
+
+        role = args[1]
+        fail 'Role name has to be provided' if role.nil? || role.empty?
+
+        msg = args[2]
+        msg = GoodData::Command::Project::DEFAULT_INVITE_MESSAGE if msg.nil? || msg.empty?
+
+        opts = options.merge(global_options)
+        GoodData.connect(opts)
+
+        GoodData::Command::Project.invite(project_id, email, role, msg)
+      end
+    end
+
+    c.desc 'List users'
+    c.command :users do |list|
+      list.action do |global_options, options, args|
         opts = options.merge(global_options)
         GoodData.connect(opts)
-        GoodData::Command::Projects.clone(id, :name => name, :token => token)
+
+        pid = global_options[:project_id]
+        fail 'Project ID has to be provided' if pid.nil? || pid.empty?
+
+        user_list = GoodData::Command::Project.users(pid)
+        puts user_list.map { |u| [u[:last_name], u[:first_name], u[:login], u[:uri]].join(',') }
       end
     end
 
@@ -112,7 +148,7 @@ GoodData::CLI.module_eval do
         id = global_options[:project_id]
         opts = options.merge(global_options)
         GoodData.connect(opts)
-        p = GoodData::Command::Projects.show(id)
+        p = GoodData::Command::Project.show(id)
         pp p.data
       end
     end
@@ -122,8 +158,8 @@ GoodData::CLI.module_eval do
       show.action do |global_options, options, args|
         opts = options.merge(global_options)
         GoodData.connect(opts)
-        spec, project_id = GoodData::Command::Projects.get_spec_and_project_id('.')
-        new_project = GoodData::Command::Projects.build(opts.merge(:spec => spec))
+        spec, _ = GoodData::Command::Project.get_spec_and_project_id('.')
+        new_project = GoodData::Command::Project.build(opts.merge(:spec => spec))
         puts "Project was created. New project PID is #{new_project.pid}, URI is #{new_project.uri}."
       end
     end
@@ -134,12 +170,36 @@ GoodData::CLI.module_eval do
 
         opts = options.merge(global_options)
         GoodData.connect(opts)
-        spec, project_id = GoodData::Command::Projects.get_spec_and_project_id('.')
-        project = GoodData::Command::Projects.update(opts.merge(:spec => spec, :project_id => global_options[:project_id] || project_id))
+        spec, project_id = GoodData::Command::Project.get_spec_and_project_id('.')
+        project_id = global_options[:project_id] || project_id
+        fail 'You have to provide "project_id". You can either provide it through -p flag or even better way is to fill it in in your Goodfile under key "project_id". If you just started a project you have to create it first. One way might be through "gooddata project build"' if project_id.nil? || project_id.empty?
+        project = GoodData::Command::Project.update(opts.merge(:spec => spec, :project_id => project_id))
         puts "Migration was done. Project PID is #{project.pid}, URI is #{project.uri}."
+      end
+    end
+
+    c.desc 'Roles'
+    c.command :roles do |roles|
+      roles.action do |global_options, options, args|
+        project_id = global_options[:project_id]
+        fail 'Project ID has to be provided' if project_id.nil? || project_id.empty?
 
+        opts = options.merge(global_options)
+        GoodData.connect(opts)
+
+        roles = GoodData::Command::Project.roles(project_id)
+
+        puts roles.map { |r| [r['url'], r['role']['projectRole']['meta']['title']].join(',') }
       end
     end
-  end
 
-end
+    c.desc 'You can run project validation which will check RI integrity and other problems.'
+    c.command :validate do |show|
+      show.action do |global_options, options, args|
+        opts = options.merge(global_options)
+        GoodData.connect(opts)
+        pp GoodData::Command::Project.validate(global_options[:project_id])
+      end
+    end
+  end
+end

data/lib/gooddata/cli/commands/projects_cmd.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+require_relative '../shared'
+require_relative '../../commands/projects'
+
+GoodData::CLI.module_eval do
+
+  desc 'Manage your projects'
+  command :projects do |c|
+
+    c.desc "Lists user's projects"
+    c.command :list do |list|
+      list.action do |global_options, options, args|
+        opts = options.merge(global_options)
+        GoodData.connect(opts)
+        list = GoodData::Command::Projects.list
+        puts list.map { |p| [p.uri, p.title].join(',') }
+      end
+    end
+  end
+end

data/lib/gooddata/cli/commands/role_cmd.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+require 'pp'
+
+require_relative '../shared'
+require_relative '../../commands/role'
+
+GoodData::CLI.module_eval do
+  desc 'Basic Role Management'
+  arg_name 'list'
+  command :role do |c|
+    c.desc 'List roles'
+    c.command :list do |list|
+      list.action do |global_options, options, args|
+        opts = options.merge(global_options)
+        GoodData.connect(opts)
+
+        pid = global_options[:project_id]
+        fail 'Project ID has to be provided' if pid.nil? || pid.empty?
+
+        role_list = GoodData::Command::Role.list(pid)
+        role_list.each do |k, v|
+          puts [k, v[:uri]].join(',')
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/cli/commands/run_ruby_cmd.rb

@@ -34,24 +34,24 @@ GoodData::CLI.module_eval do
 
     c.action do |global_options, options, args|
       verbose = global_options[:verbose]
-      options[:expanded_params] = if (options[:params])
+      options[:expanded_params] = if options[:params]
                                     MultiJson.load(File.read(options[:params]))
                                   else
                                     {}
                                   end
 
-      opts = options.merge(global_options).merge({:type => 'RUBY'})
+      opts = options.merge(global_options).merge(:type => 'RUBY')
       GoodData.connect(opts)
       if options[:remote]
         fail 'You have to specify name of the deploy when deploying remotely' if options[:name].nil? || options[:name].empty?
         require_relative '../../commands/process'
-        GoodData::Command::Process.run(options[:dir], opts)
+        GoodData::Command::Process.run(options[:dir], './main.rb', opts)
       else
         require_relative '../../commands/runners'
         GoodData::Command::Runners.run_ruby_locally(options[:dir], opts)
       end
-      puts HighLine::color('Running ruby brick - DONE', HighLine::GREEN) if verbose
+      puts HighLine.color('Running ruby brick - DONE', HighLine::GREEN) if verbose
     end
   end
 
-end
+end

data/lib/gooddata/cli/commands/scaffold_cmd.rb

@@ -31,4 +31,4 @@ GoodData::CLI.module_eval do
     end
   end
 
-end
+end

data/lib/gooddata/cli/commands/{profile_cmd.rb → user_cmd.rb}

@@ -1,24 +1,22 @@
 # encoding: UTF-8
 
-require 'pp'
-
 require_relative '../shared'
-require_relative '../../commands/profile'
+require_relative '../../commands/project'
+require_relative '../../commands/role'
+require_relative '../../commands/user'
 
 GoodData::CLI.module_eval do
 
-  desc 'Describe add here'
-  arg_name 'show'
-  command :profile do |c|
-
+  desc 'User management'
+  command :user do |c|
     c.desc 'Show your profile'
     c.command :show do |show|
       show.action do |global_options, options, args|
         opts = options.merge(global_options)
         GoodData.connect(opts)
-        pp GoodData::Command::Profile.show()
+        pp GoodData::Command::User.show
       end
     end
   end
 
-end
+end

data/lib/gooddata/cli/shared.rb

@@ -3,6 +3,7 @@
 require 'gli'
 
 require_relative '../version'
+require_relative '../core/core'
 
 include GLI::App
 
@@ -28,7 +29,7 @@ GoodData::CLI.module_eval do
   flag [:p, :project_id]
 
   desc 'Server'
-  default_value nil
+  default_value GoodData::Connection::DEFAULT_URL
   arg_name 'server'
   flag [:s, :server]
 
@@ -50,4 +51,4 @@ GoodData::CLI.module_eval do
   arg_name 'logger'
   switch [:l, :logger]
 
-end
+end

data/lib/gooddata/client.rb

@@ -1,30 +1,12 @@
 # encoding: UTF-8
 
+require 'csv'
+
 require_relative 'version'
 require_relative 'connection'
 require_relative 'helpers'
 
-# fastercsv is built in Ruby 1.9
-if RUBY_VERSION < '1.9'
-  require 'fastercsv'
-else
-  require 'csv'
-  FasterCSV = CSV
-end
-
-# Initializes required dynamically loaded classes
-def init_gd_module()
-  # Metadata packages, such as report.rb, require this to be loaded first
-  require_relative 'models/metadata.rb'
-
-  # Load models from models folder
-  Dir[File.dirname(__FILE__) + '/models/*.rb'].each { |file| require file }
-
-  # Load collections
-  Dir[File.dirname(__FILE__) + '/collections/*.rb'].each { |file| require file }
-end
-
-init_gd_module()
+FasterCSV = CSV
 
 # # GoodData API wrapper
 #
@@ -53,301 +35,31 @@ init_gd_module()
 #
 # For details about the logger options and methods, see the
 # (Logger module documentation)[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
-#
-module GoodData
-  module Threaded
-    # Used internally for thread safety
-    def threaded
-      Thread.current[:goooddata] ||= {}
-    end
-  end
-
-  # Dummy implementation of logger
-  class NilLogger
-    def debug(*args)
-      ;
-    end
-
-    alias :info :debug
-    alias :warn :debug
-    alias :error :debug
-  end
-
-  # Assigns global/default GoodData project
-  def project=(project)
-    GoodData.project = project
-    GoodData.project
-  end
 
-  alias :use :project=
+require_relative 'core/core'
 
+module GoodData
   class << self
-    include Threaded
-
     RELEASE_INFO_PATH = '/gdc/releaseInfo'
 
-    # Connect to the GoodData API
-    #
-    # @param options
-    # @param second_options
-    # @param third_options
-    #
-    def connect(options=nil, second_options=nil, third_options={})
-      if options.is_a? Hash
-        fail 'You have to provide login and password' if ((options[:login].nil? || options[:login].empty?) && (options[:password].nil? || options[:password].empty?))
-        threaded[:connection] = Connection.new(options[:login], options[:password], options)
-        GoodData.project = options[:project] if options[:project]
-      elsif options.is_a?(String) && second_options.is_a?(String)
-        fail 'You have to provide login and password' if ((options.nil? || options.empty?) && (second_options.nil? || second_options.empty?))
-        threaded[:connection] = Connection.new(options, second_options, third_options)
-      end
+    # Initializes required dynamically loaded classes
+    def init_module
+      # Metadata packages, such as report.rb, require this to be loaded first
+      require_relative 'models/metadata.rb'
 
-      return threaded[:connection]
-    end
-
-    # Disconnect (logout) if logged in
-    def disconnect
-      if threaded[:connection]
-        threaded[:connection].disconnect
-        threaded[:connection] = nil
-      end
-    end
+      # Load models from models folder
+      Dir[File.dirname(__FILE__) + '/models/*.rb'].each { |file| require file }
 
-    # Turn logging on
-    def logging_on
-      if logger.is_a? NilLogger
-        GoodData::logger = Logger.new(STDOUT)
-      end
-    end
-
-    # Turn logging off
-    def logging_off
-      GoodData::logger = NilLogger.new
-    end
-
-
-    # Hepler for starting with SST easier
-    #
-    # @param token SST token
-    # @param options Options get routed to connect eventually so everything that you can use there should be possible to use here.
-    #
-    def connect_with_sst(token, options={})
-      create_authenticated_connection(options.merge({:cookies => {'GDCAuthSST' => token}}))
-    end
-
-    # This method is aimed at creating an authenticated connection in case you do not hae pass/login but you have SST
-    #
-    # @param options :server => optional GD server uri, If nil it secure will be used. :cookies => you can specify a hash of cookies
-    #
-    def create_authenticated_connection(options={})
-      connect(options)
-      server_cookies = options[:cookies]
-      connection.merge_cookies!(server_cookies)
-      connection.status = :logged_in
-      connection
-    end
-
-    # Perform block in context of another project than currently set
-    #
-    # @param project Project to use
-    # @param bl Block to be performed
-    def with_project(project, &bl)
-      fail 'You have to specify a project when using with_project' if project.nil? || (project.is_a?(String) && project.empty?)
-      old_project = GoodData.project
-      begin
-        GoodData.use(project)
-        bl.call(GoodData.project)
-      rescue RestClient::ResourceNotFound => e
-        fail GoodData::ProjectNotFound.new(e)
-      ensure
-        GoodData.project = old_project
-      end
-    end
-
-    # Returns the active GoodData connection earlier initialized via GoodData.connect call
-    #
-    # @see GoodData.connect
-    def connection
-      threaded[:connection] || raise('Please authenticate with GoodData.connect first')
-    end
-
-    # Sets the active project
-    #
-    # @param project A project identifier
-    #
-    # ### Examples
-    #
-    # The following calls are equivalent
-    #
-    #     # Assign project ID
-    #     GoodData.project = 'afawtv356b6usdfsdf34vt'
-    #
-    #     # Use project ID
-    #     GoodData.use 'afawtv356b6usdfsdf34vt'
-    #
-    #     # Use project URL
-    #     GoodData.use '/gdc/projects/afawtv356b6usdfsdf34vt'
-    #
-    #     # Select project using indexer on GoodData::Project class
-    #     GoodData.project = Project['afawtv356b6usdfsdf34vt']
-    #
-    def project=(project)
-      if project.is_a? Project
-        threaded[:project] = project
-      elsif project.nil?
-        threaded[:project] = nil
-      else
-        threaded[:project] = Project[project]
-      end
-    end
-
-    alias :use :project=
-
-    # Returns the active project
-    #
-    def project
-      threaded[:project]
-    end
-
-    # Performs a HTTP GET request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    #
-    # ### Examples
-    #
-    #     GoodData.get '/gdc/projects'
-    #
-    def get(path, options = {})
-      connection.get(path, options)
-    end
-
-    # Performs a HTTP POST request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    # @param data The payload data in the format of a Hash object
-    #
-    # ### Examples
-    #
-    #     GoodData.post '/gdc/projects', { ... }
-    #
-    def post(path, data, options = {})
-      connection.post path, data, options
-    end
-
-    # Performs a HTTP PUT request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # ### Parameters
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    # @param data The payload data in the format of a Hash object
-    #
-    # ### Examples
-    #
-    #     GoodData.put '/gdc/projects', { ... }
-    #
-    def put(path, data, options = {})
-      connection.put path, data, options
-    end
-
-    # Performs a HTTP DELETE request.
-    #
-    # Retuns the JSON response formatted as a Hash object.
-    #
-    # @param path The HTTP path on the GoodData server (must be prefixed with a forward slash)
-    #
-    # ### Examples
-    #
-    #     GoodData.delete '/gdc/project/1'
-    #
-    def delete(path, options = {})
-      connection.delete path, options
-    end
-
-    def upload_to_user_webdav(file, options={})
-      u = URI(connection.options[:webdav_server] || GoodData.project.links['uploads'])
-      url = URI.join(u.to_s.chomp(u.path.to_s), '/uploads/')
-      connection.upload(file, options.merge({
-                                              :directory => options[:directory],
-                                              :staging_url => url
-                                            }))
-    end
-
-    def get_project_webdav_path(file, options={})
-      u = URI(connection.options[:webdav_server] || GoodData.project.links["uploads"])
-      url = URI.join(u.to_s.chomp(u.path.to_s), "/project-uploads/", "#{GoodData.project.pid}/")
-    end
-
-    def upload_to_project_webdav(file, options={})
-      url = get_project_webdav_path(file, options)
-      connection.upload(file, options.merge({
-                                              :directory => options[:directory],
-                                              :staging_url => url
-                                            }))
-    end
-
-    def get_user_webdav_path(file, options={})
-      u = URI(connection.options[:webdav_server] || GoodData.project.links["uploads"])
-      url = URI.join(u.to_s.chomp(u.path.to_s), "/uploads/")
-    end
-
-    def download_from_user_webdav(file, where, options={})
-      url = get_user_webdav_path(file, options)
-      connection.download(file, where, options.merge({
-                                                       :staging_url => url
-                                                     }))
-    end
-
-    def poll(result, key, options={})
-      sleep_interval = options[:sleep_interval] || 10
-      link = result[key]['links']['poll']
-      response = GoodData.get(link, :process => false)
-      while response.code != 204
-        sleep sleep_interval
-        GoodData.connection.retryable(:tries => 3, :on => RestClient::InternalServerError) do
-          sleep sleep_interval
-          response = GoodData.get(link, :process => false)
-        end
-      end
-    end
-
-    def test_login
-      connection.connect!
-      connection.logged_in?
-    end
-
-    # Returns the currently logged in user Profile.
-    def profile
-      threaded[:profile] ||= Profile.load
+      # Load collections
+      Dir[File.dirname(__FILE__) + '/collections/*.rb'].each { |file| require file }
     end
 
     # Returns information about the GoodData API as a Hash (e.g. version, release time etc.)
     def release_info
       @release_info ||= @connection.get(RELEASE_INFO_PATH)['release']
     end
-
-    # Returns the logger instance. The default implementation
-    # does not log anything
-    # For some serious logging, set the logger instance using
-    # the logger= method
-    #
-    # ### Example
-    #
-    #     require 'logger'
-    #     GoodData.logger = Logger.new(STDOUT)
-    #
-    def logger
-      @logger ||= NilLogger.new
-    end
-
-    # Sets the logger instance
-    def logger=(logger)
-      @logger = logger
-    end
   end
 end
+
+# Init requires
+GoodData.init_module