readmedia-garb 0.9.1.1

data/lib/garb/management/web_property.rb

@@ -0,0 +1,38 @@
+module Garb
+  module Management
+    class WebProperty
+      attr_accessor :session, :path
+      attr_accessor :id, :account_id
+
+      def self.all(session = Session, path='/accounts/~all/webproperties')
+        feed = Feed.new(session, path)
+        feed.entries.map {|entry| new_from_entry(entry, session)}
+      end
+
+      def self.for_account(account)
+        all(account.session, account.path+'/webproperties')
+      end
+
+      def self.new_from_entry(entry, session)
+        web_property = new
+        web_property.session = session
+        web_property.path = Garb.parse_link(entry, "self").gsub(Feed::BASE_URL, '')
+        web_property.properties = Garb.parse_properties(entry)
+        web_property
+      end
+
+      def properties=(properties)
+        self.id = properties["web_property_id"]
+        self.account_id = properties["account_id"]
+      end
+
+      def profiles
+        @profiles ||= Profile.for_web_property(self)
+      end
+
+      def goals
+        @goals ||= Goal.for_web_property(self)
+      end
+    end
+  end
+end

data/lib/garb/model.rb

@@ -0,0 +1,91 @@
+module Garb
+  module Model
+    MONTH = 2592000
+    URL = "https://www.googleapis.com/analytics/v2.4/data"
+
+    def self.extended(base)
+      ProfileReports.add_report_method(base)
+    end
+
+    def metrics(*fields)
+      @metrics ||= ReportParameter.new(:metrics)
+      @metrics << fields
+    end
+
+    def dimensions(*fields)
+      @dimensions ||= ReportParameter.new(:dimensions)
+      @dimensions << fields
+    end
+
+    def set_instance_klass(klass)
+      @instance_klass = klass
+    end
+
+    def instance_klass
+      @instance_klass || OpenStruct
+    end
+
+    def results(profile, options = {})
+      start_date = options.fetch(:start_date, Time.now - MONTH)
+      end_date = options.fetch(:end_date, Time.now)
+      default_params = build_default_params(profile, start_date, end_date)
+
+      param_set = [
+        default_params,
+        metrics.to_params,
+        dimensions.to_params,
+        parse_filters(options).to_params,
+        parse_segment(options),
+        parse_sort(options).to_params,
+        build_page_params(options)
+      ]
+
+      data = send_request_for_data(profile, build_params(param_set))
+      ReportResponse.new(data, instance_klass).results
+    end
+
+    private
+    def send_request_for_data(profile, params)
+      request = DataRequest.new(profile.session, URL, params)
+      response = request.send_request
+      response.body
+    end
+
+    def build_params(param_set)
+      param_set.inject({}) {|p,i| p.merge(i)}.reject{|k,v| v.nil?}
+    end
+
+    def parse_filters(options)
+      filters = FilterParameters.new
+      filters.parameters << options[:filters] if options.has_key?(:filters)
+      filters
+    end
+
+    def parse_segment(options)
+      segment_id = "gaid::#{options[:segment_id].to_i}" if options.has_key?(:segment_id)
+      {'segment' => segment_id}
+    end
+
+    def parse_sort(options)
+      sort = ReportParameter.new(:sort)
+      sort << options[:sort] if options.has_key?(:sort)
+      sort
+    end
+
+    def build_default_params(profile, start_date, end_date)
+      {
+        'ids' => Garb.to_ga(profile.id),
+        'start-date' => format_time(start_date),
+        'end-date' => format_time(end_date)
+      }
+    end
+
+    def build_page_params(options)
+      {'max-results' => options[:limit], 'start-index' => options[:offset]}
+    end
+
+    def format_time(t)
+      t.strftime('%Y-%m-%d')
+    end
+  end
+end

data/lib/garb/profile.rb

@@ -0,0 +1,33 @@
+module Garb
+  class Profile
+
+    include ProfileReports
+
+    attr_reader :session, :table_id, :title, :account_name, :account_id, :web_property_id, :goals
+
+    def initialize(entry, session)
+      @session = session
+      @title = entry['title']
+      @table_id = entry['dxp:tableId']
+      @goals = (entry[Garb.to_ga('goal')] || []).map {|g| Goal.new(g)}
+
+      Garb.parse_properties(entry).each do |k,v|
+        instance_variable_set :"@#{k}", v
+      end
+    end
+
+    def id
+      Garb.from_ga(@table_id)
+    end
+
+    def self.all(session = Session)
+      ActiveSupport::Deprecation.warn("Garb::Profile.all is deprecated in favor of Garb::Management::Profile.all")
+      AccountFeedRequest.new(session).entries.map {|entry| new(entry, session)}
+    end
+
+    def self.first(id, session = Session)
+      ActiveSupport::Deprecation.warn("Garb::Profile.first is deprecated in favor of Garb::Management::WebProperty")
+      all(session).detect {|profile| profile.id == id || profile.web_property_id == id }
+    end
+  end
+end

data/lib/garb/profile_reports.rb

@@ -0,0 +1,16 @@
+module Garb
+  module ProfileReports
+    def self.add_report_method(klass)
+      # demodulize leaves potential to redefine
+      # these methods given different namespaces
+      method_name = klass.name.to_s.demodulize.underscore
+      return unless method_name.length > 0
+
+      class_eval <<-CODE
+        def #{method_name}(opts = {}, &block)
+          #{klass}.results(self, opts, &block)
+        end
+      CODE
+    end
+  end
+end

data/lib/garb/report.rb

@@ -0,0 +1,28 @@
+module Garb
+  class Report
+    include Resource
+
+    MONTH = 2592000
+    URL = "https://www.google.com/analytics/feeds/data"
+
+    def initialize(profile, opts={})
+      ActiveSupport::Deprecation.warn("The use of Report will be removed in favor of 'extend Garb::Model'")
+
+      @profile = profile
+
+      @start_date = opts.fetch(:start_date, Time.now - MONTH)
+      @end_date = opts.fetch(:end_date, Time.now)
+      @limit = opts.fetch(:limit, nil)
+      @offset = opts.fetch(:offset, nil)
+
+      metrics opts.fetch(:metrics, [])
+      dimensions opts.fetch(:dimensions, [])
+      sort opts.fetch(:sort, [])
+    end
+
+    def results
+      ReportResponse.new(send_request_for_body).results
+    end
+
+  end
+end

data/lib/garb/report_parameter.rb

@@ -0,0 +1,25 @@
+module Garb
+  class ReportParameter
+
+    attr_reader :elements
+    
+    def initialize(name)
+      @name = name
+      @elements = []
+    end
+    
+    def name
+      @name.to_s
+    end
+    
+    def <<(element)
+      (@elements += [element].flatten).compact!
+      self
+    end
+    
+    def to_params
+      value = self.elements.map{|param| Garb.to_google_analytics(param)}.join(',')
+      value.empty? ? {} : {self.name => value}
+    end
+  end
+end

data/lib/garb/report_response.rb

@@ -0,0 +1,56 @@
+module Garb  
+  class ReportResponse
+    KEYS = ['dxp:metric', 'dxp:dimension']
+
+    def initialize(response_body, instance_klass = OpenStruct)
+      @xml = response_body
+      @instance_klass = instance_klass
+    end
+
+    def results
+      if @results.nil?
+        @results = ResultSet.new(parse)
+        @results.total_results = parse_total_results
+        @results.sampled = parse_sampled_flag
+      end
+
+      @results
+    end
+
+    def sampled?
+    end
+
+    private
+    def parse
+      entries.map do |entry|
+        @instance_klass.new(Hash[
+          values_for(entry).map {|v| [Garb.from_ga(v['name']), v['value']]}
+        ])
+      end
+    end
+
+    def entries
+      feed? ? [parsed_xml['feed']['entry']].flatten.compact : []
+    end
+
+    def parse_total_results
+      feed? ? parsed_xml['feed']['openSearch:totalResults'].to_i : 0
+    end
+
+    def parse_sampled_flag
+      feed? ? (parsed_xml['feed']['dxp:containsSampledData'] == 'true') : false
+    end
+
+    def parsed_xml
+      @parsed_xml ||= Crack::XML.parse(@xml)
+    end
+
+    def feed?
+      !parsed_xml['feed'].nil?
+    end
+
+    def values_for(entry)
+      KEYS.map {|k| entry[k]}.flatten.compact
+    end
+  end
+end

data/lib/garb/reports/bounces.rb

@@ -0,0 +1,5 @@
+class Bounces
+  extend Garb::Resource
+
+  metrics :bounces
+end

data/lib/garb/reports/exits.rb

@@ -0,0 +1,5 @@
+class Exits
+  extend Garb::Resource
+
+  metrics :exits
+end

data/lib/garb/reports/pageviews.rb

@@ -0,0 +1,5 @@
+class Pageviews
+  extend Garb::Resource
+
+  metrics :pageviews
+end

data/lib/garb/reports/unique_pageviews.rb

@@ -0,0 +1,5 @@
+class UniquePageviews
+  extend Garb::Resource
+
+  metrics :unique_pageviews
+end

data/lib/garb/reports/visits.rb

@@ -0,0 +1,5 @@
+class Visits
+  extend Garb::Resource
+
+  metrics :visits
+end

data/lib/garb/reports.rb

@@ -0,0 +1,5 @@
+require 'garb/reports/exits'
+require 'garb/reports/visits'
+require 'garb/reports/bounces'
+require 'garb/reports/pageviews'
+require 'garb/reports/unique_pageviews'

data/lib/garb/resource.rb

@@ -0,0 +1,115 @@
+module Garb
+  module Resource
+    MONTH = 2592000
+    URL = "https://www.googleapis.com/analytics/v2.4/data"
+
+    def self.extended(base)
+      # define a method on a module that gets included into profile
+      # Exits would make:
+      # to enable profile.exits(options_hash, &block)
+      # returns Exits.results(self, options_hash, &block)
+      # every class defined which extends Resource will add to the module
+
+      ActiveSupport::Deprecation.warn("The use of Garb::Resource will be removed in favor of 'extend Garb::Model'")
+      ProfileReports.add_report_method(base)
+    end
+
+    %w(metrics dimensions sort).each do |parameter|
+      class_eval <<-CODE
+        def #{parameter}(*fields)
+          @#{parameter} ||= ReportParameter.new(:#{parameter})
+          @#{parameter} << fields
+        end
+
+        def clear_#{parameter}
+          @#{parameter} = ReportParameter.new(:#{parameter})
+        end
+      CODE
+    end
+
+    def filters(*hashes, &block)
+      @filter_parameters ||= FilterParameters.new
+
+      hashes.each do |hash|
+        @filter_parameters.parameters << hash
+      end
+
+      @filter_parameters.filters(&block) if block_given?
+      @filter_parameters
+    end
+
+    def clear_filters
+      @filter_parameters = FilterParameters.new
+    end
+
+    def set_segment_id(id)
+      @segment = "gaid::#{id.to_i}"
+    end
+
+    def segment
+      @segment
+    end
+
+    def set_instance_klass(klass)
+      @instance_klass = klass
+    end
+
+    def instance_klass
+      @instance_klass || OpenStruct
+    end
+
+    def results(profile, opts = {}, &block)
+      @profile = profile.is_a?(Profile) ? profile : Profile.first(profile, opts.fetch(:session, Session))
+
+      if @profile
+        @start_date = opts.fetch(:start_date, Time.now - MONTH)
+        @end_date = opts.fetch(:end_date, Time.now)
+        @limit = opts.fetch(:limit, nil)
+        @offset = opts.fetch(:offset, nil)
+
+        instance_eval(&block) if block_given?
+
+        ReportResponse.new(send_request_for_body, instance_klass).results
+      else
+        []
+      end
+    end
+
+    def page_params
+      {'max-results' => @limit, 'start-index' => @offset}.reject{|k,v| v.nil?}
+    end
+
+    def default_params
+      {'ids' => @profile.table_id,
+        'start-date' => format_time(@start_date),
+        'end-date' => format_time(@end_date)}
+    end
+
+    def segment_params
+      segment.nil? ? {} : {'segment' => segment}
+    end
+
+    def params
+      [
+        metrics.to_params,
+        dimensions.to_params,
+        sort.to_params,
+        filters.to_params,
+        page_params,
+        segment_params
+      ].inject(default_params) do |p, i|
+        p.merge(i)
+      end
+    end
+
+    def format_time(t)
+      t.strftime('%Y-%m-%d')
+    end
+
+    def send_request_for_body
+      request = DataRequest.new(@profile.session, URL, params)
+      response = request.send_request
+      response.body
+    end
+  end
+end

data/lib/garb/result_set.rb

@@ -0,0 +1,21 @@
+module Garb
+  class ResultSet
+    include Enumerable
+
+    attr_accessor :total_results, :sampled
+
+    alias :sampled? :sampled
+
+    def initialize(results)
+      @results = results
+    end
+
+    def each(&block)
+      @results.each(&block)
+    end
+
+    def to_a
+      @results
+    end
+  end
+end

data/lib/garb/session.rb

@@ -0,0 +1,25 @@
+module Garb
+  class Session
+    module Methods
+      attr_accessor :auth_token, :access_token, :email
+
+      # use only for single user authentication
+      def login(email, password, opts={})
+        self.email = email
+        auth_request = AuthenticationRequest.new(email, password, opts)
+        self.auth_token = auth_request.auth_token(opts)
+      end
+
+      def single_user?
+        auth_token && auth_token.is_a?(String)
+      end
+
+      def oauth_user?
+        !access_token.nil?
+      end
+    end
+
+    include Methods
+    extend Methods
+  end
+end

data/lib/garb/step.rb

@@ -0,0 +1,13 @@
+module Garb
+  class Step
+    attr_reader :name, :number, :path
+
+    def initialize(attributes)
+      return unless attributes.is_a?(Hash)
+
+      @name = attributes['name']
+      @number = attributes['number'].to_i
+      @path = attributes['path']
+    end
+  end
+end

data/lib/garb/version.rb

@@ -0,0 +1,14 @@
+module Garb
+  module Version
+
+    MAJOR = 0
+    MINOR = 9
+    TINY  = 1
+    NANO  = 1
+
+    def self.to_s # :nodoc:
+      [MAJOR, MINOR, TINY, NANO].join('.')
+    end
+
+  end
+end

data/lib/garb.rb

@@ -0,0 +1,69 @@
+require 'net/http'
+require 'net/https'
+
+require 'cgi'
+require 'ostruct'
+require 'crack'
+
+begin
+  require 'active_support/inflector'
+  require 'active_support/deprecation'
+rescue Exception => e
+  require 'active_support'
+end
+
+require 'garb/version'
+require 'garb/authentication_request'
+require 'garb/data_request'
+require 'garb/account_feed_request'
+require 'garb/session'
+require 'garb/profile_reports'
+require 'garb/step'
+require 'garb/destination'
+require 'garb/goal'
+require 'garb/profile'
+require 'garb/account'
+require 'garb/filter_parameters'
+require 'garb/report_parameter'
+require 'garb/result_set'
+require 'garb/report_response'
+require 'garb/resource'
+require 'garb/report'
+
+require 'garb/model'
+
+# management
+require 'garb/management/feed'
+require 'garb/management/segment'
+require 'garb/management/account'
+require 'garb/management/web_property'
+require 'garb/management/profile'
+require 'garb/management/goal'
+
+require 'support'
+
+module Garb
+  GA = "http://schemas.google.com/analytics/2008"
+
+  extend self
+
+  def to_google_analytics(thing)
+    return thing.to_google_analytics if thing.respond_to?(:to_google_analytics)
+
+    "ga:#{thing.to_s.camelize(:lower)}"
+  end
+  alias :to_ga :to_google_analytics
+
+  def from_google_analytics(thing)
+    thing.to_s.gsub(/^ga\:/, '').underscore
+  end
+  alias :from_ga :from_google_analytics
+
+  def parse_properties(entry)
+    Hash[entry['dxp:property'].map {|p| [Garb.from_ga(p['name']),p['value']]}]
+  end
+
+  def parse_link(entry, rel)
+    entry['link'].detect {|link| link["rel"] == rel}['href']
+  end
+end

data/lib/support.rb

@@ -0,0 +1,40 @@
+class SymbolOperator
+  def initialize(field, operator)
+    @field, @operator = field, operator
+  end unless method_defined?(:initialize)
+
+  def to_google_analytics
+    operators = {
+      :eql => '==',
+      :not_eql => '!=',
+      :gt => '>',
+      :gte => '>=',
+      :lt => '<',
+      :lte => '<=',
+      :matches => '==',
+      :does_not_match => '!=',
+      :contains => '=~',
+      :does_not_contain => '!~',
+      :substring => '=@',
+      :not_substring => '!@',
+      :desc => '-',
+      :descending => '-'
+    }
+
+    target = Garb.to_google_analytics(@field)
+    operator = operators[@operator]
+
+    [:desc, :descending].include?(@operator) ? "#{operator}#{target}" : "#{target}#{operator}"
+  end
+end
+
+class Symbol
+  [:eql, :not_eql, :gt, :gte, :lt, :lte, :desc, :descending,
+    :matches, :does_not_match, :contains, :does_not_contain,
+    :substring, :not_substring].each do |operator|
+
+    define_method(operator) do
+      SymbolOperator.new(self, operator)
+    end unless method_defined?(operator)
+  end
+end