gooddata 0.6.0 → 0.6.2

data/lib/gooddata/models/links.rb

@@ -8,9 +8,9 @@ module GoodData
       @data = {}
       items.values[0]['links'].each do |item|
         category = item['category']
-        if @data[category] then
-          if @data[category]['category'] == category then
-            @data[category] = {@data[category]['identifier'] => @data[category]}
+        if @data[category]
+          if @data[category]['category'] == category
+            @data[category] = { @data[category]['identifier'] => @data[category] }
           end
           @data[category][item['identifier']] = item
         else
@@ -29,12 +29,12 @@ module GoodData
       @data[category]
     end
 
-    def is_unique?(category)
+    def unique?(category)
       @data[category]['link'].is_a? String
     end
 
-    def is_ambiguous?(category)
-      !is_unique?(category)
+    def ambiguous?(category)
+      !unique?(category)
     end
 
     def get(category, identifier)

data/lib/gooddata/models/md_object.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module GoodData
+  module Model
+    class MdObject
+      attr_accessor :name, :title
+
+      def visual
+        "TITLE \"#{title_esc}\""
+      end
+
+      def title_esc
+        title.gsub(/"/, "\\\"")
+      end
+
+      ##
+      # Generates an identifier from the object name by transliterating
+      # non-Latin character and then dropping non-alphanumerical characters.
+      #
+      def identifier
+        @identifier ||= "#{type_prefix}.#{name}"
+      end
+    end
+  end
+end

data/lib/gooddata/models/metadata.rb

@@ -1,38 +1,62 @@
 # encoding: UTF-8
 
-require_relative 'model'
+require_relative '../core/connection'
+require_relative '../core/project'
 
 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.new { a_key.to_s }
+        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
 
-      def [](id)
-        raise "Cannot search for nil #{self.class}" unless id
-        uri = if id.is_a? Integer or id =~ /^\d+$/
+      # 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 "Cannot search for nil #{self.class}" unless id
+        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
-                raise 'Unexpected object id format: expected numeric ID, identifier with no slashes or an URI starting with a slash'
+                fail 'Unexpected object id format: expected numeric ID, identifier with no slashes or an URI starting with a slash'
               end
-        self.new(GoodData.get uri) unless uri.nil?
+        new(GoodData.get uri) unless uri.nil?
       end
 
-      def find_by_tag(tag)
-        self[:all].find_all { |r| r['tags'].split(',').include?(tag) }
+      def all(options = {})
+        self[:all, options]
       end
 
-      def get_by_id(id)
-        uri = GoodData::MdObject.id_to_uri(id)
-        self[uri] unless uri.nil?
+      def find_by_tag(tag)
+        self[:all].select { |r| r['tags'].split(',').include?(tag) }
       end
 
       def find_first_by_title(title)
@@ -45,10 +69,26 @@ module GoodData
         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
+
+      # TODO: Add test
       def identifier_to_uri(*ids)
-        raise NoProjectError.new 'Connect to a project before searching for an object' unless GoodData.project
+        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}
+        response = GoodData.post uri, 'identifierToUri' => ids
         if response['identifiers'].empty?
           nil
         else
@@ -57,11 +97,20 @@ module GoodData
         end
       end
 
-      alias :id_to_uri :identifier_to_uri
+      alias_method :id_to_uri, :identifier_to_uri
+
+      alias_method :get_by_id, :[]
     end
 
-    def initialize(json)
-      @json = json
+    metadata_property_reader :uri, :identifier, :title, :summary, :tags, :deprecated, :category
+    metadata_property_writer :tags, :summary, :title
+
+    def root_key
+      raw_data.keys.first
+    end
+
+    def initialize(data)
+      @json = data.to_hash
     end
 
     def delete
@@ -72,13 +121,13 @@ module GoodData
       end
     end
 
-    def refresh
-      if saved?
-        @json = GoodData.get(uri)
-      end
+    def reload!
+      @json = GoodData.get(uri) if saved?
       self
     end
 
+    alias_method :refresh, :reload!
+
     def obj_id
       uri.split('/').last
     end
@@ -87,40 +136,30 @@ module GoodData
       data['links']
     end
 
-    def uri
-      meta && meta['uri']
-    end
-
     def browser_uri
       GoodData.connection.url + meta['uri']
     end
 
-    def identifier
-      meta['identifier']
-    end
-
-    def title
-      meta['title']
-    end
-
-    def summary
-      meta['summary']
-    end
-
-    def title=(a_title)
-      data['meta']['title'] = a_title
+    def updated
+      Time.parse(meta['updated'])
     end
 
-    def summary=(a_summary)
-      data['meta']['summary'] = a_summary
+    def created
+      Time.parse(meta['created'])
     end
 
-    def tags
-      data['meta']['tags']
+    def deprecated=(flag)
+      if flag == '1' || flag == 1
+        meta['deprecated'] = '1'
+      elsif flag == '0' || flag == 0
+        meta['deprecated'] = '0'
+      else
+        fail 'You have to provide flag as either 1 or "1" or 0 or "0"'
+      end
     end
 
-    def tags=(list_of_tags)
-      data['meta']['tags'] = list_of_tags
+    def data
+      raw_data[root_key]
     end
 
     def meta
@@ -132,34 +171,36 @@ module GoodData
     end
 
     def project
-      @project ||= Project[uri.gsub(/\/obj\/\d+$/, '')]
+      @project ||= Project[uri.gsub(%r{\/obj\/\d+$}, '')]
     end
 
-    def get_usedby
-      result = GoodData.get "#{GoodData.project.md['usedby2']}/#{obj_id}"
-      result['entries']
+    def usedby(key = nil)
+      dependency("#{GoodData.project.md['usedby2']}/#{obj_id}", key)
     end
 
-    def get_using
-      result = GoodData.get "#{GoodData.project.md['using2']}/#{obj_id}"
-      result['entries']
+    alias_method :used_by, :usedby
+
+    def using(key = nil)
+      dependency("#{GoodData.project.md['using2']}/#{obj_id}", key)
     end
 
-    def to_json
-      @json.to_json
+    def usedby?(obj)
+      dependency?(:usedby, obj)
     end
 
-    def raw_data
-      @json
+    alias_method :used_by?, :usedby?
+
+    def using?(obj)
+      dependency?(:using, obj)
     end
 
-    def data
-      key = methods.include?(:root_key) ? root_key : raw_data.keys.first
-      raw_data[key]
+    def to_json
+      @json.to_json
     end
 
     def saved?
-      !!uri
+      res = uri.nil?
+      !res
     end
 
     def save
@@ -168,15 +209,36 @@ module GoodData
       if saved?
         GoodData.put(uri, to_json)
       else
+        explicit_identifier = meta['identifier']
+        # Pre-check to provide a user-friendly error rather than
+        # failing later
+        if explicit_identifier && MdObject[explicit_identifier]
+          fail "Identifier '#{explicit_identifier}' already in use"
+        end
         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
+        if explicit_identifier
+          # Object creation API discards the identifier. If an identifier
+          # was explicitely provided in the origina object, we need to set
+          # it explicitly with an extra PUT call.
+          meta['identifier'] = explicit_identifier
+          begin
+            GoodData.put(uri, to_json)
+          rescue => e
+            # Cannot change the identifier (perhaps because it's in use
+            # already?), cleaning up.
+            GoodData.delete(uri)
+            raise e
+          end
+        end
       end
       self
     end
 
     def ==(other)
-      other.uri == uri
+      other.uri == uri && other.respond_to?(:to_hash) && other.to_hash == to_hash
     end
 
     def validate
@@ -187,5 +249,41 @@ module GoodData
       false
     end
 
+    # TODO: generate fill for other subtypes
+    def fact?
+      false
+    end
+
+    def attribute?
+      false
+    end
+
+    def metric?
+      false
+    end
+
+    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
+end

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

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+require_relative 'metadata'
+
+module GoodData
+  class Attribute < MdObject
+    root_key :attribute
+
+    ATTRIBUTE_BASE_AGGREGATIONS = [:count]
+
+    class << self
+      def [](id, options = {})
+        if id == :all
+          attrs = GoodData.get(GoodData.project.md['query'] + '/attributes/')['query']['entries']
+          options[:full] ? attrs.map { |a| Attribute[a['link']] } : attrs
+        else
+          super
+        end
+      end
+
+      def find_element_value(uri)
+        matches = uri.match(/(.*)\/elements\?id=(\d+)$/)
+        Attribute[matches[1]].primary_label.find_element_value(matches[2].to_i)
+      end
+    end
+
+    def display_forms
+      content['displayForms'].map { |df| GoodData::DisplayForm[df['meta']['uri']] }
+    end
+    alias_method :labels, :display_forms
+
+    # Returns the first display form which is the primary one
+    # @return [GoodData::DisplayForm] Primary label
+    def primary_display_form
+      labels.first
+    end
+    alias_method :primary_label, :primary_display_form
+
+    def attribute?
+      true
+    end
+
+    def create_metric(options = {})
+      an_attribute = options[:attribute]
+      a_type = options[:type] || :count
+      fail "Suggested aggreagtion function (#{a_type}) does not exist for base metric created out of attribute. You can use only one of #{ATTRIBUTE_BASE_AGGREGATIONS.map { |x| ":" + x.to_s }.join(',')}" unless ATTRIBUTE_BASE_AGGREGATIONS.include?(a_type)
+      a_title = options[:title] || "#{a_type} of #{title}"
+      if an_attribute
+        an_attribute = Attribute[an_attribute] if an_attribute.is_a?(String)
+        Metric.xcreate(:expression => "SELECT #{a_type.to_s.upcase}(![#{identifier}], ![#{an_attribute.identifier}])", :title => a_title)
+      else
+        Metric.xcreate(:expression => "SELECT #{a_type.to_s.upcase}(![#{identifier}])", :title => a_title)
+      end
+    end
+
+    # For an element id find values (titles) for all display forms. Element id can be given as both number id or URI as a string beginning with /
+    # @param [Object] element_id Element identifier either Number or a uri as a String
+    # @return [Array] list of values for certain element. Returned in the same order as is the order of labels
+    def values_for(element_id)
+      element_id = element_id.is_a?(String) ? element_id.match(/\?id=(\d)/)[1] : element_id
+      labels.map do |label|
+        label.find_element_value(element_id)
+      end
+    end
+
+    # Returns all values for all labels. 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
+    # @return [Array]
+    def values(options = {})
+      results = labels.map do |label|
+        label.values(options)
+      end
+      results.first.zip(*results[1..-1])
+    end
+
+    def label_by_name(name)
+      labels.find { |label| label.title.downcase =~ /#{name}/ || label.identifier.downcase =~ /#{name}/ }
+    end
+  end
+end