fruit_to_lime 2.5.5 → 2.5.6

data/lib/fruit_to_lime/roo_helper.rb

@@ -1,72 +1,72 @@
-require "csv"
-module FruitToLime
-    # @example transform xlsx file into rows
-    #     organizations_path = File.join(File.dirname(__FILE__), 'organizations.xlsx') # same path as this file
-    #     rows = FruitToLime::RooHelper.new(Roo::Excelx.new(organizations_path)).rows
-    class RooHelper
-
-        def initialize(data)
-            @data = data
-            @default_sheet = data.sheets.first
-        end
-
-        # Get rows for the first sheet.
-        # The rows are hashes of the first row of cells as header cells and the rest as content.
-        # @example If the header 'Name' and the second column contains 'Johan'.
-        #    FruitToLime::RooHelper.new(Roo::Excelx.new(file_path)).rows
-        #    # returns:
-        #    [{'Name'=>'Johan'}]
-        def rows
-            return rows_for_sheet(@default_sheet)
-        end
-
-        # @example transform xlsx file into rows for the second sheet
-        #     data = Roo::Excelx.new(organizations_path)
-        #     rows = FruitToLime::RooHelper.new(data).rows_for_sheet(data.sheets[1])
-        def rows_for_sheet(sheet)
-            column_headers = {}
-            1.upto(@data.last_column(sheet)) do |col|
-                column_headers[col] = @data.cell(1, col, sheet).encode('UTF-8')
-            end
-
-            rs = []
-            2.upto(@data.last_row(sheet)) do |row|
-                r = {}
-                1.upto(@data.last_column(sheet)) do |col|
-                    val = cell_to_csv(row, col, sheet)
-                    r[column_headers[col]] = val
-                end
-                rs.push(r)
-            end
-            return rs
-        end
-
-        def cell_to_csv(row, col, sheet)
-            if @data.empty?(row,col,sheet)
-                ''
-            else
-                onecell = @data.cell(row,col,sheet)
-                case @data.celltype(row,col,sheet)
-                when :string
-                    unless onecell.empty?
-                        onecell.encode('UTF-8').strip
-                    end
-                when :float, :percentage
-                    if onecell == onecell.to_i
-                      onecell.to_i.to_s
-                    else
-                      onecell.to_s
-                    end
-                when :date, :datetime
-                    onecell.to_s
-                when :time
-                    Roo::Base.integer_to_timestring(onecell)
-                when :formula
-                    onecell.to_s
-                else
-                    raise "unhandled celltype #{@data.celltype(row,col,sheet)} for cell at row: #{row}, col: #{col} in sheet #{sheet}"
-                end || ""
-            end
-        end
-    end
-end
+require "csv"
+module FruitToLime
+    # @example transform xlsx file into rows
+    #     organizations_path = File.join(File.dirname(__FILE__), 'organizations.xlsx') # same path as this file
+    #     rows = FruitToLime::RooHelper.new(Roo::Excelx.new(organizations_path)).rows
+    class RooHelper
+
+        def initialize(data)
+            @data = data
+            @default_sheet = data.sheets.first
+        end
+
+        # Get rows for the first sheet.
+        # The rows are hashes of the first row of cells as header cells and the rest as content.
+        # @example If the header 'Name' and the second column contains 'Johan'.
+        #    FruitToLime::RooHelper.new(Roo::Excelx.new(file_path)).rows
+        #    # returns:
+        #    [{'Name'=>'Johan'}]
+        def rows
+            return rows_for_sheet(@default_sheet)
+        end
+
+        # @example transform xlsx file into rows for the second sheet
+        #     data = Roo::Excelx.new(organizations_path)
+        #     rows = FruitToLime::RooHelper.new(data).rows_for_sheet(data.sheets[1])
+        def rows_for_sheet(sheet)
+            column_headers = {}
+            1.upto(@data.last_column(sheet)) do |col|
+                column_headers[col] = @data.cell(1, col, sheet).encode('UTF-8')
+            end
+
+            rs = []
+            2.upto(@data.last_row(sheet)) do |row|
+                r = {}
+                1.upto(@data.last_column(sheet)) do |col|
+                    val = cell_to_csv(row, col, sheet)
+                    r[column_headers[col]] = val
+                end
+                rs.push(r)
+            end
+            return rs
+        end
+
+        def cell_to_csv(row, col, sheet)
+            if @data.empty?(row,col,sheet)
+                ''
+            else
+                onecell = @data.cell(row,col,sheet)
+                case @data.celltype(row,col,sheet)
+                when :string
+                    unless onecell.empty?
+                        onecell.encode('UTF-8').strip
+                    end
+                when :float, :percentage
+                    if onecell == onecell.to_i
+                      onecell.to_i.to_s
+                    else
+                      onecell.to_s
+                    end
+                when :date, :datetime
+                    onecell.to_s
+                when :time
+                    Roo::Base.integer_to_timestring(onecell)
+                when :formula
+                    onecell.to_s
+                else
+                    raise "unhandled celltype #{@data.celltype(row,col,sheet)} for cell at row: #{row}, col: #{col} in sheet #{sheet}"
+                end || ""
+            end
+        end
+    end
+end

data/lib/fruit_to_lime/serialize_helper.rb

@@ -1,186 +1,186 @@
-# encoding: utf-8
-require "rexml/document"
-
-module FruitToLime
-    module SerializeHelper
-        def serialize()
-            SerializeHelper::serialize(self)
-        end
-
-        def serialize_to_file(file)
-            SerializeHelper::serialize_to_file(file, self)
-        end
-
-        # @!visibility private
-        def self.serialize_variables_rexml(elem, obj)
-            if (obj.respond_to?(:serialize_variables))
-                obj.serialize_variables.each do |serialize_variable|
-                    element_name = serialize_variable[:id].to_s.gsub(/^\@/,'').split('_').map do |m|
-                        m.capitalize
-                    end.join('')
-
-                    raw_var = obj.instance_variable_get("@#{serialize_variable[:id].to_s}")
-                    if raw_var != nil
-                        element = elem.add_element(element_name)
-                        if (raw_var.respond_to?(:serialize_variables))
-                            SerializeHelper::serialize_variables_rexml(element, raw_var)
-                        elsif (raw_var.is_a?(Array))
-                            raw_var.each do |raw_var_elem| 
-                                SerializeHelper::serialize_rexml(element, raw_var_elem) 
-                            end
-                        else
-                            element.text = raw_var.to_s.encode('UTF-8')
-                        end
-                    end
-                end
-                return
-            end
-            raise "Do not know how to handle #{obj.class} !!"
-        end
-
-        # @!visibility private
-        def self.serialize_rexml(elem, obj)
-            if obj.respond_to?(:to_rexml)
-                obj.to_rexml(elem)
-            elsif (obj.respond_to?(:serialize_variables))
-                element_name = obj.serialize_name
-                SerializeHelper::serialize_variables_rexml(elem.add_element(element_name), obj)
-            else
-                elem.text = obj.to_s
-            end
-        end
-
-        # @!visibility private
-        def self.serialize(obj, indent= 2)
-            # indent -1 to avoid indent
-            if obj.respond_to?(:to_rexml)
-                doc = REXML::Document.new()
-                SerializeHelper::serialize_rexml(doc, obj)
-                doc.write( xml_str = "" , indent, true)
-                xml_str
-            elsif (obj.respond_to?(:serialize_variables))
-                element_name = obj.serialize_name
-                doc = REXML::Document.new()
-                SerializeHelper::serialize_variables_rexml(doc.add_element(element_name), obj)
-                doc.write( xml_str = "", indent, true)
-                xml_str
-            else
-                obj.to_s.encode(:xml => :text)
-            end
-        end
-
-        # @!visibility private
-        def self.serialize_to_file(file, obj)
-            File.open(file, 'w') do |f|
-                f.write(SerializeHelper::serialize(obj))
-            end
-        end
-
-        # @!visibility private
-        def symbol_to_name(symbol)
-            symbol.to_s.split('_').join(' ').capitalize
-        end
-
-        # @!visibility private
-        def map_symbol_to_row(symbol,type)
-            {
-                :id => symbol.to_s,
-                :name => symbol == :id ? 'Go id' : symbol_to_name(symbol),
-                :type =>type
-            }
-        end
-
-        # @!visibility private
-        def map_to_row(p)
-            case p[:type]
-            when :string then
-                map_symbol_to_row(p[:id],p[:type])
-            when :bool then
-                map_symbol_to_row(p[:id],p[:type])
-            when :date then
-                map_symbol_to_row(p[:id],p[:type])
-            when :notes then
-                {
-                    :id => p[:id].to_s,
-                    :name => symbol_to_name(p[:id]),
-                    :type => p[:type],
-                    :models => SerializeHelper.get_import_rows(:note)
-                }
-            when :tags then
-                {
-                    :id => p[:id].to_s,
-                    :type => p[:type],
-                    :name => symbol_to_name(p[:id]),
-                }
-            when :persons then
-                {
-                    :id => p[:id].to_s,
-                    :type => p[:type],
-                    :name => symbol_to_name(p[:id]),
-                    :models => SerializeHelper.get_import_rows(:person)
-                }
-            when :custom_fields then
-                {
-                    :id => p[:id].to_s,
-                    :type => p[:type],
-                    :name => symbol_to_name(p[:id]),
-                    :models => SerializeHelper.get_import_rows(:custom_field)
-                }
-            when :custom_values then
-                {
-                    :id => p[:id].to_s,
-                    :type => p[:type],
-                    :name => symbol_to_name(p[:id]),
-                    :models => SerializeHelper.get_import_rows(:custom_value)
-                }
-            else
-                {
-                    :id => p[:id].to_s,
-                    :name => symbol_to_name(p[:id]),
-                    :type => p[:type],
-                    :model => SerializeHelper.get_import_rows(p[:type])
-                }
-            end
-        end
-
-        # What fields/rows on the class is supposed to be used by the Gem to generate the xml
-        # This method uses #serialize_variables.
-        def get_import_rows
-            serialize_variables.map do |p|
-                map_to_row p
-            end
-        end
-
-        # @!visibility private
-        def self.get_import_rows(type)
-            case type
-            when :person then
-                Person.new
-            when :source_ref then
-                ReferenceToSource.new
-            when :note then
-                Note.new
-            when :address then
-                Address.new
-            when :organization then
-                Organization.new
-            when :coworker_reference then
-                CoworkerReference.new
-            when :organization_reference then
-                OrganizationReference.new
-            when :custom_field then
-                CustomField.new
-            when :custom_value then
-                CustomValue.new
-            when :custom_field_reference then
-                CustomFieldReference.new
-            when :settings then
-                Settings.new
-            when :class_settings then
-                ClassSettings.new
-            else
-                raise "Unknown type: #{type}"
-            end.get_import_rows
-        end
-    end
-end
+# encoding: utf-8
+require "rexml/document"
+
+module FruitToLime
+    module SerializeHelper
+        def serialize()
+            SerializeHelper::serialize(self)
+        end
+
+        def serialize_to_file(file)
+            SerializeHelper::serialize_to_file(file, self)
+        end
+
+        # @!visibility private
+        def self.serialize_variables_rexml(elem, obj)
+            if (obj.respond_to?(:serialize_variables))
+                obj.serialize_variables.each do |serialize_variable|
+                    element_name = serialize_variable[:id].to_s.gsub(/^\@/,'').split('_').map do |m|
+                        m.capitalize
+                    end.join('')
+
+                    raw_var = obj.instance_variable_get("@#{serialize_variable[:id].to_s}")
+                    if raw_var != nil
+                        element = elem.add_element(element_name)
+                        if (raw_var.respond_to?(:serialize_variables))
+                            SerializeHelper::serialize_variables_rexml(element, raw_var)
+                        elsif (raw_var.is_a?(Array))
+                            raw_var.each do |raw_var_elem| 
+                                SerializeHelper::serialize_rexml(element, raw_var_elem) 
+                            end
+                        else
+                            element.text = raw_var.to_s.encode('UTF-8')
+                        end
+                    end
+                end
+                return
+            end
+            raise "Do not know how to handle #{obj.class} !!"
+        end
+
+        # @!visibility private
+        def self.serialize_rexml(elem, obj)
+            if obj.respond_to?(:to_rexml)
+                obj.to_rexml(elem)
+            elsif (obj.respond_to?(:serialize_variables))
+                element_name = obj.serialize_name
+                SerializeHelper::serialize_variables_rexml(elem.add_element(element_name), obj)
+            else
+                elem.text = obj.to_s
+            end
+        end
+
+        # @!visibility private
+        def self.serialize(obj, indent= 2)
+            # indent -1 to avoid indent
+            if obj.respond_to?(:to_rexml)
+                doc = REXML::Document.new()
+                SerializeHelper::serialize_rexml(doc, obj)
+                doc.write( xml_str = "" , indent, true)
+                xml_str
+            elsif (obj.respond_to?(:serialize_variables))
+                element_name = obj.serialize_name
+                doc = REXML::Document.new()
+                SerializeHelper::serialize_variables_rexml(doc.add_element(element_name), obj)
+                doc.write( xml_str = "", indent, true)
+                xml_str
+            else
+                obj.to_s.encode(:xml => :text)
+            end
+        end
+
+        # @!visibility private
+        def self.serialize_to_file(file, obj)
+            File.open(file, 'w') do |f|
+                f.write(SerializeHelper::serialize(obj))
+            end
+        end
+
+        # @!visibility private
+        def symbol_to_name(symbol)
+            symbol.to_s.split('_').join(' ').capitalize
+        end
+
+        # @!visibility private
+        def map_symbol_to_row(symbol,type)
+            {
+                :id => symbol.to_s,
+                :name => symbol == :id ? 'Go id' : symbol_to_name(symbol),
+                :type =>type
+            }
+        end
+
+        # @!visibility private
+        def map_to_row(p)
+            case p[:type]
+            when :string then
+                map_symbol_to_row(p[:id],p[:type])
+            when :bool then
+                map_symbol_to_row(p[:id],p[:type])
+            when :date then
+                map_symbol_to_row(p[:id],p[:type])
+            when :notes then
+                {
+                    :id => p[:id].to_s,
+                    :name => symbol_to_name(p[:id]),
+                    :type => p[:type],
+                    :models => SerializeHelper.get_import_rows(:note)
+                }
+            when :tags then
+                {
+                    :id => p[:id].to_s,
+                    :type => p[:type],
+                    :name => symbol_to_name(p[:id]),
+                }
+            when :persons then
+                {
+                    :id => p[:id].to_s,
+                    :type => p[:type],
+                    :name => symbol_to_name(p[:id]),
+                    :models => SerializeHelper.get_import_rows(:person)
+                }
+            when :custom_fields then
+                {
+                    :id => p[:id].to_s,
+                    :type => p[:type],
+                    :name => symbol_to_name(p[:id]),
+                    :models => SerializeHelper.get_import_rows(:custom_field)
+                }
+            when :custom_values then
+                {
+                    :id => p[:id].to_s,
+                    :type => p[:type],
+                    :name => symbol_to_name(p[:id]),
+                    :models => SerializeHelper.get_import_rows(:custom_value)
+                }
+            else
+                {
+                    :id => p[:id].to_s,
+                    :name => symbol_to_name(p[:id]),
+                    :type => p[:type],
+                    :model => SerializeHelper.get_import_rows(p[:type])
+                }
+            end
+        end
+
+        # What fields/rows on the class is supposed to be used by the Gem to generate the xml
+        # This method uses #serialize_variables.
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        # @!visibility private
+        def self.get_import_rows(type)
+            case type
+            when :person then
+                Person.new
+            when :source_ref then
+                ReferenceToSource.new
+            when :note then
+                Note.new
+            when :address then
+                Address.new
+            when :organization then
+                Organization.new
+            when :coworker_reference then
+                CoworkerReference.new
+            when :organization_reference then
+                OrganizationReference.new
+            when :custom_field then
+                CustomField.new
+            when :custom_value then
+                CustomValue.new
+            when :custom_field_reference then
+                CustomFieldReference.new
+            when :settings then
+                Settings.new
+            when :class_settings then
+                ClassSettings.new
+            else
+                raise "Unknown type: #{type}"
+            end.get_import_rows
+        end
+    end
+end