gooddata 0.6.4 → 0.6.5

data/lib/gooddata/models/metadata.rb

@@ -3,144 +3,46 @@
 require_relative '../core/connection'
 require_relative '../core/project'
 
+require_relative '../mixins/mixins'
+
 module GoodData
   class MdObject
-    MD_OBJ_CTG = 'obj'
     IDENTIFIERS_CFG = 'instance-identifiers'
 
     attr_reader :json
 
     alias_method :raw_data, :json
     alias_method :to_hash, :json
-    alias_method :data, :json
-
-    class << self
-      def root_key(a_key)
-        define_method :root_key, proc { a_key.to_s }
-      end
-
-      def metadata_property_reader(*props)
-        props.each do |prop|
-          define_method prop, proc { meta[prop.to_s] }
-        end
-      end
-
-      def metadata_property_writer(*props)
-        props.each do |prop|
-          define_method "#{prop}=", proc { |val| meta[prop.to_s] = val }
-        end
-      end
 
-      # Returns either list of objects or a specific object. This method is reimplemented in subclasses to leverage specific implementation for specific type of objects. Options is used in subclasses specifically to provide shorthand for getting a full objects after getting a list of hashes from query resource
-      # @param [Object] id id can be either a number a String (as a URI). Subclasses should also be abel to deal with getting the instance of MdObject already and a :all symbol
-      # @param [Hash] options 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 [MdObject] if id is a String or number single object is returned
-      # @return [Array] if :all was provided as an id, list of objects should be returned. Note that this is implemented only in the subclasses. MdObject does not support this since API has no means to return list of all types of objects
-      def [](id, options = {})
-        fail "You have to provide an \"id\" to be searched for." unless id
-        fail(NoProjectError, 'Connect to a project before searching for an object') unless GoodData.project
-        return all(options) if id == :all
-        return id if id.is_a?(MdObject)
-        uri = if id.is_a?(Integer) || id =~ /^\d+$/
-                "#{GoodData.project.md[MD_OBJ_CTG]}/#{id}"
-              elsif id !~ /\//
-                identifier_to_uri id
-              elsif id =~ /^\//
-                id
-              else
-                fail 'Unexpected object id format: expected numeric ID, identifier with no slashes or an URI starting with a slash'
-              end
-        new(GoodData.get uri) unless uri.nil?
-      end
-
-      # 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
-
-      def find_by_tag(tag)
-        self[:all].select { |r| r['tags'].split(',').include?(tag) }
-      end
-
-      def find_first_by_title(title)
-        all = self[:all]
-        item = if title.is_a?(Regexp)
-                 all.find { |r| r['title'] =~ title }
-               else
-                 all.find { |r| r['title'] == title }
-               end
-        self[item['link']] unless item.nil?
-      end
-
-      # Finds a specific type of the object by title. Returns all matches. Returns full object.
-      #
-      # @param title [String] title that has to match exactly
-      # @param title [Regexp] regular expression that has to match
-      # @return [Array<GoodData::MdObject>] Array of MdObject
-      def find_by_title(title)
-        all = self[:all]
-        items = if title.is_a?(Regexp)
-                  all.select { |r| r['title'] =~ title }
-                else
-                  all.select { |r| r['title'] == title }
-                end
-        items.map { |item| self[item['link']] unless item.nil? }
-      end
+    include GoodData::Mixin::RootKeyGetter
+    include GoodData::Mixin::MdJson
+    include GoodData::Mixin::DataGetter
+    include GoodData::Mixin::MetaGetter
+    include GoodData::Mixin::ObjId
+    include GoodData::Mixin::ContentGetter
+    include GoodData::Mixin::Timestamps
+    include GoodData::Mixin::Links
+    include GoodData::Mixin::NotAttribute
+    include GoodData::Mixin::NotExportable
+    include GoodData::Mixin::NotFact
+    include GoodData::Mixin::NotMetric
+    include GoodData::Mixin::NotLabel
+    include GoodData::Mixin::MdRelations
 
-      # TODO: Add test
-      def identifier_to_uri(*ids)
-        fail(NoProjectError, 'Connect to a project before searching for an object') unless GoodData.project
-        uri = GoodData.project.md[IDENTIFIERS_CFG]
-        response = GoodData.post uri, 'identifierToUri' => ids
-        if response['identifiers'].empty?
-          nil
-        else
-          identifiers = response['identifiers']
-          ids_lookup = identifiers.reduce({}) do |a, e|
-            a[e['identifier']] = e['uri']
-            a
-          end
-          uris = ids.map { |x| ids_lookup[x] }
-          uris.count == 1 ? uris.first : uris
-        end
-      end
-
-      alias_method :id_to_uri, :identifier_to_uri
-
-      alias_method :get_by_id, :[]
-
-      private
-
-      # 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
+    class << self
+      include GoodData::Mixin::RootKeySetter
+      include GoodData::Mixin::MetaPropertyReader
+      include GoodData::Mixin::MetaPropertyWriter
+      include GoodData::Mixin::MdObjId
+      include GoodData::Mixin::MdObjectQuery
+      include GoodData::Mixin::MdObjectIndexer
+      include GoodData::Mixin::MdFinders
+      include GoodData::Mixin::MdIdToUri
     end
 
     metadata_property_reader :uri, :identifier, :title, :summary, :tags, :deprecated, :category
     metadata_property_writer :tags, :summary, :title, :identifier
 
-    def root_key
-      raw_data.keys.first
-    end
-
     def initialize(data)
       @json = data.to_hash
     end
@@ -160,26 +62,10 @@ module GoodData
 
     alias_method :refresh, :reload!
 
-    def obj_id
-      uri.split('/').last
-    end
-
-    def links
-      data['links']
-    end
-
     def browser_uri
       GoodData.connection.url + meta['uri']
     end
 
-    def updated
-      Time.parse(meta['updated'])
-    end
-
-    def created
-      Time.parse(meta['created'])
-    end
-
     def deprecated=(flag)
       if flag == '1' || flag == 1
         meta['deprecated'] = '1'
@@ -190,46 +76,10 @@ module GoodData
       end
     end
 
-    def data
-      raw_data[root_key]
-    end
-
-    def meta
-      data && data['meta']
-    end
-
-    def content
-      data && data['content']
-    end
-
     def project
       @project ||= Project[uri.gsub(%r{\/obj\/\d+$}, '')]
     end
 
-    def usedby(key = nil)
-      dependency("#{GoodData.project.md['usedby2']}/#{obj_id}", key)
-    end
-
-    alias_method :used_by, :usedby
-
-    def using(key = nil)
-      dependency("#{GoodData.project.md['using2']}/#{obj_id}", key)
-    end
-
-    def usedby?(obj)
-      dependency?(:usedby, obj)
-    end
-
-    alias_method :used_by?, :usedby?
-
-    def using?(obj)
-      dependency?(:using, obj)
-    end
-
-    def to_json
-      @json.to_json
-    end
-
     def saved?
       res = uri.nil?
       !res
@@ -250,7 +100,8 @@ module GoodData
         result = GoodData.post(GoodData.project.md['obj'], to_json)
         saved_object = self.class[result['uri']]
         # TODO: add test for explicitly provided identifier
-        @json = saved_object.raw_data
+
+        @json = saved_object.json
         if explicit_identifier
           # Object creation API discards the identifier. If an identifier
           # was explicitely provided in the origina object, we need to set
@@ -274,7 +125,7 @@ module GoodData
     # @param new_title [String] New title. If not provided one is provided
     # @return [GoodData::MdObject] MdObject that has been saved as
     def save_as(new_title = "Clone of #{title}")
-      dupped = Marshal.load(Marshal.dump(raw_data))
+      dupped = Marshal.load(Marshal.dump(json))
       dupped[root_key]['meta'].delete('uri')
       dupped[root_key]['meta'].delete('identifier')
       dupped[root_key]['meta']['title'] = new_title
@@ -289,58 +140,5 @@ module GoodData
     def validate
       true
     end
-
-    def exportable?
-      false
-    end
-
-    # Returns true if the object is a fact false otherwise
-    # @return [Boolean]
-    def fact?
-      false
-    end
-
-    # Returns true if the object is an attribute false otherwise
-    # @return [Boolean]
-    def attribute?
-      false
-    end
-
-    # Returns true if the object is a metric false otherwise
-    # @return [Boolean]
-    def metric?
-      false
-    end
-
-    # Returns true if the object is a label false otherwise
-    # @return [Boolean]
-    def label?
-      false
-    end
-    alias_method :display_form?, :label?
-
-    private
-
-    def dependency(uri, key = nil)
-      result = GoodData.get("#{uri}/#{obj_id}")['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
-
-    def dependency?(type, uri)
-      objs = case type
-             when :usedby
-               usedby
-             when :using
-               using
-             end
-      uri = uri.respond_to?(:uri) ? uri.uri : uri
-      objs.any? { |obj| obj['link'] == uri }
-    end
   end
 end

data/lib/gooddata/models/metadata/attribute.rb

@@ -2,10 +2,14 @@
 
 require_relative 'metadata'
 
+require_relative '../../mixins/is_attribute'
+
 module GoodData
   class Attribute < MdObject
     root_key :attribute
 
+    include GoodData::Mixin::IsAttribute
+
     ATTRIBUTE_BASE_AGGREGATIONS = [:count]
 
     class << self
@@ -42,12 +46,6 @@ module GoodData
     end
     alias_method :primary_label, :primary_display_form
 
-    # Returns true if the object is an attribute false otherwise
-    # @return [Boolean]
-    def attribute?
-      true
-    end
-
     # Creates the basic count metric with the attribute used. If you need to compute the attribute on a different dataset you can specify that in params. The metric created is not saved.
     # @param [Hash] options the options to pass to the value list
     # @option options [Symbol] :type type of aggregation function.

data/lib/gooddata/models/metadata/fact.rb

@@ -2,12 +2,16 @@
 
 require_relative '../metadata'
 require_relative '../../core/rest'
+require_relative '../../mixins/is_fact'
+
 require_relative 'metadata'
 
 module GoodData
   class Fact < GoodData::MdObject
     root_key :fact
 
+    include GoodData::Mixin::IsFact
+
     # TODO: verify that we have all (which we do not right now)
     FACT_BASE_AGGREGATIONS = [:sum, :min, :max, :avg, :median]
 
@@ -22,12 +26,6 @@ module GoodData
       end
     end
 
-    # Returns true if the object is a fact false otherwise
-    # @return [Boolean]
-    def fact?
-      true
-    end
-
     # Creates the basic count metric with the fact used. The metric created is not saved.
     # @param [Hash] options the options to pass to the value list
     # @option options [Symbol] :type type of aggregation function. Default is :sum

data/lib/gooddata/models/metadata/{display_form.rb → label.rb}

@@ -1,21 +1,24 @@
 # encoding: UTF-8
 
 require_relative '../metadata'
+require_relative '../../mixins/is_label'
 require_relative 'metadata'
 
 module GoodData
   class Label < GoodData::MdObject
     root_key :attributeDisplayForm
 
+    include GoodData::Mixin::IsLabel
+
     # Finds an attribute element URI for given value. This URI can be used by find_element_value to find the original value again
     # @param [String] value value of an label you are looking for
     # @return [String]
     def find_value_uri(value)
-      value = CGI.escape(value)
-      results = GoodData.post("#{uri}/validElements?limit=30&offset=0&order=asc&filter=#{value}", {})
+      escaped_value = CGI.escape(value)
+      results = GoodData.post("#{uri}/validElements?limit=30&offset=0&order=asc&filter=#{escaped_value}", {})
       items = results['validElements']['items']
       if items.empty?
-        fail "#{value} not found"
+        fail(AttributeElementNotFound, value)
       else
         items.first['element']['uri']
       end
@@ -25,7 +28,7 @@ module GoodData
     # @param [Object] element_id Element identifier either Number or a uri as a String
     # @return [String] value of the element if found
     def find_element_value(element_id)
-      element_id = element_id.is_a?(String) ? element_id.match(/\?id=(\d)/)[1] : element_id
+      element_id = element_id.is_a?(String) ? element_id.match(/\?id=(\d+)/)[1] : element_id
       uri = links['elements']
       result = GoodData.get(uri + "/?id=#{element_id}")
       items = result['attributeElements']['elements']
@@ -36,6 +39,16 @@ module GoodData
       end
     end
 
+    # Finds if a label has an attribute element for given value.
+    # @param [String] value value of an label you are looking for
+    # @return [Boolean]
+    def value?(value)
+      find_value_uri(value)
+      true
+    rescue AttributeElementNotFound
+      false
+    end
+
     # Returns all values for this label. This is for inspection purposes only since obviously there can be huge number of elements.
     # @param [Hash] options the options to pass to the value list
     # @option options [Number] :limit limits the number of values to certain number. Default is 100
@@ -58,13 +71,6 @@ module GoodData
       GoodData::Attribute[content['formOf']]
     end
 
-    # Returns true if the object is an attribute false otherwise
-    # @return [Boolean]
-    def label?
-      true
-    end
-    alias_method :display_form?, :label?
-
     # Gives an attribute url of current label. Useful for mass actions when it does not introduce HTTP call.
     # @return [GoodData::Attibute]
     def attribute_uri

data/lib/gooddata/models/metadata/metric.rb

@@ -108,7 +108,7 @@ module GoodData
 
     def execute
       res = GoodData::ReportDefinition.execute(:left => self)
-      res[0][0]
+      res && res[0][0]
     end
 
     def expression