mumuki-laboratory 7.0.10 → 7.0.11

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/README.md

@@ -0,0 +1,155 @@
+# Resource Hashes
+
+## Runner Hashes
+
+### `Language`
+
+```
+  name
+  comment_type
+  runner_url
+  output_content_type
+  prompt
+  extension
+  highlight_mode
+  visible_success_output
+  devicon
+  triable
+  feedback
+  queriable
+  multifile
+  stateful_console
+  test_extension
+  test_template
+  layout_js_urls
+  layout_html_urls
+  layout_css_urls
+  editor_js_urls
+  editor_html_urls
+  editor_css_urls
+```
+
+_as defined in `Language#to_resource_h`_
+
+## Platform Hashes
+
+### `Organization`
+
+```
+  name
+  book
+  profile
+  settings
+  theme
+```
+
+_as defined in `Mumuki::Domain::Helpers::Organization#to_resource_h`_
+
+### `User`
+
+```
+  uid
+  social_id
+  image_url
+  email
+  first_name
+  last_name
+  permissions
+```
+
+_as defined in `Mumuki::Domain::Helpers::User#to_resource_h`_
+
+### `Course`
+
+```
+  slug
+  shifts
+  code
+  days
+  period
+  description
+```
+
+_as defined in `Mumuki::Domain::Helpers::Course#to_resource_h`_
+
+## Content Hashes
+
+### `Book`
+
+```
+  name
+  description
+  locale
+  slug
+  chapters
+  complements
+```
+
+_as defined in `Book#to_resource_h`_
+
+
+### `Topic`
+
+```
+  name
+  description
+  locale
+  slug
+  lessons
+```
+
+_as defined in `Topic#to_resource_h`_
+
+### `Guide`
+
+```
+  slug
+  name
+  exercises
+    name
+    bibliotheca_id
+    layout
+    editor
+    description
+    corollary
+    teacher_info
+    hint
+    locale
+    choices
+    expectations
+    assistance_rules,
+    randomizations
+    tag_list
+    extra_visible
+    test
+    manual_evaluation
+    language
+      name
+      extension
+      test_extension
+  authors
+  private
+  expectations
+  collaborators
+  sources
+  learn_more
+  description
+  corollary
+  locale
+  type
+  beta
+  teacher_info
+  language
+    name
+    extension
+    test_extension
+  id_format
+  extra
+```
+
+_as defined in `Guide#to_resource_h`_
+
+## Classroom Hashes
+
+* `Exam`
+* `Invitation`

data/vendor/bundle/ruby/2.3.0/bundler/gems/mumuki-domain-f892f79c60f0/Rakefile

@@ -0,0 +1,35 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Mumuki::Domain'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+
+load 'rails/tasks/engine.rake'
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task default: :spec
+
+
+
+
+

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

@@ -0,0 +1,31 @@
+class ApiClient < ApplicationRecord
+
+  belongs_to :user
+  accepts_nested_attributes_for :user
+  validates_presence_of :description
+
+  #TODO add JWT expiration and api client invalidation
+  #TODO rename toke to encoded_token
+  before_create :set_encoded_token!
+
+  def verify!
+    self.class.invalid_token! 'Invalid Api Client' if Mumukit::Auth::Token.decode(token).uid != user.uid
+  end
+
+  def self.verify_token!(token)
+    client = find_by token: token
+    invalid_token! 'No Api Client found for Token' unless client
+    client.verify!
+  end
+
+  private
+
+  def set_encoded_token!
+    self.token = Mumukit::Auth::Token.encode user.uid, {}
+  end
+
+  def self.invalid_token!(message)
+    raise Mumukit::Auth::InvalidTokenError, message
+  end
+
+end

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

@@ -0,0 +1,128 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  delegate :whitelist_attributes, to: :class
+
+  def self.defaults(&block)
+    after_initialize :defaults, if: :new_record?
+    define_method :defaults, &block
+  end
+
+  def self.all_except(others)
+    if others.present?
+      where.not(id: [others.map(&:id)])
+    else
+      all
+    end
+  end
+
+  def self.serialize_symbolized_hash_array(*keys)
+    keys.each do |field|
+      serialize field
+      define_method(field) { self[field]&.map { |it| it.symbolize_keys } }
+    end
+  end
+
+  def save(*)
+    super
+  rescue => e
+    self.errors.add :base, e.message
+    self
+  end
+
+  def save_and_notify_changes!
+    if changed?
+      save_and_notify!
+    else
+      save!
+    end
+  end
+
+  def destroy!
+    super
+  rescue ActiveRecord::RecordNotDestroyed => e
+    errors[:base].last.try { |it| raise ActiveRecord::RecordNotDestroyed.new it }
+    raise e
+  rescue ActiveRecord::InvalidForeignKey => e
+    raise_foreign_key_error!
+  end
+
+  def delete
+    super
+  rescue ActiveRecord::InvalidForeignKey => e
+    raise_foreign_key_error!
+  end
+
+  def save_and_notify!
+    save!
+    notify!
+    self
+  end
+
+  def update_and_notify!(data)
+    update! data
+    notify!
+    self
+  end
+
+  def self.aggregate_of(association)
+    class_eval do
+      define_method(:rebuild!) do |children|
+        transaction do
+          self.send(association).all_except(children).delete_all
+          self.update! association => children
+          children.each &:save!
+        end
+        reload
+      end
+    end
+  end
+
+  def self.numbered(*associations)
+    class_eval do
+      associations.each do |it|
+        define_method("#{it}=") do |e|
+          e.merge_numbers!
+          super(e)
+        end
+      end
+    end
+  end
+
+  def self.update_or_create!(attributes)
+    obj = first || new
+    obj.update!(attributes)
+    obj
+  end
+
+  def self.whitelist_attributes(a_hash, options={})
+    attributes = attribute_names
+    attributes += reflections.keys if options[:relations]
+    a_hash.with_indifferent_access.slice(*attributes).except(*options[:except])
+  end
+
+  def self.organic_on(*selectors)
+    selectors.each do |selector|
+      define_method("#{selector}_in_organization") do |organization = Organization.current|
+        send(selector).where(organization: organization)
+      end
+    end
+  end
+
+  ## Partially implements resource-hash protocol, by
+  ## defining `to_resource_h` and helper methods `resource_fields` and `slice_resource_h`
+  ## using the given fields
+  def self.resource_fields(*fields)
+    include Mumuki::Domain::Syncable::WithResourceFields
+
+    define_singleton_method :resource_fields do
+      fields
+    end
+  end
+
+  private
+
+  def raise_foreign_key_error!
+    raise ActiveRecord::InvalidForeignKey.new "#{model_name} is still referenced"
+  end
+end

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

@@ -0,0 +1,217 @@
+class Assignment < ApplicationRecord
+  include Contextualization
+  include WithMessages
+
+  markdown_on :extra_preview
+
+  belongs_to :exercise
+  has_one :guide, through: :exercise
+  has_many :messages,
+           -> { where.not(submission_id: nil).order(date: :desc) },
+           foreign_key: :submission_id,
+           primary_key: :submission_id,
+           dependent: :destroy
+
+  belongs_to :organization
+  belongs_to :submitter, class_name: 'User'
+
+  validates_presence_of :exercise, :submitter
+
+  delegate :language, :name, :navigable_parent, :settings,
+           :limited?, :input_kids?, :choice?, to: :exercise
+
+  alias_attribute :status, :submission_status
+  alias_attribute :attempts_count, :attemps_count
+
+  scope :by_exercise_ids, -> (exercise_ids) {
+    where(exercise_id: exercise_ids) if exercise_ids
+  }
+
+  scope :by_usernames, -> (usernames) {
+    joins(:submitter).where('users.name' => usernames) if usernames
+  }
+
+  defaults do
+    self.query_results = []
+    self.expectation_results = []
+  end
+
+  def evaluate_manually!(teacher_evaluation)
+    update! status: teacher_evaluation[:status], manual_evaluation_comment: teacher_evaluation[:manual_evaluation]
+  end
+
+  def persist_submission!(submission)
+    transaction do
+      messages.destroy_all if submission_id.present?
+      update! submission_id: submission.id
+      update! submitted_at: DateTime.current
+      update_submissions_count!
+      update_last_submission!
+    end
+  end
+
+  def extension
+    exercise.language.extension
+  end
+
+  def notify!
+    Mumukit::Nuntius.notify! 'submissions', to_resource_h unless Organization.silenced?
+  end
+
+  def notify_to_accessible_organizations!
+    warn "Don't use notify_to_accessible_organizations!. Use notify_to_student_granted_organizations! instead"
+    notify_to_student_granted_organizations!
+  end
+
+  def notify_to_student_granted_organizations!
+    submitter.student_granted_organizations.each do |organization|
+      organization.switch!
+      notify!
+    end
+  end
+
+  def self.evaluate_manually!(teacher_evaluation)
+    Assignment.find_by(submission_id: teacher_evaluation[:submission_id])&.evaluate_manually! teacher_evaluation
+  end
+
+  def content=(content)
+    if content.present?
+      self.solution = exercise.single_choice? ? exercise.choice_index_for(content) : content
+    end
+  end
+
+  def test
+    exercise.test && language.interpolate_references_for(self, exercise.test)
+  end
+
+  def extra
+    exercise.extra && language.interpolate_references_for(self, exercise.extra)
+  end
+
+  def extra_preview
+    Mumukit::ContentType::Markdown.highlighted_code(language.name, extra)
+  end
+
+  def run_update!
+    running!
+    begin
+      update! yield
+    rescue => e
+      errored! e.message
+      raise e
+    end
+  end
+
+  def passed!
+    update! submission_status: :passed
+  end
+
+  def running!
+    update! submission_status: :running,
+            result: nil,
+            test_results: nil,
+            expectation_results: [],
+            manual_evaluation_comment: nil
+  end
+
+  def errored!(message)
+    update! result: message, submission_status: :errored
+  end
+
+  %w(query try).each do |key|
+    name = "run_#{key}!"
+    define_method(name) { |params| exercise.send name, params.merge(extra: extra, settings: settings) }
+  end
+
+  def run_tests!(params)
+    exercise.run_tests! params.merge(extra: extra, test: test, settings: settings)
+  end
+
+  def to_resource_h
+    as_json(except: [:exercise_id, :submission_id, :organization_id, :id, :submitter_id, :solution, :created_at, :updated_at, :submission_status, :submitted_at],
+              include: {
+                guide: {
+                  only: [:slug, :name],
+                  include: {
+                    lesson: {only: [:number]},
+                    language: {only: [:name]}},
+                },
+                exercise: {only: [:name, :number]},
+                submitter: {only: [:email, :image_url, :social_id, :uid], methods: [:name]}}).
+      deep_merge(
+        'organization' => Organization.current.name,
+        'sid' => submission_id,
+        'created_at' => submitted_at || updated_at,
+        'content' => solution,
+        'status' => submission_status,
+        'exercise' => {
+          'eid' => exercise.bibliotheca_id
+        },
+        'guide' => {'parent' => {
+          'type' => navigable_parent.class.to_s,
+          'name' => navigable_parent.name,
+          'position' => navigable_parent.try(:number),
+          'chapter' => guide.chapter.as_json(only: [:id], methods: [:name])
+        }})
+  end
+
+  def tips
+    @tips ||= exercise.assist_with(self)
+  end
+
+  def increment_attempts!
+    self.attempts_count += 1 if should_retry?
+  end
+
+  def attempts_left
+    navigable_parent.attempts_left_for(self)
+  end
+
+  # Tells wether the submitter of this
+  # assignment can keep on sending submissions
+  # which is true for non limited or for assignments
+  # that have not reached their submissions limit
+  def attempts_left?
+    !limited? || attempts_left > 0
+  end
+
+  def current_content
+    solution || default_content
+  end
+
+  def current_content_at(index)
+    exercise.sibling_at(index).assignment_for(submitter).current_content
+  end
+
+  def default_content
+    @default_content ||= language.interpolate_references_for(self, exercise.default_content)
+  end
+
+  def files
+    exercise.files_for(current_content)
+  end
+
+  def save!(*)
+    self.organization = Organization.current
+    super
+  end
+
+  private
+
+  def update_submissions_count!
+    self.class.connection.execute(
+      "update public.exercises
+         set submissions_count = submissions_count + 1
+        where id = #{exercise.id}")
+    self.class.connection.execute(
+      "update public.assignments
+         set submissions_count = submissions_count + 1
+        where id = #{id}")
+    exercise.reload
+  end
+
+  def update_last_submission!
+    submitter.update!(last_submission_date: DateTime.current, last_exercise: exercise)
+  end
+
+end