mumuki-laboratory 7.5.0

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

@@ -0,0 +1,131 @@
+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]
+
+  alias_method :structural_children, :exercises
+
+  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 next_exercise(user)
+    pending_exercises(user).order('public.exercises.number asc').first
+  end
+
+  # TODO: Make use of pending_siblings logic
+  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 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)
+    dirty_progress_if_structural_children_changed! do
+      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
+  end
+
+  # Keep this list up to date with
+  # Mumuki::Domain::Store::Github::GuideSchema
+  def to_expanded_resource_h(options={})
+    as_json(only: BASIC_RESOURCE_FIELDS)
+      .symbolize_keys
+      .merge(super)
+      .merge(exercises: exercises.map { |it| it.to_resource_h(options) })
+      .merge(language: language.to_embedded_resource_h)
+      .tap { |it| it.markdownified!(:corollary, :description, :teacher_info) if options[:markdownified] }
+  end
+
+  def to_markdownified_resource_h
+    to_resource_h(markdownified: true)
+  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

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

@@ -0,0 +1,77 @@
+class Indicator < Progress
+  belongs_to :user
+  belongs_to :content, polymorphic: true
+  belongs_to :organization
+
+  has_many :indicators, foreign_key: :parent_id, class_name: 'Indicator'
+  has_many :assignments, foreign_key: :parent_id
+
+  def propagate_up!(&block)
+    instance_eval &block
+    parent&.instance_eval { propagate_up! &block }
+  end
+
+  def self.dirty_by_content_change!(content)
+    where(content: content).update_all dirty_by_content_change: true
+  end
+
+  def dirty_by_submission!
+    propagate_up! { update! dirty_by_submission: true }
+  end
+
+  def rebuild!
+    if dirty_by_content_change?
+      propagate_up! do
+        refresh_children_count!
+        refresh_children_passed_count!
+        clean!
+        save!
+      end
+    elsif dirty_by_submission?
+      refresh_children_passed_count!
+      clean!
+      save!
+    end
+  end
+
+  def clean!
+    self.dirty_by_submission = false
+    self.dirty_by_content_change = false
+  end
+
+  def refresh_children_count!
+    self.children_count = content.structural_children.count
+  end
+
+  def refresh_children_passed_count!
+    self.children_passed_count = children.count(&:completed?)
+  end
+
+  def completion_percentage
+    rebuild!
+    children_passed_count.fdiv children_count
+  end
+
+  def completed?
+    rebuild!
+    children_passed_count == children_count
+  end
+
+  private
+
+  def children
+    indicators.presence || assignments
+  end
+
+  %i(children_count children_passed_count).each do |selector|
+    define_method selector do
+      send "refresh_#{selector}!" unless self[selector]
+
+      self[selector]
+    end
+  end
+
+  def parent_content
+    content.usage_in_organization(organization).structural_parent
+  end
+end

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

@@ -0,0 +1,61 @@
+class Invitation < ApplicationRecord
+  include Mumuki::Domain::Syncable
+
+  belongs_to :course
+  validates_uniqueness_of :code
+
+  defaults do
+    self.code ||= self.class.generate_code
+  end
+
+  def import_from_resource_h!(json)
+    update! json.merge(course: Course.locate!(json[:course]))
+  end
+
+  def organization
+    course.organization
+  end
+
+  def course_slug
+    course.slug
+  end
+
+  def navigable_name
+    I18n.t(:invitation_for, course: course_name)
+  end
+
+  def to_resource_h
+    { code: code, course: course_slug, expiration_date: expiration_date }
+  end
+
+  def navigation_end?
+    true
+  end
+
+  def to_param
+    code
+  end
+
+  def expired?
+    Time.now > expiration_date
+  end
+
+  def unexpired
+    raise Mumuki::Domain::GoneError, "This invitation has already expired" if expired?
+    self
+  end
+
+  def self.generate_code
+    SecureRandom.urlsafe_base64 4
+  end
+
+  private
+
+  def course_name
+    course.name
+  end
+
+  def self.sync_key_id_field
+    :code
+  end
+end

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

@@ -0,0 +1,128 @@
+class Language < ApplicationRecord
+  include WithCaseInsensitiveSearch
+  include Mumuki::Domain::Syncable
+
+  enum output_content_type: [:plain, :html, :markdown]
+
+  validates_presence_of :runner_url, :output_content_type
+
+  validates :name, presence: true, uniqueness: {case_sensitive: false}
+
+  # This list must kept up to date with
+  # Mumuki::Domain::Store::Thesaurus::InfoConverter
+  resource_fields :comment_type,
+                  :devicon,
+                  :editor_css_urls,
+                  :editor_html_urls,
+                  :editor_js_urls,
+                  :editor_shows_loading_content,
+                  :expectations,
+                  :extension,
+                  :feedback,
+                  :highlight_mode,
+                  :layout_css_urls,
+                  :layout_html_urls,
+                  :layout_js_urls,
+                  :layout_shows_loading_content,
+                  :multifile,
+                  :name,
+                  :output_content_type,
+                  :prompt,
+                  :queriable,
+                  :runner_url,
+                  :settings,
+                  :stateful_console,
+                  :test_extension,
+                  :test_template,
+                  :triable,
+                  :visible_success_output
+
+  markdown_on :description
+
+  delegate :run_tests!, :run_query!, :run_try!, to: :bridge
+
+  def bridge
+    Mumukit::Bridge::Runner.new(runner_url)
+  end
+
+  def highlight_mode
+    self[:highlight_mode] || name
+  end
+
+  def output_content_type
+    Mumukit::ContentType.for(self[:output_content_type])
+  end
+
+  def to_s
+    name
+  end
+
+  def self.for_name(name)
+    find_by_ignore_case!(:name, name) if name
+  end
+
+  def devicon
+    self[:devicon] || name.downcase
+  end
+
+  def sync_key
+    Mumukit::Sync.key :language, runner_url
+  end
+
+  def import_from_resource_h!(resource_h)
+    assign_attributes resource_h.except(:runner_url)
+    save!
+  end
+
+  def directives_sections
+    new_directive Mumukit::Directives::Sections
+  end
+
+
+  def assets_urls_for(kind, content_type)
+    send "#{kind}_#{content_type}_urls"
+  end
+
+  # TODO this should be a Mumukit::Directives::Directive
+  # and be part of a pipeline
+  def interpolate_references_for(assignment, field)
+    interpolate(field, assignment.submitter.interpolations, lambda { |content| replace_content_reference(assignment, content) })
+  end
+
+  def to_embedded_resource_h
+    as_json(only: [:name, :extension, :test_extension]).symbolize_keys
+  end
+
+  private
+
+  # TODO we should use Mumukit::Directives::Pipeline
+  def interpolate(interpolee, *interpolations)
+    interpolee = interpolee || ''
+    interpolations.inject(interpolee) { |content, interpolation| directives_interpolations.interpolate(content, interpolation).first }
+  end
+
+  def directives_interpolations
+    new_directive Mumukit::Directives::Interpolations
+  end
+
+  def replace_content_reference(assignment, interpolee)
+    case interpolee
+    when /previousContent|previousSolution/
+      assignment.current_content_at(-1)
+    when /(solution|content)\[(-?\d*)\]/
+      assignment.current_content_at($2.to_i)
+    end
+  end
+
+  def new_directive(directive_type)
+    directive_type.new.tap { |it| it.comment_type = directives_comment_type }
+  end
+
+  def directives_comment_type
+    Mumukit::Directives::CommentType.parse comment_type
+  end
+
+  def self.sync_key_id_field
+    :runner_url
+  end
+end