Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2014/oss E1405 irw

2014-03-31T22:58:39Z

Seschro2:

'''Improve tests & investigate regex warnings for student_task '''

== Introduction ==
=== Background ===
This model allows for much of the functionality the student requires to interact effectively with expertiza. Here a student is able to sign up for topics, form teams, submit assignments, review other students' work, and check his or her own scores.

== Work accomplished ==
=== Objective 1: Fix existing tests ===
Initially, there were 26 tests with errors. Many tests required functionality or fixtures that were likely changed by people working on expertiza over the years.
==== Issues ====
Many fixtures required to correct the tests were missing, and had to be added or created. Additionally, several tests were referencing deleted elements of fixture files which were added in order to correct test functionality. Finally, there were certain elements of the code itself in the controller file which had to be corrected in order for tests to run.

=== Objective 2: Add additional tests ===

== Future work ==
There is no current unit test file for student_task, which means there aren't unit tests. Such tests should be added in the future in order to ensure proper functionality.

CSC/ECE 517 Spring 2014/oss E1405 irw

2014-03-31T22:57:51Z

Seschro2: Created page with "'''Improve tests & investigate regex warnings for student_task ''' == Introduction == === Background === This model allows for much of the functionality the student requires to ..."

CSC/ECE 517 Spring 2014

2014-03-31T22:04:56Z

Seschro2:

*[[CSC/ECE_517_Fall_2012/example_page]]
*[[CSC/ECE 517 Spring 2014/ch1a 1e rm]]
*[[CSC/ECE 517 Spring 2014/ch1 1w1h jg ]]
*[[CSC/ECE 517 Spring 2014/ch1 1w1b np]]
*[[CSC/ECE 517 Spring 2014/ch1 1w1f mj]]
*[[CSC/ECE 517 Spring 2014/ch1a 1d mm]]
*[[CSC/ECE 517 Spring 2014/ch1a 1c yj]]
*[[CSC/ECE 517 Spring 2014/ch1 1w1l m]]
*[[CSC/ECE 517 Spring 2014/ch1 1w1m bm]]
*[[CSC/ECE 517 Spring 2014/ch1a 1p fy]]
*[[CSC/ECE 517 Spring 2014/oss E1401 lmn]]
*[[CSC/ECE 517 Spring 2014/oss E1402 mmb]]
*[[CSC/ECE 517 Spring 2014/oss E1404 mnp]]
*[[CSC/ECE 517 Spring 2014/oss E1405 irw]]
*[[CSC/ECE 517 Spring 2014/oss E1406 st]]
*[[CSC/ECE 517 Spring 2014/oss S1402 jyy]]

CSC/ECE 517 Spring 2014/ch1 1w1l m

2014-02-24T03:17:37Z

Seschro2: /* Blocks in Ruby */

= Design Patterns Involving Closures =

== Background ==
=== Explanation of Closures ===

====Blocks in Ruby====
A block is a segment of code that can be used as an argument for a method. These segments of code may have their own initialized variables only able to be referenced locally in the block, much like in a method. Single line blocks are commonly encapsulated in curly braces after a method call, and multi-line blocks are between "do" and "end" statements. A block's code is not executed when it is encountered, but rather after all instances of the yield statement within the method.

<code>
=begin
Ruby Code blocks are chunks of code between braces or
between do- end that you can associate with method invocations
=end
def call_block
puts 'Start of method'
# you can call the block using the yield keyword
yield
yield
puts 'End of method'
end
# Code blocks may appear only in the source adjacent to a method call
call_block {puts 'In the block'}
</code>
The above code outputs the following:
<code>
>ruby p022codeblock.rb
Start of method
In the block
In the block
End of method
>Exit code: 0
</code>

====So what's a closure?====
Very simply, a closure is a function that can use a variable that was valid within the scope that the closure was defined, but need not be in-scope where the closure is called. A quick example is very illustrative.

<code>
def closure_builder(message="Default"):
def closure():
# Message is in-scope here
print message
return closure

# Build two functions
default_closure = closure_builder()
custom_closure = closure_builder("Custom")
del closure_builder

# Call the closures you built
default_closure() # Amazingly, prints "Default"
custom_closure() # Amazingly, prints "Custom"
</code>

== Examples ==

=== Decorators ===

Decorators are an interesting and powerful language feature that can be implemented elegantly with closures.

<code>
#!/usr/bin/env python

def decorate(func):
def decorated_func():
print "About to call func"
func()
print "Back from calling func"
return decorated_func

@decorate
def func_to_decorate():
print "In func_to_decorate"

func_to_decorate()
</code>

<code>
[~517/wiki]$ chmod ug+x decorator.py
[~517/wiki]$ ./decorator.py
About to call func
In func_to_decorate
Back from calling func
</code>

=== Command Pattern===
The command Pattern can be implemented using proc objects, which are the closure of an object

In the command pattern, commands for objects to be implemented are queued and can be executed at any time. Arguments are considered passed when the method is called.

<code>
count = 0

commands = []
(1..10).each do |i|
commands << proc { count +=i }
end

puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"
</code>

===Strategy Pattern===
The Strategy Pattern allows an algorithms behavior to be determined at runtime. It describes the definition of a family of interchangeable algorithm classes whose functionality is different for identically named methods.

<code>
class Fighter
def initialize(&fighting_behavior)
@finish_move = fighting_behavior
end

def finish_opponent
@finish_move.call
end
end

boxer = Fighter.new { puts 'Left hook to the body!' }
boxer.finish_opponent #=> Left hook to the body!

mortal_kombat_warrior = Fighter.new { puts 'Blast him with a lighting bolt' }
mortal_kombat_warrior.finish_opponent #=> Blast him with a lighting bolt

mma = Fighter.new { puts 'Put you to sleep, Good Night!' }
mma.finish_opponent #=> Put you to sleep, Good Night!

lion = Fighter.new { puts 'Bites your head off' }
lion.finish_opponent #=> Bites your head off!
</code>

== See Also ==
== References ==
<references />

CSC/ECE 517 Spring 2014/ch1 1w1l m

2014-02-24T03:16:32Z

Seschro2: /* Explanation of Closures */

= Design Patterns Involving Closures =

== Background ==
=== Explanation of Closures ===

====Blocks in Ruby====
A block is a segment of code that can be used as an argument for a method. These segments of code may have their own initialized variables only able to be referenced locally in the block, much like in a method. Blocks are commonly between "do" and "end" statements. A block's code is not executed when it is encountered, but rather after all instances of the yield statement within the method.

<code>
=begin
Ruby Code blocks are chunks of code between braces or
between do- end that you can associate with method invocations
=end
def call_block
puts 'Start of method'
# you can call the block using the yield keyword
yield
yield
puts 'End of method'
end
# Code blocks may appear only in the source adjacent to a method call
call_block {puts 'In the block'}
</code>
The above code outputs the following:
<code>
>ruby p022codeblock.rb
Start of method
In the block
In the block
End of method
>Exit code: 0
</code>

====So what's a closure?====
Very simply, a closure is a function that can use a variable that was valid within the scope that the closure was defined, but need not be in-scope where the closure is called. A quick example is very illustrative.

<code>
def closure_builder(message="Default"):
def closure():
# Message is in-scope here
print message
return closure

# Build two functions
default_closure = closure_builder()
custom_closure = closure_builder("Custom")
del closure_builder

# Call the closures you built
default_closure() # Amazingly, prints "Default"
custom_closure() # Amazingly, prints "Custom"
</code>

== Examples ==

=== Decorators ===

Decorators are an interesting and powerful language feature that can be implemented elegantly with closures.

<code>
#!/usr/bin/env python

def decorate(func):
def decorated_func():
print "About to call func"
func()
print "Back from calling func"
return decorated_func

@decorate
def func_to_decorate():
print "In func_to_decorate"

func_to_decorate()
</code>

<code>
[~517/wiki]$ chmod ug+x decorator.py
[~517/wiki]$ ./decorator.py
About to call func
In func_to_decorate
Back from calling func
</code>

=== Command Pattern===
The command Pattern can be implemented using proc objects, which are the closure of an object

In the command pattern, commands for objects to be implemented are queued and can be executed at any time. Arguments are considered passed when the method is called.

<code>
count = 0

commands = []
(1..10).each do |i|
commands << proc { count +=i }
end

puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"
</code>

===Strategy Pattern===
The Strategy Pattern allows an algorithms behavior to be determined at runtime. It describes the definition of a family of interchangeable algorithm classes whose functionality is different for identically named methods.

<code>
class Fighter
def initialize(&fighting_behavior)
@finish_move = fighting_behavior
end

def finish_opponent
@finish_move.call
end
end

boxer = Fighter.new { puts 'Left hook to the body!' }
boxer.finish_opponent #=> Left hook to the body!

mortal_kombat_warrior = Fighter.new { puts 'Blast him with a lighting bolt' }
mortal_kombat_warrior.finish_opponent #=> Blast him with a lighting bolt

mma = Fighter.new { puts 'Put you to sleep, Good Night!' }
mma.finish_opponent #=> Put you to sleep, Good Night!

lion = Fighter.new { puts 'Bites your head off' }
lion.finish_opponent #=> Bites your head off!
</code>

== See Also ==
== References ==
<references />

CSC/ECE 517 Spring 2014/ch1 1w1l m

2014-02-24T02:44:18Z

Seschro2:

= Design Patterns Involving Closures =

== Background ==
=== Explanation of Closures ===

Very simply, a closure is a function that can use a variable that was valid within the scope that the closure was defined, but need not be in-scope where the closure is called. A quick example is very illustrative.

<code>
def closure_builder(message="Default"):
def closure():
# Message is in-scope here
print message
return closure

# Build two functions
default_closure = closure_builder()
custom_closure = closure_builder("Custom")
del closure_builder

# Call the closures you built
default_closure() # Amazingly, prints "Default"
custom_closure() # Amazingly, prints "Custom"
</code>

== Examples ==

=== Decorators ===

Decorators are an interesting and powerful language feature that can be implemented elegantly with closures.

<code>
#!/usr/bin/env python

def decorate(func):
def decorated_func():
print "About to call func"
func()
print "Back from calling func"
return decorated_func

@decorate
def func_to_decorate():
print "In func_to_decorate"

func_to_decorate()
</code>

<code>
[~517/wiki]$ chmod ug+x decorator.py
[~517/wiki]$ ./decorator.py
About to call func
In func_to_decorate
Back from calling func
</code>

=== Command Pattern===
The command Pattern can be implemented using proc objects, which are the closure of an object

In the command pattern, commands for objects to be implemented are queued and can be executed at any time. Arguments are considered passed when the method is called.

<code>
count = 0

commands = []
(1..10).each do |i|
commands << proc { count +=i }
end

puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"
</code>

===Strategy Pattern===
The Strategy Pattern allows an algorithms behavior to be determined at runtime. It describes the definition of a family of interchangeable algorithm classes whose functionality is different for identically named methods.

<code>
class Fighter
def initialize(&fighting_behavior)
@finish_move = fighting_behavior
end

def finish_opponent
@finish_move.call
end
end

boxer = Fighter.new { puts 'Left hook to the body!' }
boxer.finish_opponent #=> Left hook to the body!

mortal_kombat_warrior = Fighter.new { puts 'Blast him with a lighting bolt' }
mortal_kombat_warrior.finish_opponent #=> Blast him with a lighting bolt

mma = Fighter.new { puts 'Put you to sleep, Good Night!' }
mma.finish_opponent #=> Put you to sleep, Good Night!

lion = Fighter.new { puts 'Bites your head off' }
lion.finish_opponent #=> Bites your head off!
</code>

== See Also ==
== References ==
<references />

CSC/ECE 517 Spring 2014/ch1 1w1l m

2014-02-24T02:10:42Z

Seschro2:

= Design Patterns Involving Closures =

== Background ==
=== Explanation of Closures ===

Very simply, a closure is a function that can use a variable that was valid within the scope that the closure was defined, but need not be in-scope where the closure is called. A quick example is very illustrative.

<code>
def closure_builder(message="Default"):
def closure():
# Message is in-scope here
print message
return closure

# Build two functions
default_closure = closure_builder()
custom_closure = closure_builder("Custom")
del closure_builder

# Call the closures you built
default_closure() # Amazingly, prints "Default"
custom_closure() # Amazingly, prints "Custom"
</code>

== Examples ==

=== Decorators ===

Decorators are an interesting and powerful language feature that can be implemented elegantly with closures.

<code>
#!/usr/bin/env python

def decorate(func):
def decorated_func():
print "About to call func"
func()
print "Back from calling func"
return decorated_func

@decorate
def func_to_decorate():
print "In func_to_decorate"

func_to_decorate()
</code>

<code>
[~517/wiki]$ chmod ug+x decorator.py
[~517/wiki]$ ./decorator.py
About to call func
In func_to_decorate
Back from calling func
</code>

=== Command Pattern===
The command Pattern can be implemented using proc objects, which are the closure of an object

In the command pattern, commands for objects to be implemented are queued and can be executed at any time. Arguments are considered passed when the method is called.

<code>
count = 0

commands = []
(1..10).each do |i|
commands << proc { count +=i }
end

puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"
</code>

===Strategy Pattern===

<code>

class Report
attr_reader :title, :text
attr_accessor :formatter
def initialize(&formatter)
@title = 'Monthly Report'
@text = [ 'Things are going', 'really, really well.' ]
@formatter = formatter
end
def output_report
@formatter.call( self )
end
end

HTML_FORMATTER = lambda do |context|
puts('<html>')
puts(' <head>')
puts(" <title>#{context.title}</title>")
puts(' </head>')
puts(' <body>')
context.text.each do |line|
puts(" <p>#{line}</p>" )
end
puts(' </body>')
puts(' </html>')
end
</code>

== See Also ==
== References ==
<references />

CSC/ECE 517 Spring 2014/ch1 1w1l m

2014-02-24T02:08:57Z

Seschro2:

= Design Patterns Involving Closures =

== Background ==
=== Explanation of Closures ===

Very simply, a closure is a function that can use a variable that was valid within the scope that the closure was defined, but need not be in-scope where the closure is called. A quick example is very illustrative.

<code>
def closure_builder(message="Default"):
def closure():
# Message is in-scope here
print message
return closure

# Build two functions
default_closure = closure_builder()
custom_closure = closure_builder("Custom")
del closure_builder

# Call the closures you built
default_closure() # Amazingly, prints "Default"
custom_closure() # Amazingly, prints "Custom"
</code>

== Examples ==

=== Decorators ===

Decorators are an interesting and powerful language feature that can be implemented elegantly with closures.

<code>
#!/usr/bin/env python

def decorate(func):
def decorated_func():
print "About to call func"
func()
print "Back from calling func"
return decorated_func

@decorate
def func_to_decorate():
print "In func_to_decorate"

func_to_decorate()
</code>

<code>
[~517/wiki]$ chmod ug+x decorator.py
[~517/wiki]$ ./decorator.py
About to call func
In func_to_decorate
Back from calling func
</code>

=== Command Pattern===
The command Pattern can be implemented using proc objects, which are the closure of an object

In the command pattern, commands for objects to be implemented are queued and can be executed at any time. Arguments are considered passed when the method is called.

<code>
count = 0

commands = []
(1..10).each do |i|
commands << proc { count +=i }
end

puts "Count is initially #{count}"
commands.each { |cmd| cmd.call }
puts "Performed all commands. count is #{count}"
</code>

===Strategy Pattern===

<code>

class Report
attr_reader :title, :text
attr_accessor :formatter
def initialize(&formatter)
@title = 'Monthly Report'
@text = [ 'Things are going', 'really, really well.' ]
@formatter = formatter
end
def output_report
@formatter.call( self )
end
end

HTML_FORMATTER = lambda do |context|
puts('<html>')
puts(' <head>')
puts(" <title>#{context.title}</title>")
puts(' </head>')
puts(' <body>')
context.text.each do |line|
puts(" <p>#{line}</p>" )
end
puts(' </body>')
puts(' </html>')
end
</code>

== See Also ==
== References ==
<references />

CSC/ECE 517 Spring 2014/ch1 1w1l m

2014-02-24T01:58:13Z

Seschro2:

CSC/ECE 517 Spring 2014/ch1 1w1l m

2014-02-24T01:37:49Z

Seschro2:

CSC/ECE 517 Spring 2014/ch1 1w1l m

2014-02-23T18:33:42Z

Seschro2: