fruit_to_lime 2.5.5 → 2.5.6

data/lib/fruit_to_lime/model/address.rb

@@ -1,61 +1,61 @@
-require 'iso_country_codes'
-module FruitToLime
-    class Address 
-        attr_accessor :street, :zip_code, :city, :country_code, :location
-        def serialize_variables
-            [ :street, :zip_code, :city, :country_code, :location].map {|p| {:id=>p,:type=>:string} }
-        end
-        include SerializeHelper
-        def initialize()
-        end
-
-        # What fields/rows on the class is supposed to be used by the Gem to generate the xml
-        # This method uses {#serialize_variables}. It also adds {#country_name} to be serialized
-        def get_import_rows
-            (serialize_variables+[{:id=>:country_name, :type=>:string}]).map do |p|
-                map_to_row p
-            end
-        end
-        # Used as a convenience in order to get country code from internally used {#country_code}
-        def country_name
-            if @country_code
-                IsoCountryCodes.find(@country_code).name
-            else
-                nil
-            end
-        end
-
-        # Used as a convenience in order to map country name to the internal {#country_code}
-        def country_name=(name)
-            @country_code = case name
-            when nil
-                nil
-            when 'Sverige'
-                'SE'
-            else
-                 IsoCountryCodes.search_by_name(name).first.alpha2
-            end
-        end
-        # parses a line like "226 48 LUND" into its corresponding
-        # zipcode and city properties on the address
-        def parse_zip_and_address_se(line)
-            Address.parse_line_to_zip_and_address_se(line, self)
-        end
-
-        private
-        def self.parse_line_to_zip_and_address_se(line, address)
-            matched_zipcode = /^\d{3}\s?\d{2}/.match(line)
-            if matched_zipcode && matched_zipcode.length == 1
-                address.zip_code = matched_zipcode[0].strip()
-                matched_city = /\D*$/.match(line)
-                if matched_city && matched_city.length == 1
-                    address.city = matched_city[0].strip()
-                    return address
-                end
-            end
-            return nil
-        end
-
-
-    end
+require 'iso_country_codes'
+module FruitToLime
+    class Address 
+        attr_accessor :street, :zip_code, :city, :country_code, :location
+        def serialize_variables
+            [ :street, :zip_code, :city, :country_code, :location].map {|p| {:id=>p,:type=>:string} }
+        end
+        include SerializeHelper
+        def initialize()
+        end
+
+        # What fields/rows on the class is supposed to be used by the Gem to generate the xml
+        # This method uses {#serialize_variables}. It also adds {#country_name} to be serialized
+        def get_import_rows
+            (serialize_variables+[{:id=>:country_name, :type=>:string}]).map do |p|
+                map_to_row p
+            end
+        end
+        # Used as a convenience in order to get country code from internally used {#country_code}
+        def country_name
+            if @country_code
+                IsoCountryCodes.find(@country_code).name
+            else
+                nil
+            end
+        end
+
+        # Used as a convenience in order to map country name to the internal {#country_code}
+        def country_name=(name)
+            @country_code = case name
+            when nil
+                nil
+            when 'Sverige'
+                'SE'
+            else
+                 IsoCountryCodes.search_by_name(name).first.alpha2
+            end
+        end
+        # parses a line like "226 48 LUND" into its corresponding
+        # zipcode and city properties on the address
+        def parse_zip_and_address_se(line)
+            Address.parse_line_to_zip_and_address_se(line, self)
+        end
+
+        private
+        def self.parse_line_to_zip_and_address_se(line, address)
+            matched_zipcode = /^\d{3}\s?\d{2}/.match(line)
+            if matched_zipcode && matched_zipcode.length == 1
+                address.zip_code = matched_zipcode[0].strip()
+                matched_city = /\D*$/.match(line)
+                if matched_city && matched_city.length == 1
+                    address.city = matched_city[0].strip()
+                    return address
+                end
+            end
+            return nil
+        end
+
+
+    end
 end

data/lib/fruit_to_lime/model/class_settings.rb

@@ -1,50 +1,50 @@
-# encoding: utf-8
-module FruitToLime
-    class ClassSettings
-        include SerializeHelper
-        attr_reader :custom_fields
-
-        def initialize(opt = nil)
-            if opt != nil
-                serialize_variables.each do |myattr|
-                    val = opt[myattr[:id]]
-                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
-                end
-            end
-        end
-
-        def serialize_variables
-            [{:id => :custom_fields, :type => :custom_fields} ]
-        end
-
-        def serialize_name
-            "ClassSettings"
-        end
-
-        # Set custom field. If there is already an existing custom field, then it is overwritten.
-        def set_custom_field(obj)
-            @custom_fields = [] if @custom_fields == nil
-
-            if obj.is_a?(CustomField)
-                field = obj
-            else
-                field = CustomField.new(obj)
-            end
-
-            if field.integration_id == "" && field.id == ""
-                raise InvalidCustomFieldError, "Custom field must have either id or integration_id"
-            end
-
-            index = @custom_fields.find_index do |custom_field|
-                custom_field.same_as?(field)
-            end
-            if index
-                @custom_fields.delete_at index
-            end
-
-            @custom_fields.push field
-
-            return field
-        end
-    end
-end
+# encoding: utf-8
+module FruitToLime
+    class ClassSettings
+        include SerializeHelper
+        attr_reader :custom_fields
+
+        def initialize(opt = nil)
+            if opt != nil
+                serialize_variables.each do |myattr|
+                    val = opt[myattr[:id]]
+                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
+                end
+            end
+        end
+
+        def serialize_variables
+            [{:id => :custom_fields, :type => :custom_fields} ]
+        end
+
+        def serialize_name
+            "ClassSettings"
+        end
+
+        # Set custom field. If there is already an existing custom field, then it is overwritten.
+        def set_custom_field(obj)
+            @custom_fields = [] if @custom_fields == nil
+
+            if obj.is_a?(CustomField)
+                field = obj
+            else
+                field = CustomField.new(obj)
+            end
+
+            if field.integration_id == "" && field.id == ""
+                raise InvalidCustomFieldError, "Custom field must have either id or integration_id"
+            end
+
+            index = @custom_fields.find_index do |custom_field|
+                custom_field.same_as?(field)
+            end
+            if index
+                @custom_fields.delete_at index
+            end
+
+            @custom_fields.push field
+
+            return field
+        end
+    end
+end

data/lib/fruit_to_lime/model/coworker.rb

@@ -1,76 +1,76 @@
-# encoding: utf-8
-module FruitToLime
-    class Coworker
-        include SerializeHelper
-        attr_accessor :id, :integration_id, :email, :first_name, :last_name, :direct_phone_number,
-        :mobile_phone_number, :home_phone_number
-
-        def initialize(opt = nil)
-            if opt != nil
-                serialize_variables.each do |myattr|
-                    val = opt[myattr[:id]]
-                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
-                end
-            end
-        end
-
-        def serialize_variables
-            [
-             :id, :integration_id, :email, :first_name, :last_name,
-             :direct_phone_number, :mobile_phone_number, :home_phone_number
-            ].map {|p| { :id => p, :type => :string } }
-        end
-
-        def to_reference
-            reference = CoworkerReference.new
-            reference.id = @id
-            reference.integration_id = @integration_id
-            reference.heading = "#{@first_name} #{@last_name}".strip
-
-            return reference
-        end
-
-        def serialize_name
-            "Coworker"
-        end
-
-        def ==(that)
-            if that.nil?
-                return false
-            end
-
-            if that.is_a? Coworker
-                return @integration_id == that.integration_id
-            end
-
-            return false
-        end
-
-        def parse_name_to_firstname_lastname_se(name, when_missing = '')
-            if name.nil? or name.empty?
-                @first_name = when_missing
-                return
-            end
-
-            splitted = name.split(' ')
-            @first_name = splitted[0]
-            if splitted.length > 1
-                @last_name = splitted.drop(1).join(' ')
-            end
-        end
-
-        def to_email_chars(s)
-            s.tr " åäöèé", "-aaoee"
-        end
-
-        def guess_email(domain)
-            return '' if @last_name.nil? || @last_name.empty?
-            return '' if @first_name.nil? || @first_name.empty?
-
-            firstname = to_email_chars @first_name.downcase
-            lastname = to_email_chars @last_name.downcase
-            return "#{firstname}.#{lastname}@#{domain}"
-        end
-
-    end
-end
+# encoding: utf-8
+module FruitToLime
+    class Coworker
+        include SerializeHelper
+        attr_accessor :id, :integration_id, :email, :first_name, :last_name, :direct_phone_number,
+        :mobile_phone_number, :home_phone_number
+
+        def initialize(opt = nil)
+            if opt != nil
+                serialize_variables.each do |myattr|
+                    val = opt[myattr[:id]]
+                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
+                end
+            end
+        end
+
+        def serialize_variables
+            [
+             :id, :integration_id, :email, :first_name, :last_name,
+             :direct_phone_number, :mobile_phone_number, :home_phone_number
+            ].map {|p| { :id => p, :type => :string } }
+        end
+
+        def to_reference
+            reference = CoworkerReference.new
+            reference.id = @id
+            reference.integration_id = @integration_id
+            reference.heading = "#{@first_name} #{@last_name}".strip
+
+            return reference
+        end
+
+        def serialize_name
+            "Coworker"
+        end
+
+        def ==(that)
+            if that.nil?
+                return false
+            end
+
+            if that.is_a? Coworker
+                return @integration_id == that.integration_id
+            end
+
+            return false
+        end
+
+        def parse_name_to_firstname_lastname_se(name, when_missing = '')
+            if name.nil? or name.empty?
+                @first_name = when_missing
+                return
+            end
+
+            splitted = name.split(' ')
+            @first_name = splitted[0]
+            if splitted.length > 1
+                @last_name = splitted.drop(1).join(' ')
+            end
+        end
+
+        def to_email_chars(s)
+            s.tr " åäöèé", "-aaoee"
+        end
+
+        def guess_email(domain)
+            return '' if @last_name.nil? || @last_name.empty?
+            return '' if @first_name.nil? || @first_name.empty?
+
+            firstname = to_email_chars @first_name.downcase
+            lastname = to_email_chars @last_name.downcase
+            return "#{firstname}.#{lastname}@#{domain}"
+        end
+
+    end
+end

data/lib/fruit_to_lime/model/coworker_reference.rb

@@ -1,33 +1,33 @@
-module FruitToLime
-    class CoworkerReference
-        include SerializeHelper
-        attr_accessor :id, :heading, :integration_id
-
-        def initialize(opt = nil)
-            if opt != nil
-                serialize_variables.each do |myattr|
-                    val = opt[myattr[:id]]
-                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
-                end
-            end
-        end
-
-        def serialize_variables
-            [:id, :integration_id, :heading].map {|p| {:id => p, :type => :string} }
-        end
-
-        def serialize_name
-            "CoworkerReference"
-        end
-
-        def self.from_coworker(coworker)
-            if coworker.nil?
-                return nil
-            elsif coworker.is_a?(Coworker)
-                return coworker.to_reference
-            elsif coworker.is_a?(CoworkerReference)
-                return coworker
-            end
-        end
-    end
-end
+module FruitToLime
+    class CoworkerReference
+        include SerializeHelper
+        attr_accessor :id, :heading, :integration_id
+
+        def initialize(opt = nil)
+            if opt != nil
+                serialize_variables.each do |myattr|
+                    val = opt[myattr[:id]]
+                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
+                end
+            end
+        end
+
+        def serialize_variables
+            [:id, :integration_id, :heading].map {|p| {:id => p, :type => :string} }
+        end
+
+        def serialize_name
+            "CoworkerReference"
+        end
+
+        def self.from_coworker(coworker)
+            if coworker.nil?
+                return nil
+            elsif coworker.is_a?(Coworker)
+                return coworker.to_reference
+            elsif coworker.is_a?(CoworkerReference)
+                return coworker
+            end
+        end
+    end
+end

data/lib/fruit_to_lime/model/customfield.rb

@@ -1,87 +1,87 @@
-module FruitToLime
-    class CustomFieldReference
-        include SerializeHelper, ModelWithIntegrationIdSameAs
-
-        attr_accessor :id, :integration_id
-
-        def initialize(opt=nil)
-            if opt != nil
-                serialize_variables.each do |myattr|
-                    val = opt[myattr[:id]]
-                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
-                end
-            end
-        end
-
-        def serialize_variables
-            [:id, :integration_id].map {|p| { :id => p, :type => :string } }
-        end
-
-        def get_import_rows
-            serialize_variables.map do |p|
-                map_to_row p
-            end
-        end
-
-        def serialize_name
-            "CustomFieldReference"
-        end
-    end
-
-    class CustomField
-        include SerializeHelper, ModelWithIntegrationIdSameAs
-        attr_accessor :id, :integration_id, :title, :type
-
-        def initialize(opt=nil)
-            if opt != nil
-                serialize_variables.each do |myattr|
-                    val = opt[myattr[:id]]
-                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
-                end
-            end
-        end
-
-        def serialize_variables
-            [:id, :integration_id, :title, :type].map {|p| { :id => p, :type => :string } }
-        end
-
-        def get_import_rows
-            serialize_variables.map do |p|
-                map_to_row p
-            end
-        end
-
-        def serialize_name
-            "CustomField"
-        end
-    end
-
-    class CustomValue
-        include SerializeHelper
-        attr_accessor :field, :value
-
-        def initialize(opt=nil)
-            if opt != nil
-                serialize_variables.each do |myattr|
-                    val = opt[myattr[:id]]
-                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
-                end
-            end
-        end
-
-        def serialize_variables
-            [ { :id =>:field, :type => :custom_field_reference },
-                { :id =>:value, :type => :string }]
-        end
-
-        def get_import_rows
-            serialize_variables.map do |p|
-                map_to_row p
-            end
-        end
-
-        def serialize_name
-            "CustomValue"
-        end
-    end
-end
+module FruitToLime
+    class CustomFieldReference
+        include SerializeHelper, ModelWithIntegrationIdSameAs
+
+        attr_accessor :id, :integration_id
+
+        def initialize(opt=nil)
+            if opt != nil
+                serialize_variables.each do |myattr|
+                    val = opt[myattr[:id]]
+                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
+                end
+            end
+        end
+
+        def serialize_variables
+            [:id, :integration_id].map {|p| { :id => p, :type => :string } }
+        end
+
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        def serialize_name
+            "CustomFieldReference"
+        end
+    end
+
+    class CustomField
+        include SerializeHelper, ModelWithIntegrationIdSameAs
+        attr_accessor :id, :integration_id, :title, :type
+
+        def initialize(opt=nil)
+            if opt != nil
+                serialize_variables.each do |myattr|
+                    val = opt[myattr[:id]]
+                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
+                end
+            end
+        end
+
+        def serialize_variables
+            [:id, :integration_id, :title, :type].map {|p| { :id => p, :type => :string } }
+        end
+
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        def serialize_name
+            "CustomField"
+        end
+    end
+
+    class CustomValue
+        include SerializeHelper
+        attr_accessor :field, :value
+
+        def initialize(opt=nil)
+            if opt != nil
+                serialize_variables.each do |myattr|
+                    val = opt[myattr[:id]]
+                    instance_variable_set("@" + myattr[:id].to_s, val) if val != nil
+                end
+            end
+        end
+
+        def serialize_variables
+            [ { :id =>:field, :type => :custom_field_reference },
+                { :id =>:value, :type => :string }]
+        end
+
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        def serialize_name
+            "CustomValue"
+        end
+    end
+end