google_api 1.0.0.beta

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec

data/google_api.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/google_api/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ondřej Moravčík"]
+  gem.email         = ["moravcik.ondrej@gmail.com"]
+  gem.description   = %q{Simple Google Api. Include google analytics.}
+  gem.summary       = %q{Simple Google Api. Include google analytics.}
+  gem.homepage      = "https://github.com/ondra-m/google_api"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "google_api"
+  gem.require_paths = ["lib"]
+  gem.version       = GoogleApi::VERSION
+
+  gem.add_dependency 'google-api-client'
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'rspec'
+end

data/lib/google_api.rb

@@ -0,0 +1,37 @@
+require "google/api_client"
+
+require "google_api/core_ext/hash"
+require "google_api/configuration"
+require "google_api/version"
+
+module GoogleApi
+
+  autoload :Cache, 'google_api/cache'
+
+  autoload :Ga, 'google_api/ga'
+
+  class SessionError < StandardError; end
+  class GaError      < StandardError; end
+  class DateError    < StandardError; end
+  class TypeError    < StandardError; end
+
+  CONFIGURATION = {
+    client_id: nil,
+    client_secret: nil,
+    client_developer_email: nil,
+    client_cert_file: nil,
+    key_secret: 'notasecret',
+    redirect_uri: nil,
+
+    ga: Configuration.new(Ga::CONFIGURATION)
+  }
+
+  def self.config
+    @config ||= Configuration.new(CONFIGURATION)
+  end
+
+  def self.configure(&block)
+    config.instance_eval(&block)
+  end
+
+end

data/lib/google_api/cache.rb

@@ -0,0 +1,49 @@
+module GoogleApi
+  class Cache
+    
+    def initialize
+      @cache = {}
+    end
+
+    def write(key, value, expire = 0)
+      expire = expire == 0 ? 0 : Time.now + (expire * 60)
+
+      @cache[key] = [value, expire]
+    end
+
+    def read(key)
+      if exists?(key)
+        return @cache[key][0]
+      end
+
+      nil
+    end
+
+    def exists?(key)
+      @cache.has_key?(key) && !expire?(key)
+    end
+
+    def delete(key)
+      @cache.delete(key)
+    end
+
+    private
+
+      def expire?(key)
+        expire = @cache[key][1]
+
+        if expire == 0
+          return false
+        end
+
+        if expire < Time.now
+          delete(key)
+
+          return true
+        end
+
+        false
+      end
+
+  end
+end

data/lib/google_api/configuration.rb

@@ -0,0 +1,37 @@
+module GoogleApi
+  class Configuration
+
+    def initialize(config = {})
+      config.each do |key, value|
+        eval <<-METHOD
+          def #{key}=(value)
+            @#{key} = value
+          end
+
+          def #{key}(value = nil, &block)
+            if block_given?
+              @#{key}.instance_eval(&block)
+            end
+
+            if value.nil?
+              return @#{key}
+            end
+
+            self.#{key} = value
+          end
+        METHOD
+
+        self.send("#{key}=", value)
+      end
+    end
+
+    def configure(&block)
+      if block_given?
+        yield self
+      end
+
+      self
+    end
+    
+  end
+end

data/lib/google_api/core_ext/hash.rb

@@ -0,0 +1,11 @@
+unless Hash.new.respond_to?(:symbolize_keys!)
+  class Hash
+    def symbolize_keys!
+      keys.each do |key|
+        self[(key.to_sym rescue key) || key] = delete(key)
+      end
+      
+      self
+    end
+  end
+end

data/lib/google_api/core_ext/string.rb

@@ -0,0 +1,13 @@
+class String
+  def red
+    "\033[31m#{self}\033[0m"
+  end
+
+  def green
+    "\033[32m#{self}\033[0m"
+  end
+
+  def bold
+    "\033[1m#{self}\033[0m"
+  end
+end

data/lib/google_api/date.rb

@@ -0,0 +1,59 @@
+require "date"
+
+module GoogleApi
+  module Date
+
+    DATE_FORMAT = /\A[0-9]{4}-[0-9]{2}-[0-9]{2}\Z/
+
+    def to_date(date)
+      if date.is_a?(String)
+        unless date =~ DATE_FORMAT
+          raise GoogleApi::DateError, "Date: #{date} must match with #{DATE_FORMAT}."
+        end
+
+        date = Date.parse(date)
+      end
+
+
+      date.to_date
+    end
+
+    def now
+      Date.today
+    end
+
+    def prev_month
+      Date.today.prev_month
+    end
+
+    def more_months?(d1, d2)
+
+      d1 = Date.parse(d1) if d1.is_a?(String)
+      d2 = Date.parse(d2) if d2.is_a?(String)
+
+      d1.month != d2.month
+    end
+
+    def more_years?(d1, d2)
+
+      d1 = Date.parse(d1) if d1.is_a?(String)
+      d2 = Date.parse(d2) if d2.is_a?(String)
+
+      d1.year != d2.year
+    end
+
+    def day_older?(date)
+      
+      if date.is_a?(String)
+        date = Date.parse(date)
+      end
+
+      if (Date.today <=> date.to_date) > 0
+        return true
+      end
+
+      return false
+    end
+
+  end
+end

data/lib/google_api/ga.rb

@@ -0,0 +1,52 @@
+module GoogleApi
+  module Ga
+
+    CONFIGURATION = {
+      client_id: nil,
+      client_secret: nil,
+      client_developer_email: nil,
+      client_cert_file: nil,
+      key_secret: 'notasecret',
+      redirect_uri: nil,
+
+      cache: GoogleApi::Cache.new
+    }
+
+    # Session
+    autoload :Session, 'google_api/ga/session'
+
+    # Management
+    autoload :Management,  'google_api/ga/management/management'
+    autoload :Account,     'google_api/ga/management/account'
+    autoload :Webproperty, 'google_api/ga/management/webproperty'
+    autoload :Profile,     'google_api/ga/management/profile'
+    autoload :Goal,        'google_api/ga/management/goal'
+    autoload :Segment,     'google_api/ga/management/segment'
+
+    # Helper
+    autoload :Helper, 'google_api/ga/helper'
+
+    # Data
+    autoload :Data,       'google_api/ga/data'
+    autoload :DataDsl,    'google_api/ga/data/data_dsl'
+    autoload :FiltersDsl, 'google_api/ga/data/filters_dsl'
+    autoload :SegmentDsl, 'google_api/ga/data/segment_dsl'
+
+    extend GoogleApi::Ga::Helper
+
+    @@id = 0
+
+    def self.id(id=nil)
+      if id.nil?
+        return @@id
+      end
+      
+      @@id = id.to_i
+    end
+
+    def self.cache
+      GoogleApi.config.ga.cache
+    end
+
+  end
+end

data/lib/google_api/ga/data.rb

@@ -0,0 +1,335 @@
+module GoogleApi
+  module Ga
+    class Data
+
+      def initialize
+        @ids, @cache = nil, nil
+        @start_date, @end_date = Date.today, Date.today
+        @metrics, @dimensions, @sort = [], [], []
+        @filters, @segment = nil, nil
+        @start_index, @max_results = nil, nil
+      end
+
+      # Auto initialize data 
+      def self.method_missing(method, *args, &block)
+        if block_given?
+          new.send(method, &block)
+        else
+          new.send(method, *args)
+        end
+      end
+
+      # Convert string, DateTime and Time to date
+      DATE_FORMAT = /\A[0-9]{4}-[0-9]{2}-[0-9]{2}\Z/
+
+      def to_date(date)
+        if date.is_a?(String)
+          unless date =~ DATE_FORMAT
+            raise GoogleApi::DateError, "Date: #{date} must match with #{DATE_FORMAT}."
+          end
+
+          date = Date.parse(date)
+        end
+
+        date.to_date
+      end
+
+      # Add prefix ga: to symbol in Array 
+      def build_param(value)
+        type?(value, Array)
+
+        value.flatten.collect { |v| v.is_a?(Symbol) ? "ga:#{v}" : v }
+      end
+
+      # Check type 
+      def type?(value, type)
+        unless value.is_a?(type)
+          raise GoogleApi::TypeError, "Value: #{value} must be #{type}."
+        end
+      end
+
+      # Clear value 
+      def clear
+        @header     = nil
+        @parameters = nil
+        @data       = nil
+        @all        = nil
+      end
+
+      # -----------------------------------------------------------------------------------
+      # Type 1, all are integer
+      #
+      # Ids, Cache, Start index, Max results
+      #
+      #          name,        alias
+      #
+      TYPE_1 = { ids:         :id,
+                 cache:       nil,
+                 start_index: :offset,
+                 max_results: :limit }
+
+      TYPE_1.each do |key, value|
+        eval <<-METHOD
+          def #{key}(value = nil)
+            if value.nil?
+              return @#{key}
+            end
+
+            self.#{key} = value
+            self
+          end
+
+          def #{key}=(value)
+            type?(value, Integer)
+
+            @#{key} = value
+          end
+        METHOD
+
+        unless value.nil?
+          eval <<-METHOD
+            alias :#{value}  :#{key}
+            alias :#{value}= :#{key}=
+          METHOD
+        end
+      end
+
+      # -----------------------------------------------------------------------------------
+      # Type 2, date
+      #
+      # Start date, End date
+      #
+      #          name,       alias
+      #
+      TYPE_2 = { start_date: :from,
+                 end_date:   :to }
+
+      TYPE_2.each do |key, value|
+        eval <<-METHOD
+          def #{key}(date = nil)
+            if date.nil?
+              return @#{key}
+            end
+
+            self.#{key} = date
+            self
+          end
+
+          def #{key}=(date)
+            if date.is_a?(Integer)
+              @#{key} += date
+            else
+              @#{key} = to_date(date)
+            end
+          end
+        METHOD
+
+        unless value.nil?
+          eval <<-METHOD
+            alias :#{value}  :#{key}
+            alias :#{value}= :#{key}=
+          METHOD
+        end
+      end
+
+      # -----------------------------------------------------------------------------------
+      # Type 3
+      #
+      # Metrics, Dimensions, Sort
+      #
+      #          name,       alias
+      #
+      TYPE_3 = { metrics:    :select,
+                 dimensions: :with,
+                 sort:       nil }
+
+      TYPE_3.each do |key, value|
+        eval <<-METHOD
+          def #{key}(*args)
+            if args.size == 0
+              return @#{key}
+            end
+
+            self.#{key} = args
+            self
+          end
+
+          def #{key}=(value)
+            clear
+            @#{key} = build_param(value)
+          end
+
+          def #{key}_add(*args)
+            if args.size == 0
+              return @#{key}
+            end
+
+            self.#{key}_add = args
+            self
+          end
+
+          def #{key}_add=(value)
+            clear
+            @#{key} += build_param(value)
+          end
+
+          def #{key}_sub(*args)
+            if args.size == 0
+              return @#{key}
+            end
+            
+            self.#{key}_sub = args
+            self
+          end
+
+          def #{key}_sub=(value)
+            clear
+            @#{key} -= build_param(value)
+          end
+        METHOD
+
+        unless value.nil?
+          eval <<-METHOD
+            alias :#{value}  :#{key}
+            alias :#{value}= :#{key}=
+
+            alias :#{value}_add  :#{key}_add
+            alias :#{value}_add= :#{key}_add=
+
+            alias :#{value}_sub  :#{key}_sub
+            alias :#{value}_sub= :#{key}_sub=
+          METHOD
+        end
+      end
+
+      # -----------------------------------------------------------------------------------
+      # Type 4
+      #
+      # Filters, Segment
+      #
+      #          name,       alias
+      #
+      TYPE_4 = { filters: :where,
+                 segment: nil }
+
+      TYPE_4.each do |key, value|
+        eval <<-METHOD
+          def #{key}(value = nil, &block)
+            if !block_given? && value.nil?
+              return @#{key}
+            end
+
+            if block_given?
+              @#{key} = #{key.to_s.capitalize}Dsl.new.instance_eval(&block).join
+            else
+              @#{key} = value
+            end
+            self
+          end
+        METHOD
+
+        unless value.nil?
+          eval <<-METHOD
+            alias :#{value} :#{key}
+          METHOD
+        end
+      end
+
+      # Add row!, header!, all!, count!. First clear and run method .
+      [:rows, :header, :all, :count].each do |value|
+        eval <<-METHOD
+          def #{value}!
+            clear
+            #{value}
+          end
+        METHOD
+      end
+
+      def rows
+        data.rows
+      end
+
+      def header
+        @header ||= data.column_headers.map { |c| c.name }
+      end
+
+      def count
+        data.total_results
+      end
+
+      def all
+        @all ||= [header, rows]
+      end
+
+      def each(&block)
+        if block.arity == 1 # each
+          rows.each do |row|
+            yield(row)
+          end
+        else                # each with index
+          i = -1
+          rows.each do |row|
+            i += 1
+            yield(i, row)
+          end
+        end
+      end
+
+      def each!(&block)
+        clear
+        each(block)
+      end
+
+      private
+
+        def data
+          @data ||= get.data
+        end
+
+        def parameters
+          return @parameters if @parameters
+
+          if @ids.nil?
+            self.ids = Ga.id
+          end
+
+          @parameters = {}
+
+          @parameters['ids']        = "ga:#{@ids}"
+          @parameters['start-date'] = @start_date.to_s
+          @parameters['end-date']   = @end_date.to_s
+          @parameters['metrics']    = @metrics.join(',')
+
+          @parameters['dimensions']  = @dimensions.join(',') unless @dimensions.empty?
+          @parameters['sort']        = @sort.join(',')       unless @sort.empty?
+          @parameters['filters']     = @filters              unless @filters.nil?
+          @parameters['start-index'] = @start_index          unless @start_index.nil?
+          @parameters['max-results'] = @max_results          unless @max_results.nil?
+
+          @parameters
+        end
+
+        def _cache
+          GoogleApi::Ga.cache
+        end
+
+        def _session
+          Session
+        end
+
+        def get
+          if @cache && _cache.exists?(parameters)
+            return _cache.read(parameters)
+          end
+
+          result = _session.client.execute( api_method: _session.api.data.ga.get,
+                                            parameters: parameters )
+
+          _cache.write(parameters, result, @cache) if @cache.is_a?(Integer)
+
+          result
+        end
+      
+    end
+  end
+end