Rcov C0 Coverage Information - RCov

 require 'fastercsv'

 require 'csv'

 class FlexibleCriterion < ActiveRecord::Base

   set_table_name "flexible_criteria" # set table name correctly

   belongs_to :assignment, :counter_cache => true

   has_many :marks, :as => :markable, :dependent => :destroy

   has_many :criterion_ta_associations,

            :as => :criterion,

            :dependent => :destroy

   has_many :tas, :through => :criterion_ta_associations

   validates_associated :assignment,

                   :message => 'association is not strong with an assignment'

   validates_uniqueness_of :flexible_criterion_name,

                           :scope => :assignment_id,

   validates_presence_of :flexible_criterion_name, :assignment_id, :max

   validates_numericality_of :assignment_id,

   validates_numericality_of :max,

   DEFAULT_MAX = 1

   def update_assigned_groups_count

     result = []

     tas.each do |ta|

       result = result.concat(ta.get_groupings_by_assignment(assignment))

     end

   def self.create_csv(assignment)

     csv_string = FasterCSV.generate do |csv|

       criteria = FlexibleCriterion.find_all_by_assignment_id(assignment.id, :order => :position)

       criteria.each do |c|

         criterion_array = [c.flexible_criterion_name, c.max, c.description]

         csv << criterion_array;

     return csv_string

   # Instantiate a FlexibleCriterion from a CSV row and attach it to the supplied

   # assignment.

   # ===Params:

   #

   # row::         An array representing one CSV file row. Should be in the following

   # assignment::  The assignment to which the newly created criterion should belong.

   #

   #

   # CSV::IllegalFormatError:: If the row does not contains enough information, if the max value

   #                           is zero (or doesn't evaluate to a float) or if the

   def self.new_from_csv_row(row, assignment)

     if row.length < 2

       raise CSV::IllegalFormatError.new(I18n.t('criteria_csv_error.incomplete_row'))

     end

     criterion = FlexibleCriterion.new

     criterion.assignment = assignment

     criterion.flexible_criterion_name = row[0]

     if (FlexibleCriterion.find_all_by_assignment_id_and_flexible_criterion_name(assignment.id, criterion.flexible_criterion_name).size != 0)

       raise CSV::IllegalFormatError.new(I18n.t('criteria_csv_error.name_not_unique'))

     criterion.max = row[1]

     if (criterion.max == 0)

       raise CSV::IllegalFormatError.new(I18n.t('criteria_csv_error.max_zero'))

     criterion.description = row[2] if !row[2].nil?

     criterion.position = next_criterion_position(assignment)

     if !criterion.save

       raise CSV::IllegalFormatError.new(criterion.errors)

     return criterion

   # ===Params:

   #

   # file::          A file object which will be tried for parsing.

   # assignment::    The assignment to which the new criteria should belong to.

   # invalid_lines:: An object to recieve all encountered _invalid_ lines.

   #                 Strings representing the faulty line followed by

   #                 a human readable error message are appended to the object

   #

   #

   def self.parse_csv(file, assignment, invalid_lines = nil)

     nb_updates = 0

     FasterCSV.parse(file.read) do |row|

       next if FasterCSV.generate_line(row).strip.empty?

       begin

         FlexibleCriterion.new_from_csv_row(row, assignment)

         nb_updates += 1

       rescue CSV::IllegalFormatError => e

         invalid_lines << row.join(',') + ": " + e.message unless invalid_lines.nil?

     end

     return nb_updates

   # ===Returns:

   def self.next_criterion_position(assignment)

     last_criterion = FlexibleCriterion.find_last_by_assignment_id(assignment.id, :order => :position)

     return last_criterion.position + 1 unless last_criterion.nil?

     return 1

   end

   def get_weight

     return 1

   end

   def all_assigned_groups

       result = result.concat(ta.get_groupings_by_assignment(assignment))

   def add_tas(ta_array)

     ta_array = Array(ta_array)

     associations = criterion_ta_associations.all(:conditions => {:ta_id => ta_array})

     ta_array.each do |ta|

       if (ta.criterion_ta_associations & associations).size < 1

         criterion_ta_associations.create(:ta => ta, :criterion => self, :assignment => self.assignment)

       end

     end

   def get_name

   end

   def remove_tas(ta_array)

     ta_array = Array(ta_array)

     associations_for_criteria = criterion_ta_associations.all(:conditions => {:ta_id => ta_array})

     ta_array.each do |ta|

       # & is the mathematical set intersection operator between two arrays

       assoc_to_remove = (ta.criterion_ta_associations & associations_for_criteria)

       if assoc_to_remove.size > 0

         criterion_ta_associations.delete(assoc_to_remove)

         assoc_to_remove.first.destroy

       end

     end

   end

   def get_ta_names

   def has_associated_ta?(ta)

     if !ta.ta?

       return false

     end

     return !(criterion_ta_associations.find_by_ta_id(ta.id) == nil)

   end

   def add_tas_by_user_name_array(ta_user_name_array)

     result = ta_user_name_array.map{|ta_user_name|

       Ta.find_by_user_name(ta_user_name)}.compact

     add_tas(result)

   def self.assign_tas_by_csv(csv_file_contents, assignment_id)

     failures = []

     FasterCSV.parse(csv_file_contents) do |row|

       criterion_name = row.shift # Knocks the first item from array

       criterion = FlexibleCriterion.find_by_assignment_id_and_flexible_criterion_name(assignment_id, criterion_name)

       if criterion.nil?

         failures.push(criterion_name)

         criterion.add_tas_by_user_name_array(row) # The rest of the array

     return failures