Refactoring Feature Envy in Rust Using Struct Method Reallocation

Introduction and Context Setting

In software design, understanding and addressing code smells such as "Feature Envy" is crucial for maintaining and improving code quality. Code smells are indicators of potential issues in your codebase that may hinder readability and maintainability. Feature Envy specifically arises when a method in a struct shows excessive interactions with the data of another struct, often leading to a tangled code structure that is difficult to test and maintain. Refactoring is the process of restructuring existing code to enhance its readability, maintainability, and performance without altering its external behavior. Common refactoring patterns such as the Move function can be employed to address code smells like Feature Envy . This involves relocating methods to the struct that holds the data they depend on, reducing unnecessary dependencies and improving cohesion. In this course, we employ Test Driven Development (TDD) practices using the Rust language. Rust is known for its emphasis on safety and concurrency, promoting efficient and readable code. We emphasize the TDD cycle — Red, Green, Refactor — to incrementally evolve the code with confidence, ensuring each step is supported by a comprehensive suite of tests.

What is Feature Envy?

Feature Envy is a code smell that occurs when a method in one struct interacts too heavily with the data of another struct, showing an unwarranted interest in the features of that struct . This often manifests when a method accesses the fields or calls the functions of another struct more frequently than it operates on its own data. This anti-pattern suggests that the method may be misplaced and that it logically belongs in the struct it is so interested in. This code smell is problematic for several reasons: Poor Encapsulation: Feature Envy often breaches encapsulation, a core principle of well-structured code. By reaching across struct boundaries to manipulate another struct ’s data, it undermines the principle that each struct should handle its own data and behavior. Increased Coupling: When structs become too intertwined due to Feature Envy, the coupling between structs increases. High coupling means changes in one struct can ripple through others, increasing the difficulty and risk of making changes. Reduced Cohesion: A struct with methods affected by Feature Envy lacks proper cohesion, meaning its methods are not focusing on its primary responsibility. This dilution of responsibility makes understanding and maintaining the struct more complex. Testing Complexity: Feature Envy can complicate unit testing because methods are reliant on external data. This may necessitate intricate test setups or the need for mocking external dependencies, reducing test simplicity and effectiveness. To mitigate Feature Envy, we leverage the refactoring pattern Move function, relocating the envious method to the struct whose data it primarily operates on. This realignment enhances the code by promoting greater cohesion, reducing coupling, and adhering to design principles, leading to more maintainable and robust software.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Rust

struct StudentGrade {
    score: f64,
    total_points: f64,
    submitted_date: std::time::SystemTime,
}

struct Student {
    grades: Vec<StudentGrade>,
}

impl Student {
    fn get_grades(&self) -> &Vec<StudentGrade> {
        &self.grades
    }
}

struct GradeAnalyzer<'a> {
    student: &'a Student,
}

impl<'a> GradeAnalyzer<'a> {
    fn calculate_final_grade(&self) -> f64 {
        let grades = self.student.get_grades();
        if grades.is_empty() {
            return 0.0;
        }

        let mut total_earned = 0.0;
        let mut total_possible = 0.0;
        for grade in grades {
            if self.is_late_submission(grade) {
                total_earned += grade.score * 0.9; // 10% penalty for late submissions
            } else {
                total_earned += grade.score;
            }
            total_possible += grade.total_points;
        }

        (total_earned / total_possible) * 100.0
    }

    fn is_late_submission(&self, grade: &StudentGrade) -> bool {
        let submission_date = grade.submitted_date;
        let due_date = std::time::SystemTime::now(); // Simplified for example
        submission_date > due_date
    }

    fn get_failed_assignments(&self) -> Vec<&StudentGrade> {
        let mut failed = Vec::new();
        for grade in self.student.get_grades() {
            if (grade.score / grade.total_points) < 0.6 {
                failed.push(grade);
            }
        }
        failed
    }
}

struct StudentGrade {
    score: f64,
    total_points: f64,
    submitted_date: std::time::SystemTime,
}

struct Student {
    grades: Vec<StudentGrade>,
}

impl Student {
    fn get_grades(&self) -> &Vec<StudentGrade> {
        &self.grades
    }
}

struct GradeAnalyzer<'a> {
    student: &'a Student,
}

impl<'a> GradeAnalyzer<'a> {
    fn calculate_final_grade(&self) -> f64 {
        let grades = self.student.get_grades();
        if grades.is_empty() {
            return 0.0;
        }

        let mut total_earned = 0.0;
        let mut total_possible = 0.0;
        for grade in grades {
            if self.is_late_submission(grade) {
                total_earned += grade.score * 0.9; // 10% penalty for late submissions
            } else {
                total_earned += grade.score;
            }
            total_possible += grade.total_points;
        }

        (total_earned / total_possible) * 100.0
    }

    fn is_late_submission(&self, grade: &StudentGrade) -> bool {
        let submission_date = grade.submitted_date;
        let due_date = std::time::SystemTime::now(); // Simplified for example
        submission_date > due_date
    }

    fn get_failed_assignments(&self) -> Vec<&StudentGrade> {
        let mut failed = Vec::new();
        for grade in self.student.get_grades() {
            if (grade.score / grade.total_points) < 0.6 {
                failed.push(grade);
            }
        }
        failed
    }
}

Rust

impl Student {
    fn calculate_final_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }

        let mut total_earned = 0.0;
        let mut total_possible = 0.0;
        for grade in &self.grades {
            total_earned += grade.score_with_late_penalty();
            total_possible += grade.total_points;
        }

        (total_earned / total_possible) * 100.0
    }
}

impl StudentGrade {
    fn score_with_late_penalty(&self) -> f64 {
        if self.is_late_submission() {
            self.score * 0.9
        } else {
            self.score
        }
    }

    fn is_late_submission(&self) -> bool {
        let submission_date = self.submitted_date;
        let due_date = std::time::SystemTime::now(); // Simplified for example
        submission_date > due_date
    }
}

impl Student {
    fn calculate_final_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }

        let mut total_earned = 0.0;
        let mut total_possible = 0.0;
        for grade in &self.grades {
            total_earned += grade.score_with_late_penalty();
            total_possible += grade.total_points;
        }

        (total_earned / total_possible) * 100.0
    }
}

impl StudentGrade {
    fn score_with_late_penalty(&self) -> f64 {
        if self.is_late_submission() {
            self.score * 0.9
        } else {
            self.score
        }
    }

    fn is_late_submission(&self) -> bool {
        let submission_date = self.submitted_date;
        let due_date = std::time::SystemTime::now(); // Simplified for example
        submission_date > due_date
    }
}

Rust

struct StudentGrade {
    score: f64,
    total_points: f64,
    submitted_date: std::time::SystemTime,
}

struct Student {
    grades: Vec<StudentGrade>,
}

impl Student {
    fn get_grades(&self) -> &Vec<StudentGrade> {
        &self.grades
    }
}

struct GradeAnalyzer<'a> {
    student: &'a Student,
}

impl<'a> GradeAnalyzer<'a> {
    fn calculate_final_grade(&self) -> f64 {
        let grades = self.student.get_grades();
        if grades.is_empty() {
            return 0.0;
        }

        let mut total_earned = 0.0;
        let mut total_possible = 0.0;
        for grade in grades {
            if self.is_late_submission(grade) {
                total_earned += grade.score * 0.9; // 10% penalty for late submissions
            } else {
                total_earned += grade.score;
            }
            total_possible += grade.total_points;
        }

        (total_earned / total_possible) * 100.0
    }

    fn is_late_submission(&self, grade: &StudentGrade) -> bool {
        let submission_date = grade.submitted_date;
        let due_date = std::time::SystemTime::now(); // Simplified for example
        submission_date > due_date
    }

    fn get_failed_assignments(&self) -> Vec<&StudentGrade> {
        let mut failed = Vec::new();
        for grade in self.student.get_grades() {
            if (grade.score / grade.total_points) < 0.6 {
                failed.push(grade);
            }
        }
        failed
    }
}

Rust

impl Student {
    fn calculate_final_grade(&self) -> f64 {
        if self.grades.is_empty() {
            return 0.0;
        }

        let mut total_earned = 0.0;
        let mut total_possible = 0.0;
        for grade in &self.grades {
            total_earned += grade.score_with_late_penalty();
            total_possible += grade.total_points;
        }

        (total_earned / total_possible) * 100.0
    }
}

impl StudentGrade {
    fn score_with_late_penalty(&self) -> f64 {
        if self.is_late_submission() {
            self.score * 0.9
        } else {
            self.score
        }
    }

    fn is_late_submission(&self) -> bool {
        let submission_date = self.submitted_date;
        let due_date = std::time::SystemTime::now(); // Simplified for example
        submission_date > due_date
    }
}

Introduction and Context Setting

What is Feature Envy?

Join the 1M+ learners on CodeSignal

Overview of the Current Codebase

Example: Identifying Feature Envy

Refactor: Move Function to Struct

Review/Summary and Heads Up About Practice Exercises