gooddata 0.2.0

data/LICENSE

@@ -0,0 +1,22 @@
+(BSD License)
+
+Copyright (c) 2010 Thomas Watson Steen & GoodData Corporation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided
+that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and
+       the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions
+       and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of the GoodData Corporation nor the names of its contributors may be used to endorse
+       or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,97 @@
+= GoodData Ruby wrapper and CLI
+
+A convenient Ruby wrapper around the GoodData RESTful API.
+
+Use the Gooddata::Client class to integrate GoodData into your own application
+or use the CLI to work with GoodData directly from the command line.
+
+The best documentation for the API can be found using these resources:
+* http://developer.gooddata.com/api
+* https://secure.gooddata.com/gdc
+
+== Usage
+
+Since this project is in its early stages, no gem have been released to rubygems.org yet.
+To install the gooddata gem, you instead have to first checkout this repository. Then install
+the gem using the rake task:
+
+  rake install
+
+Now you are ready to use either the Ruby wrapper class or the CLI.
+
+Alternatively you can run the source code directly. For details about this approach, see {the
+Development Wiki page}[http://github.com/gooddata/gooddata-ruby/wiki/Development].
+
+=== Wrapper class usage
+
+For details of how to use the Ruby wrapper class, see the Gooddata::Client RDoc.
+
+=== CLI Usage
+
+After installing the gooddata gem, GoodData is available from your command line using
+the <tt>gooddata</tt> command. To get a complete overview of possible options type:
+
+  gooddata help
+
+The examples and descriptions below does not cover all the options available via the CLI.
+So remember to refer back to the <tt>help</tt> command.
+
+Before you do anything else, a good idea is to see if your account is set up correctly and 
+that you can log in. To do this, use the <tt>api:test</tt> command:
+
+  gooddata api:test
+
+==== Authentication
+
+As you saw if you ran the above test command <tt>gooddata</tt> will prompt you
+for your GoodData username and password. If you don't wish to write your
+credentials each time you connect to GoodData using <tt>gooddata</tt>, you can
+create a simple gooddata credentials file called <tt>.gooddata</tt> in the root
+of your home directory. To make it easy you can just run the credentials file
+generator command which will create the file for you:
+
+  gooddata auth:store
+
+==== List available projects
+
+To get a list of projects available to your GoodData user account, run:
+
+  gooddata projects
+
+The output from the above command will look similar to this:
+
+     521  Some project
+    3521  Some other project
+    3642  Some third project
+
+The first column contains the project-key. You need this if you wan't to either
+see more details about the project using the <tt>projects:show</tt> comamnd or
+if you wish to delete the project using the <tt>projects:delete</tt> command.
+
+==== Create a new project
+
+To create a new project under on the GoodData servers, run:
+
+  gooddata projects:create
+
+You will then be asked about the desired project name and summary before it's created.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself we can ignore when we pull)
+* Send us a pull request. Bonus points for topic branches.
+
+== Credits
+
+This project is developed and maintained by Pavel Kolesnikov [ mailto:pavel@gooddata.com
+/ {@koles}[http:/twitter.com/koles] ] and Thomas Watson Steen [ mailto:w@tson.dk /
+{@wa7son}[http://twitter.com/wa7son] ]
+
+== Copyright
+
+Copyright (c) 2010 - 2011 GoodData Corporation and Thomas Watson Steen. See LICENSE for details.

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/bin/gooddata

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'logger'
+
+require 'gooddata'
+require 'gooddata/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+GoodData.logger = Logger.new(STDOUT) if ENV['DEBUG']
+GoodData::Command.run command, args

data/bin/igd.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'gooddata'
+require 'gooddata/command'
+
+require 'irb'
+
+include GoodData
+
+module IRB
+  def IRB.start2(bind, ap_path)
+    IRB.setup(ap_path)
+    irb = Irb.new(WorkSpace.new(bind))
+    @CONF[:MAIN_CONTEXT] = irb.context
+    trap("SIGINT") do
+      irb.signal_handle
+    end
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+param = ARGV.shift if ARGV.length
+if param == '--debug' then
+  require 'logger'
+  GoodData.logger = Logger.new STDOUT
+end
+Command.connect
+puts "Logged into GoodData as #{GoodData.profile.user} (#{GoodData.profile['login']})"
+puts
+IRB::start2 binding, $STDIN
+puts "Logging out"

data/lib/gooddata.rb

@@ -0,0 +1,3 @@
+module GoodData; end
+
+require 'gooddata/client'

data/lib/gooddata/client.rb

@@ -0,0 +1,196 @@
+require 'gooddata/version'
+require 'gooddata/connection'
+Dir[File.dirname(__FILE__) + '/models/*.rb'].each { |file| require file }
+Dir[File.dirname(__FILE__) + '/collections/*.rb'].each { |file| require file }
+
+# = GoodData API wrapper
+#
+# A convenient Ruby wrapper around the GoodData RESTful API.
+#
+# The best documentation for the API can be found using these resources:
+# * http://developer.gooddata.com/api
+# * https://secure.gooddata.com/gdc
+#
+# == Usage
+#
+# To communicate with the API you first need a personal GoodData account.
+# {Sign up here}[https://secure.gooddata.com/registration.html] if you havent already.
+#
+# Now it is just a matter of initializing the GoodData connection via the connect
+# method:
+#
+#   GoodData.connect 'gooddata_user', 'gooddata_password'
+#
+# This GoodData object can now be utalized to retrieve your GoodData profile, the available
+# projects etc.
+#
+# == Logging
+#
+#   GoodData.logger = Logger.new(STDOUT)
+#
+# 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
+
+  class NilLogger
+    def debug(*args) ; end
+    alias :info :debug
+    alias :warn :debug
+    alias :error :debug
+  end
+
+  def project=(project)
+    GoodData.project = project
+    GoodData.project
+  end
+  alias :use :project=
+
+  class << self
+    include Threaded
+
+    RELEASE_INFO_PATH = '/gdc/releaseInfo'
+
+    def version
+      VERSION
+    end
+
+    def gem_version_string
+      "gooddata-gem/#{version}"
+    end
+
+    # Connect to the GoodData API
+    #
+    # === Parameters
+    #
+    # * +user+ - A GoodData username
+    # * +password+ - A GoodData password
+    #
+    def connect(user, password, url = nil)
+      threaded[:connection] = Connection.new user, password, url
+    end
+
+    # Returns the active GoodData connection earlier initialized via
+    # GoodData.connect call
+    #
+    # @see GoodData.connect
+    #
+    def connection
+      threaded[:connection]
+    end
+
+    # Sets the active project
+    #
+    # === Parameters
+    #
+    # * +project+ - a project identifier
+    #
+    # === Examples
+    #
+    # The following calls are equivalent:
+    # * GoodData.project = 'afawtv356b6usdfsdf34vt'
+    # * GoodData.use 'afawtv356b6usdfsdf34vt'
+    # * GoodData.use '/gdc/projects/afawtv356b6usdfsdf34vt'
+    # * GoodData.project = Project['afawtv356b6usdfsdf34vt']
+    #
+    def project=(project)
+      if project.is_a? Project
+        threaded[:project] = project
+      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.
+    #
+    # === Parameters
+    #
+    # * +path+ - The HTTP path on the GoodData server (must be prefixed with a forward slash)
+    # === Examples
+    #
+    #   GoodData.get '/gdc/projects'
+    def get(path)
+      connection.get(path)
+    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
+    #
+    #   GoodData.post '/gdc/projects', { ... }
+    def post(path, data)
+      connection.post path, data
+    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
+    #
+    #   GoodData.delete '/gdc/project/1'
+    def delete(path)
+      connection.delete path
+    end
+
+    def test_login
+      connection.connect!
+      connection.logged_in?
+    end
+
+    # Returns the currently logged in user Profile.
+    def profile
+      threaded[:profile] ||= Profile.load
+    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

data/lib/gooddata/command.rb

@@ -0,0 +1,75 @@
+require 'pp'
+require 'gooddata/helpers'
+require 'gooddata/commands/base'
+Dir[File.dirname(__FILE__) + '/commands/*.rb'].each { |file| require file unless file =~ /\/base.rb$/ }
+
+module GoodData::Command
+  class InvalidCommand < RuntimeError; end
+  class InvalidOption < RuntimeError; end
+  class CommandFailed  < RuntimeError; end
+
+  extend GoodData::Helpers
+
+  class << self
+    def run(command, args)
+      begin
+        run_internal command, args.dup
+      rescue InvalidCommand
+        error "Unknown command. Run 'gooddata help' for usage information."
+      rescue InvalidOption
+        error "Unknown option."
+      rescue RestClient::Unauthorized
+        error "Authentication failure"
+      rescue RestClient::ResourceNotFound => e
+        error extract_not_found(e.http_body)
+      rescue RestClient::RequestFailed => e
+        error extract_error(e.http_body)
+      rescue RestClient::RequestTimeout
+        error "API request timed out. Please try again, or contact support@gooddata.com if this issue persists."
+      rescue CommandFailed => e
+        error e.message
+      rescue Interrupt => e
+        error "\n[canceled]"
+      end
+    end
+
+    def run_internal(command, args)
+      klass, method = parse(command)
+      runner = klass.new(args)
+      raise InvalidCommand unless runner.respond_to?(method)
+      runner.send(method)
+    end
+
+    def parse(command)
+      parts = command.split(':')
+
+      parts << :index if parts.size == 1
+      raise InvalidCommand if parts.size > 2
+
+      begin
+        return GoodData::Command.const_get(parts[0].capitalize), parts[1]
+      rescue NameError
+        raise InvalidCommand
+      end
+    end
+
+    def extract_not_found(body)
+      body =~ /^[\w\s]+ not found$/ ? body : "Resource not found"
+    end
+
+    def extract_error(body)
+      msg = parse_error_json(body) || 'Internal server error'
+      msg.split("\n").map { |line| ' !   ' + line }.join("\n")
+    end
+
+    def parse_error_json(body)
+      begin
+          error = JSON.parse(body.to_s)['error']
+          return error['message'] if !error['parameters']
+          return error['message'] % error['parameters'] rescue error
+      rescue
+          return body
+      end
+    end
+  end
+end