garb 0.9.1 → 0.9.7

data/lib/garb/account.rb

@@ -1,22 +0,0 @@
-module Garb
-  class Account
-    attr_reader :id, :name, :profiles
-
-    def initialize(profiles)
-      @id = profiles.first.account_id    
-      @name = profiles.first.account_name
-      @profiles = profiles
-    end
-
-    def self.all(session = Session)
-      ActiveSupport::Deprecation.warn("The use of Garb::Account has been deprecated in favor of 'Garb::Management::Account'")
-      profiles = {}
-
-      Profile.all(session).each do |profile|
-        (profiles[profile.account_id] ||= []) << profile
-      end
-
-      profiles.map {|k,v| v}.map {|profiles| new(profiles)}
-    end
-  end
-end

data/lib/garb/account_feed_request.rb

@@ -1,25 +0,0 @@
-module Garb
-  class AccountFeedRequest
-    URL = "https://www.google.com/analytics/feeds/accounts/default"
-
-    def initialize(session = Session)
-      @request = DataRequest.new(session, URL)
-    end
-
-    def response
-      @response ||= @request.send_request
-    end
-
-    def parsed_response
-      @parsed_response ||= Crack::XML.parse(response.body)
-    end
-
-    def entries
-      parsed_response ? Array(parsed_response['feed']['entry']).flatten.compact : []
-    end
-
-    def segments
-      parsed_response ? Array(parsed_response['feed']['dxp:segment']).flatten.compact : []
-    end
-  end
-end

data/lib/garb/authentication_request.rb

@@ -1,53 +0,0 @@
-module Garb
-  class AuthenticationRequest
-    class AuthError < StandardError;end
-
-    URL = 'https://www.google.com/accounts/ClientLogin'
-
-    def initialize(email, password, opts={})
-      @email = email
-      @password = password
-      @account_type = opts.fetch(:account_type, 'HOSTED_OR_GOOGLE')
-    end
-
-    def parameters
-      {
-        'Email'       => @email,
-        'Passwd'      => @password,
-        'accountType' => @account_type,
-        'service'     => 'analytics',
-        'source'      => 'vigetLabs-garb-001'
-      }
-    end
-    
-    def uri
-      URI.parse(URL)
-    end
-
-    def send_request(ssl_mode)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = ssl_mode
-
-      if ssl_mode == OpenSSL::SSL::VERIFY_PEER
-        http.ca_file = CA_CERT_FILE
-      end
-
-      http.request(build_request) do |response|
-        raise AuthError unless response.is_a?(Net::HTTPOK)
-      end
-    end
-
-    def build_request
-      post = Net::HTTP::Post.new(uri.path)
-      post.set_form_data(parameters)
-      post
-    end
-    
-    def auth_token(opts={})
-      ssl_mode = opts[:secure] ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
-      send_request(ssl_mode).body.match(/^Auth=(.*)$/)[1]
-    end
-
-  end
-end

data/lib/garb/data_request.rb

@@ -1,42 +0,0 @@
-module Garb
-  class DataRequest
-    class ClientError < StandardError; end
-
-    def initialize(session, base_url, parameters={})
-      @session = session
-      @base_url = base_url
-      @parameters = parameters
-    end
-
-    def query_string
-      parameter_list = @parameters.map {|k,v| "#{k}=#{v}" }
-      parameter_list.empty? ? '' : "?#{parameter_list.join('&')}"
-    end
-
-    def uri
-      URI.parse(@base_url)
-    end
-
-    def send_request
-      response = if @session.single_user?
-        single_user_request
-      elsif @session.oauth_user?
-        oauth_user_request
-      end
-
-      raise ClientError, response.body.inspect unless response.kind_of?(Net::HTTPSuccess)
-      response
-    end
-
-    def single_user_request
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      http.get("#{uri.path}#{query_string}", {'Authorization' => "GoogleLogin auth=#{@session.auth_token}", 'GData-Version' => '2'})
-    end
-
-    def oauth_user_request
-      @session.access_token.get("#{uri}#{query_string}", {'GData-Version' => '2'})
-    end
-  end
-end

data/lib/garb/goal.rb

@@ -1,20 +0,0 @@
-module Garb
-  class Goal
-    attr_reader :name, :number, :value, :destination
-
-    def initialize(attributes={})
-      return unless attributes.is_a?(Hash)
-
-      @name = attributes['name']
-      @number = attributes['number'].to_i
-      @value = attributes['value'].to_f
-      @active = (attributes['active'] == 'true')
-
-      @destination = Destination.new(attributes[Garb.to_ga('destination')])
-    end
-
-    def active?
-      @active
-    end
-  end
-end

data/lib/garb/profile.rb

@@ -1,33 +0,0 @@
-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/report.rb

@@ -1,28 +0,0 @@
-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/resource.rb

@@ -1,115 +0,0 @@
-module Garb
-  module Resource
-    MONTH = 2592000
-    URL = "https://www.google.com/analytics/feeds/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/support.rb

@@ -1,40 +0,0 @@
-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

data/test/unit/garb/account_feed_request_test.rb

@@ -1,42 +0,0 @@
-require 'test_helper'
-
-module Garb
-  class AccountFeedRequestTest < MiniTest::Unit::TestCase
-    context "An AccountFeedRequest" do
-      setup do
-        @request = stub
-        DataRequest.stubs(:new).returns(@request)
-        @feed = AccountFeedRequest.new
-      end
-
-      should "have a parsed response" do
-        Crack::XML.stubs(:parse)
-        @feed.stubs(:response).returns(stub(:body => 'response body'))
-        @feed.parsed_response
-
-        assert_received(Crack::XML, :parse) {|e| e.with('response body')}
-      end
-
-      should "have entries from the parsed response" do
-        @feed.stubs(:parsed_response).returns({'feed' => {'entry' => ['entry1', 'entry2']}})
-        assert_equal ['entry1', 'entry2'], @feed.entries
-      end
-
-      should "have segements from the parsed response" do
-        @feed.stubs(:parsed_response).returns({'feed' => {'dxp:segment' => ['segment1', 'segment2']}})
-        assert_equal ['segment1', 'segment2'], @feed.segments
-      end
-
-      should "have an empty array for entries without a response" do
-        @feed.stubs(:parsed_response).returns(nil)
-        assert_equal [], @feed.entries
-      end
-
-      should "have a response from the request" do
-        @request.stubs(:send_request)
-        @feed.response
-        assert_received(@request, :send_request)
-      end
-    end
-  end
-end

data/test/unit/garb/account_test.rb

@@ -1,53 +0,0 @@
-require 'test_helper'
-
-module Garb
-  class AccountTest < MiniTest::Unit::TestCase
-    context "The Account class" do
-      should "have an array of accounts with all profiles" do
-        p1 = stub(:account_id => '1111', :account_name => 'Blog 1')
-        p2 = stub(:account_id => '1112', :account_name => 'Blog 2')
-
-        Profile.stubs(:all).returns([p1,p2,p1,p2])
-        Account.stubs(:new).returns('account1', 'account2')
-
-        assert_equal ['account1','account2'], Account.all
-        assert_received(Profile, :all)
-        assert_received(Account, :new) {|e| e.with([p1,p1])}
-        assert_received(Account, :new) {|e| e.with([p2,p2])}
-      end
-    end
-
-    context "An instance of the Account class" do
-      setup do
-        profile = stub(:account_id => '1111', :account_name => 'Blog 1')
-        @profiles = [profile,profile]
-        @account = Account.new(@profiles)
-      end
-
-      context "all" do
-        should "use an optional user session" do
-          session = Session.new
-          Garb::Profile.expects(:all).with(session).returns(@profiles)
-
-          accounts = Account.all(session)
-          assert_equal 1, accounts.size
-          assert_equal @profiles, accounts.first.profiles
-        end
-      end
-
-      context "when creating a new account from an array of profiles" do
-        should "take the account id from the first profile" do
-          assert_equal @profiles.first.account_id, @account.id
-        end
-
-        should "take the account name from the first profile" do
-          assert_equal @profiles.first.account_name, @account.name
-        end
-
-        should "store the array of profiles" do
-          assert_equal @profiles, @account.profiles
-        end
-      end
-    end
-  end
-end