gooddata 0.6.4 → 0.6.5

data/lib/gooddata/mixins/md_object_query.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module MdObjectQuery
+      # Method intended to get all objects of that type in a specified project
+      #
+      # @param options [Hash] the options hash
+      # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
+      # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
+      def all(options = {})
+        fail NotImplementedError, 'Method should be implemented in subclass. Currently there is no way hoe to get all metadata objects on API.'
+      end
+
+      # Method intended to be called by individual classes in their all
+      # implementations. It abstracts the way interacting with query resources.
+      # It either returns the array of hashes from query. If asked it also
+      # goes and brings the full objects. Due to performance reasons
+      # :full => false is the default. This will most likely change
+      #
+      # @param query_obj_type [String] string used in URI to distinguish different query resources for different objects
+      # @param klass [Class] A class used for instantiating the returned data
+      # @param options [Hash] the options hash
+      # @option options [Boolean] :full if passed true the subclass can decide to pull in full objects. This is desirable from the usability POV but unfortunately has negative impact on performance so it is not the default
+      # @return [Array<GoodData::MdObject> | Array<Hash>] Return the appropriate metadata objects or their representation
+      def query(query_obj_type, klass, options = {})
+        fail(NoProjectError, 'Connect to a project before searching for an object') unless GoodData.project
+        query_result = GoodData.get(GoodData.project.md['query'] + "/#{query_obj_type}/")['query']['entries']
+        options[:full] ? query_result.map { |item| klass[item['link']] } : query_result
+      end
+
+      def dependency(uri, key = nil)
+        result = GoodData.get(uri)['entries']
+        if key.nil?
+          result
+        elsif key.respond_to?(:category)
+          result.select { |item| item['category'] == key.category }
+        else
+          result.select { |item| item['category'] == key }
+        end
+      end
+
+      # Checks for dependency
+      def dependency?(type, uri, target_uri)
+        uri = uri.respond_to?(:uri) ? uri.uri : uri
+        objs = case type
+               when :usedby
+                 usedby(uri)
+               when :using
+                 using(uri)
+               end
+
+        target_uri = target_uri.respond_to?(:uri) ? target_uri.uri : target_uri
+        objs.any? do |obj|
+          obj['link'] == target_uri
+        end
+      end
+
+      # Returns which objects uses this MD resource
+      def usedby(uri, key = nil, project = GoodData.project)
+        dependency("#{project.md['usedby2']}/#{obj_id(uri)}", key)
+      end
+
+      alias_method :used_by, :usedby
+
+      # Returns which objects this MD resource uses
+      def using(uri, key = nil)
+        dependency("#{GoodData.project.md['using2']}/#{obj_id(uri)}", key)
+      end
+
+      def usedby?(uri, target_uri)
+        dependency?(:usedby, uri, target_uri)
+      end
+
+      alias_method :used_by?, :usedby?
+
+      # Checks if obj is using this MD resource
+      def using?(uri, target_uri)
+        dependency?(:using, uri, target_uri)
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/md_relations.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module MdRelations
+      def dependency(uri, key = nil)
+        GoodData::MdObject.dependency(uri, key)
+      end
+
+      # Checks for dependency
+      def dependency?(type, obj)
+        GoodData::MdObject.dependency?(type, self, obj)
+      end
+
+      # Returns which objects uses this MD resource
+      def usedby(key = nil, project = GoodData.project)
+        dependency("#{project.md['usedby2']}/#{obj_id}", key)
+      end
+
+      alias_method :used_by, :usedby
+
+      # Returns which objects this MD resource uses
+      def using(key = nil)
+        dependency("#{GoodData.project.md['using2']}/#{obj_id}", key)
+      end
+
+      def usedby?(obj)
+        GoodData::MdObject.used_by?(self, obj)
+      end
+
+      alias_method :used_by?, :usedby?
+
+      # Checks if obj is using this MD resource
+      def using?(obj)
+        dependency?(:using, obj)
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/meta_getter.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module MetaGetter
+      def meta
+        data && data['meta']
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/meta_property_reader.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module MetaPropertyReader
+      def metadata_property_reader(*props)
+        props.each do |prop|
+          define_method prop, proc { meta[prop.to_s] }
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/meta_property_writer.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module MetaPropertyWriter
+      def metadata_property_writer(*props)
+        props.each do |prop|
+          define_method "#{prop}=", proc { |val| meta[prop.to_s] = val }
+        end
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/mixins.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+require 'pathname'
+
+base = Pathname(__FILE__).dirname.expand_path
+Dir.glob(base + '*.rb').each do |file|
+  blacklist = [
+    File.join(base, 'rest_getters.rb'),
+    File.join(base, 'rest_resource.rb')
+  ]
+
+  require file unless blacklist.include? file
+end
+require_relative 'rest_getters'
+require_relative 'rest_resource'

data/lib/gooddata/mixins/not_attribute.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module NotAttribute
+      # Returns true if the object is a fact false otherwise
+      # @return [Boolean]
+      def attribute?
+        false
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/not_exportable.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module NotExportable
+      def exportable?
+        false
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/not_fact.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module NotFact
+      # Returns true if the object is a fact false otherwise
+      # @return [Boolean]
+      def fact?
+        false
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/not_label.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module NotLabel
+      # Returns true if the object is a fact label otherwise
+      # @return [Boolean]
+      def label?
+        false
+      end
+
+      alias_method :display_form?, :label?
+    end
+  end
+end

data/lib/gooddata/mixins/not_metric.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module NotMetric
+      # Returns true if the object is a metric false otherwise
+      # @return [Boolean]
+      def metric?
+        false
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/obj_id.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module ObjId
+      def obj_id
+        uri.split('/').last
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/rest_getters.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+require_relative 'data_getter'
+require_relative 'meta_getter'
+
+module GoodData
+  module Mixin
+    module RestGetters
+      include GoodData::Mixin::MetaGetter
+      include GoodData::Mixin::DataGetter
+    end
+  end
+end

data/lib/gooddata/mixins/rest_resource.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+require_relative 'root_key_setter'
+require_relative 'data_property_reader'
+require_relative 'data_property_writer'
+require_relative 'meta_property_reader'
+require_relative 'meta_property_reader'
+
+module GoodData
+  module Mixin
+    module RestResource
+      include GoodData::Mixin::RootKeySetter
+      include GoodData::Mixin::DataPropertyReader
+      include GoodData::Mixin::DataPropertyWriter
+      include GoodData::Mixin::MetaPropertyReader
+      include GoodData::Mixin::MetaPropertyWriter
+    end
+  end
+end

data/lib/gooddata/mixins/root_key_getter.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module RootKeyGetter
+      def root_key
+        raw_data.keys.first
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/root_key_setter.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module RootKeySetter
+      def root_key(a_key)
+        define_method :root_key, proc { a_key.to_s }
+      end
+    end
+  end
+end

data/lib/gooddata/mixins/timestamps.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module GoodData
+  module Mixin
+    module Timestamps
+      def updated
+        Time.parse(meta['updated'])
+      end
+
+      def created
+        Time.parse(meta['created'])
+      end
+    end
+  end
+end

data/lib/gooddata/models/from_wire.rb

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+
+module GoodData
+  module Model
+    module FromWire
+      # Converts dataset from wire format into an internal blueprint representation
+      #
+      # @param stuff [Hash] Whatever comes from wire
+      # @return [Hash] Manifest for a particular reference
+      def self.dataset_from_wire(stuff)
+        Hash.new.tap do |d|
+          d[:type] = :dataset
+          d[:title] = stuff['dataset']['title'] if stuff['dataset']['title'] != stuff['dataset']['identifier'].split('.').last.titleize
+          d[:name] = stuff['dataset']['identifier'].split('.').last
+          d[:columns] = (parse_anchor(stuff) + parse_attributes(stuff) + parse_facts(stuff) + parse_references(stuff))
+        end
+      end
+
+      # Entry method for converting information about project mode from wire
+      # format into an internal blueprint representation
+      #
+      # @param stuff [Hash] Whatever comes from wire
+      # @return [GoodData::Model::ProjectBlueprint] Manifest for a particular reference
+      def self.from_wire(stuff)
+        model = stuff['projectModelView']['model']['projectModel']
+        datasets = model['datasets'] || []
+        dims = model['dateDimensions'] || []
+        ProjectBlueprint.new(
+          datasets: datasets.map { |ds| dataset_from_wire(ds) },
+          date_dimensions: dims.map { |dd| parse_date_dimensions(dd) }
+        )
+      end
+
+      # Converts anchor from wire format into an internal blueprint representation
+      #
+      # @param stuff [Hash] Whatever comes from wire
+      # @return [Hash] Manifest for a particular reference
+      def self.parse_anchor(stuff)
+        attribute = stuff['dataset']['anchor']['attribute']
+        if !attribute.key?('labels')
+          []
+        else
+          labels = attribute['labels'] || []
+          default_label = attribute['defaultLabel']
+          primary_label_name = attribute['identifier'].split('.').last
+          dataset_name = attribute['identifier'].split('.')[1]
+          primary_label_identifier = GoodData::Model.identifier_for({ name: dataset_name }, type: :primary_label, name: primary_label_name)
+          primary_labels, regular_labels = labels.partition { |x| x['label']['identifier'] == primary_label_identifier }
+          dl = primary_labels.map do |label|
+            parse_label(attribute, label, 'anchor', default_label)
+          end
+          rl = regular_labels.map do |label|
+            parse_label(attribute, label, 'label', default_label)
+          end
+          dl + rl
+        end
+      end
+
+      # Converts attrbutes from wire format into an internal blueprint representation
+      #
+      # @param stuff [Hash] Whatever comes from wire
+      # @return [Hash] Manifest for a particular reference
+      def self.parse_attributes(stuff)
+        dataset = stuff['dataset']
+        attributes = dataset['attributes'] || []
+        attributes.mapcat do |a|
+          attribute = a['attribute']
+          labels = attribute['labels'] || []
+          default_label = attribute['defaultLabel']
+          primary_label_name = attribute['identifier'].split('.').last
+          dataset_name = attribute['identifier'].split('.')[1]
+          primary_label_identifier = GoodData::Model.identifier_for({ name: dataset_name }, type: :primary_label, name: primary_label_name)
+          primary_labels, regular_labels = labels.partition { |x| x['label']['identifier'] == primary_label_identifier }
+          dl = primary_labels.map do |label|
+            parse_label(attribute, label, 'attribute', default_label)
+          end
+          rl = regular_labels.map do |label|
+            parse_label(attribute, label, 'label', default_label)
+          end
+          dl + rl
+        end
+      end
+
+      # Converts date dimensions from wire format into an internal blueprint representation
+      #
+      # @param stuff [Hash] Whatever comes from wire
+      # @return [Hash] Manifest for a particular reference
+      def self.parse_date_dimensions(stuff)
+        Hash.new.tap do |d|
+          d[:type] = :date_dimension
+          # d[:urn] = :date_dimension
+          d[:name] = stuff['dateDimension']['name']
+          d[:title] = stuff['dateDimension']['title'] if stuff['dateDimension']['title'] != stuff['dateDimension']['title'].titleize
+        end
+      end
+
+      # Converts facts from wire format into an internal blueprint representation
+      #
+      # @param stuff [Hash] Whatever comes from wire
+      # @return [Hash] Manifest for a particular reference
+      def self.parse_facts(stuff)
+        facts = stuff['dataset']['facts'] || []
+        facts.map do |fact|
+          Hash.new.tap do |f|
+            f[:type] = fact['fact']['identifier'] =~ /^dt\./ ? :date_fact : :fact
+            f[:name] = fact['fact']['identifier'].split('.').last
+            f[:title] = fact['fact']['title'] if fact['fact']['title'] != fact['fact']['identifier'].split('.').last.titleize
+            f[:gd_data_type] = fact['fact']['dataType'] if fact['fact'].key?('dataType')
+          end
+        end
+      end
+
+      # Converts label from wire format into an internal blueprint representation
+      #
+      # @param stuff [Hash] Whatever comes from wire
+      # @return [Hash] Manifest for a particular reference
+      def self.parse_label(attribute, label, type, default_label = nil)
+        Hash.new.tap do |l|
+          l[:type] = type
+          l[:reference] = attribute['identifier'].split('.').last if type == 'label'
+          l[:name] = label['label']['identifier'].split('.').last
+          l[:title] = label['label']['title'] if label['label']['title'] != label['label']['identifier'].split('.').last.titleize
+          l[:gd_data_type] = label['label']['dataType'] if label['label'].key?('dataType')
+          l[:gd_type] = label['label']['type'] if label['label'].key?('type')
+          l[:default_label] = true if default_label == label['label']['identifier']
+        end
+      end
+
+      # Converts label from wire format into an internal blueprint representation
+      #
+      # @param stuff [Hash] Whatever comes from wire
+      # @return [Hash] Manifest for a particular reference
+      def self.parse_references(stuff)
+        references = stuff['dataset']['references'] || []
+        references.map do |ref|
+          if ref =~ /^dataset\./
+            {
+              :type => :reference,
+              :name => ref.gsub('dataset.', ''),
+              :dataset => ref.gsub('dataset.', '')
+            }
+          else
+            {
+              :type => :date,
+              :name => ref.gsub('dataset.', ''),
+              :dataset => ref.gsub('dataset.', '')
+            }
+          end
+        end
+      end
+    end
+  end
+end