fruit_to_lime 0.9.1 → 0.9.2

data/lib/fruit_to_lime/roo_helper.rb

@@ -1,59 +1,59 @@
-require "csv"
-module FruitToLime
-    class RooHelper
-        def initialize(data)
-            @data = data
-            @default_sheet = data.sheets.first
-        end
-
-        def rows
-            return rows_for_sheet(@default_sheet)
-        end
-
-        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
+    class RooHelper
+        def initialize(data)
+            @data = data
+            @default_sheet = data.sheets.first
+        end
+
+        def rows
+            return rows_for_sheet(@default_sheet)
+        end
+
+        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,139 +1,139 @@
-# encoding: utf-8
-module FruitToLime
-    module SerializeHelper
-        def serialize()
-            SerializeHelper::serialize(self)
-        end
-
-        def serialize_to_file(file)
-            SerializeHelper::serialize_to_file(file, self)
-        end
-
-        def self.serialize_variables(obj)
-            if (obj.respond_to?(:serialize_variables))
-                return obj.serialize_variables.map do |ivar|
-                    varn = ivar[:id].to_s.gsub(/^\@/,'').split('_').map do |m|
-                        m.capitalize
-                    end.join('')
-
-                    varv = obj.instance_variable_get("@#{ivar[:id].to_s}")
-                    if (varv.respond_to?(:serialize_variables))
-                        varv = serialize_variables(varv)
-                    elsif (varv.is_a?(Array))
-                        varv = varv.map { |elem| SerializeHelper::serialize(elem) }.join("\n")
-                    elsif (varv == nil)
-                        varv = nil
-                    else
-                        varv = varv.to_s.encode('UTF-8').encode(:xml => :text)
-                    end
-                    if varv != nil then "<#{varn}>#{ varv }</#{varn}>" else "" end
-                    if varv != nil then "<#{varn}>#{ varv }</#{varn}>" end
-                end.join("\n")
-            end
-            raise "!!#{obj.class}"
-        end
-
-        def self.serialize(obj)
-            if (obj.respond_to?(:serialize_variables))
-                varn = obj.serialize_name
-                "<#{varn}>#{ SerializeHelper::serialize_variables(obj) }</#{varn}>"
-            elsif obj.respond_to?(:to_xml)
-                obj.to_xml
-            else
-                obj.to_s.encode(:xml => :text)
-            end
-        end
-
-        def self.serialize_to_file(file, obj)
-            File.open(file, 'w') do |f|
-                f.write(SerializeHelper::serialize(obj))
-            end
-        end
-
-        def symbol_to_name(symbol)
-            symbol.to_s.split('_').join(' ').capitalize
-        end
-
-        def map_symbol_to_row(symbol,type)
-            {
-                :id => symbol.to_s,
-                :name => symbol == :id ? 'Go id' : symbol_to_name(symbol),
-                :type =>type
-            }
-        end
-
-        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)
-                }
-            else
-                {
-                    :id => p[:id].to_s,
-                    :name => symbol_to_name(p[:id]),
-                    :type => p[:type],
-                    :model => SerializeHelper.get_import_rows(p[:type])
-                }
-            end
-        end
-
-        def get_import_rows
-            serialize_variables.map do |p|
-                map_to_row p
-            end
-        end
-
-        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
-            else
-                raise "Unknown type: #{type}"
-            end.get_import_rows
-        end
-    end
-end
+# encoding: utf-8
+module FruitToLime
+    module SerializeHelper
+        def serialize()
+            SerializeHelper::serialize(self)
+        end
+
+        def serialize_to_file(file)
+            SerializeHelper::serialize_to_file(file, self)
+        end
+
+        def self.serialize_variables(obj)
+            if (obj.respond_to?(:serialize_variables))
+                return obj.serialize_variables.map do |ivar|
+                    varn = ivar[:id].to_s.gsub(/^\@/,'').split('_').map do |m|
+                        m.capitalize
+                    end.join('')
+
+                    varv = obj.instance_variable_get("@#{ivar[:id].to_s}")
+                    if (varv.respond_to?(:serialize_variables))
+                        varv = serialize_variables(varv)
+                    elsif (varv.is_a?(Array))
+                        varv = varv.map { |elem| SerializeHelper::serialize(elem) }.join("\n")
+                    elsif (varv == nil)
+                        varv = nil
+                    else
+                        varv = varv.to_s.encode('UTF-8').encode(:xml => :text)
+                    end
+                    if varv != nil then "<#{varn}>#{ varv }</#{varn}>" else "" end
+                    if varv != nil then "<#{varn}>#{ varv }</#{varn}>" end
+                end.join("\n")
+            end
+            raise "!!#{obj.class}"
+        end
+
+        def self.serialize(obj)
+            if (obj.respond_to?(:serialize_variables))
+                varn = obj.serialize_name
+                "<#{varn}>#{ SerializeHelper::serialize_variables(obj) }</#{varn}>"
+            elsif obj.respond_to?(:to_xml)
+                obj.to_xml
+            else
+                obj.to_s.encode(:xml => :text)
+            end
+        end
+
+        def self.serialize_to_file(file, obj)
+            File.open(file, 'w') do |f|
+                f.write(SerializeHelper::serialize(obj))
+            end
+        end
+
+        def symbol_to_name(symbol)
+            symbol.to_s.split('_').join(' ').capitalize
+        end
+
+        def map_symbol_to_row(symbol,type)
+            {
+                :id => symbol.to_s,
+                :name => symbol == :id ? 'Go id' : symbol_to_name(symbol),
+                :type =>type
+            }
+        end
+
+        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)
+                }
+            else
+                {
+                    :id => p[:id].to_s,
+                    :name => symbol_to_name(p[:id]),
+                    :type => p[:type],
+                    :model => SerializeHelper.get_import_rows(p[:type])
+                }
+            end
+        end
+
+        def get_import_rows
+            serialize_variables.map do |p|
+                map_to_row p
+            end
+        end
+
+        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
+            else
+                raise "Unknown type: #{type}"
+            end.get_import_rows
+        end
+    end
+end

data/lib/fruit_to_lime/templating.rb

@@ -1,51 +1,51 @@
-require "fileutils"
-require 'open3'
-module FruitToLime
-    class Templating
-        def initialize(path)
-            @path = path
-        end
-
-        def list()
-            Dir.entries(@path).select { |d| d != '.' && d != '..' }
-        end
-
-        def exec_but_dont_show_unless_error(cmd)
-            std_out_value = []
-            Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
-                while std_line = stdout.gets
-                    std_out_value << std_line
-                end
-
-                exit_status = wait_thr.value
-                if !exit_status.success?
-                    puts "Failed with #{exit_status}"
-                    puts "std_out_value"
-                    puts std_out_value
-
-                    raise "failed exec #{cmd}"
-                end
-            end
-        end
-
-        def unpack(name, path)
-            template = list.find { |t| t == name }
-            if template
-                unpackedname = name
-
-                puts "Unpacking template #{name} to #{path}"
-                FileUtils.cp_r File.expand_path(name, @path), path
-
-                # Now make sure all gems in template are installed
-                puts "Making sure all needed gems are present"
-                Dir.chdir(File.expand_path(unpackedname, path)) do
-                    exec_but_dont_show_unless_error('bundle install --verbose')
-                end
-                true
-            else
-                puts "Unable to find template #{name}"
-                false
-            end
-        end
-    end
-end
+require "fileutils"
+require 'open3'
+module FruitToLime
+    class Templating
+        def initialize(path)
+            @path = path
+        end
+
+        def list()
+            Dir.entries(@path).select { |d| d != '.' && d != '..' }
+        end
+
+        def exec_but_dont_show_unless_error(cmd)
+            std_out_value = []
+            Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
+                while std_line = stdout.gets
+                    std_out_value << std_line
+                end
+
+                exit_status = wait_thr.value
+                if !exit_status.success?
+                    puts "Failed with #{exit_status}"
+                    puts "std_out_value"
+                    puts std_out_value
+
+                    raise "failed exec #{cmd}"
+                end
+            end
+        end
+
+        def unpack(name, path)
+            template = list.find { |t| t == name }
+            if template
+                unpackedname = name
+
+                puts "Unpacking template #{name} to #{path}"
+                FileUtils.cp_r File.expand_path(name, @path), path
+
+                # Now make sure all gems in template are installed
+                puts "Making sure all needed gems are present"
+                Dir.chdir(File.expand_path(unpackedname, path)) do
+                    exec_but_dont_show_unless_error('bundle install --verbose')
+                end
+                true
+            else
+                puts "Unable to find template #{name}"
+                false
+            end
+        end
+    end
+end