gattica 0.4.1 → 0.4.3

data/History.txt

@@ -1,3 +1,13 @@
+== 0.4.3
+  * er1c fixed start-index
+  * rpanachi fixed max_results
+
+== 0.4.2
+  * rpanachi Updates for max_results
+  * Fixed various nil references from multiple people
+  * howcast Updated Email Regex to allow "username+suffix@gmail.com"
+  * scottpersinger Added V2 API Parameter for Segment filter
+
 == 0.4.0
   * er1c added start_index and max_results
   * er1c added paging for all results

data/LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
  
-Copyright (c) 2009 Rob Cameron
+Copyright (c) 2009 The Active Network
  
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :minor: 4
-:patch: 1
+:patch: 2
 :major: 0

data/gattica.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gattica}
-  s.version = "0.4.1"
+  s.version = "0.4.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["The Active Network"]

data/lib/gattica.rb

@@ -25,22 +25,22 @@ require 'gattica/data_point'
 # Please see the README for usage docs.
 
 module Gattica
-  
-  VERSION = '0.4.0'
-  
+
+  VERSION = '0.4.3'
+
   # Creates a new instance of Gattica::Engine and gets us going. Please see the README for usage docs.
   #
   #   ga = Gattica.new({:email => 'anonymous@anon.com', :password => 'password, :profile_id => 123456 })
-  
+
   def self.new(*args)
     Engine.new(*args)
   end
-  
-  # The real meat of Gattica, deals with talking to GA, returning and parsing results. You actually get 
+
+  # The real meat of Gattica, deals with talking to GA, returning and parsing results. You actually get
   # an instance of this when you go Gattica.new()
-  
+
   class Engine
-    
+
     SERVER = 'www.google.com'
     PORT = 443
     SECURE = true
@@ -48,10 +48,10 @@ module Gattica
     DEFAULT_OPTIONS = { :email => nil, :password => nil, :token => nil, :profile_id => nil, :debug => false, :headers => {}, :logger => Logger.new(STDOUT) }
     FILTER_METRIC_OPERATORS = %w{ == != > < >= <= }
     FILTER_DIMENSION_OPERATORS = %w{ == != =~ !~ =@ ~@ }
-    
+
     attr_reader :user
     attr_accessor :profile_id, :token
-    
+
     # Create a user, and get them authorized.
     # If you're making a web app you're going to want to save the token that's retrieved by Gattica
     # so that you can use it later (Google recommends not re-authenticating the user for each and every request)
@@ -62,15 +62,17 @@ module Gattica
     # Or if you already have the token (because you authenticated previously and now want to reuse that session):
     #
     #   ga = Gattica.new({:token => '23ohda09hw...', :profile_id => 123456})
-    
+
     def initialize(options={})
       @options = DEFAULT_OPTIONS.merge(options)
       @logger = @options[:logger]
-      
+      @logger.level = Logger::INFO
+
+
       @profile_id = @options[:profile_id]     # if you don't include the profile_id now, you'll have to set it manually later via Gattica::Engine#profile_id=
       @user_accounts = nil                    # filled in later if the user ever calls Gattica::Engine#accounts
       @headers = {}.merge(@options[:headers]) # headers used for any HTTP requests (Google requires a special 'Authorization' header which is set any time @token is set)
-      
+
       # save a proxy-aware http connection for everyone to use
       proxy_host = nil
       proxy_port = nil
@@ -85,7 +87,7 @@ module Gattica
       @http = Net::HTTP::Proxy(proxy_host,proxy_port).new(SERVER, PORT)
       @http.use_ssl = SECURE
       @http.set_debug_output $stdout if @options[:debug]
-      
+
       # authenticate
       if @options[:email] && @options[:password]      # email and password: authenticate, get a token from Google's ClientLogin, save it for later
         @user = User.new(@options[:email], @options[:password])
@@ -96,11 +98,11 @@ module Gattica
       else                                            # no login or token, you can't do anything
         raise GatticaError::NoLoginOrToken, 'You must provide an email and password, or authentication token'
       end
-      
+
       # TODO: check that the user has access to the specified profile and show an error here rather than wait for Google to respond with a message
     end
-    
-    
+
+
     # Returns the list of accounts the user has access to. A user may have multiple accounts on Google Analytics
     # and each account may have multiple profiles. You need the profile_id in order to get info from GA. If you
     # don't know the profile_id then use this method to get a list of all them. Then set the profile_id of your
@@ -116,7 +118,7 @@ module Gattica
     # get the accounts and find a profile_id - you apparently already know it!
     #
     # See Gattica::Engine#get to see how to get some data.
-    
+
     def accounts
       # if we haven't retrieved the user's accounts yet, get them now and save them
       if @user_accounts.nil?
@@ -133,35 +135,35 @@ module Gattica
     #
     #   gs = Gattica.new({:email => 'johndoe@google.com', :password => 'password', :profile_id => 123456})
     #   fh = File.new("file.csv", "w")
-    #   gs.get_to_csv({ :start_date => '2008-01-01', 
-    #            :end_date => '2008-02-01', 
-    #            :dimensions => 'browser', 
-    #            :metrics => 'pageviews', 
+    #   gs.get_to_csv({ :start_date => '2008-01-01',
+    #            :end_date => '2008-02-01',
+    #            :dimensions => 'browser',
+    #            :metrics => 'pageviews',
     #            :sort => 'pageviews',
     #            :filters => ['browser == Firefox']}, fh, :short)
     #
     # See Gattica::Engine#get to see details of arguments
 
-    def get_to_csv(args={}, fh = nil, format = :long)   
+    def get_to_csv(args={}, fh = nil, format = :long)
       raise GatticaError::InvalidFileType, "Invalid file handle" unless !fh.nil?
       results(args, fh, :csv, format)
     end
-    
+
     # This is the method that performs the actual request to get data.
     #
     # == Usage
     #
     #   gs = Gattica.new({:email => 'johndoe@google.com', :password => 'password', :profile_id => 123456})
-    #   gs.get({ :start_date => '2008-01-01', 
-    #            :end_date => '2008-02-01', 
-    #            :dimensions => 'browser', 
-    #            :metrics => 'pageviews', 
+    #   gs.get({ :start_date => '2008-01-01',
+    #            :end_date => '2008-02-01',
+    #            :dimensions => 'browser',
+    #            :metrics => 'pageviews',
     #            :sort => 'pageviews',
     #            :filters => ['browser == Firefox']})
     #
     # == Input
     #
-    # When calling +get+ you'll pass in a hash of options. For a description of what these mean to 
+    # When calling +get+ you'll pass in a hash of options. For a description of what these mean to
     # Google Analytics, see http://code.google.com/apis/analytics/docs
     #
     # Required values are:
@@ -184,13 +186,13 @@ module Gattica
     # If a user doesn't have access to the +profile_id+ you specified, you'll receive an error.
     # Likewise, if you attempt to access a dimension or metric that doesn't exist, you'll get an
     # error back from Google Analytics telling you so.
-    
+
     def get(args={})
       return results(args)
     end
-    
+
     private
-    
+
     def results(args={}, fh=nil, type=nil, format=nil)
       raise GatticaError::InvalidFileType, "Invalid file type" unless type.nil? ||[:csv,:xml].include?(type)
       args = validate_and_clean(DEFAULT_ARGS.merge(args))
@@ -200,47 +202,48 @@ module Gattica
       total_results = args[:max_results]
       while(args[:start_index] < total_results)
         query_string = build_query_string(args,@profile_id)
-        @logger.debug("Query String: " + query_string) if @debug
+        @logger.info("Start Index: #{args[:start_index]}, Total Results: #{total_results}, Query String: " + query_string) if @options[:debug]
 
         data = do_http_get("/analytics/feeds/data?#{query_string}")
         result = DataSet.new(Hpricot.XML(data))
-        
+
         #handle returning results
         results.points.concat(result.points) if !results.nil? && fh.nil?
+        results = result if results.nil?
+
         #handle csv
-        
         if(!fh.nil? && type == :csv && header == 0)
           fh.write result.to_csv_header(format)
-          header = 1 
+          header = 1
         end
-        
+
         fh.write result.to_csv(:noheader) if !fh.nil? && type == :csv
         fh.flush if !fh.nil?
-        
-        results = result if results.nil?
+
+        # Update Loop Counters
         total_results = result.total_results
         args[:start_index] += args[:max_results]
         break if !args[:page] # only continue while if we are suppose to page
-      end 
+      end
       return results if fh.nil?
     end
-    
+
     # Since google wants the token to appear in any HTTP call's header, we have to set that header
     # again any time @token is changed so we override the default writer (note that you need to set
     # @token with self.token= instead of @token=)
-    
+
     def token=(token)
       @token = token
       set_http_headers
     end
-    
-    
+
+
     # Does the work of making HTTP calls and then going through a suite of tests on the response to make
     # sure it's valid and not an error
-    
+
     def do_http_get(query_string)
       response, data = @http.get(query_string, @headers)
-      
+
       # error checking
       if response.code != '200'
         case response.code
@@ -252,29 +255,38 @@ module Gattica
           raise GatticaError::UnknownAnalyticsError, response.body + " (status code: #{response.code})"
         end
       end
-      
+
       return data
     end
-    
+
     private
-    
+
     # Sets up the HTTP headers that Google expects (this is called any time @token is set either by Gattica
     # or manually by the user since the header must include the token)
     def set_http_headers
       @headers['Authorization'] = "GoogleLogin auth=#{@token}"
+      @headers['GData-Version']= '2'
     end
-    
-    
+
+
     # Creates a valid query string for GA
     def build_query_string(args,profile)
       query_params  = args.clone
+
+      # Internal Parameters, don't pass to google
+      query_params.delete(:debug)
+      query_params.delete(:page)
+
       ga_start_date = query_params.delete(:start_date)
       ga_end_date   = query_params.delete(:end_date)
       ga_dimensions = query_params.delete(:dimensions)
       ga_metrics    = query_params.delete(:metrics)
       ga_sort       = query_params.delete(:sort)
       ga_filters    = query_params.delete(:filters)
-      
+      ga_segment    = query_params.delete(:segment)
+      ga_start_index  = query_params.delete(:start_index) || query_params.delete(:'start-index')
+      ga_max_results  = query_params.delete(:max_results) || query_params.delete(:'max-results')
+
       output = "ids=ga:#{profile}&start-date=#{ga_start_date}&end-date=#{ga_end_date}"
       unless ga_dimensions.nil? || ga_dimensions.empty?
         output += '&dimensions=' + ga_dimensions.collect do |dimension|
@@ -291,9 +303,13 @@ module Gattica
           sort[0..0] == '-' ? "-ga:#{sort[1..-1]}" : "ga:#{sort}"  # if the first character is a dash, move it before the ga:
         end.join(',')
       end
-      
+
+      unless ga_segment.nil? || ga_segment.empty?
+        output += "&segment=#{ga_segment}"
+      end
+
       # TODO: update so that in regular expression filters (=~ and !~), any initial special characters in the regular expression aren't also picked up as part of the operator (doesn't cause a problem, but just feels dirty)
-      unless args[:filters].empty?    # filters are a little more complicated because they can have all kinds of modifiers
+      unless args[:filters].nil? || args[:filters].empty?    # filters are a little more complicated because they can have all kinds of modifiers
         output += '&filters=' + args[:filters].collect do |filter|
           match, name, operator, expression = *filter.match(/^(\w*)\s*([=!<>~@]*)\s*(.*)$/)           # splat the resulting Match object to pull out the parts automatically
           unless name.empty? || operator.empty? || expression.empty?                      # make sure they all contain something
@@ -303,23 +319,27 @@ module Gattica
           end
         end.join(';')
       end
- 
+
+      output += "&start-index=#{ga_start_index}" unless ga_start_index.nil? || ga_start_index.to_s.empty?
+      output += "&max-results=#{ga_max_results}" unless ga_max_results.nil? || ga_max_results.to_s.empty?
+
       query_params.inject(output) {|m,(key,value)| m << "&#{key}=#{value}"}
- 
+
       return output
     end
-    
-    
+
+
     # Validates that the args passed to +get+ are valid
     def validate_and_clean(args)
-      
-      raise GatticaError::MissingStartDate, ':start_date is required' if args[:start_date].nil? || args[:start_date].empty?
-      raise GatticaError::MissingEndDate, ':end_date is required' if args[:end_date].nil? || args[:end_date].empty?
+      raise GatticaError::MissingStartDate, ':start_date is required' if args[:start_date].nil? || args[:start_date].to_s.empty?
+      raise GatticaError::MissingEndDate, ':end_date is required' if args[:end_date].nil? || args[:end_date].to_s.empty?
       raise GatticaError::TooManyDimensions, 'You can only have a maximum of 7 dimensions' if args[:dimensions] && (args[:dimensions].is_a?(Array) && args[:dimensions].length > 7)
       raise GatticaError::TooManyMetrics, 'You can only have a maximum of 10 metrics' if args[:metrics] && (args[:metrics].is_a?(Array) && args[:metrics].length > 10)
-      
-      possible = args[:dimensions] + args[:metrics]
-      
+
+      possible = []
+      possible << args[:dimensions] << args[:metrics]
+      possible.flatten!
+
       # make sure that the user is only trying to sort fields that they've previously included with dimensions and metrics
       if args[:sort]
         missing = args[:sort].find_all do |arg|
@@ -329,7 +349,7 @@ module Gattica
           raise GatticaError::InvalidSort, "You are trying to sort by fields that are not in the available dimensions or metrics: #{missing.join(', ')}"
         end
       end
-      
+
       # make sure that the user is only trying to filter fields that are in dimensions or metrics
       if args[:filters]
         missing = args[:filters].find_all do |arg|
@@ -339,10 +359,10 @@ module Gattica
           raise GatticaError::InvalidSort, "You are trying to filter by fields that are not in the available dimensions or metrics: #{missing.join(', ')}"
         end
       end
-      
+
       return args
     end
-    
-    
+
+
   end
 end

data/lib/gattica/user.rb

@@ -1,31 +1,31 @@
 module Gattica
-  
+
   # Represents a user to be authenticated by GA
-  
+
   class User
-  
+
     include Convertible
-  
+
     attr_accessor :email, :password
-  
+
     def initialize(email,password)
       @email = email
       @password = password
       validate
     end
-    
+
     # User gets a special +to_h+ because Google expects +Email+ and +Passwd+ instead of our nicer internal names
     def to_h
       { :Email => @email,
         :Passwd => @password }
     end
-    
+
     private
     # Determine whether or not this is a valid user
     def validate
-      raise GatticaError::InvalidEmail, "The email address '#{@email}' is not valid" if not @email.match(/^(?:[_a-z0-9-]+)(\.[_a-z0-9-]+)*@([a-z0-9-]+)(\.[a-zA-Z0-9\-\.]+)*(\.[a-z]{2,4})$/i)
+      raise GatticaError::InvalidEmail, "The email address '#{@email}' is not valid" if not @email.match(/^(?:[\+_a-z0-9-]+)(\.[_a-z0-9-]+)*@([a-z0-9-]+)(\.[a-zA-Z0-9\-\.]+)*(\.[a-z]{2,4})$/i)
       raise GatticaError::InvalidPassword, "The password cannot be blank" if @password.empty? || @password.nil?
     end
-  
+
   end
 end

data/test/test_gattica.rb

@@ -1,16 +1,16 @@
 require File.dirname(__FILE__) + '/helper'
- 
+
 class TestUser < Test::Unit::TestCase
   def test_build_query_string
     @gattica = Gattica.new(:token => 'ga-token', :profile_id => 'ga-profile_id')
     expected = "ids=ga:ga-profile_id&start-date=2008-01-02&end-date=2008-01-03&dimensions=ga:pageTitle,ga:pagePath&metrics=ga:pageviews&sort=-ga:pageviews&max-results=3"
     result = @gattica.send(:build_query_string, {
-      :start_date => Date.civil(2008,1,2), 
+      :start_date => Date.civil(2008,1,2),
       :end_date => Date.civil(2008,1,3),
-      :dimensions => ['pageTitle','pagePath'], 
-      :metrics => ['pageviews'], 
+      :dimensions => ['pageTitle','pagePath'],
+      :metrics => ['pageviews'],
       :sort => '-pageviews',
-      'max-results' => '3'}, 'ga-profile_id')
+      :max_results => '3'}, 'ga-profile_id')
     assert_equal expected, result
   end
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: gattica
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 3
+  version: 0.4.3
 platform: ruby
 authors: 
 - The Active Network
@@ -14,14 +19,18 @@ default_executable:
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: hpricot
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 164
         version: 0.6.164
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: Gattica is a Ruby library for extracting data from the Google Analytics API.
 email: rob.cameron@active.com
 executables: []
@@ -68,18 +77,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Gattica is a Ruby library for extracting data from the Google Analytics API.