datafy 0.5.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a444f118259af2c44e08b0f8a9b12922162219ab41576fc8a0a73c232667c02b
+  data.tar.gz: 6089e37cb5a274c7953e17126cea75bc7e6cc8b77427b8063c56b765e1e8c19d
+SHA512:
+  metadata.gz: 55ce44b9c30c29feed0d09fcdc8c8bb06fd4b568f87cc3ce802b146d812f92e1d85f4b7f9c31055e9255074507a6a3c39832b18727f37d2508d61f7fe3a724d6
+  data.tar.gz: 110b9d262147d5c117f5bedb818ca4f46f5b80de9414854080531de8b9e6221c06abeb4304f1134da5a9d028ff386264248fc53dfe0d63aa0b800013aa54ae77

data/lib/datafy/BaseHarvester.rb

@@ -0,0 +1,138 @@
+# print "Executing: #{__FILE__}"
+
+require 'date'
+require 'logger'
+require_relative 'fileprovider'
+
+module BaseHarvester
+
+    include FileProvider
+
+    # attr_accessor :errorMessage, :logFile, :logFileName, :showLog
+
+    class HarvestError < StandardError
+        attr_reader :message, :source
+        def initialize(msg="default message", thing="BaseHarvester")
+            @message = msg
+            @thing   = thing
+            super(msg)
+        end
+    end # class HarvestError
+
+    # ==================  Data Fields Section  ==================
+
+    v, $VERBOSE = $VERBOSE, nil
+        BASE_HARVEST_DATA_FIELDS = {
+            'Harvest When'        => { property: :harvestWhen,       comment: 'Date/Time of data harvesting'              },
+            'Harvest Successful?' => { property: :harvestSuccessful, comment: 'Boolean - was harvesting successful?'      },
+            'Harvest Message'     => { property: :harvestMessage,    comment: 'Usually indicates harvesting problem'      },
+            'Persist When'        => { property: :persistWhen,       comment: 'Date/Time of data persistence to CSV file' },
+        }
+        # --
+        DETAILS_PROPERTY_FIELDS = {
+            'Class'   => { property: :klass,  comment: 'The class the details are being recorded for. (Base)'  },
+            'Detail'  => { property: :detail, comment: 'The name of the field being recorded.'                 },
+            'Index'   => { property: :index,  comment: 'Recording sequence, i.e. 1: first, 2: second, etc.'    },
+            'Line'    => { property: :line,   comment: 'The specific detail.'   },
+        }
+    $VERBOSE = v
+
+    class << self
+      def included(base)
+        base.extend DataFieldsClassMethods
+      end
+    end
+
+    module DataFieldsClassMethods
+
+        def logger
+            @logger ||= Logger.new(logFileName,5,1024000)
+        end
+
+        def logFileName
+            @logFileName ||= FileProvider.getDataFileName("#{self.class}.log")
+        end
+
+        def attr_fields fields
+            logger.debug "#{self.class}::#{__method__}"
+            logger.debug "fields: #{fields}"
+            return if fields.nil?
+            props = properties
+            fields.each do |name,hash|
+                prop        = hash[:property]
+                props[prop] = name
+                self.instance_eval do
+                    attr_accessor hash[:property].to_s
+                end
+            end
+          end
+
+        def prop_accessor *prop_groups
+            logger.debug "#{self}::#{__method__}"
+            logger.debug *prop_groups.inspect
+            prop_groups.each do |props|
+                logger.debug    props
+                attr_fields     props
+                register_fields props
+            end
+        end
+
+        def properties
+            @properties ||= Hash.new
+          end
+
+        def register_fields fields
+          logger.debug "#{self.class}::#{__method__} fields: #{fields}"
+          return if fields.nil?
+          @data_fields = {} if @data_fields.nil?
+          @data_fields.merge!(fields) unless fields.nil?
+          @data_fields.merge!(BASE_HARVEST_DATA_FIELDS)
+          attr_fields fields
+        end
+
+        # def register_details_fields fields
+            # return if fields.nil?
+            # @details_fields = {} if @details_fields.nil?
+            # @details_fields.merge!(fields)
+            # @details_fields.merge!(BASE_HARVEST_DATA_FIELDS)
+            # attr_fields @details_fields
+          # end
+
+        def details_fields
+          # puts "#{self.class}::#{__method__}"
+          if @details_fields.nil?
+              register_fields(nil)
+          end
+          @details_fields
+        end
+
+    end # module DataFieldsClassMethods
+
+    def logger
+        self.class.logger
+    end
+
+    def data_fields
+        self.class.data_fields
+    end
+
+    def details_fields
+        self.class.details_fields
+    end
+
+    def now
+        DateTime.now.strftime('%l:%M:%S%P %b %-d, %Y ').strip
+    end
+
+    def flattenTextLines lines
+        lines.is_a?(Enumerable) ? lines.join(' ') : lines.to_s
+    end
+
+    def numify str
+        number = str.is_a?(String) ? str : str.to_s
+        number.gsub!(/[^0-9]/,'')
+        num_groups = number.to_s.chars.to_a.reverse.each_slice(3)
+        num_groups.map(&:join).join(',').reverse
+    end
+
+end # module BaseHarvester

data/lib/datafy/CSVHarvester.rb

@@ -0,0 +1,528 @@
+require 'set'
+require 'csv'
+require_relative 'baseharvester'
+
+module CSVHarvester
+
+    include BaseHarvester
+    include FileProvider
+
+    class << self
+      def included(base)
+        base.extend CSVHarvesterClassMethods
+      end
+    end # class << self
+
+    module CSVHarvesterClassMethods
+
+        def logger
+            @logger ||= Logger.new(logFileName,5,1024000)
+        end
+
+        def logFileName
+            @logFileName ||= "#{FileProvider.logDir}/#{self}.log"
+        end
+
+        def data_fields
+            # @data_fields ||= KEY_FIELDS.merge( PROPERTY_FIELDS, BaseHarvester::BASE_HARVEST_DATA_FIELDS )
+            @data_fields ||= register_fields :data
+        end
+
+        def set_data_fields fields
+            @data_fields = fields
+        end
+
+        def details_fields
+            # @details_fields ||= KEY_FIELD.merge( BaseHarvester::DETAILS_PROPERTY_FIELDS, BaseHarvester::BASE_HARVEST_DATA_FIELDS )
+            @details_fields ||= register_fields :details
+          end
+
+        def details_fields= fields
+            @details_fields = fields
+        end
+
+        def set_details_fields fields
+            @details_fields = fields
+        end
+
+        def attr_fields fields
+            logger.debug "#{self.class}::#{__method__}"
+            logger.debug "fields: #{fields}"
+            return if fields.nil?
+            props = properties
+            fields.each do |name,hash|
+                prop        = hash[:property]
+                props[prop] = name
+                self.instance_eval do
+                    attr_accessor hash[:property].to_s
+                end
+            end
+          end
+
+        def properties
+            @properties ||= Hash.new
+          end
+
+        def prop_accessor *prop_groups
+            logger.debug "#{self}::#{__method__}"
+            logger.debug *prop_groups.inspect
+            prop_groups.each do |props|
+                logger.debug props
+                attr_fields props
+            end
+            register_fields
+        end
+
+        def register_fields type=:data
+            logger.debug "#{self}::#{__method__}"
+            @data_fields    = self.const_defined?(:KEY_FIELDS) ? self::KEY_FIELDS.clone : {}
+            @details_fields = @data_fields.clone
+            # --
+            data_props      = self.const_defined?(:PROPERTY_FIELDS) ? self::PROPERTY_FIELDS : {}
+            @data_fields.merge!(    data_props,                             BaseHarvester::BASE_HARVEST_DATA_FIELDS )
+            @details_fields.merge!( BaseHarvester::DETAILS_PROPERTY_FIELDS, BaseHarvester::BASE_HARVEST_DATA_FIELDS )
+            attr_fields @data_fields
+            attr_fields @details_fields
+            return type.eql?(:data) ? @data_fields : @details_fields
+        end
+
+        def printProperties
+            logger.debug "#{self}::#{__method__}"
+            if properties.empty?
+                puts "no properties to print"
+                return
+            end
+            maxLen = properties.keys.max_by(&:length).length
+            maxLen += 2
+            properties.each do |f,v|
+                puts "  %-#{maxLen}s -> '%s' " % [f.inspect,v]
+            end
+          end
+
+        def print_fields type=:data
+            logger.debug "#{self}::#{__method__}"
+            label = "#{self} #{type.capitalize} Fields"
+            puts label
+            puts '-' * label.length
+            fields    = type.eql?(:details) ? details_fields : data_fields
+            maxKeyLen = fields.keys.max_by(&:length).length
+            maxSynLen = fields.values.map{|x| x[:property]}.max_by(&:length).length + 2
+            comments  = fields.values.map{|x| x[:comment]}.compact
+            maxComLen = comments.empty? ? "Comment".length : comments.max_by(&:length).length
+            logger.debug "  class: #{self}\n  #{type} Fields [CSV]"
+            logger.debug "  %-#{maxKeyLen}s  ->  %-#{maxSynLen}s   %-#{maxComLen}s" % ['Field Name', 'Symbol', "Comment"]
+            logger.debug "  %-#{maxKeyLen}s      %-#{maxSynLen}s   %-#{maxComLen}s" % ['-' * maxKeyLen, '-' * maxSynLen, '-' * maxComLen ]
+            # puts '-' * (maxKeyLen +3)
+            fields.each do |f,v|
+                puts "  %-#{maxKeyLen}s  ->  %-#{maxSynLen}s   %s" % [f,":#{v[:property]}",v[:comment]]
+            end
+          end
+
+        def printFields  *args
+            logger.debug "#{self}::#{__method__} -c- args: #{args} empty? #{args.empty?}"
+            if args.empty?
+                print_fields :data
+                print_fields :details
+                return
+            end
+            args.each do |type|
+                case type.to_s.downcase
+                    when 'data'    then print_fields :data
+                    when 'details' then print_fields :details
+                end
+            end
+          end
+
+        def printDataFields
+            print_fields :data
+          end
+
+        def printDetailsFields
+            print_fields :details
+          end
+
+        def getCSVFiles label=nil
+            logger.debug "#{self}::#{__method__}"
+            fqname = FileProvider.getDataFileName("")
+            logger.debug fqname
+            puts fqname
+            raise HarvestError.new "ERROR: method '#{self}::#{__method__}' not implemented source: CSVHarvester"
+          end
+        def prep_csv_file name, fields
+            logger.debug "#{self.class}::#{__method__} name:'#{name}' fields:#{fields}"
+            file = nil
+            if File.file?(name)
+                logger.debug 'Data file already exists'
+                FileProvider.backupFile(name)
+                fileFields = CSV.open(name, &:readline)
+                if fields == fileFields
+                    logger.debug 'headers match'
+                    file  = CSV.open(name,'a', :headers => true)
+                else
+                    logger.debug 'headers DO NOT match'
+                    file  = CSV.open(name,'w')
+                    file << fields
+                end
+            else
+                logger.debug 'Data file DOES NOT already exist'
+                puts 'Data file DOES NOT already exist'
+                file  = CSV.open(name,'w')
+                file << fields
+            end
+            return file
+          end
+
+        def baseFileName
+            logger.debug "#{self.class}::#{__method__}"
+            "#{self}".strip
+          end
+
+        def csv_files
+            @csv_files ||= loadCSVFiles
+          end
+
+        def csv_file type=:data
+            csv_files[type]
+          end
+
+        def loadCSVFiles type=:data
+            logger.debug "#{self.class}::#{__method__} type:'#{type}'"
+            name_data    = FileProvider.getDataFileName("#{baseFileName} Data.csv")
+            name_details = FileProvider.getDataFileName("#{baseFileName} Details.csv")
+            logger.debug "base_name   : #{baseFileName} "
+            logger.debug "name_data   : #{name_data}"
+            logger.debug "name_details: #{name_details}"
+            unless @csv_files.nil?
+                @csv_files.each do |type,file|
+                    begin
+                        file.close
+                    rescue => e
+                        logger.error "Closing CSV file #{type} | #{file} failed"
+                    end
+                end
+            end
+            @csv_files = {}
+            @csv_files[:data]    = prep_csv_file(name_data,    data_fields.keys)
+            @csv_files[:details] = prep_csv_file(name_details, details_fields.keys)
+            data_msg = "CSV file with data as Fields     : #{name_data}"
+            flds_msg = "CSV file with data as Keys/Values: #{name_details}"
+            logger.debug data_msg
+            logger.debug flds_msg
+            return @csv_files
+          end
+
+        def printDataFiles show_fields=true
+            logger.debug "#{self.class}::#{__method__} show_fields:#{show_fields}"
+            puts "CSV Files\n---------"
+            type_len = show_fields ? 4 : 7
+            csv_files.each do |type,file|
+                puts "%#{type_len}s file -> %-s" % [type.to_s.capitalize,file.path]
+                if show_fields
+                    printFields type
+                    puts ''
+                end
+            end
+            puts "---------"
+        end
+
+        def closeCSVFiles
+            unless @csv_files.nil?
+                @csv_files.each do |type,file|
+                    begin
+                        file.close
+                    rescue => e
+                        logger.warn "Closing CSV file #{type} | #{file} failed"
+                    end
+                end
+            end
+            @csv_files = nil
+          end
+
+          def persistWhen
+              @persistWhen ||= DateTime.now.strftime('%l:%M:%S%P %b %-d, %Y ').strip
+          end
+          def persistWhen= persist_when=now
+              @persistWhen = persist_when
+          end
+
+    end # module CSVHarvesterClassMethods
+
+    def logger
+        # puts "#{self.class}::#{__method__}"
+        self.class.logger
+    end
+
+    def logFileName
+        self.class.logFileName
+    end
+
+    def data_fields
+        self.class.data_fields
+    end
+
+    def details_fields
+        self.class.details_fields
+    end
+
+    def harvest
+        harvestNow
+    end
+
+    def harvestNow
+        record( property: :harvestWhen, value: now, append: false )
+        return now
+    end
+
+    def persistWhen
+        # persist_when = self.class.persistWhen
+        record( property: :persistWhen, value: now, append: false )
+        return now
+    end
+
+    def printDataFields
+        self.class.printFields :data
+    end
+
+    def printFields *args
+        # puts "#{self}::#{__method__} args: -i- #{args}"
+        self.class.printFields *args
+    end
+
+    def properties
+        logger.debug "#{self.class}::#{__method__} [i]"
+        self.class.properties
+    end
+
+    def printProperties
+        logger.debug "#{self.class}::#{__method__} [i]"
+        self.class.printProperties
+    end
+
+    def printDetailsFields
+        self.class.printFields :details
+    end
+
+    def record(property:, value:, append: true)
+        logger.debug "#{self.class}::#{__method__}"
+        begin
+            if ''.eql?(value) || value.nil?
+                logger.debug "  !!! NOT setting nil or empty property"
+                return
+            end
+            prop_name   = property.is_a?(String) ? property : property.to_s
+            prop_name.sub!(/[=]+$/,'')
+            curr_val    = send(prop_name)
+            assign_prop = prop_name.concat('=')
+            assign_val  = if append && !curr_val.nil? && !value.eql?(curr_val)
+                              "#{curr_val} | #{value}"
+                          else
+                              value
+                          end
+            send(assign_prop, assign_val)
+            register_detail(property: property, value: value)
+        rescue => e
+            puts "#{self.class}::#{__method__} ERROR:#{e}"
+        end
+    end
+
+    def resetDataFields
+        data_fields.each do |fieldName,parts|
+            methodName = "#{parts[:property].to_s}="
+            methodName.gsub!(/[=]+$/,'=')
+            send(methodName,nil)
+        end
+        @errorMessage = nil
+    end
+
+    def resetDetails
+        logger.debug "#{self.class}::#{__method__}"
+        @details = Hash.new { |k,v| k[v] = Set.new }
+        @detailsCSVRecords = nil
+        logger.debug "Details : #{@details.inspect}"
+        logger.debug "CSV recs: #{@detailsCSVRecords.inspect}"
+    end
+
+    def registerError error
+        logger.debug "#{self.class}::#{__method__}"
+        record( property: :harvestSuccessful, value: false )
+        record( property: :harvestMessage,    value: error.message[0..150].gsub("\n", ' | ') )
+        @errorMessage = error.full_message.to_s # @errorMessage declared in BaseHarvester, useful for debugging
+    end
+
+    def csvRecord
+        logger.debug "#{self.class}::#{__method__}"
+        rec = CSV::Row.new(  self.data_fields.keys, [] )
+        self.data_fields.each do |fieldName,parts|
+            value = send(parts[:property])
+            logger.debug "fieldName: '#{fieldName}' => :#{parts[:property]} ==> #{value} nil?#{value.nil?}"
+            rec[fieldName] = value
+        end
+        return rec
+    end
+
+    def printCSVRecord
+        logger.debug "#{self.class}::#{__method__}"
+        rec = csvRecord
+        maxLen = rec.headers.max_by(&:length).length
+        puts "CSV Record"
+        puts '=' * (maxLen)
+        unless rec.nil? || rec.empty?
+            rec.each do |f,v|
+                # logger.info "  %-#{maxLen}s -> %s " % [f,v]
+                puts "%-#{maxLen}s : %s " % [f,v]
+            end
+            puts '-' * maxLen
+        end
+    end
+
+    def details
+        @details ||= Hash.new { |k,v| k[v] = Set.new }
+    end
+
+    # Use this method to only add a Details line, it does not set the property
+    def register_detail(property:, value:)
+        logger.debug "#{self.class}::#{__method__} prop:'#{property.inspect}' value:'#{value}'"
+        return if value.nil? || ''.eql?(value)
+        detail = properties.has_key?([property]) ? properties[property] : property
+        deets  = details
+        logger.debug " - details has new? #{deets[detail].include?(value)}"
+        unless (deets.has_key?(detail) && deets[detail].include?(value))
+            deets[detail] << value.to_s.strip # .to_s handles cases of non-String value
+        end
+    end
+
+    def printDetails
+        logger.debug "#{self.class}::#{__method__}"
+        if details.empty?
+            msg = " - no details to print i.e. @details is nil or empty"
+            puts msg
+            logger.info msg
+        else
+            # maxKeyLen = properties.values.max_by(&:length).length
+            details.each do |type,lines|
+                # log true, type
+                # puts "%-#{maxKeyLen}s :: [%s]" % [properties[type],type]
+                puts "%s [%s]" % [properties[type],type]
+                lines.each do |line|
+                    puts "  - '#{line}'"
+                end
+            end
+        end
+      end #def printDetails
+
+    def detailsCSVRecords
+        logger.debug "#{self.class}::#{__method__}"
+        @detailsCSVRecords = Set.new
+        begin
+            details.each do |detail,lines|
+                @detail = detail
+                field   = properties[detail]
+                lines.each_with_index do |line,index|
+                    rec = CSV::Row.new( details_fields.keys, [] )
+                    # rec = CSV::Row.new( detailsDataFields.keys, [] )
+                    # DETAILS_DATA_FIELDS.each do |fieldName,parts|
+                    details_fields.each do |fieldName,parts|
+                        prop = parts[:property]
+                        resp = respond_to?(prop)
+                        if resp
+                            value = send(prop)
+                            rec[fieldName] = value
+                        end
+                    end
+                    rec['Class']  = self.class # klass
+                    rec['Detail'] = field
+                    rec['Index']  = index + 1
+                    rec['Line']   = line
+                    rec['Harvest When'] = @harvestWhen.nil? ? now : detail.eql?(:harvestWhen) ? now : harvestWhen
+                    rec['Persist When'] = @persistWhen.nil? ? now : persistWhen
+                    @detailsCSVRecords << rec
+                end
+            end
+        rescue => e
+            registerError e
+        end
+        return @detailsCSVRecords
+    end
+
+    def printDataFiles show_fields=true
+        logger.debug "#{self.class}::#{__method__} show_fields:#{show_fields}"
+        self.class.printDataFiles show_fields
+    end
+
+    def printDetailsCSVRecords
+        logger.debug "#{self.class}::#{__method__}"
+        begin
+            puts "Details Records"
+            recs   = detailsCSVRecords
+            if recs.nil? || recs.empty?
+                # log true, "No Details records exist to print."
+                puts " - no details records exist to print"
+            else
+                maxLen = recs.first.headers.max_by(&:length).length
+                puts '=' * maxLen
+                recs.each do |r|
+                    r.entries.each do |e,v|
+                        puts "%-#{maxLen}s : %s" % [e,v]
+                    end
+                    puts '-' * maxLen
+                end
+            end
+        rescue => e
+            registerError e
+        end
+    end
+
+    def persist_data
+        logger.debug "#{self.class}::#{__method__}"
+        begin
+            # @persistWhen = now
+            persistWhen
+            file = self.class.csv_files[:data]
+            $fields_file = file
+            unless file.nil?
+                file << csvRecord
+            end
+        rescue => e
+            logger.error "ERROR persisting CSV fields aka csvRecord:'#{e.message}'"
+        end
+      end
+
+    def persist_details
+        logger.debug "#{self.class}::#{__method__}"
+        begin
+            file = self.class.csv_files[:details]
+            $details_file = file
+            detailsCSVRecords.each do |rec|
+                file << rec
+            end
+            return
+        rescue => e
+            logger.error "ERROR persisting CSV data in details form:'#{e.message}'"
+        end
+      end
+
+    def persist(*args, persist_when: nil, append: true, close_on_exit: true)
+        logger.debug "#{self.class}::#{__method__} args:#{args}"
+        record( property: :persistWhen, value: persist_when.nil? ? now : persist_when, append: append )
+        persist_data
+        persist_details
+        self.class.closeCSVFiles if close_on_exit
+    end
+
+    def to_s
+        str = "#{self.class}:: "
+        consts = self.class.constants.grep(/KEY/)
+        consts.each do |c|
+            fields = self.class.const_get(c)
+            fields.each do |name,prop|
+                str+= " -#{name}-|#{send(prop[:property])}|"
+            end
+            # end
+            # key       = key_field.first
+            # val       = send(key_field.last[:property])
+            # str = "#{self.class}: '#{key}':'#{val}'"
+        end
+        return str
+    end
+
+end # module CSVHarvester

data/lib/datafy/FileProvider.rb

@@ -0,0 +1,109 @@
+# puts "Executing: #{__FILE__}"
+
+require 'fileutils'
+
+module FileProvider
+
+    def self.localDir
+        @local_dir ||= Dir.pwd
+    end
+
+    def self.localDir= dir
+        @local_dir = dir
+    end
+
+    def self.dataDir
+        @data_dir ||= getDataDir
+    end
+
+    def self.getDataDir
+        getDir 'data'
+    end
+
+    def self.logDir
+        @log_dir ||= getLogDir
+    end
+
+    def self.getLogDir
+        getDir 'logs'
+    end
+
+    def self.getDir dir='data'
+        dir_name =  "#{localDir}/#{dir}".gsub(/[\/]+/,'/')
+        unless Dir.exists?(dir_name)
+            Dir.mkdir(dir_name)
+        end
+        return dir_name
+    end
+
+    def self.dataDir= dir
+        @data_dir = dir
+    end
+
+    def self.logDir= dir
+        @log_dir = dir
+    end
+
+    attr_reader :file_name
+
+    def self.getDataFileName fileName
+        normFileName = fileName.split('/').last
+        file_name = "#{dataDir}/#{normFileName}"
+        return file_name
+    end
+
+    def dataTextFile fileName, mode='a'
+        fqname = getDataFileName(fileName)
+        file = nil
+        begin
+            file = File.open(fqname,mode)
+        rescue => e
+            puts "FileProvider.dataTextFile(#{fileName}) problem: #{e.message}"
+            file = nil
+        end
+        # return HarvesterFile.new fileName, fqname, file
+        return file
+    end
+
+    def openLogFile fileName="#{self.class.to_s}_log.txt"
+        fqname = getDataFileName(fileName)
+        @logFile = File.open(fqname, 'a+')
+    end # def openLogFile
+
+    def removeFile fileName
+        fqname = getDataFileName(fileName)
+        status = ''
+        if File.file?(fqname)
+            # puts 'Data file already exists'
+            backupFile(fqname)
+            # puts "removing data file: '#{fileName}' -> '#{fqname}'"
+            result = system "rm '#{fqname}'"
+            status = result.is_a?(TrueClass) ? 'Success' : 'Failue'
+        else
+            status = 'File not found'
+        end
+        return status
+    end
+
+    def self.backupFile fileName
+        status = nil
+        if File.file?(fileName)
+            backupName = getBackupFileName fileName
+            FileUtils.cp(fileName,backupName)
+            status = { status: :backedUp, name: backupName }
+        else
+            status = { status: :originalFileNotFound }
+        end
+        return status
+    end
+
+    def backupFile fileName
+        self.class.backupFile fileName
+    end
+
+    def self.getBackupFileName fileName
+        fqname = getDataFileName fileName
+        "#{fileName}.#{DateTime.now}"
+    end
+
+end # module FileProvider

data/lib/datafy.rb

@@ -0,0 +1,9 @@
+require_relative 'csvify/baseharvester'
+require_relative 'csvify/fileprovider'
+require_relative 'csvify/csvharvester'
+
+class Datafy
+  def self.hi
+    puts "Hello world! Datafy here to help you persist Ruby attributes as data Fields."
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: datafy
+version: !ruby/object:Gem::Version
+  version: 0.5.8
+platform: ruby
+authors:
+- Chris Gerrard
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-27 00:00:00.000000000 Z
+dependencies: []
+description: Represent, record, and persist Ruby classes' attributes as CSV fields
+  and persist them as data fields into CSV files.
+email:
+- Chris@Gerrard.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/datafy.rb
+- lib/datafy/BaseHarvester.rb
+- lib/datafy/CSVHarvester.rb
+- lib/datafy/FileProvider.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.11
+signing_key:
+specification_version: 4
+summary: Record and persist data as CSV fields.
+test_files: []