mumuki-domain 6.0.0

data/app/models/book.rb

@@ -0,0 +1,64 @@
+class Book < Content
+  numbered :chapters
+  aggregate_of :chapters
+
+  has_many :chapters, -> { order(number: :asc) }, dependent: :delete_all
+  has_many :complements, dependent: :delete_all
+
+  has_many :exercises, through: :chapters
+  has_many :discussions, through: :exercises
+
+  delegate :first_lesson, to: :first_chapter
+
+  def to_s
+    slug
+  end
+
+  def first_chapter
+    chapters.first
+  end
+
+  def next_lesson_for(user)
+    user.try(:last_lesson)|| first_lesson
+  end
+
+  def import_from_resource_h!(resource_h)
+    self.assign_attributes resource_h.except(:chapters, :complements, :id, :description, :teacher_info)
+    self.description = resource_h[:description]&.squeeze(' ')
+
+    rebuild! resource_h[:chapters].map { |it| Topic.find_by!(slug: it).as_chapter_of(self) }
+    rebuild_complements! resource_h[:complements].to_a.map { |it| Guide.find_by(slug: it)&.as_complement_of(self) }.compact
+
+    Organization.where(book: self).each { |org| org.reindex_usages! }
+  end
+
+  def to_resource_h
+    super.merge(
+      chapters: chapters.map(&:slug),
+      complements: complements.map(&:slug))
+  end
+
+  def rebuild_complements!(complements) #FIXME use rebuild
+    transaction do
+      self.complements.all_except(complements).delete_all
+      self.update! :complements => complements
+      complements.each &:save!
+    end
+    reload
+  end
+
+  def index_usage!(organization)
+    [chapters, complements].flatten.each { |item| item.index_usage! organization }
+  end
+
+  ## Forking
+
+  def fork_to!(organization, syncer)
+    rebased_dup(organization).tap do |dup|
+      dup.chapters = chapters.map { |chapter| chapter.topic.fork_to!(organization, syncer).as_chapter_of(self) }
+      dup.complements = complements.map { |complement| complement.guide.fork_to!(organization, syncer).as_complement_of(self) }
+      dup.save!
+      syncer.export! dup
+    end
+  end
+end

data/app/models/chapter.rb

@@ -0,0 +1,29 @@
+class Chapter < ApplicationRecord
+  include WithStats
+  include WithNumber
+
+  include FriendlyName
+
+  include TopicContainer
+
+  belongs_to :book, optional: true
+  belongs_to :topic
+
+  has_many :exercises, through: :topic
+
+  include SiblingsNavigation
+  include TerminalNavigation
+
+  def used_in?(organization)
+    organization.book == self.book
+  end
+
+  def pending_siblings_for(user)
+    book.pending_chapters(user)
+  end
+
+  def index_usage!(organization = Organization.current)
+    organization.index_usage_of! topic, self
+    lessons.each { |lesson| lesson.index_usage! organization }
+  end
+end

data/app/models/complement.rb

@@ -0,0 +1,15 @@
+class Complement < ApplicationRecord
+  include GuideContainer
+  include FriendlyName
+
+  validates_presence_of :book
+
+  belongs_to :guide
+  belongs_to :book
+
+  include TerminalNavigation
+
+  def used_in?(organization)
+    organization.book == book
+  end
+end

data/app/models/concerns/assistable.rb

@@ -0,0 +1,25 @@
+module Assistable
+  extend ActiveSupport::Concern
+
+  included do
+    serialize :assistance_rules, Array
+    validate :ensure_assistance_rules_format
+  end
+
+  def assistant
+    Mumukit::Assistant.parse(assistance_rules)
+  end
+
+  def assist_with(assignment)
+    # not strictly necessary, but avoid going through
+    # all the assistence process when there are no rules
+    assistance_rules.blank? ? [] : assistant.assist_with(assignment)
+  end
+
+  private
+
+  def ensure_assistance_rules_format
+    errors.add :assistance_rules,
+               :invalid_format unless Mumukit::Assistant.valid? assistance_rules.to_a
+  end
+end

data/app/models/concerns/contextualization.rb

@@ -0,0 +1,82 @@
+module Contextualization
+  extend ActiveSupport::Concern
+
+  class_methods do
+
+    private
+
+    def submission_mapping
+      class_attrs = Mumuki::Domain::Submission::Base.mapping_attributes.map { |it| submission_fields_overrides[it] || it }
+      class_attrs.zip Mumuki::Domain::Submission::Base.mapping_attributes
+    end
+
+    def submission_fields_overrides
+      { status: :submission_status }
+    end
+  end
+
+  included do
+    serialize :submission_status, Mumuki::Domain::Status::Submission
+    validates_presence_of :submission_status
+
+    serialize_symbolized_hash_array :expectation_results, :test_results, :query_results
+
+    composed_of :submission, mapping: submission_mapping, constructor: :from_attributes, class_name: 'Mumuki::Domain::Submission::Base'
+
+    delegate :visible_success_output?, to: :exercise
+    delegate :output_content_type, to: :language
+    delegate :should_retry?, :to_submission_status, *Mumuki::Domain::Status::Submission.test_selectors, to: :submission_status
+    delegate :inspection_keywords, to: :exercise
+  end
+
+  def queries_with_results
+    queries.zip(query_results).map do |query, result|
+      {query: query, status: result&.dig(:status).defaulting(:pending), result: result&.dig(:result)}
+    end
+  end
+
+  def single_visual_result?
+    test_results.size == 1 && test_results.first[:title].blank? && visible_success_output?
+  end
+
+  def single_visual_result_html
+    output_content_type.to_html test_results.first[:result]
+  end
+
+  def results_visible?
+    (visible_success_output? || !passed?) && !exercise.choices? && !manual_evaluation_pending?
+  end
+
+  def result_preview
+    result.truncate(100) unless passed?
+  end
+
+  def result_html
+    output_content_type.to_html(result)
+  end
+
+  def feedback_html
+    output_content_type.to_html(feedback)
+  end
+
+  def failed_expectation_results
+    expectation_results.to_a.select { |it| it[:result].failed? }
+  end
+
+  def expectation_results_visible?
+    failed_expectation_results.present?
+  end
+
+  def visible_expectation_results
+    exercise.input_kids? ? failed_expectation_results.first(1) : failed_expectation_results
+  end
+
+  def humanized_expectation_results
+    visible_expectation_results.map do |it|
+      {
+        result: it[:result],
+        explanation: Mumukit::Inspection::Expectation.parse(it).translate(inspection_keywords)
+      }
+    end
+  end
+end

data/app/models/concerns/friendly_name.rb

@@ -0,0 +1,10 @@
+module FriendlyName
+
+  def to_param
+    friendly_name
+  end
+
+  def friendly_name
+    "#{id} #{friendly}".friendlish
+  end
+end

data/app/models/concerns/guide_container.rb

@@ -0,0 +1,54 @@
+module GuideContainer
+  extend ActiveSupport::Concern
+
+  included do
+    validates_presence_of :guide
+
+    delegate :name,
+             :slug,
+             :language,
+             :search_tags,
+             :exercises,
+             :first_exercise,
+             :next_exercise,
+             :stats_for,
+             :exercises_count, to: :guide
+  end
+
+  def index_usage!(organization = Organization.current)
+    organization.index_usage_of! guide, self
+  end
+
+  def friendly
+    defaulting_name { "#{navigable_parent.friendly}: #{name}" }
+  end
+
+  def validate_accessible_for!(user)
+  end
+
+  # Tells the number of remaning
+  # attemps for a given assignment that belongs to this
+  # container, or `nil`, if this container does not impose
+  # any limit to the number of submissions
+  def attempts_left_for(assignment)
+    nil
+  end
+
+  # Tells if this guide container
+  # imposes any kind of limit to the number of submission
+  # to its assignments, which may depend on the exercise's type
+  def limited_for?(exercise)
+    false
+  end
+
+  def timed?
+    false
+  end
+
+  def start!(user)
+  end
+
+  def resettable?
+    true
+  end
+end

data/app/models/concerns/navigation/parent_navigation.rb

@@ -0,0 +1,27 @@
+module ParentNavigation
+
+  def leave(user)
+    navigable_parent.next_for(user)
+  end
+
+  def navigation_end?
+    false
+  end
+
+  def navigable_name
+    defaulting_name { super }
+  end
+
+  def navigable_parent
+    structural_parent.usage_in_organization
+  end
+
+  #required :structural_parent
+
+  private
+
+  def defaulting_name(&block)
+    navigable_parent.defaulting(name, &block)
+  end
+end
+

data/app/models/concerns/navigation/siblings_navigation.rb

@@ -0,0 +1,19 @@
+module SiblingsNavigation
+
+  def next_for(user)
+    pending_siblings_for(user).select { |it| it.number > number }.sort_by(&:number).first
+  end
+
+  def restart(user)
+    pending_siblings_for(user).sort_by(&:number).first
+  end
+
+  # Names
+
+  def navigable_name
+    "#{number}. #{name}"
+  end
+
+  # Answers a - maybe empty - list of pending siblings for the given user
+  #required :pending_siblings_for
+end

data/app/models/concerns/navigation/terminal_navigation.rb

@@ -0,0 +1,13 @@
+module TerminalNavigation
+  def navigation_end?
+    true
+  end
+
+  def friendly
+    name
+  end
+
+  def navigable_name
+    name
+  end
+end

data/app/models/concerns/submittable/confirmable.rb

@@ -0,0 +1,5 @@
+module Confirmable
+  def submit_confirmation!(user)
+    submit! user, Mumuki::Domain::Submission::Confirmation.new
+  end
+end

data/app/models/concerns/submittable/queriable.rb

@@ -0,0 +1,9 @@
+module Queriable
+  def submit_query!(user, attributes)
+    submit! user, Mumuki::Domain::Submission::Query.new(attributes)
+  end
+
+  def run_query!(params)
+    language.run_query!(params)
+  end
+end

data/app/models/concerns/submittable/questionable.rb

@@ -0,0 +1,6 @@
+module Questionable
+  def submit_question!(user, question)
+    assignment, _ = find_assignment_and_submit! user, Mumuki::Domain::Submission::Question.new
+    assignment.send_question!(question)
+  end
+end

data/app/models/concerns/submittable/solvable.rb

@@ -0,0 +1,32 @@
+module Solvable
+  def submit_solution!(user, attributes={})
+    assignment, _ = find_assignment_and_submit! user, attributes[:content].to_mumuki_solution(language)
+    try_solve_discussions(user) if assignment.passed?
+    assignment
+  end
+
+  def run_tests!(params)
+    language.run_tests!(params.merge(locale: locale, expectations: expectations))
+  end
+end
+
+class NilClass
+  def to_mumuki_solution(language)
+    Mumuki::Domain::Submission::Solution.new
+  end
+end
+
+class String
+  def to_mumuki_solution(language)
+    Mumuki::Domain::Submission::Solution.new content: normalize_whitespaces
+  end
+end
+
+class Hash
+  def to_mumuki_solution(language)
+    language
+      .directives_sections
+      .join(self)
+      .to_mumuki_solution(language)
+  end
+end

data/app/models/concerns/submittable/submittable.rb

@@ -0,0 +1,11 @@
+module Submittable
+  def submit!(user, submission)
+    find_assignment_and_submit!(user, submission).last
+  end
+
+  def find_assignment_and_submit!(user, submission)
+    assignment = assignment_for user
+    results = submission.run! assignment, evaluation_class.new
+    [assignment, results]
+  end
+end

data/app/models/concerns/submittable/triable.rb

@@ -0,0 +1,9 @@
+module Triable
+  def submit_try!(user, attributes={})
+    find_assignment_and_submit! user, Mumuki::Domain::Submission::Try.new(attributes)
+  end
+
+  def run_try!(params)
+    language.run_try! params.merge(locale: locale, goal: goal)
+  end
+end

data/app/models/concerns/with_assignments.rb

@@ -0,0 +1,32 @@
+module WithAssignments
+  extend ActiveSupport::Concern
+
+  # TODO we must avoid _for(user) methods when they
+  # are hidden the assignment object, since an assignment already encapsulates
+  # the exercise-user pair, and many times they impose a performance hit,
+  # since in the normal scenario the assignment object already exists
+
+  included do
+    has_many :assignments, dependent: :destroy
+  end
+
+  def messages_for(user)
+    assignment_for(user).messages
+  end
+
+  def has_messages_for?(user)
+    messages_for(user).present?
+  end
+
+  def find_assignment_for(user)
+    assignments.find_by(submitter: user)
+  end
+
+  def status_for(user)
+    assignment_for(user).status if user
+  end
+
+  def assignment_for(user)
+    find_assignment_for(user) || user.assignments.build(exercise: self)
+  end
+end