mumuki-laboratory 7.0.10 → 7.0.11

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/exam_authorization.rb

@@ -0,0 +1,10 @@
+class ExamAuthorization < ApplicationRecord
+
+  belongs_to :user
+  belongs_to :exam
+
+  def start!
+    update!(started: true, started_at: Time.now) unless started?
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/exercise.rb

@@ -0,0 +1,241 @@
+class Exercise < ApplicationRecord
+  RANDOMIZED_FIELDS = [:default_content, :description, :extra, :hint, :test]
+  BASIC_RESOURCE_FIELDS = %i(
+    name layout editor corollary teacher_info manual_evaluation locale
+    choices assistance_rules randomizations tag_list extra_visible goal
+    free_form_editor_source initial_state final_state)
+
+  include WithDescription
+  include WithLocale
+  include WithNumber,
+          WithName,
+          WithAssignments,
+          FriendlyName,
+          WithLanguage,
+          Assistable,
+          WithRandomizations,
+          WithDiscussions
+
+  include Submittable,
+          Questionable
+
+  include SiblingsNavigation,
+          ParentNavigation
+
+  belongs_to :guide
+
+  markdown_on :teacher_info
+
+  defaults { self.submissions_count = 0 }
+
+  serialize :choices, Array
+  serialize :settings, Hash
+
+  validates_presence_of :submissions_count,
+                        :guide, :bibliotheca_id
+
+  randomize(*RANDOMIZED_FIELDS)
+  delegate :timed?, to: :navigable_parent
+
+  def console?
+    queriable?
+  end
+
+  def used_in?(organization=Organization.current)
+    guide.usage_in_organization(organization).present?
+  end
+
+  def pending_siblings_for(user)
+    guide.pending_exercises(user)
+  end
+
+  def structural_parent
+    guide
+  end
+
+  def guide_done_for?(user)
+    guide.done_for?(user)
+  end
+
+  def previous
+    sibling_at number.pred
+  end
+
+  def sibling_at(index)
+    index = number + index unless index.positive?
+    guide.exercises.find_by(number: index)
+  end
+
+  def search_tags
+    [language&.name, *tag_list].compact
+  end
+
+  def transparent_id
+    "#{guide.transparent_id}/#{bibliotheca_id}"
+  end
+
+  def transparent_params
+    guide.transparent_params.merge(bibliotheca_id: bibliotheca_id)
+  end
+
+  def friendly
+    defaulting_name { "#{navigable_parent.friendly} - #{name}" }
+  end
+
+  def submission_for(user)
+    assignment_for(user).submission
+  end
+
+  def new_solution
+    Mumuki::Domain::Submission::Solution.new(content: default_content)
+  end
+
+  def import_from_resource_h!(number, resource_h)
+    self.language = Language.for_name(resource_h.dig(:language, :name)) || guide.language
+    self.locale = guide.locale
+
+    reset!
+
+    attrs = whitelist_attributes(resource_h, except: [:type, :id])
+    attrs[:choices] = resource_h[:choices].to_a
+    attrs[:bibliotheca_id] = resource_h[:id]
+    attrs[:number] = number
+    attrs[:manual_evaluation] ||= false
+    attrs = attrs.except(:expectations, :custom_expectations) if type != 'Problem'
+
+    assign_attributes(attrs)
+    save!
+  end
+
+  def choice_values
+    self[:choice_values].presence || choices.map { |it| it.indifferent_get(:value) }
+  end
+
+  def choice_index_for(value)
+    choice_values.index(value)
+  end
+
+  def to_resource_h
+    to_expanded_resource_h.compact
+  end
+
+  # Keep this list up to date with
+  # Mumuki::Domain::Store::ExerciseSchema
+  def to_expanded_resource_h
+    language_resource_h = language.to_embedded_resource_h if language != guide.language
+    as_json(only: BASIC_RESOURCE_FIELDS)
+      .merge(id: bibliotheca_id, language: language_resource_h, type: type.underscore)
+      .merge(expectations: self[:expectations])
+      .merge(custom_expectations: self[:custom_expectations])
+      .merge(settings: self[:settings])
+      .merge(RANDOMIZED_FIELDS.map { |it| [it, self[it]] }.to_h)
+      .symbolize_keys
+  end
+
+  def reset!
+    self.name = nil
+    self.description = nil
+    self.corollary = nil
+    self.hint = nil
+    self.extra = nil
+    self.tag_list = []
+  end
+
+  def ensure_type!(type)
+    if self.type != type
+      reclassify! type
+    else
+      self
+    end
+  end
+
+  def reclassify!(type)
+    update!(type: type)
+    Exercise.find(id)
+  end
+
+  def messages_path_for(user)
+    "api/guides/#{guide.slug}/#{bibliotheca_id}/student/#{URI.escape user.uid}/messages?language=#{language}"
+  end
+
+  def messages_url_for(user)
+    Mumukit::Platform.classroom_api.organic_url_for(Organization.current, messages_path_for(user))
+  end
+
+  def description_context
+    Mumukit::ContentType::Markdown.to_html splitted_description.first
+  end
+
+  def splitted_description
+    description.split('> ')
+  end
+
+  def description_task
+    Mumukit::ContentType::Markdown.to_html splitted_description.drop(1).join("\n")
+  end
+
+  def custom?
+    false
+  end
+
+  def inspection_keywords
+    {}
+  end
+
+  # Submits the user solution
+  # only if the corresponding assignment has attemps left
+  def try_submit_solution!(user, solution={})
+    assignment = assignment_for(user)
+    if assignment.attempts_left?
+      submit_solution!(user, solution)
+    else
+      assignment
+    end
+  end
+
+  def limited?
+    navigable_parent.limited_for?(self)
+  end
+
+  def files_for(current_content)
+    language
+      .directives_sections
+      .split_sections(current_content)
+      .map { |name, content| Mumuki::Domain::File.new name, content }
+  end
+
+  def self.find_transparently!(params)
+    Guide.find_transparently!(params).locate_exercise! params[:bibliotheca_id]
+  end
+
+  def self.locate!(slug_and_bibliotheca_id)
+    slug, bibliotheca_id = slug_and_bibliotheca_id
+    Guide.locate!(slug).locate_exercise! bibliotheca_id
+  end
+
+  def settings
+    guide.settings.deep_merge super
+  end
+
+  private
+
+  def evaluation_class
+    if manual_evaluation?
+      manual_evaluation_class
+    else
+      automated_evaluation_class
+    end
+  end
+
+  def manual_evaluation_class
+    Mumuki::Domain::Evaluation::Manual
+  end
+
+  def automated_evaluation_class
+    Mumuki::Domain::Evaluation::Automated
+  end
+
+  def self.default_layout
+    layouts.keys[0]
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/exercise/challenge.rb

@@ -0,0 +1,25 @@
+class Challenge < Exercise
+  include WithLayout
+
+  markdown_on :hint
+
+  def reset!
+    super
+    self.layout = self.class.default_layout
+  end
+
+  def extra(*)
+    [guide.extra, super]
+      .compact
+      .join("\n")
+      .strip
+      .ensure_newline
+  end
+
+  private
+
+  def defaults
+    super
+    self.layout = self.class.default_layout
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/exercise/interactive.rb

@@ -0,0 +1,41 @@
+class Interactive < Challenge
+  include Triable
+
+  markdown_on :corollary
+  validate :ensure_triable_language
+  validate :ensure_stateful_console
+
+  serialize :goal
+  name_model_as Exercise
+
+  def console?
+    true
+  end
+
+  def stateful_console?
+    true
+  end
+
+  def queriable?
+    false
+  end
+
+  def hidden?
+    false
+  end
+
+  def upload?
+    false
+  end
+
+  private
+
+  def ensure_triable_language
+    errors.add(:base, :language_not_triable) unless language.triable?
+  end
+
+  def ensure_stateful_console
+    errors.add(:base, :console_not_stateful) unless language.stateful_console?
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/exercise/playground.rb

@@ -0,0 +1,23 @@
+class Playground < QueriableChallenge
+  validate :ensure_queriable_language
+
+  name_model_as Exercise
+
+  def setup_query_assignment!(assignment)
+    assignment.running!
+  end
+
+  def save_query_results!(assignment)
+    unless assignment.passed?
+      assignment.passed!
+      assignment.notify!
+    end
+  end
+
+  private
+
+  def ensure_queriable_language
+    errors.add(:base, :language_not_queriable) unless queriable?
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/exercise/problem.rb

@@ -0,0 +1,53 @@
+class Problem < QueriableChallenge
+  include WithExpectations,
+          WithEditor,
+          Solvable
+
+  markdown_on :corollary
+
+  validate :ensure_evaluation_criteria
+
+  name_model_as Exercise
+
+  def setup_query_assignment!(assignment)
+  end
+
+  def save_query_results!(assignment)
+  end
+
+  def reset!
+    super
+    self.test = nil
+    self.expectations = []
+  end
+
+  def expectations
+    own_expectations + guide_expectations
+  end
+
+  def custom_expectations
+    "#{own_custom_expectations}\n#{guide_custom_expectations}"
+  end
+
+  def guide_expectations
+    guide.expectations
+  end
+
+  def guide_custom_expectations
+    guide.custom_expectations
+  end
+
+  def evaluation_criteria?
+    manual_evaluation? || expectations? || test.present?
+  end
+
+  def expectations?
+    own_expectations.present? || own_custom_expectations.present?
+  end
+
+  private
+
+  def ensure_evaluation_criteria
+    errors.add :base, :evaluation_criteria_required unless evaluation_criteria?
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/exercise/queriable_challenge.rb

@@ -0,0 +1,5 @@
+class QueriableChallenge < Challenge
+  include Queriable
+
+  delegate :stateful_console?, to: :language
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/exercise/reading.rb

@@ -0,0 +1,17 @@
+class Reading < Exercise
+  include Confirmable
+
+  name_model_as Exercise
+
+  def layout
+    :input_bottom
+  end
+
+  def input_kids?
+    false
+  end
+
+  def queriable?
+    false
+  end
+end

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/app/models/guide.rb

@@ -0,0 +1,132 @@
+class Guide < Content
+  BASIC_RESOURCE_FIELDS = %i(
+    authors beta collaborators corollary
+    custom_expectations expectations extra id_format
+    learn_more private settings sources teacher_info type)
+
+  include WithStats,
+          WithExpectations,
+          WithLanguage
+
+  markdown_on :corollary, :sources, :learn_more, :teacher_info
+
+  numbered :exercises
+  has_many :exercises, -> { order(number: :asc) }, dependent: :destroy
+
+  serialize :settings, Hash
+
+  self.inheritance_column = nil
+
+  enum type: [:learning, :practice]
+
+  def clear_progress!(user, organization=Organization.current)
+    transaction do
+      exercises.each do |exercise|
+        exercise.find_assignment_for(user, organization)&.destroy!
+      end
+    end
+  end
+
+  def lesson
+    usage_in_organization_of_type Lesson
+  end
+
+  def chapter
+    lesson.try(:chapter) #FIXME temporary
+  end
+
+  def exercises_count
+    exercises.count
+  end
+
+  def pending_exercises(user)
+    exercises.
+        joins("left join public.assignments assignments
+                on assignments.exercise_id = exercises.id
+                and assignments.submitter_id = #{user.id}
+                and assignments.submission_status = #{Mumuki::Domain::Status::Submission::Passed.to_i}").
+        where('assignments.id is null')
+  end
+
+  def next_exercise(user)
+    pending_exercises(user).order('public.exercises.number asc').first
+  end
+
+  def first_exercise
+    exercises.first
+  end
+
+  def search_tags
+    exercises.flat_map(&:search_tags).uniq
+  end
+
+  def done_for?(user)
+    stats_for(user).done?
+  end
+
+  # Finds an exercise by bibliotheca_id within this guide
+  def locate_exercise!(bibliotheca_id)
+    exercises.find_by!(bibliotheca_id: bibliotheca_id)
+  end
+
+  def import_from_resource_h!(resource_h)
+    self.assign_attributes whitelist_attributes(resource_h)
+    self.language = Language.for_name(resource_h.dig(:language, :name))
+    self.save!
+
+    resource_h[:exercises]&.each_with_index do |e, i|
+      exercise = Exercise.find_by(guide_id: self.id, bibliotheca_id: e[:id])
+      exercise_type = e[:type] || 'problem'
+
+      exercise = exercise ?
+          exercise.ensure_type!(exercise_type.as_module_name) :
+          exercise_type.as_module.new(guide_id: self.id, bibliotheca_id: e[:id])
+
+      exercise.import_from_resource_h! (i+1), e
+    end
+
+    new_ids = resource_h[:exercises].map { |it| it[:id] }
+    self.exercises.where.not(bibliotheca_id: new_ids).destroy_all
+
+    reload
+  end
+
+  # Keep this list up to date with
+  # Mumuki::Domain::Store::Github::GuideSchema
+  def to_expanded_resource_h
+    as_json(only: BASIC_RESOURCE_FIELDS)
+      .symbolize_keys
+      .merge(super)
+      .merge(exercises: exercises.map(&:to_resource_h))
+      .merge(language: language.to_embedded_resource_h)
+  end
+
+  def to_markdownified_resource_h
+    to_resource_h.tap do |guide|
+      %i(corollary description teacher_info).each do |it|
+        guide[it] = Mumukit::ContentType::Markdown.to_html(guide[it])
+      end
+      %i(hint corollary description teacher_info).each do |it|
+        guide[:exercises].each { |exercise| exercise[it] = Mumukit::ContentType::Markdown.to_html(exercise[it]) }
+      end
+    end
+  end
+
+  def as_lesson_of(topic)
+    topic.lessons.find_by(guide_id: id) || Lesson.new(guide: self, topic: topic)
+  end
+
+  def as_complement_of(book) #FIXME duplication
+    book.complements.find_by(guide_id: id) || Complement.new(guide: self, book: book)
+  end
+
+  def resettable?
+    usage_in_organization.resettable?
+  end
+
+  ## Forking
+
+  def fork_children_into!(dup, _organization, _syncer)
+    dup.exercises = exercises.map(&:dup)
+  end
+end