garb 0.9.1 → 0.9.7

data/lib/garb/attributes.rb

@@ -0,0 +1,35 @@
+module Garb
+  module Attributes
+    def self.extended(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def ga_attribute(*keys)
+        hashes, symbols = keys.partition { |k| k.is_a? Hash }
+        symbols.each { |key| define_a_method_for key }
+        hashes.each { |hash| map_values_for hash }
+      end
+
+      private
+      def define_a_method_for(key, custom_key = nil)
+        custom_key ||= key.to_s.camelize(:lower)
+        define_method(key) do
+          var = "@#{key}"
+          if instance_variable_defined? var
+            instance_variable_get var
+          else
+            hash_key = (custom_key || key).to_s
+            instance_variable_set var, @entry[hash_key]
+          end
+        end #unless method_defined?(key)
+      end
+
+      def map_values_for(hash)
+        hash.each_pair do |key, value|
+          define_a_method_for key, value
+        end
+      end
+    end
+  end
+end

data/lib/garb/core_ext/array.rb

@@ -0,0 +1,13 @@
+unless Object.const_defined?('ActiveSupport')
+  class Array
+    def self.wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary
+      else
+        [object]
+      end
+    end
+  end
+end

data/lib/garb/core_ext/string.rb

@@ -0,0 +1,48 @@
+# Pull in some AS String utilities (not loaded if AS is available)
+unless Object.const_defined?('ActiveSupport')
+  class String
+    def camelize(first_letter = :upper)
+      case first_letter
+        when :upper then Garb::Inflector.camelize(self, true)
+        when :lower then Garb::Inflector.camelize(self, false)
+      end
+    end
+    alias_method :camelcase, :camelize
+
+    def underscore
+      Garb::Inflector.underscore(self)
+    end
+
+    def demodulize
+      Garb::Inflector.demodulize(self)
+    end
+  end
+
+  module Garb
+    module Inflector
+      extend self
+
+      def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+        if first_letter_in_uppercase
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+        else
+          lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+        end
+      end
+
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      def demodulize(class_name_in_module)
+        class_name_in_module.to_s.gsub(/^.*::/, '')
+      end
+    end
+  end
+end

data/lib/garb/core_ext/symbol.rb

@@ -0,0 +1,59 @@
+module SymbolOperatorMethods
+  OPERATORS = {
+    :eql     => '==',
+    :not_eql => '!=',
+    :gt      => '>',
+    :gte     => '>=',
+    :lt      => '<',
+    :lte     => '<=',
+    :matches => '==',
+    
+    :does_not_match   => '!=',
+    :contains         => '=~',
+    :does_not_contain => '!~',
+    :substring        => '=@',
+    :not_substring    => '!@',
+    
+    :desc       => '-',
+    :descending => '-'
+  }
+  SLUGS = OPERATORS.keys.freeze
+
+  def to_google_analytics
+    t = Garb.to_google_analytics @field || @target
+    o = OPERATORS[@operator]
+
+    [:desc, :descending].include?(@operator) ? "#{o}#{t}" : "#{t}#{o}"
+  end
+end
+
+class SymbolOperator
+  include SymbolOperatorMethods
+  
+  def initialize(field, operator)
+    @field, @operator = field, operator
+  end unless method_defined? :initialize
+end
+
+symbol_slugs = if Object.const_defined?('DataMapper')
+  # make sure the class is defined
+  require 'dm-core/core_ext/symbol'
+
+  # add to_google_analytics to DM's Opeartor
+  class DataMapper::Query::Operator
+    include SymbolOperatorMethods
+  end
+
+  SymbolOperatorMethods::SLUGS - DataMapper::Query::Conditions::Comparison.slugs
+else
+  SymbolOperatorMethods::SLUGS
+end
+
+# define the remaining symbol operators
+symbol_slugs.each do |operator|
+  Symbol.class_eval <<-RUBY
+    def #{operator}
+      SymbolOperator.new self, :#{operator}
+    end unless method_defined? :#{operator}
+  RUBY
+end

data/lib/garb/destination.rb

@@ -1,18 +1,17 @@
 module Garb
   class Destination
-    attr_reader :match_type, :expression, :steps, :case_sensitive
+    attr_reader :match_type, :url, :steps, :case_sensitive
 
     alias :case_sensitive? :case_sensitive
 
     def initialize(attributes)
-      return unless attributes.is_a?(Hash)
+      return unless attributes.is_a? Hash
 
       @match_type = attributes['matchType']
-      @expression = attributes['expression']
-      @case_sensitive = (attributes['caseSensitive'] == 'true')
+      @url = attributes['url'] # TODO was @expression
+      @case_sensitive = attributes['caseSensitive']
 
-      step_attributes = attributes[Garb.to_ga('step')]
-      @steps = Array(step_attributes.is_a?(Hash) ? [step_attributes] : step_attributes).map {|s| Step.new(s)}
+      @steps = attributes['steps'] && attributes['steps'].map { |s| Step.new(s) }
     end
   end
 end

data/lib/garb/errors.rb

@@ -0,0 +1,20 @@
+module Garb
+  class Error < StandardError; end
+  class MissingCertFileError < Error; end
+  class AuthError < Error; end
+  class ClientError < Error
+    attr_reader :code, :message, :errors, :uri
+    
+    def initialize(uri, message, code = nil, errors = [])
+      @code, @message, @errors, @uri = code, message, errors, uri
+    end
+    
+    def to_s
+      "#{code ? "[#{code}] #{message}" : message} : #{uri}"
+    end
+  end
+  class BadRequestError < ClientError; end
+  class InvalidCredentialsError < ClientError; end
+  class InsufficientPermissionsError < ClientError; end
+  class BackendError < ClientError; end
+end

data/lib/garb/filter_parameters.rb

@@ -1,42 +1,33 @@
 module Garb
   class FilterParameters
-    def self.define_operators(*methods)
-      methods.each do |method|
-        class_eval <<-CODE
-          def #{method}(field, value)
-            @filter_hash.merge!({SymbolOperator.new(field, :#{method}) => value})
-          end
-        CODE
-      end
-    end
-
-    define_operators :eql, :not_eql, :gt, :gte, :lt, :lte, :matches,
-      :does_not_match, :contains, :does_not_contain, :substring, :not_substring
-
     attr_accessor :parameters
 
-    def initialize
-      self.parameters = []
+    def initialize(parameters)
+      self.parameters = (Array.wrap(parameters) || []).compact
     end
 
-    def filters(&block)
-      @filter_hash = {}
-
-      instance_eval &block
-
-      self.parameters << @filter_hash
+    def to_params
+      value = array_to_params(self.parameters)
+      value.empty? ? {} : {'filters' => value}
     end
 
-    def to_params
-      value = self.parameters.map do |param|
-        param.map do |k,v|
-          next unless k.is_a?(SymbolOperator)
-          escaped_v = v.to_s.gsub(/([,;\\])/) {|c| '\\'+c}
-          "#{URI.encode(k.to_google_analytics, /[=<>]/)}#{CGI::escape(escaped_v)}"
-        end.join('%3B') # Hash AND (no duplicate keys), escape char for ';' fixes oauth
+    private
+    def array_to_params(arr)
+      arr.map do |param|
+        case param
+        when Hash  then hash_to_params(param)
+        when Array then array_to_params(param)
+        end
       end.join(',') # Array OR
+    end
 
-      value.empty? ? {} : {'filters' => value}
+    def hash_to_params(hsh)
+      hsh.map do |k, v|
+        next unless k.is_a?(SymbolOperatorMethods)
+
+        escaped_v = v.to_s.gsub(/([,;])/) { |c| '\\' + c }
+        "#{URI.encode(k.to_google_analytics, /[=<>]/)}#{CGI::escape(escaped_v)}"
+      end.join('%3B') # Hash AND (no duplicate keys), escape char for ';' fixes oauth
     end
   end
 end

data/lib/garb/management/account.rb

@@ -1,26 +1,20 @@
 module Garb
   module Management
     class Account
-      attr_accessor :session, :path
-      attr_accessor :id, :title, :name
+      extend Garb::Attributes
+      include PathAttribute
 
-      def self.all(session = Session)
-        feed = Feed.new(session, '/accounts')
-        feed.entries.map {|entry| new_from_entry(entry, session)}
-      end
+      attr_reader :session
+      ga_attribute :id, :name
 
-      def self.new_from_entry(entry, session)
-        account = new
-        account.session = session
-        account.path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
-        account.title = entry['title'].gsub('Google Analytics Account ', '') # can we get this in properties=?
-        account.properties = Garb.parse_properties(entry)
-        account
+      def initialize(entry, session)
+        @entry = entry
+        @session = session
       end
 
-      def properties=(properties)
-        self.id = properties["account_id"]
-        self.name = properties["account_name"]
+      def self.all(session = Session)
+        feed = Feed.new(session, '/accounts')
+        feed.entries.map { |entry| new(entry, session) }
       end
 
       def web_properties

data/lib/garb/management/feed.rb

@@ -1,21 +1,20 @@
 module Garb
   module Management
     class Feed
-      BASE_URL = "https://www.google.com/analytics/feeds/datasources/ga"
+      BASE_URL = 'https://www.googleapis.com/analytics/v3/management'
 
       attr_reader :request
 
       def initialize(session, path)
-        @request = DataRequest.new(session, BASE_URL+path)
+        @request = Request::Data.new(session, BASE_URL + path)
       end
 
       def parsed_response
-        @parsed_response ||= Crack::XML.parse(response.body)
+        @parsed_response ||= MultiJson.load(response.body)
       end
 
       def entries
-        # possible to have nil entries, yuck
-        parsed_response ? [parsed_response['feed']['entry']].flatten.compact : []
+        parsed_response && parsed_response['items'] || []
       end
 
       def response

data/lib/garb/management/goal.rb

@@ -1,15 +1,17 @@
 module Garb
   module Management
     class Goal
+      extend Attributes
+      include PathAttribute
 
-      attr_accessor :session, :path
-      attr_accessor :name, :number, :value, :destination, :active
+      attr_reader :session
+      ga_attribute :name, :number, :value, :active
 
       alias :active? :active
 
       def self.all(session = Session, path = '/accounts/~all/webproperties/~all/profiles/~all/goals')
         feed = Feed.new(session, path)
-        feed.entries.map {|entry| new_from_entry(entry, session)}
+        feed.entries.map { |entry| new(entry, session) }
       end
 
       def self.for_account(account)
@@ -24,20 +26,13 @@ module Garb
         all(profile.session, profile.path + '/goals')
       end
 
-      def self.new_from_entry(entry, session)
-        goal = new
-        goal.session = session
-        goal.path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
-        goal.properties = entry[Garb.to_ga('goal')]
-        goal
+      def initialize(entry, session)
+        @entry = entry
+        @session = session
       end
 
-      def properties=(properties)
-        self.name = properties["name"]
-        self.number = properties["number"].to_i
-        self.value = properties["value"].to_f
-        self.active = (properties["active"] == "true")
-        self.destination = Destination.new(properties[Garb.to_ga('destination')])
+      def destination
+        @destination ||= Destination.new(@entry['urlDestinationDetails'])
       end
     end
   end

data/lib/garb/management/profile.rb

@@ -3,41 +3,32 @@ module Garb
     class Profile
 
       include ProfileReports
+      include PathAttribute
+      extend Attributes
 
-      attr_accessor :session, :path
-      attr_accessor :id, :table_id, :title, :account_id, :web_property_id
+      attr_reader :session
+      ga_attribute :id, :name, :account_id, :web_property_id, :website_url
 
       def self.all(session = Session, path = '/accounts/~all/webproperties/~all/profiles')
         feed = Feed.new(session, path)
-        feed.entries.map {|entry| new_from_entry(entry, session)}
+        feed.entries.map { |entry| new(entry, session) }
       end
 
       def self.for_account(account)
-        all(account.session, account.path+'/webproperties/~all/profiles')
+        all(account.session, account.path + '/webproperties/~all/profiles')
       end
 
       def self.for_web_property(web_property)
-        all(web_property.session, web_property.path+'/profiles')
+        all(web_property.session, web_property.path + '/profiles')
       end
 
-      def self.new_from_entry(entry, session)
-        profile = new
-        profile.session = session
-        profile.path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
-        profile.properties = Garb.parse_properties(entry)
-        profile
-      end
-
-      def properties=(properties)
-        self.id = properties['profile_id']
-        self.table_id = properties['dxp:table_id']
-        self.title = properties['profile_name']
-        self.account_id = properties['account_id']
-        self.web_property_id = properties['web_property_id']
+      def initialize(entry, session)
+        @entry = entry
+        @session = session
       end
 
       def goals
-        Goal.for_profile(self)
+        Goal.for_profile self
       end
     end
   end

data/lib/garb/management/segment.rb

@@ -1,26 +1,20 @@
 module Garb
   module Management
     class Segment
-      attr_accessor :session, :path
-      attr_accessor :id, :name, :definition
+      extend Attributes
+      include PathAttribute
+
+      attr_reader :session
+      ga_attribute :name, :definition, :id => 'segmentId'
 
       def self.all(session = Session)
         feed = Feed.new(session, '/segments')
-        feed.entries.map {|entry| new_from_entry(entry, session)}
-      end
-
-      def self.new_from_entry(entry, session)
-        segment = new
-        segment.session = session
-        segment.path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
-        segment.properties = entry['dxp:segment']
-        segment
+        feed.entries.map { |entry| new(entry, session) }
       end
 
-      def properties=(properties)
-        self.id = properties['id']
-        self.name = properties['name']
-        self.definition = properties['dxp:definition']
+      def initialize(entry, session)
+        @entry = entry
+        @session = session
       end
     end
   end