gooddata 0.6.7 → 0.6.8

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

@@ -12,8 +12,8 @@ GoodData::CLI.module_eval do
     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
+        client = GoodData.connect(opts)
+        list = GoodData::Command::Projects.list(client: client)
         puts list.map { |p| [p.uri, p.title].join(',') }
       end
     end

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

@@ -9,7 +9,7 @@ require_relative '../../client'
 
 GoodData::CLI.module_eval do
 
-  desc 'Run ruby bricks either locally or remotely deployed on our server'
+  desc 'Run ruby bricks either locally or remotely deployed on our server. Currently private alpha.'
 # arg_name 'show'
   command :run_ruby do |c|
 

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

@@ -13,8 +13,8 @@ GoodData::CLI.module_eval do
     c.command :show do |show|
       show.action do |global_options, options, args|
         opts = options.merge(global_options)
-        GoodData.connect(opts)
-        pp GoodData::Command::User.show
+        client = GoodData.connect(opts)
+        pp GoodData::Command::User.show(client: client)
       end
     end
   end

data/lib/gooddata/cli/hooks.rb

@@ -3,6 +3,8 @@
 require 'gli'
 require 'pp'
 
+require_relative '../helpers/auth_helpers'
+
 GoodData::CLI.module_eval do
   pre do |global, command, options, args|
     require 'logger'
@@ -11,7 +13,7 @@ GoodData::CLI.module_eval do
     password = global[:password]
     token = global[:token]
 
-    creds = GoodData::Command::Auth.read_credentials
+    creds = GoodData::Helpers::AuthHelper.read_credentials
 
     username = creds[:username] if username.nil?
     password = creds[:password] if password.nil?
@@ -39,7 +41,7 @@ GoodData::CLI.module_eval do
     # return false to skip default error handling
     # binding.pry
     # pp exception.backtrace
-    pp exception
+    # pp exception
     true
   end
 end

data/lib/gooddata/cli/shared.rb

@@ -30,7 +30,7 @@ GoodData::CLI.module_eval do
   flag [:p, :project_id]
 
   desc 'Server'
-  default_value GoodData::Connection::DEFAULT_URL
+  default_value GoodData::Rest::Connection::DEFAULT_URL
   arg_name 'server'
   flag [:s, :server]
 

data/lib/gooddata/cli/terminal.rb

@@ -5,7 +5,7 @@ require 'highline'
 # Define GoodData::CLI as GLI Wrapper
 module GoodData
   module CLI
-    DEFAULT_TERMINAL = HighLine.new
+    DEFAULT_TERMINAL = HighLine.new unless const_defined?(:DEFAULT_TERMINAL)
 
     class << self
       def terminal

data/lib/gooddata/commands/api.rb

@@ -25,7 +25,7 @@ module GoodData
         # Test of login
         def test
           if GoodData.test_login
-            puts "Succesfully logged in as #{GoodData.profile.email}"
+            puts "Succesfully logged in as #{GoodData.profile.user}"
           else
             puts 'Unable to log in to GoodData server!'
           end

data/lib/gooddata/commands/auth.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 
 require 'highline/import'
-require 'multi_json'
 
 require_relative '../cli/terminal'
 require_relative '../helpers/helpers'
@@ -10,11 +9,6 @@ module GoodData
   module Command
     class Auth
       class << self
-        # Get path of .gooddata config
-        def credentials_file
-          "#{GoodData::Helpers.home_directory}/.gooddata"
-        end
-
         # Ask for credentials
         def ask_for_credentials
           puts 'Enter your GoodData credentials.'
@@ -25,26 +19,8 @@ module GoodData
           { :username => user, :password => password, :auth_token => auth_token }
         end
 
-        # Read credentials
-        def read_credentials(credentials_file_path = credentials_file)
-          if File.exist?(credentials_file_path)
-            config = File.read(credentials_file_path)
-            MultiJson.load(config, :symbolize_keys => true)
-          else
-            {}
-          end
-        end
-
-        # Writes credentials
-        def write_credentials(credentials, credentials_file_path = credentials_file)
-          File.open(credentials_file_path, 'w', 0600) do |f|
-            f.puts MultiJson.encode(credentials, :pretty => true)
-          end
-          credentials
-        end
-
         # Ask for credentials and store them
-        def store(credentials_file_path = credentials_file)
+        def store(credentials_file_path = Helpers::AuthHelper.credentials_file)
           credentials = ask_for_credentials
 
           ovewrite = if File.exist?(credentials_file_path)
@@ -54,15 +30,15 @@ module GoodData
                      end
 
           if ovewrite == 'y'
-            write_credentials(credentials, credentials_file_path)
+            Helpers::AuthHelper.write_credentials(credentials, credentials_file_path)
           else
             puts 'Aborting...'
           end
         end
 
         # Delete stored credentials
-        def unstore(credentials_file_path = credentials_file)
-          FileUtils.rm_f(credentials_file_path)
+        def unstore(credentials_file_path = Helpers::AuthHelper.credentials_file)
+          Helpers::AuthHelper.remove_credentials_file(credentials_file_path)
         end
       end
     end

data/lib/gooddata/commands/domain.rb

@@ -10,12 +10,17 @@ module GoodData
       attr_reader :name
 
       class << self
-        def add_user(domain, login, password)
-          GoodData::Domain.add_user(domain, login, password)
+        def add_user(domain, login, password, opts = { :client => GoodData.connection })
+          data = {
+            :domain => domain,
+            :login => login,
+            :password => password
+          }
+          GoodData::Domain.add_user(data.merge(opts))
         end
 
-        def list_users(domain)
-          GoodData::Domain.users(domain)
+        def list_users(domain, opts = { :client => GoodData.connection })
+          GoodData::Domain.users(domain, opts)
         end
       end
     end

data/lib/gooddata/commands/process.rb

@@ -8,49 +8,52 @@ module GoodData
   module Command
     class Process
       class << self
-        def list(options = {})
-          GoodData.with_project(options[:project_id]) do
-            GoodData::Process[:all]
-          end
+        def list(options = { :client => GoodData.connection, :project => GoodData.project })
+          GoodData::Process[:all, options]
         end
 
         def get(options = {})
-          id = options[:process_id]
-          fail 'Unspecified process id' if id.nil?
+          pid = options[:project_id]
+          fail ArgumentError, 'None or invalid project_id specified' if pid.nil? || pid.empty?
 
-          GoodData.with_project(options[:project_id]) do
-            GoodData::Process[id]
+          id = options[:process_id]
+          fail ArgumentError, 'None or invalid process_id' if id.nil? || id.empty?
+          c = options[:client]
+          c.with_project(pid) do |project|
+            project.processes(id)
           end
         end
 
-        def delete(process_id, options = {})
-          GoodData.with_project(options[:project_id]) do
-            process = GoodData::Process[process_id]
-            process.delete
+        def delete(process_id, options = { :client => GoodData.connection, :project => GoodData.project })
+          c = options[:client]
+          pid = options[:project_id]
+          process = c.with_project(pid) do |project|
+            project.processes(process_id)
           end
+          process.delete
         end
 
         # TODO: check files_to_exclude param. Does it do anything? It should check that in case of using CLI, it makes sure the files are not deployed
-        def deploy(dir, options = {})
-          GoodData.with_project(options[:project_id]) do
-            params = options[:params].nil? ? [] : [options[:params]]
-            GoodData::Process.deploy(dir, options.merge(:files_to_exclude => params))
+        def deploy(dir, options = { :client => GoodData.connection, :project => GoodData.project })
+          params = options[:params].nil? ? [] : [options[:params]]
+          c = options[:client]
+          pid = options[:project_id]
+          c.with_project(pid) do |project|
+            project.deploy_process(dir, options.merge(:files_to_exclude => params))
           end
         end
 
-        def execute_process(process_id, executable, options = {})
-          GoodData.with_project(options[:project_id]) do
-            process = GoodData::Process[process_id]
-            process.execute_process(executable, options)
-          end
+        def execute_process(process_id, executable, options = { :client => GoodData.connection, :project => GoodData.project })
+          process = GoodData::Process[process_id, options]
+          process.execute_process(executable, options)
         end
 
-        def run(dir, executable, options = {})
+        def run(dir, executable, options = { :client => GoodData.connection, :project => GoodData.project })
           verbose = options[:v]
           dir = Pathname(dir)
           name = options[:name] || "Temporary deploy[#{dir}][#{options[:project_name]}]"
 
-          GoodData::Process.with_deploy(dir, options.merge(:name => name)) do |process|
+          GoodData::Process.with_deploy(dir, options.merge(:name => name, :project_id => ProjectHelper::PROJECT_ID)) do |process|
             puts HighLine.color('Executing', HighLine::BOLD) if verbose
             process.execute(executable, options)
           end

data/lib/gooddata/commands/project.rb

@@ -7,39 +7,49 @@ module GoodData
     class Project
       class << self
         # Create new project based on options supplied
-        def create(options = {})
+        def create(options = { client: GoodData.connection })
           title = options[:title]
           summary = options[:summary]
           template = options[:template]
           token = options[:token]
-
-          GoodData::Project.create(:title => title, :summary => summary, :template => template, :auth_token => token)
+          client = options[:client]
+          GoodData::Project.create(:title => title, :summary => summary, :template => template, :auth_token => token, :client => client)
         end
 
         # Show existing project
-        def show(id)
-          GoodData::Project[id]
+        def show(id, options = { client: GoodData.connection })
+          client = options[:client]
+          client.projects(id)
         end
 
-        def invite(project_id, email, role, msg = GoodData::Project::DEFAULT_INVITE_MESSAGE)
-          msg = GoodData::Project::DEFAULT_INVITE_MESSAGE if msg.nil? || msg.empty?
-
-          project = GoodData::Project[project_id]
+        def invite(project_id, email, role, msg = GoodData::Project::DEFAULT_INVITE_MESSAGE, options = {})
+          client = options[:client]
+          project = client.projects(project_id)
           fail "Invalid project id '#{project_id}' specified" if project.nil?
 
           project.invite(email, role, msg)
         end
 
         # Clone existing project
-        def clone(project_id, options)
-          GoodData.with_project(project_id) do |project|
+        #
+        # @param project_id [String | GoodData::Project] Project id or project instance to delete
+        # @option options [String] :data Clone including all the data (default true)
+        # @option options [String] :users Clone including all the users (default false)
+        # @option options [String] :title Name of the cloned project (default "Clone of {old_project_title}")
+        # @option options [Boolean] :verbose (false) Switch on verbose mode for detailed logging
+        def clone(project_id, options = { client: GoodData.connection })
+          client = options[:client]
+          client.with_project(project_id) do |project|
             project.clone(options)
           end
         end
 
-        # Delete existing project
-        def delete(project_id)
-          p = GoodData::Project[project_id]
+        # Deletes existing project
+        #
+        # @param project_id [String | GoodData::Project] Project id or project instance to delete
+        def delete(project_id, options = { client: GoodData.connection })
+          client = options[:client]
+          p = client.projects(project_id)
           p.delete
         end
 
@@ -62,47 +72,35 @@ module GoodData
           [spec, goodfile[:project_id]]
         end
 
-        def list_users(pid)
-          users = []
-          finished = false
-          offset = 0
-          # Limit set to 1000 to be safe
-          limit = 1000
-          until finished
-            result = GoodData.get('/gdc/projects/#{pid}/users?offset=#{offset}&limit=#{limit}')
-            result['users'].map do |u|
-              as = u['user']
-              users.push(
-                  :login => as['content']['email'],
-                  :uri => as['links']['self'],
-                  :first_name => as['content']['firstname'],
-                  :last_name => as['content']['lastname'],
-                  :role => as['content']['userRoles'].first,
-                  :status => as['content']['status']
-            )
-            end
-            if result['users'].count == limit
-              offset += limit
-            else
-              finished = true
-            end
-          end
-          users
-        end
-
         # Update project
-        def update(options = {})
-          project = options[:project]
-          GoodData::Model::ProjectCreator.migrate(:spec => options[:spec], :project => project)
+        def update(opts = { client: GoodData.connection })
+          client = opts[:client]
+          fail ArgumentError, 'No :client specified' if client.nil?
+
+          p = opts[:project]
+          fail ArgumentError, 'No :project specified' if p.nil?
+
+          project = GoodData::Project[p, opts]
+          fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+          GoodData::Model::ProjectCreator.migrate(:spec => opts[:spec], :client => client, :project => project)
         end
 
         # Build project
-        def build(options = {})
-          GoodData::Model::ProjectCreator.migrate(:spec => options[:spec], :token => options[:token])
+        def build(opts = { client: GoodData.connection })
+          client = opts[:client]
+          fail ArgumentError, 'No :client specified' if client.nil?
+
+          GoodData::Model::ProjectCreator.migrate(:spec => opts[:spec], :token => opts[:token], :client => client)
         end
 
-        def validate(project_id)
-          GoodData.with_project(project_id) do |p|
+        # Performs project validation
+        #
+        # @param project_id [String | GoodData::Project] Project id or project instance to validate
+        # @return [Object] Report of found problems
+        def validate(project_id, options = { client: GoodData.connection })
+          client = options[:client]
+          client.with_project(project_id) do |p|
             p.validate
           end
         end
@@ -120,7 +118,11 @@ module GoodData
 
             begin
               require 'gooddata'
-              GoodData.with_project(project_id) do |project|
+              client = GoodData.connect(options)
+
+              GoodData.with_project(project_id, :client => client) do |project|
+                fail ArgumentError, 'Wrong project specified' if project.nil?
+
                 puts "Use 'exit' to quit the live session. Use 'q' to jump out of displaying a large output."
                 binding.pry(:quiet => true,
                             :prompt => [proc do |target_self, nest_level, pry|
@@ -143,6 +145,28 @@ module GoodData
             spin_session.call({}, nil)
           end
         end
+
+        # Lists roles in a project
+        #
+        # @param project_id [String | GoodData::Project] Project id or project instance to list the users in
+        # @return [Array <GoodData::Role>] List of project roles
+        def roles(project_id, options = { client: GoodData.connection })
+          client = options[:client]
+          client.with_project(project_id) do |p|
+            p.roles
+          end
+        end
+
+        # Lists users in a project
+        #
+        # @param project_id [String | GoodData::Project] Project id or project instance to list the users in
+        # @return [Array <GoodData::Membership>] List of project users
+        def users(project_id, options = { client: GoodData.connection })
+          client = options[:client]
+          client.with_project(project_id) do |p|
+            p.users
+          end
+        end
       end
     end
   end

data/lib/gooddata/commands/projects.rb

@@ -6,8 +6,9 @@ module GoodData
   module Command
     class Projects
       class << self
-        def list
-          GoodData::Project.all
+        def list(options = { client: GoodData.connection })
+          client = options[:client]
+          client.projects
         end
       end
     end

data/lib/gooddata/commands/role.rb

@@ -6,12 +6,18 @@ module GoodData
   module Command
     class Role
       class << self
-        def list(pid)
-          roles_response = GoodData.get("/gdc/projects/#{pid}/roles")
+        def list(pid, opts = { :client => GoodData.connection, :project => GoodData.project })
+          p = opts[:project]
+          fail ArgumentError, 'No :project specified' if p.nil?
+
+          project = GoodData::Project[p, opts]
+          fail ArgumentError, 'Wrong :project specified' if project.nil?
+
+          roles_response = client.get("/gdc/projects/#{project.pid}/roles")
 
           roles = {}
           roles_response['projectRoles']['roles'].each do |role_uri|
-            r = GoodData.get(role_uri)
+            r = client.get(role_uri)
             identifier = r['projectRole']['meta']['identifier']
             roles[identifier] = {
               :user_uri => r['projectRole']['links']['roleUsers'],