如何在Ruby中使用matchdata对象编写条件逻辑？

Question

I've written a simple program that parses my banks transaction CSV file. My expression pushes results to array/hash data structure that will be saved to a database.

There are two parts:

1. A run method that opens a file, reads each line and pushes it.
2. A view that pulls out data from the hash.

I've included my main parse method below. It checks each line for a keyword, and if the match fails, it SHOULD push to an unclassified Hash. However, the conditional either pushes ALL or NO transactions based on whether I use elsif or else .

Matchdata objects return strings by default so else should work shouldn't it? Here's the method that builds the data structure. I've commented the portion I'm having trouble with:

def generateHashDataStructure(fileToParse, wordListToCheckAgainst)
  transactionInfo = Hash.new
  transactionInfo[:transactions] = Hash.new
  transactionInfo[:unclassifiedTransaction] = Hash.new
  transaction = transactionInfo[:transactions]
  unclassifiedTransaction = transactionInfo[:unclassifiedTransaction]

  wordListToCheckAgainst.each do |word|
    transaction[word] = Array.new
    unclassifiedTransaction[:unclassifiedTransaction] = Array.new
    File.open(fileToParse).readlines.each do |line|
       if transaction = /(?<transaction>)#{word}/.match(line)   
        date = /(?<Month>\d{1,2})\D(?<Day>\d{2})\D(?<Year>\d{4})/.match(line).to_s
        transaction = /(?<transaction>)#{word}/.match(line).to_s
        amount =/-+(?<dollars>\d+)\.(?<cents>\d+)/.match(line).to_s
        transactions[word].push({:date => date, 
                                :name => transaction, :amount =>    amount.to_f.round(2)})

        # this is problem: else/elsif don't push only if match fails
        else
         date = /(?<Month>\d{1,2})\D(?<Day>\d{2})\D(?<Year>\d{4})/.match(line).to_s
         transaction = /(?<Middle>)".*"/.match(line).to_s
         amount =/-*(?<dollars>\d+)\.(?<cents>\d+)/.match(line).to_s
         unclassifiedTransaction[:unclassifiedTransaction].push({:date => date, 
                                   :name => transaction, :amount => amount.to_f.round(2)})
         next
        end
     end
     return transactionInfo
   end

Any ideas would be great. I've researched this and I feel I've been defeated by reaching out to the community. I realize regex might not be best approach so I'm open to all feedback.

Answer 1

I made your code more idiomatic, which helps reveal some very questionable things.

1. Ruby methods and variables are written in snake_case, not CamelCase. While this seems like a matter of personal opinion, it also becomes a case of maintainability/readability. The _ helps our brains visually separate the word segments from each other in the variable name, rather than seeing a run-together string with mixed case "humps". Try_reading_a_bunch_of_text_that_is_identical exceptForThatAndSeeWhichIsMoreExhausting .

2. You're assigning to a variable inside a conditional test:

    if transaction = /(?<transaction>)#{word}/.match(line) 

   Don't do that. Even if it's intentional, it opens up potential for maintenance errors when someone else doesn't understand why you'd do something like that. Instead, write it in two steps so it's obvious what was intended:

    transaction = /(?<transaction>)#{word}/.match(line) if transaction 

   Or, your "assignment then compare" really should be written as:

    if transaction == /(?<transaction>)#{word}/.match(line) 

   Or:

    if /(?<transaction>)#{word}/.match(line) 

   Which is even more clean/safe/obvious.

3. Rather than use Hash.new , and Array.new , use the direct assignments {} and [] respectively. They're less noisy and more commonly seen. Also, rather than incrementally define your hash:

    transactionInfo = Hash.new transactionInfo[:transactions] = Hash.new transactionInfo[:unclassifiedTransaction] = Hash.new 

   Use:

    transaction_info = { :transactions => {}, :unclassified_transaction => {} } 

   Instantly your structure is revealed, making the intention a lot clearer.

4. File.open(fileToParse).readlines.each do |line| is a convoluted way of doing:

    File.foreach(fileToParse) do |line| 

   Only foreach doesn't waste memory sucking the entire file into memory all at once. There's no appreciable speed improvement to "slurping" your file, only downsides to it if the file grows to "ginormous" proportions.

5. Instead of using:

    transactions[word].push({:date => date, :name => transaction, :amount => amount.to_f.round(2)}) 

   Write your code more simply. push obscures what you're doing, as does the way you formatted your lines:

    transactions[word] << { :date => date, :name => transaction, :amount => amount.to_f.round(2) } 

   Note the alignment into columns. Some people eschew that particular habit, but when you're dealing with a lot of assignments it can make a big difference seeing the variations in each line.

Here's more idiomatic Ruby code:

def generate_hash_data_structure(file_to_parse, word_list_to_check_against)

  transaction_info = {
    :transactions => {},
    :unclassified_transaction => {}
  }

  transaction = transaction_info[:transactions]
  unclassified_transaction = transaction_info[:unclassified_transaction]

  word_list_to_check_against.each do |word|

    transaction[word] = []
    unclassified_transaction[:unclassified_transaction] = []

    File.foreach(file_to_parse) do |line|

      if transaction = /(?<transaction>)#{word}/.match(line)   

        date        = /(?<Month>\d{1,2})\D(?<Day>\d{2})\D(?<Year>\d{4})/.match(line).to_s
        transaction = /(?<transaction>)#{word}/.match(line).to_s
        amount      = /-+(?<dollars>\d+)\.(?<cents>\d+)/.match(line).to_s

        transactions[word] << {
          :date   => date,
          :name   => transaction,
          :amount => amount.to_f.round(2)
        }

        # this is problem: else/elsif don't push only if match fails

      else

        date        = /(?<Month>\d{1,2})\D(?<Day>\d{2})\D(?<Year>\d{4})/.match(line).to_s
        transaction = /(?<Middle>)".*"/.match(line).to_s
        amount      = /-*(?<dollars>\d+)\.(?<cents>\d+)/.match(line).to_s

        unclassified_transaction[:unclassified_transaction] << {
            :date   => date,
            :name   => transaction,
            :amount => amount.to_f.round(2)
          }

        # next
      end

    end

    transaction_info

  end
end