gooddata 0.2.0

data/lib/gooddata/commands/api.rb

@@ -0,0 +1,37 @@
+module GoodData::Command
+  class Api < Base
+    def info
+      json = gooddata.release_info
+      puts "GoodData API"
+      puts "  Version: #{json['releaseName']}"
+      puts "  Released: #{json['releaseDate']}"
+      puts "  For more info see #{json['releaseNotesUri']}"
+    end
+    alias :index :info
+
+    def test
+      connect
+      if GoodData.test_login
+        puts "Succesfully logged in as #{GoodData.profile.user}"
+      else
+        puts "Unable to log in to GoodData server!"
+      end
+    end
+
+    def get
+      path = args.shift rescue nil
+      raise(CommandFailed, "Specify the path you want to GET.") if path.nil?
+      connect
+      result = GoodData.get path
+      jj result rescue puts result
+    end
+
+    def delete
+      path = args.shift rescue nil
+      raise(CommandFailed, "Specify the path you want to DELETE.") if path.nil?
+      connect
+      result = GoodData.delete path
+      jj result rescue puts result
+    end
+  end
+end

data/lib/gooddata/commands/auth.rb

@@ -0,0 +1,74 @@
+module GoodData::Command
+  class Auth < Base
+    def connect
+      unless defined? @connected
+        GoodData.connect user, password, url
+        @connected = true
+      end
+      @connected
+    end
+
+    def user
+      ensure_credentials
+      @credentials[:username]
+    end
+
+    def password
+      ensure_credentials
+      @credentials[:password]
+    end
+
+    def url
+      ensure_credentials
+      @credentials[:url]
+    end
+
+    def credentials_file
+      "#{home_directory}/.gooddata"
+    end
+
+    def ensure_credentials
+      return if defined? @credentials
+      unless @credentials = read_credentials
+        @credentials = ask_for_credentials
+      end
+      @credentials
+    end
+
+    def read_credentials
+      if File.exists?(credentials_file) then
+        config = File.read(credentials_file)
+        JSON.parser.new(config, :symbolize_names => true).parse
+      end
+    end
+
+    def ask_for_credentials
+      puts "Enter your GoodData credentials."
+      user = ask("Email")
+      password = ask("Password", :secret => true)
+      { :username => user, :password => password }
+    end
+
+    def store
+      credentials = ask_for_credentials
+
+      ovewrite = if File.exist?(credentials_file)
+        ask "Overwrite existing stored credentials", :answers => %w(y n)
+      else
+        'y'
+      end
+
+      if ovewrite == 'y'
+        File.open(credentials_file, 'w', 0600) do |f|
+          f.puts JSON.pretty_generate(credentials)
+        end
+      else
+        puts 'Aborting...'
+      end
+    end
+
+    def unstore
+      FileUtils.rm_f(credentials_file)
+    end
+  end
+end

data/lib/gooddata/commands/base.rb

@@ -0,0 +1,80 @@
+module GoodData
+  module Command
+
+    # Initializes GoodData connection with credentials loaded from
+    # ~/.gooddata. If the file doesn't exist or doesn't contain
+    # necessary information, a command line prompt will be issued
+    # using the GoodData::Command::Base#ask method
+    #
+    def self.connect
+      run_internal('auth:connect', [])
+    end
+
+    class Base
+      include GoodData::Helpers
+
+      attr_accessor :args
+
+      def initialize(args)
+        @args = args
+      end
+
+      def connect
+        @connected ||= Command.connect
+        GoodData.connection
+      end
+
+      def extract_option(options, default=true)
+        values = options.is_a?(Array) ? options : [options]
+        return unless opt_index = args.select { |a| values.include? a }.first
+        opt_position = args.index(opt_index) + 1
+        if args.size > opt_position && opt_value = args[opt_position]
+          if opt_value.include?('--')
+            opt_value = nil
+          else
+            args.delete_at(opt_position)
+          end
+        end
+        opt_value ||= default
+        args.delete(opt_index)
+        block_given? ? yield(opt_value) : opt_value
+      end
+
+      def ask(question, options = {})
+        begin
+          if options.has_key? :answers
+            answer = nil
+            while !options[:answers].include?(answer)
+              answer = get_answer "#{question} [#{options[:answers].join(',')}]? ", options[:secret]
+            end
+          else
+            question = "#{question} [#{options[:default]}]" if options[:default]
+            answer = get_answer "#{question}: ", options[:secret], options[:default]
+          end
+          puts if options[:secret] # extra line-break
+        rescue NoMethodError, Interrupt => e
+          system "stty echo"
+          puts e
+          exit
+        end
+
+        if block_given?
+          yield answer
+        else
+          return answer
+        end
+      end
+
+      private
+
+      def get_answer(question, secret, default = nil)
+        print question
+        system "stty -echo" if secret
+        answer = $stdin.gets.chomp
+        system "stty echo" if secret
+        answer = default if answer.empty? && default
+        answer
+      end
+    end
+  end
+end

data/lib/gooddata/commands/datasets.rb

@@ -0,0 +1,228 @@
+require 'date'
+require 'gooddata/extract'
+
+module GoodData
+  module Command
+    class Datasets < Base
+
+      # List all data sets present in the project specified by the --project option
+      #
+      # == Usage
+      #
+      # <tt>gooddata datasets --project <projectid></tt>
+      # <tt>gooddata datasets:list --project <projectid></tt>
+      #
+      # * <tt>--project</tt> - GoodData project identifier
+      #
+      def index
+        connect
+        with_project do |project_id|
+          Project[project_id].datasets.each do |ds|
+            puts "#{ds.uri}\t#{ds.identifier}\t#{ds.title}"
+          end
+        end
+      end
+
+      # Describe a data set. Currently, only a CSV data set is supported.
+      #
+      # The command prescans the data set, picks possible LDM types for it's
+      # fields and asks user for confirmation.
+      #
+      # == Usage
+      #
+      # <tt>gooddata datasets:describe --file-csv <path> --name <name> --output <output path></tt>
+      #
+      # * <tt>--file-csv</tt> - path to the CSV file (required)
+      # * <tt>--name</tt> - name of the data set (user will be prompted unless provided)
+      # * <tt>--output</tt> - name of the output JSON file with the model description (user will be prompted unless provided)
+      #
+      def describe
+        columns  = ask_for_fields
+        name   = extract_option('--name') || ask("Enter the dataset name")
+        output = extract_option('--output') || ask("Enter path to the file where to save the model description", :default => "#{name}.json")
+        open output, 'w' do |f|
+          f << JSON.pretty_generate( :title => name, :columns => columns ) + "\n"
+          f.flush
+        end
+      end
+
+      # Creates a server-side model based on local model description. The model description
+      # is read from a JSON file that can be generated using the +datasets:describe+ command
+      #
+      # == Usage
+      #
+      # <tt>gooddata datasets:apply --project <projectid> <data set config></tt>
+      #
+      # * <tt>--project</tt> - GoodData project identifier
+      # * <tt>data set config</tt> - JSON file with the model description (possibly generated by the <tt>datasets:describe</tt> command)
+      #
+      def apply
+        connect
+        with_project do |project_id|
+          cfg_file = args.shift rescue nil
+          raise(CommandFailed, "Usage: #{$0} <dataset config>") unless cfg_file
+          config = JSON.load open(cfg_file) rescue raise(CommandFailed, "Error reading dataset config file '#{cfg_file}'")
+          objects = Project[project_id].add_dataset config['title'], config['columns']
+          puts "Dataset #{config['title']} added to the project, #{objects['uris'].length} metadata objects affected"
+        end
+      end
+
+      # Load a CSV file into an existing server-side data set
+      #
+      # == Usage
+      #
+      # <tt>gooddata datasets:load --project <projectid> <file> <dataset config></tt>
+      #
+      # * <tt>--project</tt> - GoodData project identifier
+      # * <tt>file</tt> - CSV file to load
+      # * <tt>data set config</tt> - JSON file with the model description (possibly generated by the <tt>datasets:describe</tt> command)
+      #
+      def load
+        connect
+        with_project do |project_id|
+          file, cfg_file = args
+          raise(CommandFailed, "Usage: #{$0} datasets:load <file> <dataset config>") unless cfg_file
+          config = JSON.load open(cfg_file) rescue raise(CommandFailed, "Error reading dataset config file '#{cfg_file}'")
+          schema = Model::Schema.new config
+          Project[project_id].upload file, schema
+        end
+      end
+
+      private
+
+      def with_project
+        unless @project_id
+          @project_id = extract_option('--project')
+          raise CommandFailed.new("Project not specified, use the --project switch") unless @project_id
+        end
+        yield @project_id
+      end
+
+      def ask_for_fields
+        guesser = Guesser.new create_dataset.read
+        guess = guesser.guess(1000)
+        model = []
+        connection_point_set = false
+        question_fmt = 'Select data type of column #%i (%s)'
+        guesser.headers.each_with_index do |header, i|
+          options = guess[header].map { |t| t.to_s }
+          options = options.select { |t| t != :connection_point.to_s } if connection_point_set
+          type = ask question_fmt % [ i + 1, header ], :answers => options
+          model.push :title => header, :name => header, :type => type.upcase
+          connection_point_set = true if type == :connection_point.to_s
+        end
+        model
+      end
+
+      def create_dataset
+        file = extract_option('--file-csv')
+        return Extract::CsvFile.new(file) if file
+        raise CommandFailed.new("Unknown data set. Please specify a data set using --file-csv option (more supported data sources to come!)")
+      end
+    end
+
+    ##
+    # Utility class to guess data types of a data stream by looking at first couple of rows
+    #
+    class Guesser
+
+      TYPES_PRIORITY = [ :connection_point, :fact, :date, :attribute ]
+      attr_reader :headers
+
+      class << self
+        def sort_types(types)
+          types.sort do |x, y|
+            TYPES_PRIORITY.index(x) <=> TYPES_PRIORITY.index(y)
+          end
+        end
+      end
+
+      def initialize(reader)
+        @reader = reader
+        @headers = reader.shift.map! { |h| h.to_s } or raise "Empty data set"
+        @pros = {}; @cons = {}; @seen = {}
+        @headers.map do |h|
+          @cons[h.to_s] = {}
+          @pros[h.to_s] = {}
+          @seen[h.to_s] = {}
+        end
+      end
+
+      def guess(limit)
+        count = 0
+        while row = @reader.shift
+          break unless row && !row.empty? && count < limit
+          raise "%i fields in row %i, %i expected" % [ row.size, count + 1, @headers.size ] if row.size != @headers.size
+          row.each_with_index do |value, j|
+            header = @headers[j]
+            number = check_number(header, value)
+            date   = check_date(header, value)
+            store_guess header, { @pros => :attribute } unless number || date
+            hash_increment @seen[header], value
+          end
+          count += 1
+        end
+        # fields with unique values are connection point candidates
+        @seen.each do |header, values|
+          store_guess header, { @pros => :connection_point } if values.size == count
+        end
+        guess_result
+      end
+
+      private
+
+      def guess_result
+        result = {}
+        @headers.each do |header|
+          result[header] = Guesser::sort_types @pros[header].keys.select { |type| @cons[header][type].nil? }
+        end
+        result
+      end
+
+      def hash_increment(hash, key)
+        if hash[key]
+          hash[key] += 1
+        else
+          hash[key] = 1
+        end
+      end
+
+      def check_number(header, value)
+        if value.nil? || value =~ /^[\+-]?\d*(\.\d*)?$/
+          return store_guess(header, @pros => [ :fact, :attribute ] )
+        end
+        store_guess header, { @cons => :fact }
+      end
+
+      def check_date(header, value)
+        return store_guess(header, @pros => [ :date, :attribute, :fact ]) if value.nil? || value == '0000-00-00'
+        begin
+          DateTime.parse value
+          return store_guess(header, @pros => [ :date, :attribute ])
+        rescue ArgumentError; end
+        store_guess header, { @cons => :date }
+      end
+
+      ##
+      # Stores a guess about given header.
+      #
+      # Returns true if the @pros key is present, false otherwise
+      #
+      # === Parameters
+      #
+      # * +header+ - A header name
+      # * +guess+ - A hash with optional @pros and @cons keys
+      #
+      def store_guess(header, guess)
+        result = !guess[@pros].nil?
+        [@pros, @cons].each do |hash|
+          if guess[hash] then
+            guess[hash] = [ guess[hash] ] unless guess[hash].is_a? Array
+            guess[hash].each { |type| hash_increment hash[header], type }
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/gooddata/commands/help.rb

@@ -0,0 +1,104 @@
+module GoodData
+  module Command
+  class   Help < Base
+      class HelpGroup < Array
+        attr_reader :title
+
+        def initialize(title)
+          @title = title
+        end
+
+        def command(name, description)
+          self << [name, description]
+        end
+
+        def space
+          self << ['', '']
+        end
+      end
+
+      class << self
+        def groups
+          @groups ||= []
+        end
+
+        def group(title, &block)
+          groups << begin
+            group = HelpGroup.new(title)
+            yield group
+            group
+          end
+        end
+
+        def create_default_groups!
+          group 'General Commands' do |group|
+            group.command 'help',                         'show this usage'
+            group.command 'version',                      'show the gem version'
+            group.space
+            group.command 'api',                          'general info about the current GoodData API version'
+            group.command 'api:test',                     'test you credentials and the connection to GoodData server'
+            group.command 'api:get',                      'issue a generic GET request to the GoodData API'
+            group.space
+            group.command 'auth:store',                   'save your GoodData credentials and we won\'t ask you for them ever again'
+            group.command 'auth:unstore',                 'remove the saved GoodData credentials from your computer'
+            group.space
+            group.command 'datasets',                     'list remote data sets in the project specified via --project'
+            group.command 'datasets:describe',            'describe a local data set and save the description in a JSON file'
+            group.space
+            group.command 'profile',                      'show your GoodData profile'
+            group.space
+            group.command 'projects',                     'list available projects'
+            group.command 'projects:create',              'create new project'
+            group.command 'projects:show <key>',          'show project details'
+            group.command 'projects:delete <key> [...]',  'delete one or more existing projects'
+          end
+
+          group 'General Options' do |group|
+            group.command '--log-level <level>', 'Set the log level (fatal, error, warn [default], info, debug)'
+            group.command '--project <project_id>', 'Set the working remote project identified by an URI or project ID'
+          end
+        end
+      end
+
+      def index
+        puts usage
+      end
+
+      def version
+        puts Client.version
+      end
+
+      def usage
+        longest_command_length = self.class.groups.map do |group|
+          group.map { |g| g.first.length }
+        end.flatten.max
+
+        s = StringIO.new
+        s << <<-EOT
+=== Usage
+
+gooddata COMMAND [options]
+
+EOT
+
+        self.class.groups.inject(s) do |output, group|
+          output.puts "=== %s" % group.title
+          output.puts
+
+          group.each do |command, description|
+            if command.empty?
+              output.puts
+            else
+              output.puts "%-*s # %s" % [longest_command_length, command, description]
+            end
+          end
+
+          output.puts
+          output
+        end.string
+      end
+    end
+  end
+end
+
+GoodData::Command::Help.create_default_groups!