google_api 1.0.3 → 1.1.0.beta

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## v1.1.0.beta
+
+* add google urlshorter
+* login_by_cert! can be end by ctr+c
+* session start logic moved to GoogleApi::Session
+* add check_session without raise error
+* fix: login_by_line are now first write messae and then write
+
 ## v1.0.3
 
 * GoogleApi::Ga::Data has now silent error, GoogleApi::Ga::Data.error(true) - raise error, GoogleApi::Ga::Data.error(false) - not error (default)

data/README.md

@@ -1,7 +1,8 @@
 Google Api [![Build Status](https://secure.travis-ci.org/ondra-m/google_api.png)](http://travis-ci.org/ondra-m/google_api)
 ==========
 
-Analytics - v1.0.0<br>
+Analytics<br>
+Url shortener - documentation is not complete yet<br>
 Calendar - will be soon 
 
 Google Analytics
@@ -289,7 +290,7 @@ GoogleApi::Ga::Data
     </tr>
     <tr>
       <td>max_results</td>
-      <td>offset</td>
+      <td>limit</td>
     </tr>
   </tbody>
 </table>
@@ -359,12 +360,13 @@ For how long in minutes will be data cached. Use 0 for never expire.
 GoogleApi::Ga::Data.cache(minutes)
 
 # you can also clear cache
+# it will clear cache only for entered parameters
 GoogleApi::Ga::Data.clear_cache
 
 # if you want clear cache and cache new
 GoogleApi::Ga::Data.select(:visits).clear_cache.cache(60)
 
-# orif you don't want use cache at all, default: true
+# or if you don't want use cache at all, default: true
 GoogleApi::Ga::Data.use_cache(false)
 ```
 
@@ -388,12 +390,12 @@ You can use one of these. Data is stored in the class.
 .rows   # rows returned by google analytics
 .header # header of data, (["ga:day", "ga:month", "ga:visitis"])
 .count  # number of rows
-.each   # each as you expected, (`|data|` or `|index, data|`)
+.each   # each as you expected, (|data| or |index, data|)
 ```
 
 ### Clear stored data and fetch again
 
-If you add some parameters clear is called automaticlly.
+If you add some parameters clear is called automatically.
 
 clear: `.clear`<br>
 
@@ -448,7 +450,7 @@ Examples
 # Check session, error if not login
 # =================================
 
-  GoogleApi::Ga::Session.check_session!
+  GoogleApi::Ga::Session.check_session
   
   
   

data/google_api.gemspec

@@ -4,8 +4,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.description   = %q{Simple Google Api. Include google analytics, url shortener.}
+  gem.summary       = %q{Simple Google Api. Include google analytics, url shortener.}
   gem.homepage      = "https://github.com/ondra-m/google_api"
 
   gem.files         = `git ls-files`.split($\)

data/lib/google_api.rb

@@ -6,25 +6,26 @@ require "google_api/version"
 
 module GoogleApi
 
+  autoload :Session,        'google_api/session/session'
+  autoload :SessionMethods, 'google_api/session/session_methods'
+
   autoload :Cache, 'google_api/cache'
 
-  autoload :Ga, 'google_api/ga'
+  autoload :Ga,      'google_api/ga/ga'           # Google analytics
+  autoload :Shorten, 'google_api/shorten/shorten' # Google urlshortener
 
   class SessionError  < StandardError; end
   class GaError       < StandardError; end
+  class ShortenError  < StandardError; end
   class DateError     < StandardError; end
   class TypeError     < StandardError; end
   class CanBeNilError < StandardError; end
+  class RequireError  < StandardError; end
 
+  # Global configuration
   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)
+    ga:      Configuration.new(Ga::CONFIGURATION),
+    shorten: Configuration.new(Shorten::CONFIGURATION)
   }
 
   def self.config

data/lib/google_api/configuration.rb

@@ -1,13 +1,23 @@
 module GoogleApi
   class Configuration
 
-    def initialize(config = {})
+    DEFAULT = {
+      client_id: nil,
+      client_secret: nil,
+      client_developer_email: nil,
+      client_cert_file: nil,
+      key_secret: 'notasecret',
+      redirect_uri: nil,
+    }
+
+    def initialize(config, use_default = true)
+
+      if use_default
+        config = DEFAULT.merge(config)
+      end
+
       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)
@@ -19,6 +29,10 @@ module GoogleApi
 
             self.#{key} = value
           end
+
+          def #{key}=(value)
+            @#{key} = value
+          end
         METHOD
 
         self.send("#{key}=", value)

data/lib/google_api/ga/data.rb

@@ -2,6 +2,8 @@ module GoogleApi
   module Ga
     class Data
 
+      # Initialize ----------------------------------------------------------------------------------
+
       def initialize
         @ids, @cache = nil, nil
         @start_date, @end_date = Date.today, Date.today
@@ -21,262 +23,209 @@ module GoogleApi
         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
+      # Parameters for google analytics -------------------------------------------------------------
 
-        date.to_date
-      end
+      TYPE_INTEGER = { ids: 'id',
+                       cache: nil,
+                       start_index: 'offset',
+                       max_results: 'limit' }
 
-      # Add prefix ga: to symbol in Array 
-      def build_param(value)
-        type?(value, Array)
+      TYPE_DATE = { start_date: 'from',
+                    end_date: 'to' }
 
-        value.flatten.collect { |v| v.is_a?(Symbol) ? "ga:#{v}" : v }
-      end
+      TYPE_ARRAY = { metrics: 'select',
+                     dimensions: 'with',
+                     sort: nil }
 
-      # Check type 
-      def type?(value, type)
-        unless value.is_a?(type)
-          raise GoogleApi::TypeError, "Value: #{value} must be #{type}."
-        end
-      end
+      TYPE_BLOCK = { filters: 'where',
+                     segment: nil }
 
-      # Clear value 
-      def clear
-        @header     = nil
-        @parameters = nil
-        @data       = nil
-        @all        = nil
-      end
+      TYPE_BOOLEAN = { error: nil,
+                       use_cache: nil }
 
-      # -----------------------------------------------------------------------------------
-      # Type 1, all are integer
+      # Create a base method
+      # ids, cache, start_index, max_results, start_date, end_date, error, use_cache
       #
-      # Ids, Cache, Start index, Max results
+      # Example:
       #
-      #          name,        alias
+      #   def ids(value = nil)
+      #     if value.nil?
+      #       return @ids
+      #     end
       #
-      TYPE_1 = { ids:         :id,
-                 cache:       nil,
-                 start_index: :offset,
-                 max_results: :limit }
-
-      TYPE_1.each do |key, value|
+      #     self.ids = value
+      #     self
+      #   end
+      #
+      def self.create_base_method(name)
         eval <<-METHOD
-          def #{key}(value = nil)
+          def #{name}(value = nil)
             if value.nil?
-              return @#{key}
+              return @#{name}
             end
 
-            self.#{key} = value
+            self.#{name} = value
             self
           end
-
-          def #{key}=(value)
-            value = value.to_i
-
-            @#{key} = value
-          end
         METHOD
-
-        unless value.nil?
-          eval <<-METHOD
-            alias :#{value}  :#{key}
-            alias :#{value}= :#{key}=
-          METHOD
-        end
       end
 
-      # -----------------------------------------------------------------------------------
-      # Type 2, date
+      # Create an array method, suffix is for _add or _sub 
+      # metrics, dimensions, sort
       #
-      # Start date, End date
+      # Example:
       #
-      #          name,       alias
+      #   def metrics(*args)
+      #     if args.empty?
+      #       return @metrics
+      #     end
       #
-      TYPE_2 = { start_date: :from,
-                 end_date:   :to }
-
-      TYPE_2.each do |key, value|
+      #     self.metrics = args
+      #     self
+      #   end
+      #
+      #   def metrics=(value)
+      #     clear
+      #     @metrics = build_param(value)
+      #   end
+      #
+      def self.create_array_method(name, operator = '', suffix = '')
         eval <<-METHOD
-          def #{key}(date = nil)
-            if date.nil?
-              return @#{key}
+          def #{name}#{suffix}(*args)
+            if args.empty?
+              return @#{name}
             end
 
-            self.#{key} = date
+            self.#{name}#{suffix} = args
             self
           end
 
-          def #{key}=(date)
-            if date.is_a?(Integer)
-              @#{key} += date
-            else
-              @#{key} = to_date(date)
-            end
+          def #{name}#{suffix}=(value)
+            clear
+            @#{name} #{operator}= build_param(value)
           end
         METHOD
+      end
 
-        unless value.nil?
+      # Create a base alias
+      # ids, cache, start_index, max_results, start_date, end_date, metrics, dimensions, sort
+      #
+      # Example:
+      #
+      #   alias :id  :ids
+      #   alias :id= :ids=
+      #
+      def self.create_base_alias(name, method_alias, suffix = '')
+        unless method_alias.nil?
           eval <<-METHOD
-            alias :#{value}  :#{key}
-            alias :#{value}= :#{key}=
+            alias :#{method_alias}#{suffix}  :#{name}#{suffix}
+            alias :#{method_alias}#{suffix}= :#{name}#{suffix}=
           METHOD
         end
       end
 
-      # -----------------------------------------------------------------------------------
-      # Type 3
-      #
-      # Metrics, Dimensions, Sort
-      #
-      #          name,       alias
-      #
-      TYPE_3 = { metrics:    :select,
-                 dimensions: :with,
-                 sort:       nil }
+      # ids, cache, start_index, max_results
+      TYPE_INTEGER.each do |name, method_alias|
+        create_base_method(name)
 
-      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)
+          def #{name}=(value)
             clear
-            @#{key} = build_param(value)
+            @#{name} = value.to_i
           end
+        METHOD
 
-          def #{key}_add(*args)
-            if args.size == 0
-              return @#{key}
-            end
+        create_base_alias(name, method_alias)
+      end
 
-            self.#{key}_add = args
-            self
-          end
+      # start_date, end_date
+      TYPE_DATE.each do |name, method_alias|
+        create_base_method(name)
 
-          def #{key}_add=(value)
+        eval <<-METHOD
+          def #{name}=(value)
             clear
-            @#{key} += build_param(value)
-          end
-
-          def #{key}_sub(*args)
-            if args.size == 0
-              return @#{key}
+            if value.is_a?(Integer)
+              @#{name} += value
+            else
+              @#{name} = to_date(value)
             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}=
+        create_base_alias(name, method_alias)
+      end
 
-            alias :#{value}_add  :#{key}_add
-            alias :#{value}_add= :#{key}_add=
+      # metrics, dimensions, sort
+      TYPE_ARRAY.each do |name, method_alias|
+        create_array_method(name)
+        create_array_method(name, '+', '_add')
+        create_array_method(name, '-', '_sub')
 
-            alias :#{value}_sub  :#{key}_sub
-            alias :#{value}_sub= :#{key}_sub=
-          METHOD
-        end
+        create_base_alias(name, method_alias)
+        create_base_alias(name, method_alias, '_add')
+        create_base_alias(name, method_alias, '_sub')
       end
 
-      # -----------------------------------------------------------------------------------
-      # Type 4
-      #
-      # Filters, Segment
-      #
-      #          name,       alias
-      #
-      TYPE_4 = { filters: :where,
-                 segment: nil }
-
-      TYPE_4.each do |key, value|
+      # filters, segment
+      TYPE_BLOCK.each do |name, method_alias|
         eval <<-METHOD
-          def #{key}(value = nil, &block)
+          def #{name}(value = nil, &block)
             if !block_given? && value.nil?
-              return @#{key}
+              return @#{name}
             end
 
             if block_given?
-              @#{key} = #{key.to_s.capitalize}Dsl.new.instance_eval(&block).join
+              @#{name} = #{name.to_s.capitalize}Dsl.new.instance_eval(&block).join
             else
-              @#{key} = value
+              @#{name} = value
             end
             self
           end
         METHOD
 
-        unless value.nil?
+        unless method_alias.nil?
           eval <<-METHOD
-            alias :#{value} :#{key}
+            alias :#{method_alias} :#{name}
           METHOD
         end
       end
 
-      # -----------------------------------------------------------------------------------
-      # Type 5
-      #
-      # Error, use cache
-      #
-      TYPE_5 = { error:     nil,
-                 use_cache: nil }
-      TYPE_5.each do |key, value|
-        eval <<-METHOD
-          def #{key}(value = nil)
-            if value.nil?
-              return @#{key}
-            end
+      # error, user_cache
+      TYPE_BOOLEAN.each do |name, method_alias|
+        create_base_method(name)
 
+        eval <<-METHOD
+          def #{name}=(value)
             if !value.is_a?(TrueClass) && !value.is_a?(FalseClass)
               raise GoogleApi::TypeError, "Value must be true of false"
             end
 
-            self.#{key} = value
-            self
-          end
-
-          def #{key}=(value)
-            @#{key} = value
+            @#{name} = value
           end
         METHOD
       end
 
+      # Methods for manipulations with data ---------------------------------------------------------
+
+      # Clear values 
+      def clear
+        @header     = nil
+        @parameters = nil
+        @data       = nil
+        @all        = nil
+      end
+
+      # Clear cache
       def clear_cache
         _cache.delete(parameters)
         self
       end
 
-      # Add row!, header!, all!, count!. First clear and run method .
+      # Add row!, header!, all!, count!. First clear and run normal method.
       [:rows, :header, :all, :count].each do |value|
         eval <<-METHOD
-          def #{value}!
-            clear
-            #{value}
-          end
+          def #{value}!; clear; #{value}; end
         METHOD
       end
 
@@ -317,10 +266,41 @@ module GoogleApi
 
       private
 
+        # Store data, call clear for fetch again
         def data
           @data ||= get
         end
 
+        # Convert string, DateTime and Time to date for google analytics YYYY-MM-DD
+        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
+
+        # Build and store parameters
         def parameters
           return @parameters if @parameters
 
@@ -356,6 +336,7 @@ module GoogleApi
           Session
         end
 
+        # Get data from google analytics
         def get
           if @use_cache && _cache.exists?(parameters)
             return _cache.read(parameters)