gaku_core 0.1.1 → 0.2.0

data/lib/gaku/grading/collection/calculations.rb

@@ -0,0 +1,36 @@
+module Gaku
+  module Grading
+    module Collection
+      class  Calculations
+
+        attr_reader :grading_methods, :students, :exam
+
+        def initialize(grading_method, students, exam)
+          @exam            = exam
+          @students        = students
+          @grading_methods = grading_method
+        end
+
+        def calculate
+          {}.tap do |hash|
+            @grading_methods.each do |grading_method|
+              grading = grading_types[grading_method.grading_type].constantize.new(@exam, @students, grading_method.criteria)
+              hash[grading_method.id] = grading.grade
+            end
+          end
+        end
+
+        private
+
+        def grading_types
+          ActiveSupport::HashWithIndifferentAccess.new(
+            score: 'Gaku::Grading::Collection::Score',
+            percentage: 'Gaku::Grading::Collection::Percentage',
+            ordinal: 'Gaku::Grading::Collection::Ordinal',
+            interval: 'Gaku::Grading::Collection::Interval'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/gaku/grading/collection/interval.rb

@@ -0,0 +1,55 @@
+class Gaku::Grading::Collection::Interval < Gaku::Grading::Collection::BaseMethod
+
+  def grade_exam
+
+    @scores = students_with_scores
+
+    formated_student_results.each do |student|
+      @result << Gaku::Grading::Single::Interval.new(@gradable, student).grade_exam
+    end
+
+    @result
+  end
+
+  private
+
+  def student_positions
+    criteria.map {|key, value| [key, ( @scores.count * (value.to_f/100)).ceil] }.to_h
+  end
+
+  def students_by_score
+    @scores.group_by(&:last).sort.reverse.map{|a| a.last.map(&:first)}
+  end
+
+
+  def interval_results
+    @students_by_score = students_by_score
+    student_positions.each_with_object(Hash.new{|h, k| h[k] = []}) do |( key, value), hash|
+
+      while value > hash[key].length
+        break if @students_by_score.empty?
+        hash[key].push(*@students_by_score.shift)
+      end
+
+    end
+  end
+
+  def score_results
+    Gaku::Grading::Collection::Score.new(@gradable, @students).grade
+  end
+
+  def students_with_scores
+    score_results['student_results'].each_with_object({}) do |student_result, h|
+      h[student_result['id']] = student_result['score']
+    end.reject {|_student_id, score| score.nil? }
+  end
+
+  def students_without_scores
+    score_results['student_results'].select {|results| results['score'].nil? }.map {|x| [x['id'], x['score']]}
+  end
+
+  def formated_student_results
+    interval_results.flat_map {|k, v| v.map { |x| [x, k] } }.push *students_without_scores
+  end
+
+end

data/lib/gaku/grading/collection/ordinal.rb

@@ -0,0 +1,10 @@
+class Gaku::Grading::Collection::Ordinal < Gaku::Grading::Collection::BaseMethod
+
+  def grade_exam
+    @students.each do |student|
+      @result << Gaku::Grading::Single::Ordinal.new(@gradable, student, criteria).grade_exam
+    end
+    @result
+  end
+
+end

data/lib/gaku/grading/collection/percentage.rb

@@ -0,0 +1,10 @@
+class Gaku::Grading::Collection::Percentage < Gaku::Grading::Collection::BaseMethod
+
+  def grade_exam
+    @students.each do |student|
+      @result << Gaku::Grading::Single::Percentage.new(@gradable, student).grade_exam
+    end
+    @result
+  end
+
+end

data/lib/gaku/grading/collection/result.rb

@@ -0,0 +1,18 @@
+module Gaku
+  module Grading
+    module Collection
+      class  Result
+
+        def initialize(exam_id, result)
+          @exam_id = exam_id
+          @result = result
+        end
+
+        def as_json
+          { exam_id: @exam_id, student_results: @result }.as_json
+        end
+
+      end
+    end
+  end
+end

data/lib/gaku/grading/collection/score.rb

@@ -0,0 +1,10 @@
+class Gaku::Grading::Collection::Score < Gaku::Grading::Collection::BaseMethod
+
+  def grade_exam
+    @students.each do |student|
+      @result << Gaku::Grading::Single::Score.new(@gradable, student).grade_exam
+    end
+    @result
+  end
+
+end

data/lib/gaku/grading/single/base_method.rb

@@ -0,0 +1,30 @@
+module Gaku
+  module Grading
+    module Single
+      class  BaseMethod
+        attr_reader :gradable, :gradable_type, :student, :criteria, :result
+
+        # Pass a gradable object [exam or assignment] and students
+        def initialize(gradable, student, criteria = nil)
+          @gradable = gradable
+          @student = student
+          @criteria = criteria
+          @result = {}
+        end
+
+        # Obtain graded hash of results
+        def grade
+          case @gradable
+          when Gaku::Exam
+            grade_exam
+          when Gaku::Assignment
+            #grade_assignment
+          end
+
+          Gaku::Grading::Single::Result.new(@gradable.id, @result).as_json
+        end
+
+      end
+    end
+  end
+end

data/lib/gaku/grading/single/calculations.rb

@@ -0,0 +1,42 @@
+module Gaku
+  module Grading
+    module Single
+      class  Calculations
+
+        attr_reader :grading_methods, :student, :exam, :collection_students
+
+        def initialize(grading_methods, student, exam, collection_students = nil)
+          @exam                = exam
+          @student             = student
+          @grading_methods     = grading_methods
+          @collection_students = collection_students
+        end
+
+        def calculate
+          {}.tap do |hash|
+            @grading_methods.each do |grading_method|
+              if grading_method.interval?
+                grading = Gaku::Grading::Collection::Interval.new(@exam, collection_students, grading_method.criteria )
+                hash[grading_method.id] = grading.grade
+              else
+                grading = grading_types[grading_method.grading_type].constantize.new(@exam, @student, grading_method.criteria)
+                hash[grading_method.id] = grading.grade
+              end
+            end
+          end
+
+        end
+
+        private
+
+        def grading_types
+          ActiveSupport::HashWithIndifferentAccess.new(
+            score: 'Gaku::Grading::Single::Score',
+            percentage: 'Gaku::Grading::Single::Percentage',
+            ordinal: 'Gaku::Grading::Single::Ordinal'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/gaku/grading/single/interval.rb

@@ -0,0 +1,7 @@
+class Gaku::Grading::Single::Interval < Gaku::Grading::Single::BaseMethod
+
+  def grade_exam
+    @result = { id: student.first, score: student.last }
+  end
+
+end

data/lib/gaku/grading/single/ordinal.rb

@@ -0,0 +1,30 @@
+class Gaku::Grading::Single::Ordinal < Gaku::Grading::Single::BaseMethod
+
+  attr_accessor :criteria
+
+  def grade_exam
+    exam = @gradable
+
+    percentage = Gaku::Grading::Single::Percentage.new(exam, @student).grade
+    @result = { id: @student.id, score: ordinal(percentage['score']) }
+  end
+
+  private
+
+  def ordinal(percentage)
+    if percentage
+      criteria.sort_by(&:last).reverse.find  do |grade, min_points|
+        percentage >= min_points.to_i
+      end.first
+    end
+  end
+
+  def criteria
+    if @criteria.values.include? '0'
+      @criteria
+    else
+      @criteria.merge('' => '0')
+    end
+  end
+
+end

data/lib/gaku/grading/single/pass_fail.rb

@@ -0,0 +1,2 @@
+class Gaku::Grading::Single::PassFail < Gaku::Grading::Single::BaseMethod
+end

data/lib/gaku/grading/single/percentage.rb

@@ -0,0 +1,26 @@
+class Gaku::Grading::Single::Percentage < Gaku::Grading::Single::BaseMethod
+
+  attr_reader :scores
+
+  def grade_exam
+    exam = @gradable
+
+    @scores = []
+    @max_score = exam.max_score
+
+    exam.exam_portions.each_with_index do |exam_portion, index|
+      ep_score = @student.exam_portion_scores.where(exam_portion_id: exam_portion.id).first_or_create!
+      @scores << ep_score.score if ep_score.score
+    end
+
+    @result = { id: @student.id, score: formated_score }
+  end
+
+  def score
+    @scores.inject(:+) / @max_score unless @scores.blank?
+  end
+
+  def formated_score
+    score.try(:*, 100).try(:round, 3)
+  end
+end

data/lib/gaku/grading/single/ratio.rb

@@ -0,0 +1,2 @@
+class Gaku::Grading::Single::Ratio < Gaku::Grading::Single::BaseMethod
+end

data/lib/gaku/grading/single/result.rb

@@ -0,0 +1,18 @@
+module Gaku
+  module Grading
+    module Single
+      class Result
+
+        def initialize(exam_id, result)
+          @exam_id = exam_id
+          @result = result
+        end
+
+        def as_json
+          @result.merge(exam_id: @exam_id).as_json
+        end
+
+      end
+    end
+  end
+end

data/lib/gaku/grading/single/score.rb

@@ -0,0 +1,15 @@
+class Gaku::Grading::Single::Score < Gaku::Grading::Single::BaseMethod
+
+  def grade_exam
+    @score = nil
+    exam = @gradable
+
+    exam.exam_portions.each_with_index do |exam_portion, index|
+      ep_score = @student.exam_portion_scores.where(exam_portion_id: exam_portion.id).first_or_create!
+      @score = @score.to_f + ep_score.score if ep_score.score
+    end
+
+    @result = { id: @student.id, score: @score }
+  end
+
+end

data/lib/gaku/migrations.rb

@@ -1,7 +1,7 @@
 module Gaku
   module Migrations
 
-    def self.included(base)
+    def self.included(_base)
       ActiveRecord::ConnectionAdapters::Table.send :include, TableDefinition
       ActiveRecord::ConnectionAdapters::TableDefinition.send :include, TableDefinition
     end

data/lib/gaku/streamer/sse.rb

@@ -1,15 +1,15 @@
-#change SSE.new with rails SSE object when is released
-#https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/metal/live.rb
+# change SSE.new with rails SSE object when is released
+# https://github.com/rails/rails/blob/master/actionpack/lib/action_controller/metal/live.rb
 require 'json'
 
 module Streamer
   class SSE
-    def initialize io
+    def initialize(io)
       @io = io
     end
 
-    def write object, options = {}
-      options.each do |k,v|
+    def write(object, options = {})
+      options.each do |k, v|
         @io.write "#{k}: #{v}\n"
       end
       @io.write "data: #{object}\n\n"

data/lib/gaku/testing/auth_helpers.rb

@@ -12,7 +12,11 @@ module Gaku::Testing::AuthHelpers
 
   module Feature
     def as(user)
-      login_as create("#{user.to_sym}_user"), scope: :user
+      if user.is_a?(Symbol)
+        login_as create("#{user.to_sym}_user"), scope: :user
+      else
+        login_as user, scope: :user
+      end
     end
   end
 
@@ -20,6 +24,6 @@ end
 
 RSpec.configure do |config|
   config.include Gaku::Testing::AuthHelpers::Controller, type: :controller
+  config.include Gaku::Testing::AuthHelpers::Feature, type: :request
   config.include Gaku::Testing::AuthHelpers::Feature, type: :feature
 end
-

data/lib/gaku/testing/common_rake.rb

@@ -4,19 +4,25 @@ end
 
 desc 'Generates a dummy app for testing'
 namespace :common do
-  task :test_app do |t, args|
+  task :test_app do
 
     require "#{ENV['LIB_NAME']}"
 
     puts ENV['LIB_NAME']
 
     Gaku::DummyGenerator.start ["--lib_name=#{ENV['LIB_NAME']}", '--quiet']
-    Gaku::InstallGenerator.start ["--lib_name=#{ENV['LIB_NAME']}", '--auto-accept', '--migrate=false', '--seed=false', '--sample=false', '--quiet']
+    Gaku::InstallGenerator.start ["--lib_name=#{ENV['LIB_NAME']}",
+                                  '--auto-accept',
+                                  '--migrate=false',
+                                  '--seed=false',
+                                  '--sample=false',
+                                  '--quiet'
+                                 ]
 
     puts 'Setting up dummy database...'
     cmd = 'bundle exec rake db:drop db:create db:migrate db:test:prepare RAILS_ENV=test'
 
-    if RUBY_PLATFORM =~ /mswin/ #windows
+    if RUBY_PLATFORM =~ /mswin/ # windows
       cmd += ' >nul'
     else
       cmd += ' >/dev/null'

data/lib/gaku/testing/controller_helpers.rb

@@ -1,7 +1,13 @@
 module Gaku::Testing::ControllerHelpers
 
+  extend ActiveSupport::Concern
+
+  included do
+    routes { ::Gaku::Core::Engine.routes }
+  end
+
   def gaku_get(action, parameters = nil, session = nil, flash = nil)
-    process_gaku_action(action,'GET', parameters, session, flash)
+    process_gaku_action(action, 'GET', parameters, session, flash)
   end
 
   def gaku_post(action, parameters = nil, session = nil, flash = nil)
@@ -49,47 +55,46 @@ module Gaku::Testing::ControllerHelpers
   end
 
   def ensure_not_found
-    expect(json_response).to eq({ 'error' => 'The resource you were looking for could not be found.' })
+    expect(json_response).to eq('error' => 'The resource you were looking for could not be found.')
     expect(response.status).to eq 404
   end
 
   def ensure_unauthorized
-    expect(json_response).to eq({ 'error' => 'You need to sign in or sign up before continuing.' })
+    expect(json_response).to eq('error' => 'You need to sign in or sign up before continuing.')
     expect(response.status).to eq 401
   end
 
-  def api_get(action, params={}, session=nil, flash=nil)
+  def api_get(action, params = {}, session = nil, flash = nil)
     api_process(action, params, session, flash, 'GET')
   end
 
-  def api_post(action, params={}, session=nil, flash=nil)
+  def api_post(action, params = {}, session = nil, flash = nil)
     api_process(action, params, session, flash, 'POST')
   end
 
-  def api_put(action, params={}, session=nil, flash=nil)
+  def api_put(action, params = {}, session = nil, flash = nil)
     api_process(action, params, session, flash, 'PUT')
   end
 
-  def api_delete(action, params={}, session=nil, flash=nil)
+  def api_delete(action, params = {}, session = nil, flash = nil)
     api_process(action, params, session, flash, 'DELETE')
   end
 
-  def api_process(action, params={}, session=nil, flash=nil, method='get')
+  def api_process(action, params = {}, session = nil, flash = nil, method = 'get')
     scoping = respond_to?(:resource_scoping) ? resource_scoping : {}
     process(action, method, params.merge(scoping).reverse_merge!(format: :json, use_route: :gaku), session, flash)
   end
 
   private
 
-  def process_gaku_action(action, method = 'GET' ,parameters = nil, session = nil, flash = nil)
+  def process_gaku_action(action, method = 'GET', parameters = nil, session = nil, flash = nil)
     parameters ||= {}
-    process(action, method, parameters.merge!(use_route: :gaku), session, flash)
+    process(action, method, parameters, session, flash)
   end
 
-  def process_js_gaku_action(action, method = 'GET' ,parameters = nil, session = nil, flash = nil)
+  def process_js_gaku_action(action, method = 'GET', parameters = nil, session = nil, flash = nil)
     parameters ||= {}
     parameters.reverse_merge!(format: :js)
-    parameters.merge!(use_route: :gaku)
     xml_http_request(method, action, parameters, session, flash)
   end