gcal_mapper 0.1.1

data/lib/gcal_mapper/sync.rb

@@ -0,0 +1,159 @@
+module GcalMapper
+  #
+  # Provide methods to synch google calendar and local bd
+  #
+  class Sync
+
+    # proxy to call sync methods and set new instance
+    #
+    # @param [Configuration] config configuration class seted by DSL
+    # @param [Class] base class of the caller
+    def self.sync(config, base)
+      new(config, base).sync_gcal
+    end
+
+    # new Sync object
+    #
+    # @param [Configuration] config configuration class seted by DSL
+    # @param [Class] base class of the calle
+    def initialize(config, base)
+      @config = config
+      @base = base
+    end
+
+    # full synchronization step by step
+    #
+    def sync_gcal
+      authenticate
+      fetch_events
+      save_events
+    end
+
+    private
+    # call Authentification class to authenticate the API
+    #
+    def authenticate
+      @auth = GcalMapper::Authentification.new(@config.file, @config.client_email, @config.user_email, @config.password)
+      @auth.authenticate
+    end
+
+    # Get all events from specified calendar(s).
+    #
+    # @return [Array] all events from given calendar(s) id.
+    def fetch_events
+      events_list = []
+
+      calendar = GcalMapper::Calendar.new
+      retried = false
+      begin
+        calendars_list = calendar.get_calendars_list(@auth.access_token)
+      rescue
+        if !retried
+          @auth.refresh_token
+          retried = true
+          retry
+        else
+          raise
+        end
+      end
+
+      if calendars_list.empty?
+        raise GcalMapper::CalendarAvailabilityError
+      end
+
+      @config.calendars.each do |cal|
+        events_list = []
+        if calendars_list.include?(cal)
+          retried = false
+          begin
+            events_list += (calendar.get_events_list(@auth.access_token, cal))
+          rescue
+            if !retried
+              @auth.refresh_token
+              retried = true
+              retry
+            else
+              raise
+            end
+          end
+        else
+          raise GcalMapper::CalendarAccessibilityError
+        end
+      end
+
+      @events_list = events_list
+    end
+
+    # Get all events from specified calendar(s). an keep synchronize with the online gcal
+    #
+    def save_events
+      adapter = Mapper.adapter
+
+      @events_list.each do |event|
+
+        existed_event = adapter.find_by(@config.gid, event['id'])
+        event_exist = !existed_event.nil?
+
+        if event_exist
+          if event['status'] == 'cancelled'
+            adapter.delete!(existed_event.id)
+          else
+            updated_attrib = set_attrib(event)
+            current_attrib = existed_event.attributes
+            current_attrib.delete('id')
+            if current_attrib != updated_attrib
+              adapter.update!(existed_event.id, updated_attrib)
+            end
+          end
+        end
+
+        if !event_exist && event['status'] != 'cancelled'
+          adapter.create!(set_attrib(event))
+        end
+      end
+    end
+
+    # set the object from fields configuration
+    #
+    # @param [Hash] event event to save in obj
+    # @return [hash] hash of setted attributes
+    def set_attrib(event)
+      attrib_hash = {@config.gid => event['id']}
+      @config.fields.each do |field, source|
+        if source[:source].include?('.')
+          data = source[:source].split('.')
+          attrib_hash[field] = eval_value(source, event[data[0]][data[1]])
+        else
+          attrib_hash[field] = eval_value(source, event[source[:source]])
+        end
+        if (attrib_hash[field].nil? && source.has_key?(:if_empty))
+          if source[:if_empty].include?('.')
+            data = source[:if_empty].split('.')
+            attrib_hash[field] = eval_value(source, event[data[0]][data[1]])
+          else
+            attrib_hash[field] = eval_value(source, event[source[:if_empty]])
+          end
+        end
+      end
+
+      attrib_hash
+    end
+
+    # eval the value from the source options
+    #
+    # @param [Hash] source source of the field
+    # @param [string] raw_data the string extract form google event data
+    # @return the data asked
+    def eval_value(source, raw_data)
+      if source[:match]
+        data = source[:match].match(raw_data).to_s
+        data = source[:default] if data == ''
+      else
+        data = raw_data
+      end
+
+      data
+    end
+
+  end
+end

data/lib/gcal_mapper/version.rb

@@ -0,0 +1,4 @@
+module GcalMapper
+  #version number of GcalMapper
+  VERSION = '0.1.1'
+end

data/spec/authentification/assertion_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe GcalMapper::Authentification::Assertion do
+
+  it "should have access_token attribute", :vcr do
+    auth = GcalMapper::Authentification::Assertion.new(@p12, @client_email, @user_email, 'notasecret')
+    auth.should respond_to(:access_token)
+  end
+
+  it "should have refresh_token attribute", :vcr do
+    auth = GcalMapper::Authentification::Assertion.new(@p12, @client_email, @user_email, 'notasecret')
+    auth.should respond_to(:refresh_token)
+  end
+
+end

data/spec/authentification/base_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe GcalMapper::Authentification::Base do
+  before :all do
+    class DummyClass < GcalMapper::Authentification::Base
+    end
+
+    @dummy = DummyClass.new
+  end
+
+  it "should raise error if access_token don't exist" do
+    expect {@dummy.access_token}.to raise_error(NotImplementedError)
+  end
+
+  it "should raise error if refresh_token don't exist" do
+    expect {@dummy.refresh_token}.to raise_error(NotImplementedError)
+  end
+end

data/spec/authentification/oauth2_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe GcalMapper::Authentification::Oauth2 do
+
+  it "should have access_token attribute" do
+    auth = GcalMapper::Authentification::Oauth2.new(@yaml)
+    auth.should respond_to(:access_token)
+  end
+
+  it "should have refresh_token attribute", :vcr do
+    auth = GcalMapper::Authentification::Oauth2.new(@yaml)
+    auth.should respond_to(:refresh_token)
+  end
+
+end

data/spec/authentification_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe GcalMapper::Authentification do
+  
+  it "should raise an error if the file is don't exist" do
+    expect {GcalMapper::Authentification.new('/home/test')}.to raise_error
+  end
+  
+  it "should return an error if bad yaml file is given" do
+    auth = GcalMapper::Authentification.new(@bad_yaml)
+    expect {auth.authenticate}.to raise_error
+  end
+  
+  it "should not raise an error if relative path is given" do
+    auth = GcalMapper::Authentification.new(@yaml_relative)
+    expect {auth.authenticate}.to_not raise_error
+  end
+    
+  it "access token should exist with oauth2 auth" do
+    auth = GcalMapper::Authentification.new(@yaml)
+    auth.authenticate.should be_true
+  end
+
+  it "access token should exist with assertion auth", :vcr do
+    auth = GcalMapper::Authentification.new(@p12, @client_email)
+    auth.authenticate.should be_true
+  end
+  
+  it "should be fasle if bad client email is given", :vcr do
+    auth = GcalMapper::Authentification.new(@p12, 'test@dtest.com')
+    expect {auth.authenticate}.to raise_error
+  end
+  
+end

data/spec/calendar_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe GcalMapper::Calendar do
+  before :all do
+    @auth_oauth2 = GcalMapper::Authentification.new(@yaml)
+    @auth_oauth2.authenticate
+    @list = GcalMapper::Calendar.new
+    @bad_token = 'a bad token'
+
+  end
+
+  it "should get the calendar list", :vcr do
+    begin
+      calendar = @list.get_calendars_list(@auth_oauth2.access_token)
+    rescue
+      @auth_oauth2.refresh_token
+      calendar = @list.get_calendars_list(@auth_oauth2.access_token)
+    end
+    @list.get_calendars_list(@auth_oauth2.access_token).should_not be_nil
+  end
+
+  it "should get the events list", :vcr do
+    @list.get_events_list(@auth_oauth2.access_token, @calendar_id).should_not be_nil
+  end
+
+  it "should raise error if the token is bad", :vcr do
+    expect {@list.get_calendars_list(@bad_token)}.to raise_error
+  end
+
+  it "should raise error if the calendar id isn't accessible", :vcr do
+    expect {@list.get_events_list(@auth_oauth2.access_token, 'test')}.to raise_error
+  end
+end

data/spec/gcal_mapper_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe GcalMapper do
+
+end

data/spec/mapper/active_record_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe GcalMapper::Mapper::ActiveRecord do
+
+  before :all do
+    class User < ActiveRecord::Base
+
+    end
+
+    @klass = GcalMapper::Mapper::ActiveRecord::ActiveRecord.new(User)
+  end
+
+  it "should create a new object and save it" do
+    @klass.create!({'first_name' => 'a_name', 'name' => 'a_name'})
+    User.all.should_not eql([])
+  end
+
+  it "shoudl list all stored entry" do
+     @klass.find_all.should eql(User.all)
+  end
+
+  it "should update an entry" do
+    user = User.first
+    name_before = user.name
+    @klass.update!(user.id, {'name' => 'another_name'})
+    name_after = User.first.name
+
+    name_before.should_not eql(name_after)
+  end
+
+  it "should delete an entry" do
+    user = User.first
+    @klass.delete!(user.id)
+
+    User.all.should eql([])
+  end
+
+  it "should find an entry from field name and value" do
+    @klass.create!({'first_name' => 'a_name', 'name' => 'a_name'})
+    @klass.create!({'first_name' => 'a_name', 'name' => 'another_name'})
+    @klass.create!({'first_name' => 'a_name', 'name' => 'different_name'})
+
+    @klass.find_by('name', 'a_name').should be_an_instance_of(User)
+  end
+
+end

data/spec/mapper/dsl_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe GcalMapper::Mapper::DSL do
+  before :all do
+    @dsl = GcalMapper::Mapper::DSL.new(GcalMapper::Configuration.new)
+  end
+
+  describe :field do
+    it "should raise error if field option don't exist" do
+      expect {@dsl.field('test', {:source => 'test', :test => 'test'})}.to raise_error
+    end
+
+    it "should accept :source, :match, :default" do
+      expect {@dsl.field('test', {:source => 'test', :match => /test/, :default => 'test'})}.to_not raise_error
+    end
+
+    it "should raise error if regexp is invalid" do
+      expect {@dsl.field('test', {:source => 'test', :match => test, :default => 'test'})}.to raise_error
+    end
+
+    it "should raise error if :source isn't present" do
+      expect {@dsl.field('test', {:match => /test/, :default => 'test'})}.to raise_error
+    end
+  end
+
+  describe :configure do
+    it "should raise an error if :file isn't present" do
+      expect {@dsl.configure({:client_email => '87', :user_email => 'web', :password => 'notasecret'})}.to raise_error
+    end
+  end
+end

data/spec/mapper/simple_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe GcalMapper::Mapper::Simple do
+  before :all do
+    class User2
+      include GcalMapper::Mapper::Simple
+      attr_accessor :id, :first_name, :name
+
+    end
+
+    @base = GcalMapper::Mapper::Simple::Simple.new(User2)
+  end
+
+  it "should create a new object and save it" do
+    @base.create!({'first_name' => 'a_name', 'name' => 'a_name'})
+    @base.events.should_not eql([])
+  end
+
+  it "shoudl list all stored entry" do
+     @base.find_all.should eql(@base.events)
+  end
+
+  it "should update an entry" do
+    user = @base.events[0]
+    name_before = user.name
+    @base.update!(user.id, {'name' => 'another_name'})
+    name_after = @base.events[0].name
+
+    name_before.should_not eql(name_after)
+  end
+
+  it "should delete an entry" do
+    @base.create!({'first_name' => 'a_name', 'name' => 'a_name'})
+    before_count = @base.events.count
+    user = @base.events[0]
+    @base.delete!(user.id)
+
+    before_count.should > (@base.events.count)
+  end
+
+  it "should find an entry from field name and value" do
+    @base.create!({'first_name' => 'a_name', 'name' => 'another_name'})
+    @base.create!({'first_name' => 'a_name', 'name' => 'different_name'})
+
+    @base.find_by('name', 'a_name').should be_an_instance_of(User2)
+  end
+
+end

data/spec/mapper_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe GcalMapper::Mapper do
+
+  before :all do
+    load File.dirname(__FILE__) + '/support/models/event.rb'
+  end
+
+  it "should load a file containing DSL with no error" do
+    expect{load File.dirname(__FILE__) + '/support/models/event.rb'}.to_not raise_error
+  end
+
+  it "should save all events", :vcr do
+    Event.synchronize_calendar
+    Event.all.should_not eql([])
+  end
+
+  it "should save events only once", :vcr do
+    before = Event.count
+    Event.synchronize_calendar
+    Event.count.should eq(before)
+  end
+
+  it "should erase cancelled event", :vcr do
+    cancelled = 0
+    Event.all.each do |event|
+      cancelled += 1 if event.status == 'cancelled'
+    end
+    cancelled.should eq(0)
+  end
+
+end