gooddata-edge 0.6.27.edge

data/lib/gooddata/extensions/false.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+class FalseClass
+  # +false+ is not duplicable:
+  #
+  #   false.duplicable? # => false
+  #   false.dup         # => TypeError: can't dup FalseClass
+  def duplicable?
+    false
+  end
+end

data/lib/gooddata/extensions/hash.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+class Hash
+  # Return a hash that includes everything but the given keys. This is useful for
+  # limiting a set of parameters to everything but a few known toggles:
+  #
+  #   @person.update_attributes(params[:person].except(:admin))
+  #
+  # If the receiver responds to +convert_key+, the method is called on each of the
+  # arguments. This allows +except+ to play nice with hashes with indifferent access
+  # for instance:
+  #
+  #   {:a => 1}.with_indifferent_access.except(:a)  # => {}
+  #   {:a => 1}.with_indifferent_access.except("a") # => {}
+  #
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+
+  def slice(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if key?(k) }
+  end
+
+  def compact
+    select { |_, value| !value.nil? }
+  end
+end

data/lib/gooddata/extensions/nil.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+class NilClass
+  # +nil+ is not duplicable:
+  #
+  #   nil.duplicable? # => false
+  #   nil.dup         # => TypeError: can't dup NilClass
+  def duplicable?
+    false
+  end
+end

data/lib/gooddata/extensions/numeric.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+class Numeric
+  # Numbers are not duplicable:
+  #
+  #  3.duplicable? # => false
+  #  3.dup         # => TypeError: can't dup Fixnum
+  def duplicable?
+    false
+  end
+end

data/lib/gooddata/extensions/object.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+class Object
+  class << self
+    def set_const(name, val)
+      send(:remove_const, name) if const_defined?(name)
+      send(:const_set, name, val)
+    end
+  end
+
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def duplicable?
+    true
+  end
+
+  def set_const(name, val)
+    send(:remove_const, name) if const_defined?(name)
+    send(:const_set, name, val)
+  end
+end

data/lib/gooddata/extensions/symbol.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+class Symbol
+  # Symbols are not duplicable:
+  #
+  #   :my_symbol.duplicable? # => false
+  #   :my_symbol.dup         # => TypeError: can't dup Symbol
+  def duplicable?
+    false
+  end
+end

data/lib/gooddata/extensions/true.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+class TrueClass
+  # +true+ is not duplicable:
+  #
+  #   true.duplicable? # => false
+  #   true.dup         # => TypeError: can't dup TrueClass
+  def duplicable?
+    false
+  end
+end

data/lib/gooddata/extract.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'csv'
+
+module GoodData
+  module Extract
+    class CsvFile
+      def initialize(file)
+        @file = file
+      end
+
+      def read(&block)
+        CSV.open @file, 'r', &block
+      end
+    end
+  end
+end

data/lib/gooddata/goodzilla/goodzilla.rb

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+module GoodData
+  module SmallGoodZilla
+    class << self
+      # Scans the provided MAQL and returns Array pairs of [attribute, element] pairs for each element that is found in the definition
+      # @param maql Input MAQL string
+      # @return [Array<Array>] Pairs [attribute, attribute_element]
+      def extract_element_uri_pairs(maql)
+        arr = maql.scan(%r{\[([^\[\]]*)\/elements\?id=(\d+)\]}).flatten
+        evens = arr.select.each_with_index { |_, i| i.even? }
+        odds = arr.select.each_with_index { |_, i| i.odd? }.map(&:to_i)
+        evens.zip(odds)
+      end
+
+      # Scans the provided MAQL and returns Array of all the URIs included in the MAQL. This basically return anything that is enclosed in aquare brackets []
+      # @param maql Input MAQL string
+      # @return [Array<String>] Pairs of URIs
+      def get_uris(a_maql_string)
+        a_maql_string.scan(/\[([^\"\]]+)\]/).flatten.uniq
+      end
+
+      # Get IDs from extendedMAQL string
+      # @param a_maql_string Input MAQL string
+      # @return [Array<String>] List of IDS
+      def get_ids(a_maql_string)
+        a_maql_string.scan(/!\[([^\"\]]+)\]/).flatten.uniq
+      end
+
+      # Get Facts from extendedMAQL string
+      # @param a_maql_string Input MAQL string
+      # @return [Array<String>] List of Facts
+      def get_facts(a_maql_string)
+        a_maql_string.scan(/#\"([^\"]+)\"/).flatten
+      end
+
+      # Get Attributes from extendedMAQL string
+      # @param a_maql_string Input MAQL string
+      # @return [Array<String>] List of Attributes
+      def get_attributes(a_maql_string)
+        a_maql_string.scan(/@\"([^\"]+)\"/).flatten
+      end
+
+      # Get Metrics from extendedMAQL string
+      # @param a_maql_string Input MAQL string
+      # @return [Array<String>] List of Metrics
+      def get_metrics(a_maql_string)
+        a_maql_string.scan(/\?"([^\"]+)\"/).flatten
+      end
+
+      alias_method :get_measures, :get_metrics
+
+      # Method takes a specification of the attribute filter (category filter) and returns it representation that is
+      # suitable for posting on the API. The spec is expected to be an array. First object can be an attribute (id, obj_id or
+      # directly an object). Alternativel it can be an attribute (again any representation should work). In case of attribute
+      # primary label is taken. The rest of the array are expected to be String represenation of values of particular label.
+      #
+      # For example it could look like
+      # ['label.states.name', 'California', 'New Jersey', 'Kansas']
+      #
+      # @param spec [Array<Object>] Input MAQL string
+      # @return [Array<Hash>] List of Metrics
+      def create_category_filter(spec, project)
+        item = project.objects(spec.first)
+        label = item.is_a?(GoodData::Attribute) ? item.primary_label : item
+        col = spec[1..-1].flat_map do |v|
+          case v
+          when Range
+            v.to_a
+          when Symbol
+            [v]
+          else
+            [v.to_s]
+          end
+        end
+        if col.first == :not
+          values = col[1..-1].map { |v| label.find_value_uri(v) }
+          elements = values.map { |v| "[#{v}]" }.join(', ')
+          { expression: "[#{label.attribute.uri}] NOT IN (#{elements})" }
+        else
+          values = col.map { |v| label.find_value_uri(v) }
+          elements = values.map { |v| "[#{v}]" }.join(', ')
+          { expression: "[#{label.attribute.uri}] IN (#{elements})" }
+        end
+      end
+
+      # Pretty prints the MAQL expression. This basically means it finds out names of objects and elements and print their values instead of URIs
+      # @param expression [String] Expression to be beautified
+      # @return [String] Pretty printed MAQL expression
+      def pretty_print(expression, opts = { client: GoodData.connection, project: GoodData.project })
+        temp = expression.dup
+        pairs = get_uris(expression).pmap do |uri|
+          if uri =~ /elements/
+            begin
+              [uri, Attribute.find_element_value(uri, opts)]
+            rescue AttributeElementNotFound
+              [uri, '(empty value)']
+            end
+          else
+            [uri, GoodData::MdObject[uri, opts].title]
+          end
+        end
+        pairs.each do |el|
+          uri = el[0]
+          obj = el[1]
+          temp.sub!(uri, obj)
+        end
+        temp
+      end
+
+      def interpolate(values, dictionaries)
+        {
+          :facts => interpolate_values(values[:facts], dictionaries[:facts]),
+          :attributes => interpolate_values(values[:attributes], dictionaries[:attributes]),
+          :metrics => interpolate_values(values[:metrics], dictionaries[:metrics])
+        }
+      end
+
+      def interpolate_ids(options, *ids)
+        ids = ids.flatten
+        if ids.empty?
+          []
+        else
+          res = GoodData::MdObject.identifier_to_uri(options, *ids)
+          fail 'Not all of the identifiers were resolved' if Array(res).size != ids.size
+          res
+        end
+      end
+
+      def interpolate_values(keys, values)
+        x = values.values_at(*keys)
+        keys.zip(x)
+      end
+
+      def interpolate_metric(metric, dictionary, options = { :client => GoodData.connection, :project => GoodData.project })
+        interpolated = interpolate({
+                                     :facts => GoodData::SmallGoodZilla.get_facts(metric),
+                                     :attributes => GoodData::SmallGoodZilla.get_attributes(metric),
+                                     :metrics => GoodData::SmallGoodZilla.get_metrics(metric)
+                                   }, dictionary)
+
+        ids = GoodData::SmallGoodZilla.get_ids(metric)
+        interpolated_ids = ids.zip(Array(interpolate_ids(options, ids)))
+
+        metric = interpolated[:facts].reduce(metric) { |a, e| a.sub("#\"#{e[0]}\"", "[#{e[1]}]") }
+        metric = interpolated[:attributes].reduce(metric) { |a, e| a.sub("@\"#{e[0]}\"", "[#{e[1]}]") }
+        metric = interpolated[:metrics].reduce(metric) { |a, e| a.sub("?\"#{e[0]}\"", "[#{e[1]}]") }
+        metric = interpolated_ids.reduce(metric) { |a, e| a.gsub("![#{e[0]}]", "[#{e[1]}]") }
+        metric
+      end
+
+      alias_method :interpolate_measure, :interpolate_metric
+    end
+  end
+end

data/lib/gooddata/helpers/auth_helpers.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'fileutils'
+require 'json'
+
+require_relative 'global_helpers'
+
+module GoodData
+  module Helpers
+    module AuthHelper
+      class << self
+        # Get path of .gooddata config
+        def credentials_file
+          "#{Helpers.home_directory}/.gooddata"
+        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
+
+        # Try read environemnt
+        #
+        # Tries to read it from ~/.gooddata file or from environment variable GD_SERVER
+        # @param [String] credentials_file_path (credentials_file) Path to .gooddata file
+        # @return [String] server token from environment variable, .gooddata or nil
+        def read_environment(credentials_file_path = credentials_file)
+          goodfile = read_credentials(credentials_file_path)
+          [ENV['GD_ENVIRONMENT'], goodfile[:environment], GoodData::Project::DEFAULT_ENVIRONMENT].find { |x| !x.nil? && !x.empty? }
+        end
+
+        # Try read server
+        #
+        # Tries to read it from ~/.gooddata file or from environment variable GD_SERVER
+        # @param [String] credentials_file_path (credentials_file) Path to .gooddata file
+        # @return [String] server token from environment variable, .gooddata or DEFAULT_URL
+        def read_server(credentials_file_path = credentials_file)
+          goodfile = read_credentials(credentials_file_path)
+          [ENV['GD_SERVER'], goodfile[:server], GoodData::Rest::Connection::DEFAULT_URL].find { |x| !x.nil? && !x.empty? }
+        end
+
+        # Try read token
+        #
+        # Tries to read it from ~/.gooddata file or from environment variable GD_PROJECT_TOKEN
+        # @param [String] credentials_file_path (credentials_file) Path to .gooddata file
+        # @return [String] auth token from environment variable, .gooddata or nil
+        def read_token(credentials_file_path = credentials_file)
+          goodfile = read_credentials(credentials_file_path)
+          [ENV['GD_PROJECT_TOKEN'], goodfile[:auth_token], goodfile[:token]].find { |x| !x.nil? && !x.empty? }
+        end
+
+        # Writes credentials
+        def write_credentials(credentials, credentials_file_path = credentials_file)
+          File.open(credentials_file_path, 'w', 0600) do |f|
+            f.puts JSON.pretty_generate(credentials)
+          end
+          credentials
+        end
+
+        def remove_credentials_file(credentials_file_path = credentials_file)
+          FileUtils.rm_f(credentials_file_path)
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/helpers/csv_helper.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+#
+# Copyright (c) 2010-2015 GoodData Corporation. All rights reserved.
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+require 'csv'
+
+module GoodData
+  module Helpers
+    class Csv
+      class << self
+        # Read data from CSV
+        #
+        # @param [Hash] opts
+        # @option opts [String] :path File to read data from
+        # @option opts [Boolean] :header File to read data from
+        # @return Array of rows with loaded data
+        def read(opts)
+          path = opts[:path]
+          res = []
+
+          line = 0
+
+          CSV.foreach(path) do |row|
+            line += 1
+            next if opts[:header] && line == 1
+
+            if block_given?
+              data = yield row
+            else
+              data = row
+            end
+
+            res << data if data
+          end
+
+          res
+        end
+
+        # Write data to CSV
+        # @option opts [String] :path File to write data to
+        # @option opts [Array] :data Mandatory array of data to write
+        # @option opts [String] :header Optional Header row
+        def write(opts, &_block)
+          path = opts[:path]
+          header = opts[:header]
+          data = opts[:data]
+
+          CSV.open(path, 'w') do |csv|
+            csv << header unless header.nil?
+            data.each do |entry|
+              res = yield entry
+              csv << res if res
+            end
+          end
+        end
+      end
+    end
+  end
+end