Expertiza_Wiki - User contributions [en]

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-25T03:04:19Z

Rananth2: /* Current Implementation */

== '''Background Information''' ==
This project aims to contribute to Mozilla's experimental browser engine called Servo, which is implemented in a language called RUST(useful for implementing features that need concurrency and memory safety).

Many of the components of Servo are still under development and one such feature is the [https://www.techopedia.com/definition/792/bitmap-bmp| ImageBitmap].

Major browsers support the ImageBitmap standard which can be used to create images that are ready to be drawn efficiently to [https://en.wikipedia.org/wiki/Canvas_element| HTML canvas elements]. Servo is a new, experimental browser that supports these canvas APIs.

The goal of and motivation behind this project is to implement support for image bitmaps and improve our canvas automated test coverage as a result.

== '''About ImageBitMap and Motivation behind the project''' ==
We usually decode images for a use with canvas to allow users to customize an avatar, crop an image, or just zoom in on a picture. The problem with decoding images is that it can be CPU intensive, and that can sometimes mean jank or checkerboarding.

But the createImageBitmap() method allows us to decode the image in the background and get access to a new ImageBitmap primitive, which you can draw into a canvas in the same way you would an <img> element, another canvas, or a video.

The aim of this project is to develop the ImageBitmap for the servo environment.

This can be done in the steps mentioned in the following section.

== '''Steps for implementation''' ==

'''Initial Phase'''
* '''Step 1: '''Add a ImageBitmap WebIDL interface to ''components/script/dom/webidl''s and Rust implementation in components/script/dom/imagebitmap.rs
* '''Step 2: ''' Add the ''createImageBitmap'' method that takes no extra x/y/w/h parameters in ''component/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and implement the method in ''component/script/dom/window.rs'', handling the HTMLCanvasElement and OffscreenCanvas types from the possible image sources

'''Subsequent phase'''
* '''Step 1: '''Implement several remaining image source types (HTMLImageElement, ImageData, ImageBitmap)
* '''Step 2: '''Implement the ''createImageBitmap'' overload that accepts x/y/w/h parameters
* '''Step 3: '''Implement support for ImageBitmaps as canvas image sources in ''components/script/canvas_state.rs''
[[File:AllSteps.jpg]]

== '''Details about previous work on implementation''' ==
The steps that have been implemented so far in this project by the previous batch are:

'''Step 1:''' Added the ImageBitmap interface to ''components/script/dom/webidls'' that represents a bitmap image which can be drawn to a <canvas> without undue latency. The interface contains height and weight as its attributes which are read only unsigned long integers.
<pre>
//[Exposed=(Window,Worker), Serializable, Transferable]
[Exposed=(Window,Worker)]
interface ImageBitmap {
readonly attribute unsigned long width;
readonly attribute unsigned long height;
//void close();
};

typedef (CanvasImageSource or
Blob or
ImageData) ImageBitmapSource;

enum ImageOrientation { "none", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
ImageOrientation imageOrientation = "none";
PremultiplyAlpha premultiplyAlpha = "default";
ColorSpaceConversion colorSpaceConversion = "default";
[EnforceRange] unsigned long resizeWidth;
[EnforceRange] unsigned long resizeHeight;
ResizeQuality resizeQuality = "low";
};
</pre>

The ImageBitmap webidl also defines a dictionary for various ImageBitmap Options that can be used to modify the ImageBitmap object.

'''Step 2:''' Implemented the rust code for the webidl interface at ''components/script/dom/imagebitmap.rs''. For more details on the code [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Spring_2020_-_M2000._Implement_ImageBitMap_web_API#Implementation visit]
<pre>
use crate::dom::bindings::cell::DomRefCell;

use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;

use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use dom_struct::dom_struct;

use std::vec::Vec;

#[dom_struct]
pub struct ImageBitmap {
reflector_: Reflector,
width: u32,
height: u32,
bitmap_data: DomRefCell<Vec<u8>>,
}

impl ImageBitmap {
fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
width: width_arg,
height: height_arg,
bitmap_data: DomRefCell::new(vec![]),
}
}

#[allow(dead_code)]
pub fn new(global: &GlobalScope, width: u32, height: u32) -> Fallible<DomRoot<ImageBitmap>> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));

Ok(reflect_dom_object(imagebitmap, global))
}
}
</pre>

The code also implements the getter methods for height and width attribute of an ImageBitmap object.
<pre>
impl ImageBitmapMethods for ImageBitmap {
// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height
fn Height(&self) -> u32 {
//to do: add a condition for checking detached internal slot
//and return 0 if set to true
self.height
}

// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width
fn Width(&self) -> u32 {
//to do: add a condition to check detached internal slot
////and return 0 if set to true
self.width
}
}
</pre>

== '''Proposed Implementation''' ==
Among the remaining steps in the initial and subsequent phases, the focus will be on step 2 of initial phase and once there is progress made on this step, implementation of the subsequent steps will take place.

;Starting with createImageBitmap()

:*The createImageBitmap() method creates a bitmap from a given source, optionally cropped to contain only a portion of that source. The method exists on the global scope in both windows and workers. It accepts a variety of different image sources, and returns a Promise which resolves to an ImageBitmap.
:*This method is defined in the file ''components/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and rust code is implemented at ''components/script/dom/window.rs''.
:*The syntax of the method looks like
:::const imageBitmapPromise = createImageBitmap(image[, options]);
:::const imageBitmapPromise = createImageBitmap(image, sx, sy, sw, sh[, options]);
::where the parameters indicate:
:::'''image:''' an image source, which can be an img element, a SVG image element, a video element, a canvas element, a blob object, an ImageData object or another ImageBitmap object.
:::'''sx, sy, sw, sh:''' if given, source image is cropped to the given pixels.
:::'''options (Optional):''' the ImageBitmap object's bitmap data is modified according to options. Available options are:
:::*imageOrientation
:::*premultiplyAlpha
:::*colorSpaceConversion
:::*resizeWidth
:::*resizeHeight
:::*resizeQuality
:::: You can read more about these options [https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap here]
::The return value is a Promise that is resolved when a new ImageBitmap is created.
:* As a first step, we will be implementing the method to handle canvas elements. Subsequently, we will be enhancing the method to handle other image sources and the x/y/w/h parameters.

;Implementing close() method from previous work

:* close() is a method in the ImageBitmap interface. It is implemented in ''components/script/dom/imagebitmap.rs'' file.
:* This method disposes of all graphical resources associated with an ImageBitmap.

== '''Current Implementation''' ==

* Implemented createImageBitmap method for canvas image source(HTMLCanvasElement and OffscreenCanvas) using RUST programming language.
<pre>
// https://html.spec.whatwg.org/multipage/#dom-createimagebitmap
fn CreateImageBitmap(
&self,
image: ImageBitmapSource,
options: &ImageBitmapOptions,
) -> Rc<Promise> {
let global = self.global();
let in_realm_proof = AlreadyInRealm::assert(&global);
let p = Promise::new_in_current_realm(&global, InRealm::Already(&in_realm_proof));
if options.resizeWidth.unwrap() == 0 {
p.reject_error(Error::InvalidState)
}

if options.resizeHeight.unwrap() == 0 {
p.reject_error(Error::InvalidState)
}

let image_bitmap = ImageBitmap::new(&global, 0, 0).unwrap();

let promise = match image {
ImageBitmapSource::HTMLCanvasElement(ref canvas) => {
// https://html.spec.whatwg.org/multipage/#check-the-usability-of-the-image-argument
if !canvas.is_valid() {
p.reject_error(Error::InvalidState)
}

if let Some((data, size)) = canvas.fetch_all_data() {
let data = DomRefCell::new(
data.map(|data| data.to_vec())
.unwrap_or_else(|| vec![0; size.area() as usize * 4]),
);

image_bitmap.set_bitmap_data(data);
image_bitmap.set_origin_clean(canvas.origin_is_clean());
p.resolve_native(&(image_bitmap));
}
p
},
ImageBitmapSource::OffscreenCanvas(ref canvas) => {
// https://html.spec.whatwg.org/multipage/#check-the-usability-of-the-image-argument
if !canvas.is_valid() {
p.reject_error(Error::InvalidState)
}

if let Some((data, size)) = canvas.fetch_all_data() {
let data = DomRefCell::new(
data.map(|data| data.to_vec())
.unwrap_or_else(|| vec![0; size.area() as usize * 4]),
);

image_bitmap.set_bitmap_data(data);
image_bitmap.set_origin_clean(canvas.origin_is_clean());
p.resolve_native(&(image_bitmap));
}
p
},
_ => p,
};
promise
}
</pre>
* Tested the build using ‘mach’ commands

== '''Algorithm to design the createImageBitmap() method''' ==

On invoking the createImageBitmap(image, options) or the createImageBitmap(image sx, sy, sw, sh, options) the following in the sequence of actions

[[File:fig1.png|border]]

Switching on the "image" argument the following is the sequence of actions

=== If the image is an SVGImage===
[[File:fig2.png|border]]

=== If the image is a video===
[[File:ReFigure3.png|border]]

=== If the image is a canvas===
[[File:ReFigure4.png|border]]

=== If the image is an ImageBitmap===
[[File:ImageBitmap.jpg|border]]

=== If the image is an ImageData===
[[File:ImageData.jpg|border]]

=='''Test Plan'''==
The following are the respective steps in testing:
* Servo check should be successful.
The compiling time for servo build takes a lot of time. In order to make sure that our changes didn't break any of the existing features, we run
<pre>
For Linux or macOS:
./mach check
</pre>
<pre>
For Windows:
mach.bat check
</pre>

[[File:machCheck.png]]

* Servo building test should be successful.
The compiling time is based on the CPU clock speed and the OS of the system where the file is being run. For a 64-bit Linux OS, it takes from about 1 hour to 2 hours for the entire build. It takes 2.5 hours on Windows OS.
<pre>
For Linux or macOS:
./mach build --dev
</pre>
<pre>
For Windows:
mach.bat build --dev
</pre>
[[File:machBuild.png]]

* Check for the file tidiness (following standards of servo) using the command:
<pre>
For Linux or macOS:
./mach test-tidy
./mach fmt
</pre>
<pre>
For Windows:
mach.bat test-tidy
mach.bat fmt
</pre>

[[File:machTestTidy.png]]

*Servo automated Unit-testing should be successful.
Running the following commands will run all the unit-tests
<pre>
For Linux or macOS:
./mach test-unit
</pre>
<pre>
For Windows:
mach.bat test-unit
</pre>
Note: A log file can be maintained to make keep a check on the tests that are passing.
* Update the automated servo Web Platform tests(wpt):
For a DOM feature, extensive tests already exist under tests/wpt. Any change in DOM would require updating the expected results in the automated tests.

This first requires storing the log in raw format from a test run, for example by running
<pre>
./mach test-wpt --log-raw /path/for/storing/log/file/<filename>.log
</pre>

Once log is saved, then run to update test expectations
<pre>
./mach update-wpt /path/to/logfile/<filename>.log
</pre>

* Finally, to run the servo with a webpage (Google.com) :
<pre>
For Linux or macOS:
./mach run https://www.google.com
</pre>
<pre>
For Windows:
mach.bat run https://www.google.com
</pre>

[[File:machRun.png]]

== '''Team Details''' ==

Jayalakshmi Vishwanathan (jviswan@ncsu.edu)

Nita Radhakrishnan (nradhak2@ncsu.edu)

Ramya Ananth (rananth2@ncsu.edu)

Sandeep Kundala (skundal@ncsu.edu)

== '''Mentor Details''' ==
Jay Modi

== '''References''' ==

* [https://en.wikipedia.org/wiki/Servo_(software)| What is servo?]
* [https://en.wikipedia.org/wiki/Rust_(programming_language)| what is RUST programming?]

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-25T03:00:38Z

Rananth2: /* Current Implementation */

File:MachBuild.png

2020-04-25T00:09:11Z

Rananth2:

File:MachCheck.png

2020-04-25T00:08:17Z

Rananth2:

File:MachRun.png

2020-04-25T00:08:00Z

Rananth2:

File:MachTestTidy.png

2020-04-25T00:05:33Z

Rananth2:

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-14T03:49:32Z

Rananth2: /* Steps for implementation */

== '''Background Information''' ==
This project aims to contribute to Mozilla's experimental browser engine called Servo, which is implemented in a language called RUST(useful for implementing features that need concurrency and memory safety).

Many of the components of Servo are still under development and one such feature is the [https://www.techopedia.com/definition/792/bitmap-bmp| ImageBitmap].

Major browsers support the ImageBitmap standard which can be used to create images that are ready to be drawn efficiently to [https://en.wikipedia.org/wiki/Canvas_element| HTML canvas elements]. Servo is a new, experimental browser that supports these canvas APIs.

The goal of and motivation behind this project is to implement support for image bitmaps and improve our canvas automated test coverage as a result.

== '''About ImageBitMap and Motivation behind the project''' ==
We usually decode images for a use with canvas to allow users to customize an avatar, crop an image, or just zoom in on a picture. The problem with decoding images is that it can be CPU intensive, and that can sometimes mean jank or checkerboarding.

But the createImageBitmap() method allows us to decode the image in the background and get access to a new ImageBitmap primitive, which you can draw into a canvas in the same way you would an <img> element, another canvas, or a video.

The aim of this project is to develop the ImageBitmap for the servo environment.

This can be done in the steps mentioned in the following section.

== '''Steps for implementation''' ==

'''Initial Phase'''
* '''Step 1: '''Add a ImageBitmap WebIDL interface to ''components/script/dom/webidl''s and Rust implementation in components/script/dom/imagebitmap.rs
* '''Step 2: ''' Add the ''createImageBitmap'' method that takes no extra x/y/w/h parameters in ''component/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and implement the method in ''component/script/dom/window.rs'', handling the HTMLCanvasElement and OffscreenCanvas types from the possible image sources

'''Subsequent phase'''
* '''Step 1: '''Implement several remaining image source types (HTMLImageElement, ImageData, ImageBitmap)
* '''Step 2: '''Implement the ''createImageBitmap'' overload that accepts x/y/w/h parameters
* '''Step 3: '''Implement support for ImageBitmaps as canvas image sources in ''components/script/canvas_state.rs''
[[File:AllSteps.jpg]]

== '''Details about previous work on implementation''' ==
The steps that have been implemented so far in this project by the previous batch are:

'''Step 1:''' Added the ImageBitmap interface to ''components/script/dom/webidls'' that represents a bitmap image which can be drawn to a <canvas> without undue latency. The interface contains height and weight as its attributes which are read only unsigned long integers.
<pre>
//[Exposed=(Window,Worker), Serializable, Transferable]
[Exposed=(Window,Worker)]
interface ImageBitmap {
readonly attribute unsigned long width;
readonly attribute unsigned long height;
//void close();
};

typedef (CanvasImageSource or
Blob or
ImageData) ImageBitmapSource;

enum ImageOrientation { "none", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
ImageOrientation imageOrientation = "none";
PremultiplyAlpha premultiplyAlpha = "default";
ColorSpaceConversion colorSpaceConversion = "default";
[EnforceRange] unsigned long resizeWidth;
[EnforceRange] unsigned long resizeHeight;
ResizeQuality resizeQuality = "low";
};
</pre>

The ImageBitmap webidl also defines a dictionary for various ImageBitmap Options that can be used to modify the ImageBitmap object.

'''Step 2:''' Implemented the rust code for the webidl interface at ''components/script/dom/imagebitmap.rs''. For more details on the code [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Spring_2020_-_M2000._Implement_ImageBitMap_web_API#Implementation visit]
<pre>
use crate::dom::bindings::cell::DomRefCell;

use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;

use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use dom_struct::dom_struct;

use std::vec::Vec;

#[dom_struct]
pub struct ImageBitmap {
reflector_: Reflector,
width: u32,
height: u32,
bitmap_data: DomRefCell<Vec<u8>>,
}

impl ImageBitmap {
fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
width: width_arg,
height: height_arg,
bitmap_data: DomRefCell::new(vec![]),
}
}

#[allow(dead_code)]
pub fn new(global: &GlobalScope, width: u32, height: u32) -> Fallible<DomRoot<ImageBitmap>> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));

Ok(reflect_dom_object(imagebitmap, global))
}
}
</pre>

The code also implements the getter methods for height and width attribute of an ImageBitmap object.
<pre>
impl ImageBitmapMethods for ImageBitmap {
// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height
fn Height(&self) -> u32 {
//to do: add a condition for checking detached internal slot
//and return 0 if set to true
self.height
}

// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width
fn Width(&self) -> u32 {
//to do: add a condition to check detached internal slot
////and return 0 if set to true
self.width
}
}
</pre>

== '''Details about current work on implementation''' ==
Among the remaining steps in the initial and subsequent phases, the focus will be on step 2 of initial phase and once there is progress made on this step, implementation of the subsequent steps will take place.

;Starting with createImageBitmap()

:*The createImageBitmap() method creates a bitmap from a given source, optionally cropped to contain only a portion of that source. The method exists on the global scope in both windows and workers. It accepts a variety of different image sources, and returns a Promise which resolves to an ImageBitmap.
:*This method is defined in the file ''components/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and rust code is implemented at ''components/script/dom/window.rs''.
:*The syntax of the method looks like
:::const imageBitmapPromise = createImageBitmap(image[, options]);
:::const imageBitmapPromise = createImageBitmap(image, sx, sy, sw, sh[, options]);
::where the parameters indicate:
:::'''image:''' an image source, which can be an img element, a SVG image element, a video element, a canvas element, a blob object, an ImageData object or another ImageBitmap object.
:::'''sx, sy, sw, sh:''' if given, source image is cropped to the given pixels.
:::'''options (Optional):''' the ImageBitmap object's bitmap data is modified according to options. Available options are:
:::*imageOrientation
:::*premultiplyAlpha
:::*colorSpaceConversion
:::*resizeWidth
:::*resizeHeight
:::*resizeQuality
:::: You can read more about these options [https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap here]
::The return value is a Promise that is resolved when a new ImageBitmap is created.
:* As a first step, we will be implementing the method to handle canvas elements. Subsequently, we will be enhancing the method to handle other image sources and the x/y/w/h parameters.

;Implementing close() method from previous work

:* close() is a method in the ImageBitmap interface. It is implemented in ''components/script/dom/imagebitmap.rs'' file.
:* This method disposes of all graphical resources associated with an ImageBitmap.

== '''Algorithm to design the createImageBitmap() method''' ==

On invoking the createImageBitmap(image, options) or the createImageBitmap(image sx, sy, sw, sh, options) the following in the sequence of actions

[[File:fig1.png|border]]

Switching on the "image" argument the following is the sequence of actions

=== If the image is an SVGImage===
[[File:fig2.png|border]]

=== If the image is a video===
[[File:ReFigure3.png|border]]

=== If the image is a canvas===
[[File:ReFigure4.png|border]]

=== If the image is an ImageBitmap===
[[File:ImageBitmap.jpg|border]]

=== If the image is an ImageData===
[[File:ImageData.jpg|border]]

=='''Test Plan'''==
The following are the respective steps in testing:
* Servo building test should be successful.
The compiling time is based on the CPU clock speed and the OS of the system where the file is being run. For a 64-bit Linux OS, it takes from about 1 hour to 2 hours for the entire build. It takes 2.5 hours on Windows OS.
* Check for the file tidiness (following standards of servo) using the command:
<pre>
For Linux or macOS:
./mach test-tidy
./mach fmt
</pre>
<pre>
For Windows:
mach.bat test-tidy
mach.bat fmt
</pre>
*Servo automated Unit-testing should be successful.
Running the following commands will run all the unit-tests
<pre>
For Linux or macOS:
./mach test-unit
</pre>
<pre>
For Windows:
mach.bat test-unit
</pre>
Note: A log file can be maintained to make keep a check on the tests that are passing.
* Update the automated servo Web Platform tests(wpt):
For a DOM feature, extensive tests already exist under tests/wpt. Any change in DOM would require updating the expected results in the automated tests.

This first requires storing the log in raw format from a test run, for example by running
<pre>
./mach test-wpt --log-raw /path/for/storing/log/file/<filename>.log
</pre>

Once log is saved, then run to update test expectations
<pre>
./mach update-wpt /path/to/logfile/<filename>.log
</pre>

== '''Team Details''' ==

Jayalakshmi Vishwanathan (jviswan@ncsu.edu)

Nita Radhakrishnan (nradhak2@ncsu.edu)

Ramya Ananth (rananth2@ncsu.edu)

Sandeep Kundala (skundal@ncsu.edu)

== '''Mentor Details''' ==
Jay Modi

== '''References''' ==

* [https://en.wikipedia.org/wiki/Servo_(software)| What is servo?]
* [https://en.wikipedia.org/wiki/Rust_(programming_language)| what is RUST programming?]

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-14T03:49:21Z

Rananth2: /* Steps for implementation */

== '''Background Information''' ==
This project aims to contribute to Mozilla's experimental browser engine called Servo, which is implemented in a language called RUST(useful for implementing features that need concurrency and memory safety).

Many of the components of Servo are still under development and one such feature is the [https://www.techopedia.com/definition/792/bitmap-bmp| ImageBitmap].

Major browsers support the ImageBitmap standard which can be used to create images that are ready to be drawn efficiently to [https://en.wikipedia.org/wiki/Canvas_element| HTML canvas elements]. Servo is a new, experimental browser that supports these canvas APIs.

The goal of and motivation behind this project is to implement support for image bitmaps and improve our canvas automated test coverage as a result.

== '''About ImageBitMap and Motivation behind the project''' ==
We usually decode images for a use with canvas to allow users to customize an avatar, crop an image, or just zoom in on a picture. The problem with decoding images is that it can be CPU intensive, and that can sometimes mean jank or checkerboarding.

But the createImageBitmap() method allows us to decode the image in the background and get access to a new ImageBitmap primitive, which you can draw into a canvas in the same way you would an <img> element, another canvas, or a video.

The aim of this project is to develop the ImageBitmap for the servo environment.

This can be done in the steps mentioned in the following section.

== '''Steps for implementation''' ==

'''Initial Phase'''
* '''Step 1: '''Add a ImageBitmap WebIDL interface to ''components/script/dom/webidl''s and Rust implementation in components/script/dom/imagebitmap.rs
* '''Step 2: ''' Add the ''createImageBitmap'' method that takes no extra x/y/w/h parameters in ''component/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and implement the method in ''component/script/dom/window.rs'', handling the HTMLCanvasElement and OffscreenCanvas types from the possible image sources

'''Subsequent phase'''
* '''Step 1: '''Implement several remaining image source types (HTMLImageElement, ImageData, ImageBitmap)
* '''Step 2: '''Implement the ''createImageBitmap'' overload that accepts x/y/w/h parameters
* '''Step 3: '''Implement support for ImageBitmaps as canvas image sources in ''components/script/canvas_state.rs''
[[File:AllSteps.jpg|600px]]

== '''Details about previous work on implementation''' ==
The steps that have been implemented so far in this project by the previous batch are:

'''Step 1:''' Added the ImageBitmap interface to ''components/script/dom/webidls'' that represents a bitmap image which can be drawn to a <canvas> without undue latency. The interface contains height and weight as its attributes which are read only unsigned long integers.
<pre>
//[Exposed=(Window,Worker), Serializable, Transferable]
[Exposed=(Window,Worker)]
interface ImageBitmap {
readonly attribute unsigned long width;
readonly attribute unsigned long height;
//void close();
};

typedef (CanvasImageSource or
Blob or
ImageData) ImageBitmapSource;

enum ImageOrientation { "none", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
ImageOrientation imageOrientation = "none";
PremultiplyAlpha premultiplyAlpha = "default";
ColorSpaceConversion colorSpaceConversion = "default";
[EnforceRange] unsigned long resizeWidth;
[EnforceRange] unsigned long resizeHeight;
ResizeQuality resizeQuality = "low";
};
</pre>

The ImageBitmap webidl also defines a dictionary for various ImageBitmap Options that can be used to modify the ImageBitmap object.

'''Step 2:''' Implemented the rust code for the webidl interface at ''components/script/dom/imagebitmap.rs''. For more details on the code [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Spring_2020_-_M2000._Implement_ImageBitMap_web_API#Implementation visit]
<pre>
use crate::dom::bindings::cell::DomRefCell;

use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;

use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use dom_struct::dom_struct;

use std::vec::Vec;

#[dom_struct]
pub struct ImageBitmap {
reflector_: Reflector,
width: u32,
height: u32,
bitmap_data: DomRefCell<Vec<u8>>,
}

impl ImageBitmap {
fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
width: width_arg,
height: height_arg,
bitmap_data: DomRefCell::new(vec![]),
}
}

#[allow(dead_code)]
pub fn new(global: &GlobalScope, width: u32, height: u32) -> Fallible<DomRoot<ImageBitmap>> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));

Ok(reflect_dom_object(imagebitmap, global))
}
}
</pre>

The code also implements the getter methods for height and width attribute of an ImageBitmap object.
<pre>
impl ImageBitmapMethods for ImageBitmap {
// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height
fn Height(&self) -> u32 {
//to do: add a condition for checking detached internal slot
//and return 0 if set to true
self.height
}

// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width
fn Width(&self) -> u32 {
//to do: add a condition to check detached internal slot
////and return 0 if set to true
self.width
}
}
</pre>

== '''Details about current work on implementation''' ==
Among the remaining steps in the initial and subsequent phases, the focus will be on step 2 of initial phase and once there is progress made on this step, implementation of the subsequent steps will take place.

;Starting with createImageBitmap()

:*The createImageBitmap() method creates a bitmap from a given source, optionally cropped to contain only a portion of that source. The method exists on the global scope in both windows and workers. It accepts a variety of different image sources, and returns a Promise which resolves to an ImageBitmap.
:*This method is defined in the file ''components/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and rust code is implemented at ''components/script/dom/window.rs''.
:*The syntax of the method looks like
:::const imageBitmapPromise = createImageBitmap(image[, options]);
:::const imageBitmapPromise = createImageBitmap(image, sx, sy, sw, sh[, options]);
::where the parameters indicate:
:::'''image:''' an image source, which can be an img element, a SVG image element, a video element, a canvas element, a blob object, an ImageData object or another ImageBitmap object.
:::'''sx, sy, sw, sh:''' if given, source image is cropped to the given pixels.
:::'''options (Optional):''' the ImageBitmap object's bitmap data is modified according to options. Available options are:
:::*imageOrientation
:::*premultiplyAlpha
:::*colorSpaceConversion
:::*resizeWidth
:::*resizeHeight
:::*resizeQuality
:::: You can read more about these options [https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap here]
::The return value is a Promise that is resolved when a new ImageBitmap is created.
:* As a first step, we will be implementing the method to handle canvas elements. Subsequently, we will be enhancing the method to handle other image sources and the x/y/w/h parameters.

;Implementing close() method from previous work

:* close() is a method in the ImageBitmap interface. It is implemented in ''components/script/dom/imagebitmap.rs'' file.
:* This method disposes of all graphical resources associated with an ImageBitmap.

== '''Algorithm to design the createImageBitmap() method''' ==

On invoking the createImageBitmap(image, options) or the createImageBitmap(image sx, sy, sw, sh, options) the following in the sequence of actions

[[File:fig1.png|border]]

Switching on the "image" argument the following is the sequence of actions

=== If the image is an SVGImage===
[[File:fig2.png|border]]

=== If the image is a video===
[[File:ReFigure3.png|border]]

=== If the image is a canvas===
[[File:ReFigure4.png|border]]

=== If the image is an ImageBitmap===
[[File:ImageBitmap.jpg|border]]

=== If the image is an ImageData===
[[File:ImageData.jpg|border]]

=='''Test Plan'''==
The following are the respective steps in testing:
* Servo building test should be successful.
The compiling time is based on the CPU clock speed and the OS of the system where the file is being run. For a 64-bit Linux OS, it takes from about 1 hour to 2 hours for the entire build. It takes 2.5 hours on Windows OS.
* Check for the file tidiness (following standards of servo) using the command:
<pre>
For Linux or macOS:
./mach test-tidy
./mach fmt
</pre>
<pre>
For Windows:
mach.bat test-tidy
mach.bat fmt
</pre>
*Servo automated Unit-testing should be successful.
Running the following commands will run all the unit-tests
<pre>
For Linux or macOS:
./mach test-unit
</pre>
<pre>
For Windows:
mach.bat test-unit
</pre>
Note: A log file can be maintained to make keep a check on the tests that are passing.
* Update the automated servo Web Platform tests(wpt):
For a DOM feature, extensive tests already exist under tests/wpt. Any change in DOM would require updating the expected results in the automated tests.

This first requires storing the log in raw format from a test run, for example by running
<pre>
./mach test-wpt --log-raw /path/for/storing/log/file/<filename>.log
</pre>

Once log is saved, then run to update test expectations
<pre>
./mach update-wpt /path/to/logfile/<filename>.log
</pre>

== '''Team Details''' ==

Jayalakshmi Vishwanathan (jviswan@ncsu.edu)

Nita Radhakrishnan (nradhak2@ncsu.edu)

Ramya Ananth (rananth2@ncsu.edu)

Sandeep Kundala (skundal@ncsu.edu)

== '''Mentor Details''' ==
Jay Modi

== '''References''' ==

* [https://en.wikipedia.org/wiki/Servo_(software)| What is servo?]
* [https://en.wikipedia.org/wiki/Rust_(programming_language)| what is RUST programming?]

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-14T03:47:35Z

Rananth2: /* Test Plan */

== '''Background Information''' ==
This project aims to contribute to Mozilla's experimental browser engine called Servo, which is implemented in a language called RUST(useful for implementing features that need concurrency and memory safety).

Many of the components of Servo are still under development and one such feature is the [https://www.techopedia.com/definition/792/bitmap-bmp| ImageBitmap].

Major browsers support the ImageBitmap standard which can be used to create images that are ready to be drawn efficiently to [https://en.wikipedia.org/wiki/Canvas_element| HTML canvas elements]. Servo is a new, experimental browser that supports these canvas APIs.

The goal of and motivation behind this project is to implement support for image bitmaps and improve our canvas automated test coverage as a result.

== '''About ImageBitMap and Motivation behind the project''' ==
We usually decode images for a use with canvas to allow users to customize an avatar, crop an image, or just zoom in on a picture. The problem with decoding images is that it can be CPU intensive, and that can sometimes mean jank or checkerboarding.

But the createImageBitmap() method allows us to decode the image in the background and get access to a new ImageBitmap primitive, which you can draw into a canvas in the same way you would an <img> element, another canvas, or a video.

The aim of this project is to develop the ImageBitmap for the servo environment.

This can be done in the steps mentioned in the following section.

== '''Steps for implementation''' ==

'''Initial Phase'''
* '''Step 1: '''Add a ImageBitmap WebIDL interface to ''components/script/dom/webidl''s and Rust implementation in components/script/dom/imagebitmap.rs
* '''Step 2: ''' Add the ''createImageBitmap'' method that takes no extra x/y/w/h parameters in ''component/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and implement the method in ''component/script/dom/window.rs'', handling the HTMLCanvasElement and OffscreenCanvas types from the possible image sources

'''Subsequent phase'''
* '''Step 1: '''Implement several remaining image source types (HTMLImageElement, ImageData, ImageBitmap)
* '''Step 2: '''Implement the ''createImageBitmap'' overload that accepts x/y/w/h parameters
* '''Step 3: '''Implement support for ImageBitmaps as canvas image sources in ''components/script/canvas_state.rs''
[[File:AllSteps.jpg]]

== '''Details about previous work on implementation''' ==
The steps that have been implemented so far in this project by the previous batch are:

'''Step 1:''' Added the ImageBitmap interface to ''components/script/dom/webidls'' that represents a bitmap image which can be drawn to a <canvas> without undue latency. The interface contains height and weight as its attributes which are read only unsigned long integers.
<pre>
//[Exposed=(Window,Worker), Serializable, Transferable]
[Exposed=(Window,Worker)]
interface ImageBitmap {
readonly attribute unsigned long width;
readonly attribute unsigned long height;
//void close();
};

typedef (CanvasImageSource or
Blob or
ImageData) ImageBitmapSource;

enum ImageOrientation { "none", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
ImageOrientation imageOrientation = "none";
PremultiplyAlpha premultiplyAlpha = "default";
ColorSpaceConversion colorSpaceConversion = "default";
[EnforceRange] unsigned long resizeWidth;
[EnforceRange] unsigned long resizeHeight;
ResizeQuality resizeQuality = "low";
};
</pre>

The ImageBitmap webidl also defines a dictionary for various ImageBitmap Options that can be used to modify the ImageBitmap object.

'''Step 2:''' Implemented the rust code for the webidl interface at ''components/script/dom/imagebitmap.rs''. For more details on the code [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Spring_2020_-_M2000._Implement_ImageBitMap_web_API#Implementation visit]
<pre>
use crate::dom::bindings::cell::DomRefCell;

use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;

use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use dom_struct::dom_struct;

use std::vec::Vec;

#[dom_struct]
pub struct ImageBitmap {
reflector_: Reflector,
width: u32,
height: u32,
bitmap_data: DomRefCell<Vec<u8>>,
}

impl ImageBitmap {
fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
width: width_arg,
height: height_arg,
bitmap_data: DomRefCell::new(vec![]),
}
}

#[allow(dead_code)]
pub fn new(global: &GlobalScope, width: u32, height: u32) -> Fallible<DomRoot<ImageBitmap>> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));

Ok(reflect_dom_object(imagebitmap, global))
}
}
</pre>

The code also implements the getter methods for height and width attribute of an ImageBitmap object.
<pre>
impl ImageBitmapMethods for ImageBitmap {
// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height
fn Height(&self) -> u32 {
//to do: add a condition for checking detached internal slot
//and return 0 if set to true
self.height
}

// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width
fn Width(&self) -> u32 {
//to do: add a condition to check detached internal slot
////and return 0 if set to true
self.width
}
}
</pre>

== '''Details about current work on implementation''' ==
Among the remaining steps in the initial and subsequent phases, the focus will be on step 2 of initial phase and once there is progress made on this step, implementation of the subsequent steps will take place.

;Starting with createImageBitmap()

:*The createImageBitmap() method creates a bitmap from a given source, optionally cropped to contain only a portion of that source. The method exists on the global scope in both windows and workers. It accepts a variety of different image sources, and returns a Promise which resolves to an ImageBitmap.
:*This method is defined in the file ''components/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and rust code is implemented at ''components/script/dom/window.rs''.
:*The syntax of the method looks like
:::const imageBitmapPromise = createImageBitmap(image[, options]);
:::const imageBitmapPromise = createImageBitmap(image, sx, sy, sw, sh[, options]);
::where the parameters indicate:
:::'''image:''' an image source, which can be an img element, a SVG image element, a video element, a canvas element, a blob object, an ImageData object or another ImageBitmap object.
:::'''sx, sy, sw, sh:''' if given, source image is cropped to the given pixels.
:::'''options (Optional):''' the ImageBitmap object's bitmap data is modified according to options. Available options are:
:::*imageOrientation
:::*premultiplyAlpha
:::*colorSpaceConversion
:::*resizeWidth
:::*resizeHeight
:::*resizeQuality
:::: You can read more about these options [https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap here]
::The return value is a Promise that is resolved when a new ImageBitmap is created.
:* As a first step, we will be implementing the method to handle canvas elements. Subsequently, we will be enhancing the method to handle other image sources and the x/y/w/h parameters.

;Implementing close() method from previous work

:* close() is a method in the ImageBitmap interface. It is implemented in ''components/script/dom/imagebitmap.rs'' file.
:* This method disposes of all graphical resources associated with an ImageBitmap.

== '''Algorithm to design the createImageBitmap() method''' ==

On invoking the createImageBitmap(image, options) or the createImageBitmap(image sx, sy, sw, sh, options) the following in the sequence of actions

[[File:fig1.png|border]]

Switching on the "image" argument the following is the sequence of actions

=== If the image is an SVGImage===
[[File:fig2.png|border]]

=== If the image is a video===
[[File:ReFigure3.png|border]]

=== If the image is a canvas===
[[File:ReFigure4.png|border]]

=== If the image is an ImageBitmap===
[[File:ImageBitmap.jpg|border]]

=== If the image is an ImageData===
[[File:ImageData.jpg|border]]

=='''Test Plan'''==
The following are the respective steps in testing:
* Servo building test should be successful.
The compiling time is based on the CPU clock speed and the OS of the system where the file is being run. For a 64-bit Linux OS, it takes from about 1 hour to 2 hours for the entire build. It takes 2.5 hours on Windows OS.
* Check for the file tidiness (following standards of servo) using the command:
<pre>
For Linux or macOS:
./mach test-tidy
./mach fmt
</pre>
<pre>
For Windows:
mach.bat test-tidy
mach.bat fmt
</pre>
*Servo automated Unit-testing should be successful.
Running the following commands will run all the unit-tests
<pre>
For Linux or macOS:
./mach test-unit
</pre>
<pre>
For Windows:
mach.bat test-unit
</pre>
Note: A log file can be maintained to make keep a check on the tests that are passing.
* Update the automated servo Web Platform tests(wpt):
For a DOM feature, extensive tests already exist under tests/wpt. Any change in DOM would require updating the expected results in the automated tests.

This first requires storing the log in raw format from a test run, for example by running
<pre>
./mach test-wpt --log-raw /path/for/storing/log/file/<filename>.log
</pre>

Once log is saved, then run to update test expectations
<pre>
./mach update-wpt /path/to/logfile/<filename>.log
</pre>

== '''Team Details''' ==

Jayalakshmi Vishwanathan (jviswan@ncsu.edu)

Nita Radhakrishnan (nradhak2@ncsu.edu)

Ramya Ananth (rananth2@ncsu.edu)

Sandeep Kundala (skundal@ncsu.edu)

== '''Mentor Details''' ==
Jay Modi

== '''References''' ==

* [https://en.wikipedia.org/wiki/Servo_(software)| What is servo?]
* [https://en.wikipedia.org/wiki/Rust_(programming_language)| what is RUST programming?]

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-14T03:47:13Z

Rananth2: /* Team Details */

== '''Background Information''' ==
This project aims to contribute to Mozilla's experimental browser engine called Servo, which is implemented in a language called RUST(useful for implementing features that need concurrency and memory safety).

Many of the components of Servo are still under development and one such feature is the [https://www.techopedia.com/definition/792/bitmap-bmp| ImageBitmap].

Major browsers support the ImageBitmap standard which can be used to create images that are ready to be drawn efficiently to [https://en.wikipedia.org/wiki/Canvas_element| HTML canvas elements]. Servo is a new, experimental browser that supports these canvas APIs.

The goal of and motivation behind this project is to implement support for image bitmaps and improve our canvas automated test coverage as a result.

== '''About ImageBitMap and Motivation behind the project''' ==
We usually decode images for a use with canvas to allow users to customize an avatar, crop an image, or just zoom in on a picture. The problem with decoding images is that it can be CPU intensive, and that can sometimes mean jank or checkerboarding.

But the createImageBitmap() method allows us to decode the image in the background and get access to a new ImageBitmap primitive, which you can draw into a canvas in the same way you would an <img> element, another canvas, or a video.

The aim of this project is to develop the ImageBitmap for the servo environment.

This can be done in the steps mentioned in the following section.

== '''Steps for implementation''' ==

'''Initial Phase'''
* '''Step 1: '''Add a ImageBitmap WebIDL interface to ''components/script/dom/webidl''s and Rust implementation in components/script/dom/imagebitmap.rs
* '''Step 2: ''' Add the ''createImageBitmap'' method that takes no extra x/y/w/h parameters in ''component/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and implement the method in ''component/script/dom/window.rs'', handling the HTMLCanvasElement and OffscreenCanvas types from the possible image sources

'''Subsequent phase'''
* '''Step 1: '''Implement several remaining image source types (HTMLImageElement, ImageData, ImageBitmap)
* '''Step 2: '''Implement the ''createImageBitmap'' overload that accepts x/y/w/h parameters
* '''Step 3: '''Implement support for ImageBitmaps as canvas image sources in ''components/script/canvas_state.rs''
[[File:AllSteps.jpg]]

== '''Details about previous work on implementation''' ==
The steps that have been implemented so far in this project by the previous batch are:

'''Step 1:''' Added the ImageBitmap interface to ''components/script/dom/webidls'' that represents a bitmap image which can be drawn to a <canvas> without undue latency. The interface contains height and weight as its attributes which are read only unsigned long integers.
<pre>
//[Exposed=(Window,Worker), Serializable, Transferable]
[Exposed=(Window,Worker)]
interface ImageBitmap {
readonly attribute unsigned long width;
readonly attribute unsigned long height;
//void close();
};

typedef (CanvasImageSource or
Blob or
ImageData) ImageBitmapSource;

enum ImageOrientation { "none", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
ImageOrientation imageOrientation = "none";
PremultiplyAlpha premultiplyAlpha = "default";
ColorSpaceConversion colorSpaceConversion = "default";
[EnforceRange] unsigned long resizeWidth;
[EnforceRange] unsigned long resizeHeight;
ResizeQuality resizeQuality = "low";
};
</pre>

The ImageBitmap webidl also defines a dictionary for various ImageBitmap Options that can be used to modify the ImageBitmap object.

'''Step 2:''' Implemented the rust code for the webidl interface at ''components/script/dom/imagebitmap.rs''. For more details on the code [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Spring_2020_-_M2000._Implement_ImageBitMap_web_API#Implementation visit]
<pre>
use crate::dom::bindings::cell::DomRefCell;

use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;

use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use dom_struct::dom_struct;

use std::vec::Vec;

#[dom_struct]
pub struct ImageBitmap {
reflector_: Reflector,
width: u32,
height: u32,
bitmap_data: DomRefCell<Vec<u8>>,
}

impl ImageBitmap {
fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
width: width_arg,
height: height_arg,
bitmap_data: DomRefCell::new(vec![]),
}
}

#[allow(dead_code)]
pub fn new(global: &GlobalScope, width: u32, height: u32) -> Fallible<DomRoot<ImageBitmap>> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));

Ok(reflect_dom_object(imagebitmap, global))
}
}
</pre>

The code also implements the getter methods for height and width attribute of an ImageBitmap object.
<pre>
impl ImageBitmapMethods for ImageBitmap {
// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height
fn Height(&self) -> u32 {
//to do: add a condition for checking detached internal slot
//and return 0 if set to true
self.height
}

// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width
fn Width(&self) -> u32 {
//to do: add a condition to check detached internal slot
////and return 0 if set to true
self.width
}
}
</pre>

== '''Details about current work on implementation''' ==
Among the remaining steps in the initial and subsequent phases, the focus will be on step 2 of initial phase and once there is progress made on this step, implementation of the subsequent steps will take place.

;Starting with createImageBitmap()

:*The createImageBitmap() method creates a bitmap from a given source, optionally cropped to contain only a portion of that source. The method exists on the global scope in both windows and workers. It accepts a variety of different image sources, and returns a Promise which resolves to an ImageBitmap.
:*This method is defined in the file ''components/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and rust code is implemented at ''components/script/dom/window.rs''.
:*The syntax of the method looks like
:::const imageBitmapPromise = createImageBitmap(image[, options]);
:::const imageBitmapPromise = createImageBitmap(image, sx, sy, sw, sh[, options]);
::where the parameters indicate:
:::'''image:''' an image source, which can be an img element, a SVG image element, a video element, a canvas element, a blob object, an ImageData object or another ImageBitmap object.
:::'''sx, sy, sw, sh:''' if given, source image is cropped to the given pixels.
:::'''options (Optional):''' the ImageBitmap object's bitmap data is modified according to options. Available options are:
:::*imageOrientation
:::*premultiplyAlpha
:::*colorSpaceConversion
:::*resizeWidth
:::*resizeHeight
:::*resizeQuality
:::: You can read more about these options [https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap here]
::The return value is a Promise that is resolved when a new ImageBitmap is created.
:* As a first step, we will be implementing the method to handle canvas elements. Subsequently, we will be enhancing the method to handle other image sources and the x/y/w/h parameters.

;Implementing close() method from previous work

:* close() is a method in the ImageBitmap interface. It is implemented in ''components/script/dom/imagebitmap.rs'' file.
:* This method disposes of all graphical resources associated with an ImageBitmap.

== '''Algorithm to design the createImageBitmap() method''' ==

On invoking the createImageBitmap(image, options) or the createImageBitmap(image sx, sy, sw, sh, options) the following in the sequence of actions

[[File:fig1.png|border]]

Switching on the "image" argument the following is the sequence of actions

=== If the image is an SVGImage===
[[File:fig2.png|border]]

=== If the image is a video===
[[File:ReFigure3.png|border]]

=== If the image is a canvas===
[[File:ReFigure4.png|border]]

=== If the image is an ImageBitmap===
[[File:ImageBitmap.jpg|border]]

=== If the image is an ImageData===
[[File:ImageData.jpg|border]]

=='''Test Plan'''==
The following are the respective steps in testing:
* Servo building test should be successful.
The compiling time is based on the CPU clock speed and the OS of the system where the file is being run. For a 64-bit Linux OS, it takes from about 1 hour to 2 hours for the entire build. It takes 2.5 hours on Windows OS.
* Check for the file tidiness (following standards of servo) using the command:
<pre>
For Linux or macOS:
./mach test-tidy
./mach fmt
</pre>
<pre>
For Windows:
mach.bat test-tidy
mach.bat fmt
</pre>
*Servo automated Unit-testing should be successful.
Running the following commands will run all the unit-tests
<pre>
For Linux or macOS:
./mach test-unit
</pre>
<pre>
For Windows:
mach.bat test-unit
</pre>
Note: A log file can be maintained to make keep a check on the tests that are passing.
* Update the automated servo Web Platform tests(wpt):
For a DOM feature, extensive tests already exist under tests/wpt. Any change in DOM would require updating the expected results in the automated tests.

This first requires storing the log in raw format from a test run, for example by running
<pre>
./mach test-wpt --log-raw /path/for/storing/log/file/<filename>.log
</pre>

Once log is saved, then run to update test expectations
<pre>
./mach update-wpt /path/to/logfile/<filename>.log
</pre>
* 

== '''Team Details''' ==

Jayalakshmi Vishwanathan (jviswan@ncsu.edu)

Nita Radhakrishnan (nradhak2@ncsu.edu)

Ramya Ananth (rananth2@ncsu.edu)

Sandeep Kundala (skundal@ncsu.edu)

== '''Mentor Details''' ==
Jay Modi

== '''References''' ==

* [https://en.wikipedia.org/wiki/Servo_(software)| What is servo?]
* [https://en.wikipedia.org/wiki/Rust_(programming_language)| what is RUST programming?]

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-14T03:46:38Z

Rananth2: /* Test Plan */

== '''Background Information''' ==
This project aims to contribute to Mozilla's experimental browser engine called Servo, which is implemented in a language called RUST(useful for implementing features that need concurrency and memory safety).

Many of the components of Servo are still under development and one such feature is the [https://www.techopedia.com/definition/792/bitmap-bmp| ImageBitmap].

Major browsers support the ImageBitmap standard which can be used to create images that are ready to be drawn efficiently to [https://en.wikipedia.org/wiki/Canvas_element| HTML canvas elements]. Servo is a new, experimental browser that supports these canvas APIs.

The goal of and motivation behind this project is to implement support for image bitmaps and improve our canvas automated test coverage as a result.

== '''About ImageBitMap and Motivation behind the project''' ==
We usually decode images for a use with canvas to allow users to customize an avatar, crop an image, or just zoom in on a picture. The problem with decoding images is that it can be CPU intensive, and that can sometimes mean jank or checkerboarding.

But the createImageBitmap() method allows us to decode the image in the background and get access to a new ImageBitmap primitive, which you can draw into a canvas in the same way you would an <img> element, another canvas, or a video.

The aim of this project is to develop the ImageBitmap for the servo environment.

This can be done in the steps mentioned in the following section.

== '''Steps for implementation''' ==

'''Initial Phase'''
* '''Step 1: '''Add a ImageBitmap WebIDL interface to ''components/script/dom/webidl''s and Rust implementation in components/script/dom/imagebitmap.rs
* '''Step 2: ''' Add the ''createImageBitmap'' method that takes no extra x/y/w/h parameters in ''component/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and implement the method in ''component/script/dom/window.rs'', handling the HTMLCanvasElement and OffscreenCanvas types from the possible image sources

'''Subsequent phase'''
* '''Step 1: '''Implement several remaining image source types (HTMLImageElement, ImageData, ImageBitmap)
* '''Step 2: '''Implement the ''createImageBitmap'' overload that accepts x/y/w/h parameters
* '''Step 3: '''Implement support for ImageBitmaps as canvas image sources in ''components/script/canvas_state.rs''
[[File:AllSteps.jpg]]

== '''Details about previous work on implementation''' ==
The steps that have been implemented so far in this project by the previous batch are:

'''Step 1:''' Added the ImageBitmap interface to ''components/script/dom/webidls'' that represents a bitmap image which can be drawn to a <canvas> without undue latency. The interface contains height and weight as its attributes which are read only unsigned long integers.
<pre>
//[Exposed=(Window,Worker), Serializable, Transferable]
[Exposed=(Window,Worker)]
interface ImageBitmap {
readonly attribute unsigned long width;
readonly attribute unsigned long height;
//void close();
};

typedef (CanvasImageSource or
Blob or
ImageData) ImageBitmapSource;

enum ImageOrientation { "none", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
ImageOrientation imageOrientation = "none";
PremultiplyAlpha premultiplyAlpha = "default";
ColorSpaceConversion colorSpaceConversion = "default";
[EnforceRange] unsigned long resizeWidth;
[EnforceRange] unsigned long resizeHeight;
ResizeQuality resizeQuality = "low";
};
</pre>

The ImageBitmap webidl also defines a dictionary for various ImageBitmap Options that can be used to modify the ImageBitmap object.

'''Step 2:''' Implemented the rust code for the webidl interface at ''components/script/dom/imagebitmap.rs''. For more details on the code [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Spring_2020_-_M2000._Implement_ImageBitMap_web_API#Implementation visit]
<pre>
use crate::dom::bindings::cell::DomRefCell;

use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;

use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use dom_struct::dom_struct;

use std::vec::Vec;

#[dom_struct]
pub struct ImageBitmap {
reflector_: Reflector,
width: u32,
height: u32,
bitmap_data: DomRefCell<Vec<u8>>,
}

impl ImageBitmap {
fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
width: width_arg,
height: height_arg,
bitmap_data: DomRefCell::new(vec![]),
}
}

#[allow(dead_code)]
pub fn new(global: &GlobalScope, width: u32, height: u32) -> Fallible<DomRoot<ImageBitmap>> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));

Ok(reflect_dom_object(imagebitmap, global))
}
}
</pre>

The code also implements the getter methods for height and width attribute of an ImageBitmap object.
<pre>
impl ImageBitmapMethods for ImageBitmap {
// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height
fn Height(&self) -> u32 {
//to do: add a condition for checking detached internal slot
//and return 0 if set to true
self.height
}

// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width
fn Width(&self) -> u32 {
//to do: add a condition to check detached internal slot
////and return 0 if set to true
self.width
}
}
</pre>

== '''Details about current work on implementation''' ==
Among the remaining steps in the initial and subsequent phases, the focus will be on step 2 of initial phase and once there is progress made on this step, implementation of the subsequent steps will take place.

;Starting with createImageBitmap()

:*The createImageBitmap() method creates a bitmap from a given source, optionally cropped to contain only a portion of that source. The method exists on the global scope in both windows and workers. It accepts a variety of different image sources, and returns a Promise which resolves to an ImageBitmap.
:*This method is defined in the file ''components/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and rust code is implemented at ''components/script/dom/window.rs''.
:*The syntax of the method looks like
:::const imageBitmapPromise = createImageBitmap(image[, options]);
:::const imageBitmapPromise = createImageBitmap(image, sx, sy, sw, sh[, options]);
::where the parameters indicate:
:::'''image:''' an image source, which can be an img element, a SVG image element, a video element, a canvas element, a blob object, an ImageData object or another ImageBitmap object.
:::'''sx, sy, sw, sh:''' if given, source image is cropped to the given pixels.
:::'''options (Optional):''' the ImageBitmap object's bitmap data is modified according to options. Available options are:
:::*imageOrientation
:::*premultiplyAlpha
:::*colorSpaceConversion
:::*resizeWidth
:::*resizeHeight
:::*resizeQuality
:::: You can read more about these options [https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap here]
::The return value is a Promise that is resolved when a new ImageBitmap is created.
:* As a first step, we will be implementing the method to handle canvas elements. Subsequently, we will be enhancing the method to handle other image sources and the x/y/w/h parameters.

;Implementing close() method from previous work

:* close() is a method in the ImageBitmap interface. It is implemented in ''components/script/dom/imagebitmap.rs'' file.
:* This method disposes of all graphical resources associated with an ImageBitmap.

== '''Algorithm to design the createImageBitmap() method''' ==

On invoking the createImageBitmap(image, options) or the createImageBitmap(image sx, sy, sw, sh, options) the following in the sequence of actions

[[File:fig1.png|border]]

Switching on the "image" argument the following is the sequence of actions

=== If the image is an SVGImage===
[[File:fig2.png|border]]

=== If the image is a video===
[[File:ReFigure3.png|border]]

=== If the image is a canvas===
[[File:ReFigure4.png|border]]

=== If the image is an ImageBitmap===
[[File:ImageBitmap.jpg|border]]

=== If the image is an ImageData===
[[File:ImageData.jpg|border]]

=='''Test Plan'''==
The following are the respective steps in testing:
* Servo building test should be successful.
The compiling time is based on the CPU clock speed and the OS of the system where the file is being run. For a 64-bit Linux OS, it takes from about 1 hour to 2 hours for the entire build. It takes 2.5 hours on Windows OS.
* Check for the file tidiness (following standards of servo) using the command:
<pre>
For Linux or macOS:
./mach test-tidy
./mach fmt
</pre>
<pre>
For Windows:
mach.bat test-tidy
mach.bat fmt
</pre>
*Servo automated Unit-testing should be successful.
Running the following commands will run all the unit-tests
<pre>
For Linux or macOS:
./mach test-unit
</pre>
<pre>
For Windows:
mach.bat test-unit
</pre>
Note: A log file can be maintained to make keep a check on the tests that are passing.
* Update the automated servo Web Platform tests(wpt):
For a DOM feature, extensive tests already exist under tests/wpt. Any change in DOM would require updating the expected results in the automated tests.

This first requires storing the log in raw format from a test run, for example by running
<pre>
./mach test-wpt --log-raw /path/for/storing/log/file/<filename>.log
</pre>

Once log is saved, then run to update test expectations
<pre>
./mach update-wpt /path/to/logfile/<filename>.log
</pre>
* 

== '''Team Details''' ==
Sandeep Kundala (skundal@ncsu.edu)

Nita Radhakrishnan (nradhak2@ncsu.edu)

Jayalakshmi Vishwanathan (jviswan@ncsu.edu)

Ramya Ananth (rananth2@ncsu.edu)

== '''Mentor Details''' ==
Jay Modi

== '''References''' ==

* [https://en.wikipedia.org/wiki/Servo_(software)| What is servo?]
* [https://en.wikipedia.org/wiki/Rust_(programming_language)| what is RUST programming?]

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-14T03:42:53Z

Rananth2: /* Test Plan */

== '''Background Information''' ==
This project aims to contribute to Mozilla's experimental browser engine called Servo, which is implemented in a language called RUST(useful for implementing features that need concurrency and memory safety).

Many of the components of Servo are still under development and one such feature is the [https://www.techopedia.com/definition/792/bitmap-bmp| ImageBitmap].

Major browsers support the ImageBitmap standard which can be used to create images that are ready to be drawn efficiently to [https://en.wikipedia.org/wiki/Canvas_element| HTML canvas elements]. Servo is a new, experimental browser that supports these canvas APIs.

The goal of and motivation behind this project is to implement support for image bitmaps and improve our canvas automated test coverage as a result.

== '''About ImageBitMap and Motivation behind the project''' ==
We usually decode images for a use with canvas to allow users to customize an avatar, crop an image, or just zoom in on a picture. The problem with decoding images is that it can be CPU intensive, and that can sometimes mean jank or checkerboarding.

But the createImageBitmap() method allows us to decode the image in the background and get access to a new ImageBitmap primitive, which you can draw into a canvas in the same way you would an <img> element, another canvas, or a video.

The aim of this project is to develop the ImageBitmap for the servo environment.

This can be done in the steps mentioned in the following section.

== '''Steps for implementation''' ==

'''Initial Phase'''
* '''Step 1: '''Add a ImageBitmap WebIDL interface to ''components/script/dom/webidl''s and Rust implementation in components/script/dom/imagebitmap.rs
* '''Step 2: ''' Add the ''createImageBitmap'' method that takes no extra x/y/w/h parameters in ''component/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and implement the method in ''component/script/dom/window.rs'', handling the HTMLCanvasElement and OffscreenCanvas types from the possible image sources

'''Subsequent phase'''
* '''Step 1: '''Implement several remaining image source types (HTMLImageElement, ImageData, ImageBitmap)
* '''Step 2: '''Implement the ''createImageBitmap'' overload that accepts x/y/w/h parameters
* '''Step 3: '''Implement support for ImageBitmaps as canvas image sources in ''components/script/canvas_state.rs''
[[File:AllSteps.jpg]]

== '''Details about previous work on implementation''' ==
The steps that have been implemented so far in this project by the previous batch are:

'''Step 1:''' Added the ImageBitmap interface to ''components/script/dom/webidls'' that represents a bitmap image which can be drawn to a <canvas> without undue latency. The interface contains height and weight as its attributes which are read only unsigned long integers.
<pre>
//[Exposed=(Window,Worker), Serializable, Transferable]
[Exposed=(Window,Worker)]
interface ImageBitmap {
readonly attribute unsigned long width;
readonly attribute unsigned long height;
//void close();
};

typedef (CanvasImageSource or
Blob or
ImageData) ImageBitmapSource;

enum ImageOrientation { "none", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
ImageOrientation imageOrientation = "none";
PremultiplyAlpha premultiplyAlpha = "default";
ColorSpaceConversion colorSpaceConversion = "default";
[EnforceRange] unsigned long resizeWidth;
[EnforceRange] unsigned long resizeHeight;
ResizeQuality resizeQuality = "low";
};
</pre>

The ImageBitmap webidl also defines a dictionary for various ImageBitmap Options that can be used to modify the ImageBitmap object.

'''Step 2:''' Implemented the rust code for the webidl interface at ''components/script/dom/imagebitmap.rs''. For more details on the code [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Spring_2020_-_M2000._Implement_ImageBitMap_web_API#Implementation visit]
<pre>
use crate::dom::bindings::cell::DomRefCell;

use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;

use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use dom_struct::dom_struct;

use std::vec::Vec;

#[dom_struct]
pub struct ImageBitmap {
reflector_: Reflector,
width: u32,
height: u32,
bitmap_data: DomRefCell<Vec<u8>>,
}

impl ImageBitmap {
fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
width: width_arg,
height: height_arg,
bitmap_data: DomRefCell::new(vec![]),
}
}

#[allow(dead_code)]
pub fn new(global: &GlobalScope, width: u32, height: u32) -> Fallible<DomRoot<ImageBitmap>> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));

Ok(reflect_dom_object(imagebitmap, global))
}
}
</pre>

The code also implements the getter methods for height and width attribute of an ImageBitmap object.
<pre>
impl ImageBitmapMethods for ImageBitmap {
// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height
fn Height(&self) -> u32 {
//to do: add a condition for checking detached internal slot
//and return 0 if set to true
self.height
}

// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width
fn Width(&self) -> u32 {
//to do: add a condition to check detached internal slot
////and return 0 if set to true
self.width
}
}
</pre>

== '''Details about current work on implementation''' ==
Among the remaining steps in the initial and subsequent phases, the focus will be on step 2 of initial phase and once there is progress made on this step, implementation of the subsequent steps will take place.

;Starting with createImageBitmap()

:*The createImageBitmap() method creates a bitmap from a given source, optionally cropped to contain only a portion of that source. The method exists on the global scope in both windows and workers. It accepts a variety of different image sources, and returns a Promise which resolves to an ImageBitmap.
:*This method is defined in the file ''components/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and rust code is implemented at ''components/script/dom/window.rs''.
:*The syntax of the method looks like
:::const imageBitmapPromise = createImageBitmap(image[, options]);
:::const imageBitmapPromise = createImageBitmap(image, sx, sy, sw, sh[, options]);
::where the parameters indicate:
:::'''image:''' an image source, which can be an img element, a SVG image element, a video element, a canvas element, a blob object, an ImageData object or another ImageBitmap object.
:::'''sx, sy, sw, sh:''' if given, source image is cropped to the given pixels.
:::'''options (Optional):''' the ImageBitmap object's bitmap data is modified according to options. Available options are:
:::*imageOrientation
:::*premultiplyAlpha
:::*colorSpaceConversion
:::*resizeWidth
:::*resizeHeight
:::*resizeQuality
:::: You can read more about these options [https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap here]
::The return value is a Promise that is resolved when a new ImageBitmap is created.
:* As a first step, we will be implementing the method to handle canvas elements. Subsequently, we will be enhancing the method to handle other image sources and the x/y/w/h parameters.

;Implementing close() method from previous work

:* close() is a method in the ImageBitmap interface. It is implemented in ''components/script/dom/imagebitmap.rs'' file.
:* This method disposes of all graphical resources associated with an ImageBitmap.

== '''Algorithm to design the createImageBitmap() method''' ==

On invoking the createImageBitmap(image, options) or the createImageBitmap(image sx, sy, sw, sh, options) the following in the sequence of actions

[[File:fig1.png|border]]

Switching on the "image" argument the following is the sequence of actions

=== If the image is an SVGImage===
[[File:fig2.png|border]]

=== If the image is a video===
[[File:ReFigure3.png|border]]

=== If the image is a canvas===
[[File:ReFigure4.png|border]]

=== If the image is an ImageBitmap===
[[File:ImageBitmap.jpg|border]]

=== If the image is an ImageData===
[[File:ImageData.jpg|border]]

=='''Test Plan'''==
The following are the respective steps in testing:
* Servo building test should be successful.
The compiling time is based on the CPU clock speed and the OS of the system where the file is being run. For a 64-bit Linux OS, it takes from about 1 hour to 2 hours for the entire build. It takes 2.5 hours on Windows OS.
* Check for the file tidiness (following standards of servo) using the command:
<pre>
For Linux or macOS:
./mach test-tidy
./mach fmt
</pre>
<pre>
For Windows:
mach.bat test-tidy
mach.bat fmt
</pre>
*Servo automated Unit-testing should be successful.
Running the following commands will run all the unit-tests
<pre>
For Linux or macOS:
./mach test-unit
</pre>
<pre>
For Windows:
mach.bat test-unit
</pre>
Note: A log file can be maintained to make keep a check on the tests that are passing.
* Update the automated servo Web Platform tests(wpt):
For a DOM feature, extensive tests already exist under tests/wpt. Any change in DOM would require updating the expected results in the automated tests.

This first requires storing the log in raw format from a test run, for example by running
<pre>
./mach test-wpt --log-raw /path/for/storing/log/file/<filename>.log
</pre>

Once log is saved, then run to update test expectations
<pre>
./mach update-wpt /path/to/logfile/<filename>.log
</pre>

== '''Team Details''' ==
Sandeep Kundala (skundal@ncsu.edu)

Nita Radhakrishnan (nradhak2@ncsu.edu)

Jayalakshmi Vishwanathan (jviswan@ncsu.edu)

Ramya Ananth (rananth2@ncsu.edu)

== '''Mentor Details''' ==
Jay Modi

== '''References''' ==

* [https://en.wikipedia.org/wiki/Servo_(software)| What is servo?]
* [https://en.wikipedia.org/wiki/Rust_(programming_language)| what is RUST programming?]

CSC/CSC 517 Spring 2020/Implement ImageBitMap WebAPI

2020-04-14T03:32:14Z

Rananth2: /* Algorithm to design the createImageBitmap() method */

== '''Background Information''' ==
This project aims to contribute to Mozilla's experimental browser engine called Servo, which is implemented in a language called RUST(useful for implementing features that need concurrency and memory safety).

Many of the components of Servo are still under development and one such feature is the [https://www.techopedia.com/definition/792/bitmap-bmp| ImageBitmap].

Major browsers support the ImageBitmap standard which can be used to create images that are ready to be drawn efficiently to [https://en.wikipedia.org/wiki/Canvas_element| HTML canvas elements]. Servo is a new, experimental browser that supports these canvas APIs.

The goal of and motivation behind this project is to implement support for image bitmaps and improve our canvas automated test coverage as a result.

== '''About ImageBitMap and Motivation behind the project''' ==
We usually decode images for a use with canvas to allow users to customize an avatar, crop an image, or just zoom in on a picture. The problem with decoding images is that it can be CPU intensive, and that can sometimes mean jank or checkerboarding.

But the createImageBitmap() method allows us to decode the image in the background and get access to a new ImageBitmap primitive, which you can draw into a canvas in the same way you would an <img> element, another canvas, or a video.

The aim of this project is to develop the ImageBitmap for the servo environment.

This can be done in the steps mentioned in the following section.

== '''Steps for implementation''' ==

'''Initial Phase'''
* '''Step 1: '''Add a ImageBitmap WebIDL interface to ''components/script/dom/webidl''s and Rust implementation in components/script/dom/imagebitmap.rs
* '''Step 2: ''' Add the ''createImageBitmap'' method that takes no extra x/y/w/h parameters in ''component/script/dom/webidls/WindowOrWorkerGlobalScope.webidl'' and implement the method in ''component/script/dom/window.rs'', handling the HTMLCanvasElement and OffscreenCanvas types from the possible image sources

'''Subsequent phase'''
* '''Step 1: '''Implement several remaining image source types (HTMLImageElement, ImageData, ImageBitmap)
* '''Step 2: '''Implement the ''createImageBitmap'' overload that accepts x/y/w/h parameters
* '''Step 3: '''Implement support for ImageBitmaps as canvas image sources in ''components/script/canvas_state.rs''
[[File:AllSteps.jpg]]

== '''Details about previous work on implementation''' ==
The steps that have been implemented so far in this project by the previous batch are:

'''Step 1:''' Added the ImageBitmap interface to ''components/script/dom/webidls'' that represents a bitmap image which can be drawn to a <canvas> without undue latency. The interface contains height and weight as its attributes which are read only unsigned long integers.
<pre>
//[Exposed=(Window,Worker), Serializable, Transferable]
[Exposed=(Window,Worker)]
interface ImageBitmap {
readonly attribute unsigned long width;
readonly attribute unsigned long height;
//void close();
};

typedef (CanvasImageSource or
Blob or
ImageData) ImageBitmapSource;

enum ImageOrientation { "none", "flipY" };
enum PremultiplyAlpha { "none", "premultiply", "default" };
enum ColorSpaceConversion { "none", "default" };
enum ResizeQuality { "pixelated", "low", "medium", "high" };

dictionary ImageBitmapOptions {
ImageOrientation imageOrientation = "none";
PremultiplyAlpha premultiplyAlpha = "default";
ColorSpaceConversion colorSpaceConversion = "default";
[EnforceRange] unsigned long resizeWidth;
[EnforceRange] unsigned long resizeHeight;
ResizeQuality resizeQuality = "low";
};
</pre>

The ImageBitmap webidl also defines a dictionary for various ImageBitmap Options that can be used to modify the ImageBitmap object.

'''Step 2:''' Implemented the rust code for the webidl interface at ''components/script/dom/imagebitmap.rs''. For more details on the code [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Spring_2020_-_M2000._Implement_ImageBitMap_web_API#Implementation visit]
<pre>
use crate::dom::bindings::cell::DomRefCell;

use crate::dom::bindings::codegen::Bindings::ImageBitmapBinding::ImageBitmapMethods;
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;

use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use dom_struct::dom_struct;

use std::vec::Vec;

#[dom_struct]
pub struct ImageBitmap {
reflector_: Reflector,
width: u32,
height: u32,
bitmap_data: DomRefCell<Vec<u8>>,
}

impl ImageBitmap {
fn new_inherited(width_arg: u32, height_arg: u32) -> ImageBitmap {
ImageBitmap {
reflector_: Reflector::new(),
width: width_arg,
height: height_arg,
bitmap_data: DomRefCell::new(vec![]),
}
}

#[allow(dead_code)]
pub fn new(global: &GlobalScope, width: u32, height: u32) -> Fallible<DomRoot<ImageBitmap>> {
//assigning to a variable the return object of new_inherited
let imagebitmap = Box::new(ImageBitmap::new_inherited(width, height));

Ok(reflect_dom_object(imagebitmap, global))
}
}
</pre>

The code also implements the getter methods for height and width attribute of an ImageBitmap object.
<pre>
impl ImageBitmapMethods for ImageBitmap {
// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-height
fn Height(&self) -> u32 {
//to do: add a condition for checking detached internal slot
//and return 0 if set to true
self.height
}

// https://html.spec.whatwg.org/multipage/#dom-imagebitmap-width
fn Width(&self) -> u32 {
//to do: add a condition to check detached internal slot
////and return 0 if set to true
self.width
}
}
</pre>

== '''Details about current work on implementation''' ==
Among the remaining steps in the initial and subsequent phases, the focus will be on step 2 of initial phase and once there is progress made on this step, implementation of the subsequent steps will take place.

;Starting with createImageBitmap()

:*The createImageBitmap() method creates a bitmap from a given source, optionally cropped to contain only a portion of that source. The method exists on the global scope in both windows and workers. It accepts a variety of different image sources, and returns a Promise which resolves to an ImageBitmap.
:*The syntax of the method looks like
:::const imageBitmapPromise = createImageBitmap(image[, options]);
:::const imageBitmapPromise = createImageBitmap(image, sx, sy, sw, sh[, options]);
::where the parameters indicate:
:::'''image:''' an image source, which can be an img element, a SVG image element, a video element, a canvas element, a blob object, an ImageData object or another ImageBitmap object.
:::'''sx, sy, sw, sh:''' if given, source image is cropped to the given pixels.
:::'''options (Optional):''' the ImageBitmap object's bitmap data is modified according to options. Available options are:
:::*imageOrientation
:::*premultiplyAlpha
:::*colorSpaceConversion
:::*resizeWidth
:::*resizeHeight
:::*resizeQuality
:::: You can read more about these options [https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap here]
::The return value is a Promise that is resolved when a new ImageBitmap is created.
:* As a first step, we will be implementing the method to handle canvas elements. Subsequently, we will be enhancing the method to handle other image sources and the x/y/w/h parameters.

;Implementing close() method from previous work

:* close() is a method in the ImageBitmap interface. It is implemented in ''components/script/dom/imagebitmap.rs'' file.
:* This method disposes of all graphical resources associated with an ImageBitmap.

== '''Algorithm to design the createImageBitmap() method''' ==

On invoking the createImageBitmap(image, options) or the createImageBitmap(image sx, sy, sw, sh, options) the following in the sequence of actions

[[File:fig1.png|border]]

Switching on the "image" argument the following is the sequence of actions

=== If the image is an SVGImage===
[[File:fig2.png|border]]

=== If the image is a video===
[[File:ReFigure3.png|border]]

=== If the image is a canvas===
[[File:ReFigure4.png|border]]

=== If the image is an ImageBitmap===
[[File:ImageBitmap.jpg|border]]

=== If the image is an ImageData===
[[File:ImageData.jpg|border]]

=='''Test Plan'''==
The following are the respective steps in testing:
* Servo building test should be successful.
* Check for the file tidiness (following standards of servo) using the command:
<pre>
For Linux or macOS:
./mach test-tidy
./mach fmt
</pre>
<pre>
For Windows:
mach.bat test-tidy
mach.bat fmt
</pre>

* Update the automated servo Web Platform tests(wpt):
For a DOM feature, extensive tests already exist under tests/wpt. Any change in DOM would require updating the expected results in the automated tests.

This first requires storing the log in raw format from a test run, for example by running
<pre>
./mach test-wpt --log-raw /path/for/storing/log/file/<filename>.log
</pre>

Once log is saved, then run to update test expectations
<pre>
./mach update-wpt /path/to/logfile/<filename>.log
</pre>

== '''Team Details''' ==
Sandeep Kundala (skundal@ncsu.edu)

Nita Radhakrishnan (nradhak2@ncsu.edu)

Jayalakshmi Vishwanathan (jviswan@ncsu.edu)

Ramya Ananth (rananth2@ncsu.edu)

== '''Mentor Details''' ==
Jay Modi

== '''References''' ==

* [https://en.wikipedia.org/wiki/Servo_(software)| What is servo?]
* [https://en.wikipedia.org/wiki/Rust_(programming_language)| what is RUST programming?]

File:Location screenshot.jpg

2020-04-01T04:31:52Z

Rananth2:

File:Location screenshot.PNG

2020-04-01T04:25:41Z

Rananth2: Rananth2 uploaded a new version of File:Location screenshot.PNG

File:Location screenshot.PNG

2020-04-01T04:24:52Z

Rananth2: Rananth2 uploaded a new version of File:Location screenshot.PNG

File:Location screenshot.PNG

2020-04-01T04:23:55Z

Rananth2:

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:53:37Z

Rananth2: /* Test Plan */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Testing==
===Test Plan===

The main objective of improving the current Assessment 360 Controller testing is to make sure each of the functionalities are being looked into regardless of the test coverage because of the number of calculations that are actually being taken place inside the controller. In order to achieve this, tests were written for two main newly added methods in the controller. The first few tests have assumed to expect a normal condition i.e., a person exists and all other information do exist.

===Test Cases===
The following test cases were made for the major methods added to the Assessment 360 Controller:
*insure_existence_of
- Checking if the course participants are empty 
- Check if function redirects to back 
- Check if function flashes an error if it's not present 
- When method is called, it should check if there are course participants and redirects to back and flashes error if there are no participants

*assignment_grade_summary
- Checking if the course participants are empty 
- Check if function redirects to back 
- Check if function flashes an error if it's not present 
- When method is called, it should check if there are course participants. When this passes, and when there are participants with team id, the total value returned for final grade should be valid

===UI Testing===
By following the below steps, a reviewer can manually test the changes made to the Assessment 360 Controller.

1. Visit [http://152.46.16.125:8080/ http://152.46.16.125:8080/] and enter the following credentials, 
Username: instructor6 
Password: password

2. From the menu bar, select Manage > Courses

3. Scroll down to find the respective course, and select the blue globe icon. The page should load.

4. Scroll down to find the respective course, and select the brown menu icon. The page should load.

==Submission==
===Github Link===

The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.

===Pull Request===

The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:53:02Z

Rananth2: /* Test Cases */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Testing==
===Test Plan===

The main objective of improving the current Assessment 360 Controller testing is to make sure each of the functionalities are being looked into regardless of the test coverage because of the number of calculations that are actually being taken place inside the controller. In order to achieve this, tests were written for each newly added method in the controller. The first few tests have assumed to expect a normal condition i.e., a person exists and all other information do exist.

===Test Cases===
The following test cases were made for the major methods added to the Assessment 360 Controller:
*insure_existence_of
- Checking if the course participants are empty 
- Check if function redirects to back 
- Check if function flashes an error if it's not present 
- When method is called, it should check if there are course participants and redirects to back and flashes error if there are no participants

*assignment_grade_summary
- Checking if the course participants are empty 
- Check if function redirects to back 
- Check if function flashes an error if it's not present 
- When method is called, it should check if there are course participants. When this passes, and when there are participants with team id, the total value returned for final grade should be valid

===UI Testing===
By following the below steps, a reviewer can manually test the changes made to the Assessment 360 Controller.

1. Visit [http://152.46.16.125:8080/ http://152.46.16.125:8080/] and enter the following credentials, 
Username: instructor6 
Password: password

2. From the menu bar, select Manage > Courses

3. Scroll down to find the respective course, and select the blue globe icon. The page should load.

4. Scroll down to find the respective course, and select the brown menu icon. The page should load.

==Submission==
===Github Link===

The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.

===Pull Request===

The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:47:44Z

Rananth2: /* UI Testing */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Testing==
===Test Plan===

The main objective of improving the current Assessment 360 Controller testing is to make sure each of the functionalities are being looked into regardless of the test coverage because of the number of calculations that are actually being taken place inside the controller. In order to achieve this, tests were written for each newly added method in the controller. The first few tests have assumed to expect a normal condition i.e., a person exists and all other information do exist.

===Test Cases===
The following test cases were made for each respective methods added to the Assessment 360 Controller:

===UI Testing===
By following the below steps, a reviewer can manually test the changes made to the Assessment 360 Controller.

1. Visit [http://152.46.16.125:8080/ http://152.46.16.125:8080/] and enter the following credentials, 
Username: instructor6 
Password: password

2. From the menu bar, select Manage > Courses

3. Scroll down to find the respective course, and select the blue globe icon. The page should load.

4. Scroll down to find the respective course, and select the brown menu icon. The page should load.

==Submission==
===Github Link===

The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.

===Pull Request===

The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:46:50Z

Rananth2: /* UI Testing */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Testing==
===Test Plan===

The main objective of improving the current Assessment 360 Controller testing is to make sure each of the functionalities are being looked into regardless of the test coverage because of the number of calculations that are actually being taken place inside the controller. In order to achieve this, tests were written for each newly added method in the controller. The first few tests have assumed to expect a normal condition i.e., a person exists and all other information do exist.

===Test Cases===
The following test cases were made for each respective methods added to the Assessment 360 Controller:

===UI Testing===
By following the below steps, a reviewer can manually test the changes made to the Assessment 360 Controller.

1. Visit [http://152.46.16.125:8080/ http://152.46.16.125:8080/] and enter the following credentials, 
Username:instructor6 
Password:password

2. From the menu bar, select Manage > Courses

3. Scroll down to find the respective course, and select the blue globe icon. The page should load.

4. Scroll down to find the respective course, and select the brown menu icon. The page should load.

==Submission==
===Github Link===

The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.

===Pull Request===

The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

File:Menu.PNG

2020-04-01T03:44:51Z

Rananth2:

File:Globe.PNG

2020-04-01T03:44:06Z

Rananth2:

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:43:29Z

Rananth2: /* Submission */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Testing==
===Test Plan===

The main objective of improving the current Assessment 360 Controller testing is to make sure each of the functionalities are being looked into regardless of the test coverage because of the number of calculations that are actually being taken place inside the controller. In order to achieve this, tests were written for each newly added method in the controller. The first few tests have assumed to expect a normal condition i.e., a person exists and all other information do exist.

===Test Cases===
The following test cases were made for each respective methods added to the Assessment 360 Controller:

===UI Testing===
By following the below steps, a reviewer can manually test the changes made to the Assessment 360 Controller.

1. Visit [http://152.46.16.125:8080/ http://152.46.16.125:8080/] and enter the following credentials, 
Username:instructor6 
Password:password

2. From the menu bar, select Manage > Courses

3. Scroll down to find the respective course, and select the

==Submission==
===Github Link===

The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.

===Pull Request===

The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:43:14Z

Rananth2: /* UI Testing */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Testing==
===Test Plan===

The main objective of improving the current Assessment 360 Controller testing is to make sure each of the functionalities are being looked into regardless of the test coverage because of the number of calculations that are actually being taken place inside the controller. In order to achieve this, tests were written for each newly added method in the controller. The first few tests have assumed to expect a normal condition i.e., a person exists and all other information do exist.

===Test Cases===
The following test cases were made for each respective methods added to the Assessment 360 Controller:

===UI Testing===
By following the below steps, a reviewer can manually test the changes made to the Assessment 360 Controller.

1. Visit [http://152.46.16.125:8080/ http://152.46.16.125:8080/] and enter the following credentials, 
Username:instructor6 
Password:password

2. From the menu bar, select Manage > Courses

3. Scroll down to find the respective course, and select the

==Submission==
'''Github Link'''

The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.

===Pull Request===

The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:42:38Z

Rananth2: /* Github Link */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Testing==
===Test Plan===

The main objective of improving the current Assessment 360 Controller testing is to make sure each of the functionalities are being looked into regardless of the test coverage because of the number of calculations that are actually being taken place inside the controller. In order to achieve this, tests were written for each newly added method in the controller. The first few tests have assumed to expect a normal condition i.e., a person exists and all other information do exist.

===Test Cases===
The following test cases were made for each respective methods added to the Assessment 360 Controller:

===UI Testing===
By following the below steps, a reviewer can manually test the changes made to the Assessment 360 Controller.

1. Visit [http://152.46.16.125:8080/ http://152.46.16.125:8080/] and enter the following credentials, 
Username:instructor6 
Password:password

2. From the menu bar, select Manage > Courses

3. Scroll down to find the respective course, and select the

==Submission==
'''Github Link'''

The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.

===Pull Request===

The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

File:Test pass.PNG

2020-04-01T03:41:41Z

Rananth2: Rananth2 uploaded a new version of File:Test pass.PNG

File:Test pass.PNG

2020-04-01T03:41:09Z

Rananth2: Rananth2 uploaded a new version of File:Test pass.PNG

File:Test pass.PNG

2020-04-01T03:40:48Z

Rananth2:

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:39:44Z

Rananth2:

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Testing==
===Test Plan===

The main objective of improving the current Assessment 360 Controller testing is to make sure each of the functionalities are being looked into regardless of the test coverage because of the number of calculations that are actually being taken place inside the controller. In order to achieve this, tests were written for each newly added method in the controller. The first few tests have assumed to expect a normal condition i.e., a person exists and all other information do exist.

===Test Cases===
The following test cases were made for each respective methods added to the Assessment 360 Controller:

===UI Testing===
By following the below steps, a reviewer can manually test the changes made to the Assessment 360 Controller.

1. Visit [http://152.46.16.125:8080/ http://152.46.16.125:8080/] and enter the following credentials, 
Username:instructor6 
Password:password

2. From the menu bar, select Manage > Courses

3. Scroll down to find the respective course, and select the

==Submission==
===Github Link===

The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.

===Pull Request===

The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:21:26Z

Rananth2: /* Pull Request */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Submission==
===Github Link===
The changes made to the code is present on this [https://github.com/ramyananth/expertiza link]. Multiple comments and refactoring have been addressed in detail here.
===Pull Request===
The initial build made out of pull request [https://github.com/expertiza/expertiza/pull/1691 1691], kept failing continuously since it was made to the master branch of expertiza. It changed the Gemfile.lock and also the database schema. This push was actually made because the beta branch and master branch of expertiza were not different at all. The new pull request [https://github.com/expertiza/expertiza/pull/1713 1713] was made to the beta branch from our beta branch and it worked completely fine.

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:16:50Z

Rananth2: /* Method name explanations */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Method name explanations==
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Pull Request==
The initial pull request

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T03:16:31Z

Rananth2:

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

====Method name explanations====
One of the methods devised in this project is use nouns instead of verbs. Ideally the name of a variable or method should be enough to identify it's function in the class. This is because assessment_360 controller, of course is an exception and does explain what each of the functions do on their function names,

*all_students_all_reviews - Find the list of all students and assignments pertaining to the course. This data is used to compute the metareview and teammate review scores.
*avg_review_calc_per_student - Calculate the overall average review grade that a student has gotten from their teammate(s) and instructor(s)
*overall_review_count - To avoid divide by zero error
*course_student_grade_summary - Find the list of all students and assignments pertaining to the course. This data is used to compute the instructor assigned grade and peer review scores.
*assignment_grade_summary - To pull information about the student's grades for particular assignment
*insure_existence_of - To make sure there are participants for the course
*calc_overall_review_info - The function populates the hash value for all students for all the reviews that they have gotten. I.e., Teammate and Meta for each of the assignments that they have taken. This value is then used to display the overall teammate_review and meta_review grade in the view
*find_peer_review_score - The peer review score is taken from the questions for the assignment

==Pull Request==
The initial pull request

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-04-01T02:41:30Z

Rananth2: /* Refactor course_student_grade_summary method */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
#Skip if there are no peers
next if peer_review_score.nil?
#Skip if there are no reviews done by peers
next if peer_review_score[:review].nil?
#Skip if there are no reviews scores assigned by peers
next if peer_review_score[:review][:scores].nil?
#Skip if there are is no peer review average score
next if peer_review_score[:review][:scores][:avg].nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-24T04:00:48Z

Rananth2: /* Refactor course_student_grade_summary method */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

====Refactor course_student_grade_summary method====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-24T04:00:31Z

Rananth2: /* Refactor all_students_all_reviews method */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

====Refactor all_students_all_reviews method====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

=====Refactor course_student_grade_summary method=====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-24T03:59:45Z

Rananth2: /* Proposed Implementation */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Fixing the bug on course_student_grade_summary====
The current implementation of the method throws a nil error at the moment on the following line,
<pre>unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)</pre>
This is rectified by introducing,
<pre>next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?</pre>

====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

=====Refactor all_students_all_reviews method=====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

=====Refactor course_student_grade_summary method=====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-24T03:55:39Z

Rananth2: /* Refactor course_student_grade_summary method */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

=====Refactor all_students_all_reviews method=====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

=====Refactor course_student_grade_summary method=====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

'''After refactoring'''

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0
@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id
assignment_participant = assignment.participants.find_by(user_id: user_id)
# break out of the loop if there are no participants in the assignment
next if assignment.participants.find_by(user_id: user_id).nil?
# break out of the loop if the participant has no team
next if TeamsUser.team_id(assignment_id, user_id).nil?
# pull information about the student's grades for particular assignment
assignment_grade_summary(cp, assignment_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)
next if (peer_review_score[:review] && peer_review_score[:review][:scores] && peer_review_score[:review][:scores][:avg]).nil?
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
</pre>

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-24T03:55:02Z

Rananth2: /* Refactor all_students_all_reviews method */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

=====Refactor all_students_all_reviews method=====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

=====Refactor course_student_grade_summary method=====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-24T03:54:31Z

Rananth2: /* Refactor course_student_grade_summary method */

==About Expertiza==
[http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instructor and students with the following privileges,

===Instructors===
* Create new assignments
* Customize new or existing assignments
* Create a list of topics that students can sign up for
* Give grades/reviews for the students' submissions

===Students===
* Form teams with other students to work on various projects and assignments
* Peer review other students' submissions

Note: Expertiza supports submissions across various document types, including URL and wiki pages

==Project Description==

===About assessment_360 Controller===
The assessment_360 controller is designed to gather data from all stakeholders about the performance of a student in a course. Thus, its purpose is to provide course-level statistics. At present, the controller provides only two top-level functions where each of them gives a list of students in the class.

* all_students_all_reviews contains teammate and meta-review scores received by students for all assignments in the course
* course_student_grade_summary gives a listing of students and what topic they worked on and what grade they received on each assignment during the semester

===Problem Statement===
The assessment360 controller had three major issues. This project is aimed to address some of them, including:

 Issue 1: Methods all_students_all_reviews and course_student_grade_summary were too long. Common initialization and looping had to factored out by moving them into smaller methods with mnemonic names

 Issue 2: Method populate_hash_for_all_students_all_reviews is not easy to understand. It uses a special data structure to do a very simple task. That had to be refactored

 Issue 3: Method course_student_grade_summary stopped working and has to be fixed

===Motivation===
This project aims at encouraging students to collaborate and contribute to open-source project in turn helping them understand what goes on in a full-fledged software deployment process. It also paves a way to understand how one can use Rails, RSpec to develop a system that does justice to the DRY code practicing principles.

==Approach==
Problem 1: Refactoring all_students_all_reviews and course_student_grade_summary

(a) The common elements in these files i.e., checking if the course participant list is empty or not is moved to a different function called inspect_course_participants

(b) Adding on to this, all_student_all_review was broken down to two more functions, avg_review_calc_per_student and overall_review_count

(c) The method course_student_grade_summary is broken down to one more function assignment_grade_summary

Problem 2: Refactoring populate_hash_for_all_students_all_reviews

The approach in this function is pretty straight forward when we try to break it down. It calculates,

(a) The average score for each assignment for each course

(b) The overall review grade for each assignment for all the students who have taken the course

Passing the average score calculated from (a) checks if the student has teammates which could result in not having an average teammate_review_score. If we calculate (b) in our main function (this can be done) we would be repeating the checks that we are already doing for (a). Hence, this function is not changed

Problem 3: Fix course_student_grade_summary

The current implementation ran into an issue when it was comparing the Key-Value pair passed in '''peer_review_score'''. It was hard to check if each of the keys were present or not. The proposed solution makes use of a basic hash value presence check that retrieves a value from the array/hash, given a set of keys. If no value is found, it'll return nil.

==Proposed Implementation==
====Common refactoring of all_students_all_reviews and course_student_grade_summary method====
The functionality that the methods shared was that, both of them checked if there were course participants who had taken a particular course. This occupied 4 lines of code in both the functions. So, this is defined in a separate function called insure_existence_of and called from the two functions.

<pre>
def insure_existence_of(course_participants)
if course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
end
</pre>

=====Refactor all_students_all_reviews method=====
The all_students_all_reviews method is one of the biggest methods in assessment360_controller.rb file. It finds the list of all students and assignments pertaining to the course. This data is then used to compute the metareview and teammate review scores for each student.

The code before refactoring had 64 lines of code as shown below,
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
populate_hash_for_all_students_all_reviews(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
populate_hash_for_all_students_all_reviews(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
if @teammate_review_info_per_stu[1] > 0
temp_avg_grade = @teammate_review_info_per_stu[0] * 1.0 / @teammate_review_info_per_stu[1]
@teammate_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
if @meta_review_info_per_stu[1] > 0
temp_avg_grade = @meta_review_info_per_stu[0] * 1.0 / @meta_review_info_per_stu[1]
@meta_review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
# avoid divide by zero error
@assignments.each do |assignment|
temp_count = @overall_teammate_review_count[assignment.id]
@overall_teammate_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = @overall_meta_review_count[assignment.id]
@overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

To calculate the average grade for each student on all assignments in this course that a student has taken in this course is refactoring in the base code by adding the avg_review_calc_per_student method.

<pre>
def avg_review_calc_per_student(cp, review_info_per_stu, review)
# check to see if the student has been given a review
if review_info_per_stu[1] > 0
temp_avg_grade = review_info_per_stu[0] * 1.0 / review_info_per_stu[1]
review[cp.id][:avg_grade_for_assgt] = temp_avg_grade.round.to_s + '%'
end
end
</pre>

To avoid a divide by zero error that is thrown when we try to calculate the average grade when a student has no teammate is handled by the overall_review_count method.

<pre>
def overall_review_count(assignments, overall_teammate_review_count, overall_meta_review_count)
assignments.each do |assignment|
temp_count = overall_teammate_review_count[assignment.id]
overall_review_count_hash[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
temp_count = overall_meta_review_count[assignment.id]
overall_meta_review_count[assignment.id] = 1 if temp_count.nil? or temp_count.zero?
end
end
</pre>

'''After refactoring'''
<pre>
def all_students_all_reviews
course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
insure_existence_of(@course_participants)
# hashes for view
@meta_review = {}
@teammate_review = {}
@teamed_count = {}
# for course
# eg. @overall_teammate_review_grades = {assgt_id1: 100, assgt_id2: 178, ...}
# @overall_teammate_review_count = {assgt_id1: 1, assgt_id2: 2, ...}
%w[teammate meta].each do |type|
instance_variable_set("@overall_#{type}_review_grades", {})
instance_variable_set("@overall_#{type}_review_count", {})
end
@course_participants.each do |cp|
# for each assignment
# [aggregrate_review_grades_per_stu, review_count_per_stu] --> [0, 0]
%w[teammate meta].each {|type| instance_variable_set("@#{type}_review_info_per_stu", [0, 0]) }
students_teamed = StudentTask.teamed_students(cp.user)
@teamed_count[cp.id] = students_teamed[course.id].try(:size).to_i
@assignments.each do |assignment|
@meta_review[cp.id] = {} unless @meta_review.key?(cp.id)
@teammate_review[cp.id] = {} unless @teammate_review.key?(cp.id)
assignment_participant = assignment.participants.find_by(user_id: cp.user_id)
next if assignment_participant.nil?
teammate_reviews = assignment_participant.teammate_reviews
meta_reviews = assignment_participant.metareviews
calc_overall_review_info(assignment,
cp,
teammate_reviews,
@teammate_review,
@overall_teammate_review_grades,
@overall_teammate_review_count,
@teammate_review_info_per_stu)
calc_overall_review_info(assignment,
cp,
meta_reviews,
@meta_review,
@overall_meta_review_grades,
@overall_meta_review_count,
@meta_review_info_per_stu)
end
# calculate average grade for each student on all assignments in this course
avg_review_calc_per_student(cp, @teammate_review_info_per_stu, @teammate_review)
avg_review_calc_per_student(cp, @meta_review_info_per_stu, @meta_review)
end
# avoid divide by zero error
overall_review_count(@assignments, @overall_teammate_review_count, @overall_meta_review_count)
end
</pre>

=====Refactor course_student_grade_summary method=====
This method finds the list of all students and assignments pertaining to the course. The data obtained is then used to compute the instructor assigned grade and peer review scores. It was the secong biggest method in the assessment360_controller.rb controller file. The code before refactoring is shown below,

<pre>
def course_student_grade_summary
@topics = {}
@assignment_grades = {}
@peer_review_scores = {}
@final_grades = {}

course = Course.find(params[:course_id])
@assignments = course.assignments.reject(&:is_calibrated).reject {|a| a.participants.empty? }
@course_participants = course.get_participants
if @course_participants.empty?
flash[:error] = "There is no course participant in course #{course.name}"
redirect_to(:back)
end

@course_participants.each do |cp|
@topics[cp.id] = {}
@assignment_grades[cp.id] = {}
@peer_review_scores[cp.id] = {}
@final_grades[cp.id] = 0

@assignments.each do |assignment|
user_id = cp.user_id
assignment_id = assignment.id

assignment_participant = assignment.participants.find_by(user_id: user_id)
next if assignment.participants.find_by(user_id: user_id).nil?

# A topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)

# Instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
next if team_id.nil?

team = Team.find(team_id)
peer_review_score = find_peer_review_score(user_id, assignment_id)

# Set the assignment grade, peer review score, and sum for the final student summary
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
unless @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end

unless (peer_review_score.nil? || peer_review_score[:review][:scores][:avg].nil?)
@peer_review_scores[cp.id][assignment_id] = peer_review_score[:review][:scores][:avg].round(2)
end
end
end
end
</pre>

In this function, all the functionalities pertaining to a course participant - student in this case, in a given assignment is invoked by introducing a new method called assignment_grade_summary. This method checks if a topic exists and if it does, it passes the final grade that is calculated for that student in that course.

<pre>
def assignment_grade_summary(cp, assignment_id)
user_id = cp.user_id
# topic exists if a team signed up for a topic, which can be found via the user and the assignment
topic_id = SignedUpTeam.topic_id(assignment_id, user_id)
@topics[cp.id][assignment_id] = SignUpTopic.find_by(id: topic_id)
# instructor grade is stored in the team model, which is found by finding the user's team for the assignment
team_id = TeamsUser.team_id(assignment_id, user_id)
team = Team.find(team_id)
@assignment_grades[cp.id][assignment_id] = team[:grade_for_submission]
return if @assignment_grades[cp.id][assignment_id].nil?
@final_grades[cp.id] += @assignment_grades[cp.id][assignment_id]
end
</pre>

==Team Information==
[mailto:rananth2@ncsu.edu Ramya Ananth] - [https://www.linkedin.com/in/ramyananth/ LinkedIn]

[mailto:suppala@ncsu.edu Sri Harsha Varma Uppalapati] - [https://www.linkedin.com/in/sri-harsha-varma-uppalapati LinkedIn]

[mailto:efg@ncsu.edu Mentor: Dr. Edward F Gehringer] - [https://www.ece.ncsu.edu/people/efg/ Website]

==References==
1.[https://github.com/expertiza/expertiza/ Expertiza on GitHub]

2.[https://github.com/ramyananth/expertiza GitHub Project Repository Fork]

3.[http://expertiza.ncsu.edu/ Live Expertiza website]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-24T03:48:43Z

Rananth2:

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-24T03:21:39Z

Rananth2:

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-22T20:45:39Z

Rananth2:

CSC/ECE 517 Fall 2019 - E2003. Refactor and improve assessment360 controller

2020-03-22T20:30:32Z

Rananth2: Rananth2 moved page CSC/ECE 517 Fall 2019 - E2003. Refactor and improve assessment360 controller to CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

#REDIRECT [[CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller]]

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-22T20:30:32Z

Rananth2: Rananth2 moved page CSC/ECE 517 Fall 2019 - E2003. Refactor and improve assessment360 controller to CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-22T20:29:20Z

Rananth2:

CSC/ECE 517 Spring 2020 - E2003. Refactor and improve assessment360 controller

2020-03-22T18:54:19Z

Rananth2: Created page with "==About Expertiza== [http://expertiza.ncsu.edu/ Expertiza] is an open-source project based on [http://rubyonrails.org/ Ruby on Rails] framework. The software allows the instru..."