mumuki-laboratory 7.5.0

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/avatar.rb

@@ -0,0 +1,5 @@
+class Avatar < ApplicationRecord
+  def self.sample
+    Avatar.order('RANDOM()').first
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/book.rb

@@ -0,0 +1,65 @@
+class Book < Content
+  numbered :chapters
+  aggregate_of :chapters
+  aggregate_of :complements
+
+  has_many :chapters, -> { order(number: :asc) }, dependent: :destroy
+  has_many :topics, through: :chapters
+  has_many :complements, dependent: :destroy
+
+  has_many :exercises, through: :chapters
+  has_many :discussions, through: :exercises
+  organic_on :discussions
+
+  delegate :first_lesson, to: :first_chapter
+
+  alias_method :structural_children, :chapters
+
+  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)
+    dirty_progress_if_structural_children_changed! do
+      self.assign_attributes resource_h.except(:chapters, :complements, :id, :description)
+      self.description = resource_h[:description]&.squeeze(' ')
+
+      rebuild_chapters! 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
+    end
+  end
+
+  def to_expanded_resource_h
+    super.merge(
+      chapters: chapters.map(&:slug),
+      complements: complements.map(&:slug))
+  end
+
+  def index_usage!(organization)
+    organization.index_usage_of! self, self
+    [chapters, complements].flatten.each { |item| item.index_usage! organization }
+  end
+
+  def reindex_usages!
+    Organization.where(book: self).each &:reindex_usages!
+  end
+
+  ## Forking
+
+  def fork_children_into!(dup, organization, syncer)
+    dup.chapters = chapters.map { |chapter| chapter.topic.fork_to!(organization, syncer, quiet: true).as_chapter_of(dup) }
+    dup.complements = complements.map { |complement| complement.guide.fork_to!(organization, syncer, quiet: true).as_complement_of(dup) }
+  end
+
+  def structural_parent
+    nil
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/chapter.rb

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

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/complement.rb

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

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/contextualization.rb

@@ -0,0 +1,137 @@
+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, :completed?, :solved?, *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
+
+  # deprecated: this method does hidden assumptions about the UI not wanting
+  # non-empty titles to not be displayed. Also it incorrectly uses the term `visual` instead of `visible`
+  def single_visual_result?
+    warn 'use single_visible_test_result? instead'
+    single_visible_test_result? && first_test_result[:title].blank?
+  end
+
+  # deprecated: this method does not validate nor depends on any `visible` condition
+  # Also, it incorrectly uses the term `visual` instead of `visible`
+  def single_visual_result_html
+    warn 'use first_test_result_html intead'
+    first_test_result_html
+  end
+
+  def single_visible_test_result?
+    test_results.size == 1 && visible_success_output?
+  end
+
+  def first_test_result
+    test_results.first
+  end
+
+  def first_test_result_html
+    test_result_html first_test_result
+  end
+
+  def test_result_html(test_result)
+    output_content_type.to_html test_result[:result]
+  end
+
+  def results_body_hidden?
+    (passed? && !visible_success_output?) || exercise.choice? || manual_evaluation_pending? || skipped?
+  end
+
+  def visible_status
+    status
+  end
+
+  def iconize
+    visible_status.iconize
+  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? }.uniq
+  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
+    warn "Don't use humanized_expectation_results. Use affable_expectation_results, which also handles markdown and sanitization"
+    visible_expectation_results.map do |it|
+      {
+        result: it[:result],
+        explanation: Mulang::Expectation.parse(it).translate(inspection_keywords)
+      }
+    end
+  end
+
+  ####################
+  ## Affable results
+  ####################
+
+  def affable_expectation_results
+    visible_expectation_results.map do |it|
+      {
+        result: it[:result],
+        explanation: Mulang::Expectation.parse(it).translate(inspection_keywords).affable
+      }
+    end
+  end
+
+  def affable_tips
+    tips.map(&:affable)
+  end
+
+  def affable_test_results
+    test_results.to_a.map do |it|
+      { summary: it.dig(:summary, :message).affable }
+        .compact
+        .merge(
+          title: it[:title].affable,
+          result: it[:result].sanitized,
+          status: it[:status])
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/disabling.rb

@@ -0,0 +1,37 @@
+# The disposable module is a soft-delete helper that:
+#
+#  * adds `disable!` method that set a `disabled_at` attribute and then _buries_ the object
+#  * adds a `bury!`  hook method that allows further modification when disabling
+#  * aliases `destroy!` and `destroy` to `disable!`, but still keeps `delete` and friends
+#
+module Disabling
+  extend ActiveSupport::Concern
+
+  def disable!
+    transaction do
+      update_attribute :disabled_at, Time.current
+      bury!
+    end
+  end
+
+  def disabled?
+    disabled_at.present?
+  end
+
+  def enabled?
+    !disabled?
+  end
+
+  # override to perform additional
+  # post-disable actions
+  def bury!
+  end
+
+  def ensure_enabled!
+    raise Mumuki::Domain::DisabledError if disabled?
+  end
+
+  alias_method :destroy!,  :disable!
+  alias_method :destroy,   :disable!
+end
+

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/guide_container.rb

@@ -0,0 +1,61 @@
+module GuideContainer
+  extend ActiveSupport::Concern
+  include WithContent
+
+  included do
+    associated_content :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
+
+  # Tells if this guide container
+  # hides the results for students
+  def results_hidden_for?(_exercise)
+    false
+  end
+
+  def timed?
+    false
+  end
+
+  def start!(user)
+  end
+
+  def resettable?
+    true
+  end
+end

data/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/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/vendor/bundle/ruby/2.6.0/bundler/gems/mumuki-domain-acb12583b793/app/models/concerns/navigation/siblings_navigation.rb

@@ -0,0 +1,28 @@
+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
+
+  def siblings
+    structural_parent.structural_children
+  end
+
+  #TODO reestablish this after indicators reliably linked to assignments
+  # def pending_siblings_for(user, organization=Organization.current)
+  #   siblings.reject { |it| it.progress_for(user, organization).completed? }
+  # 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