mumukit-sync 0.0.0

data/lib/mumukit/sync/store/github/licenses/README.md.erb

@@ -0,0 +1,6 @@
+## License
+![License icon](https://licensebuttons.net/l/by-sa/3.0/88x31.png)
+
+This content is distributed under Creative Commons License Share-Alike, 4.0. [https://creativecommons.org/licenses/by-sa/4.0/](https://creativecommons.org/licenses/by-sa/4.0)
+
+<%= @copyright %>

data/lib/mumukit/sync/store/github/operation.rb

@@ -0,0 +1,47 @@
+class Mumukit::Sync::Store::Github
+  class Operation
+    attr_accessor :bot
+
+    def initialize(options)
+      @bot = options[:bot]
+      @web_hook_base_url = options[:web_hook_base_url]
+    end
+
+    def with_local_repo(&block)
+      Dir.mktmpdir("mumuki.#{self.class.name}") do |dir|
+        bot.clone_into repo, dir, &block
+      end
+    end
+
+    def can_run?
+      true
+    end
+
+    def run!
+      return unless can_run?
+
+      puts "#{self.class.name} : running before run hook for repository #{repo}"
+      before_run_in_local_repo
+
+      result = nil
+      with_local_repo do |dir, local_repo|
+        puts "#{self.class.name} : running run hook for repository #{repo}"
+        result = run_in_local_repo dir, local_repo
+      end
+
+      puts "#{self.class.name} : running after run hook repository #{repo}"
+      ensure_post_commit_hook!
+      result
+    end
+
+    def ensure_post_commit_hook!
+      bot.register_post_commit_hook!(repo, @web_hook_base_url) if bot.authenticated? && @web_hook_base_url
+    end
+
+    def before_run_in_local_repo
+    end
+
+    def run_in_local_repo(dir, local_repo)
+    end
+  end
+end

data/lib/mumukit/sync/store/github/ordering.rb

@@ -0,0 +1,23 @@
+class Mumukit::Sync::Store::Github
+  module Ordering
+    def self.from(order)
+      order ? FixedOrdering.new(order) : NaturalOrdering
+    end
+  end
+
+  class FixedOrdering
+    def initialize(order)
+      @order = order
+    end
+
+    def position_for(id)
+      @order.index(id) + 1
+    end
+  end
+
+  module NaturalOrdering
+    def self.position_for(id)
+      id
+    end
+  end
+end

data/lib/mumukit/sync/store/github/schema.rb

@@ -0,0 +1,123 @@
+class Mumukit::Sync::Store::Github
+  ## Schema definition explanation
+  #
+  #  * name: the name of the field
+  #  * kind: the type of the field: metadata, special, file or transient.
+  #     * metadata fields are those that are small and fit into the metadata.yml when exported to git
+  #     * special fields are those are essentials and not part of any file, like the id or name when exported to git
+  #     * transient fields are not exported to git
+  #     * file fields are large fields that are exported to git within their own file.
+  #  * reverse: the name of the field in the model. By default, it is assumed to be the same of name, but
+  #    can be overridden with this option
+  #  * default: the default value of the field
+  #  * extension: the file extension. It only applies to file kinds. It can be a plain extension or one of the following
+  #    special extensions:
+  #      * test: the extension of the test framework
+  #      * code: the normal extension for the language
+  #
+  module Schema
+    def defaults
+      fields.map { |it| [it.reverse_name, it.default] }.to_h.compact
+    end
+
+    def metadata_fields
+      fields.select { |it| it.kind == :metadata }
+    end
+
+    def simple_fields
+      fields.select { |it| [:special, :file].include? it.kind }
+    end
+
+    def file_fields
+      fields.select { |it| it.kind == :file }
+    end
+
+    def fields
+      @field ||= fields_schema.map { |it| new_field(it) }
+    end
+
+    def slice(json)
+      json.slice(*fields.map(&:reverse_name))
+    end
+
+    def yaml_hash
+      struct to: proc(&:to_yaml),
+             from: proc { |path| YAML.load_file(path) }
+    end
+
+    def yaml_list(key)
+      struct to: proc { |it| {key => it.map(&:stringify_keys)}.to_yaml },
+             from: proc { |path| YAML.load_file(path).try { |it| it[key] } }
+    end
+
+    def name
+      with { |it| it&.dig(:name) }
+    end
+
+    def with(&block)
+      struct to: block, from: proc { |it| File.read(it) }
+    end
+
+    private
+
+    def new_field(it)
+      Field.new(it)
+    end
+
+    class Field < OpenStruct
+      def reverse_name
+        reverse || name
+      end
+
+      def safe_transform
+        transform || struct(to: proc { |it| it }, from: proc { |it| File.read(it) })
+      end
+
+      ## Writing fields to Github
+
+      def get_file_name(language)
+        "#{name}.#{get_file_extension(language)}"
+      end
+
+      def get_field_value(document)
+        safe_transform.to.call document[reverse_name]
+      end
+
+      def field_value_present?(document)
+        document[reverse_name].present?
+      end
+
+      def get_file_extension(language)
+        case extension
+        when :code then
+          language[:extension]
+        when :test then
+          language[:test_extension]
+        else
+          extension
+        end
+      end
+
+      ## Reading fields from Github
+
+      def find_file_name(root)
+        files = Dir.glob("#{root}/#{name}.*")
+        if files.length == 1
+          files[0]
+        elsif files.empty? && required
+          raise "Missing #{name} file"
+        else
+          nil
+        end
+      end
+
+      def read_field_file(root)
+        find_file_name(root).try { |it| safe_transform.from.call it }
+      end
+
+    end
+  end
+end
+
+require_relative './schema/exercise'
+require_relative './schema/guide'

data/lib/mumukit/sync/store/github/schema/exercise.rb

@@ -0,0 +1,37 @@
+module Mumukit::Sync::Store::Github::Schema::Exercise
+  extend Mumukit::Sync::Store::Github::Schema
+
+  def self.fields_schema
+    [
+      {name: :id, kind: :special},
+      {name: :name, kind: :special},
+
+      {name: :tags, kind: :metadata, reverse: :tag_list, transform: with { |it| it.to_a }},
+      {name: :layout, kind: :metadata},
+      {name: :editor, kind: :metadata},
+
+      {name: :type, kind: :metadata},
+      {name: :extra_visible, kind: :metadata},
+      {name: :language, kind: :metadata, transform: name },
+      {name: :teacher_info, kind: :metadata},
+      {name: :manual_evaluation, kind: :metadata},
+      {name: :choices, kind: :metadata},
+
+      {name: :expectations,     kind: :file, extension: 'yml', transform: yaml_list('expectations')},
+      {name: :assistance_rules, kind: :file, extension: 'yml', transform: yaml_list('rules')},
+      {name: :randomizations,   kind: :file, extension: 'yml', transform: yaml_hash},
+
+      {name: :goal, kind: :metadata},
+      {name: :test, kind: :file, extension: :test},
+      {name: :extra, kind: :file, extension: :code},
+      {name: :default, kind: :file, extension: :code, reverse: :default_content},
+
+      {name: :description, kind: :file, extension: 'md', required: true},
+      {name: :hint, kind: :file, extension: 'md'},
+      {name: :corollary, kind: :file, extension: 'md'},
+      {name: :initial_state, kind: :file, extension: 'md'},
+      {name: :final_state, kind: :file, extension: 'md'},
+      {name: :free_form_editor_source, kind: :file, extension: 'html'}
+    ]
+  end
+end

data/lib/mumukit/sync/store/github/schema/guide.rb

@@ -0,0 +1,28 @@
+module Mumukit::Sync::Store::Github::Schema::Guide
+  extend Mumukit::Sync::Store::Github::Schema
+
+  def self.fields_schema
+    [
+      {name: :exercises, kind: :special},
+      {name: :id, kind: :special},
+      {name: :slug, kind: :special},
+
+      {name: :name, kind: :metadata},
+      {name: :locale, kind: :metadata},
+      {name: :type, kind: :metadata},
+      {name: :beta, kind: :metadata},
+      {name: :teacher_info, kind: :metadata},
+      {name: :language, kind: :metadata, transform: name },
+      {name: :id_format, kind: :metadata},
+      {name: :order, kind: :metadata, transform: with { |it| it.map { |e| e[:id] } }, reverse: :exercises},
+      {name: :private, kind: :metadata},
+      {name: :expectations},
+
+      {name: :description, kind: :file, extension: 'md', required: true},
+      {name: :corollary, kind: :file, extension: 'md'},
+      {name: :extra, kind: :file, extension: :code},
+      {name: :AUTHORS, kind: :file, extension: 'txt', reverse: :authors},
+      {name: :COLLABORATORS, kind: :file, extension: 'txt', reverse: :collaborators}
+    ]
+  end
+end

data/lib/mumukit/sync/store/github/with_file_reading.rb

@@ -0,0 +1,19 @@
+require 'yaml'
+
+class Mumukit::Sync::Store::Github
+  module WithFileReading
+    def read_code_file(root, filename)
+      files = Dir.glob("#{root}/#{filename}.*")
+      file = files[0]
+      read_file(file) if files.length == 1
+    end
+
+    def read_yaml_file(path)
+      YAML.load_file(path) if path && File.exist?(path)
+    end
+
+    def read_file(path)
+      File.read(path) if path && File.exist?(path)
+    end
+  end
+end

data/lib/mumukit/sync/store/json.rb

@@ -0,0 +1,27 @@
+module Mumukit::Sync::Store
+  class Json
+    def initialize(json)
+      @json = json
+    end
+
+    def sync_keys
+      raise 'Non-discoverable store'
+    end
+
+    def read_resource(sync_key)
+      post_transform sync_key.kind, pre_transform(sync_key.kind, @json).deep_symbolize_keys
+    end
+
+    def write_resource!(*)
+      raise 'Read-only store'
+    end
+
+    def pre_transform(kind, json)
+      json
+    end
+
+    def post_transform(kind, json)
+      json
+    end
+  end
+end

data/lib/mumukit/sync/store/thesaurus.rb

@@ -0,0 +1,19 @@
+module Mumukit::Sync::Store
+  class Thesaurus
+    def initialize(thesaurus_bridge)
+      @thesaurus_bridge = thesaurus_bridge
+    end
+    def sync_keys
+      @thesaurus_bridge.runners.map { |it| Mumukit::Sync.key(:language, it) }
+    end
+
+    def read_resource(sync_key)
+      return unless sync_key.kind == :language
+      Mumukit::Bridge::Runner.new(runner_url).importable_info
+    end
+
+    def write_resource!(*)
+      raise 'Read-only store'
+    end
+  end
+end

data/lib/mumukit/sync/syncer.rb

@@ -0,0 +1,63 @@
+## An import and export pipeline for generic resources.
+##
+## A resource - that is, something that can be imported or exported - must implement the following methods:
+##
+## * #sync_key: returns a kind-id pair created using `Mumukit::Sync.key`, used to locate resources within a store
+## * #to_resource_h: returns a canonical hash representation of the resource. Only required by `Mumukit::Sync#export!`
+## * #import_from_resource_h!: populates and saves the resource with its canonical hash representation
+## * .locate_resource(resource_id): finds or initializes the resource given its resource id. Only required by `Mumukit::Sync#import_all!`
+
+module Mumukit::Sync
+  class Syncer
+    def initialize(store, inflators = [], resource_classifier = nil)
+      @store = store
+      @inflators = inflators
+      @resource_classifier ||= proc { |kind| Mumukit::Sync.constantize(kind) }
+    end
+
+    def sync_keys_matching(id_regex = nil)
+      id_regex ||= /.*/
+      @store.sync_keys.select { |key| id_regex.matches? key.id }
+    end
+
+    def import_all!(id_regex = nil)
+      sync_keys_matching(id_regex).each do |key|
+        puts "Importing #{key.kind} #{key.id}"
+        begin
+          locate_and_import! key
+        rescue => e
+          puts "Ignoring #{key.id} because of import error #{e}"
+        end
+      end
+    end
+
+    def locate_and_import!(*args)
+      locate(key_for(*args)).tap { |it| import! it }
+    end
+
+    def import!(resource)
+      resource_h = @store.read_resource(resource.sync_key)
+      Mumukit::Sync::Inflator.inflate_with! resource.sync_key, resource_h, @inflators
+      resource.import_from_resource_h!(resource_h)
+    end
+
+    def locate_and_export!(*args)
+      locate(key_for(*args)).tap { |it| export! it }
+    end
+
+    def export!(resource)
+      resource_h = resource.to_resource_h
+      @store.write_resource!(resource.sync_key, resource_h)
+    end
+
+    private
+
+    def locate(key)
+      @resource_classifier.call(key.kind).locate_resource(key.id)
+    end
+
+    def key_for(*args)
+      args.size == 1 ? args.first : Mumukit::Sync.key(*args)
+    end
+  end
+end

data/lib/mumukit/sync/version.rb

@@ -0,0 +1,5 @@
+module Mumukit
+  module Sync
+    VERSION = "0.0.0"
+  end
+end

data/mumukit-sync.gemspec

@@ -0,0 +1,34 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "mumukit/sync/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mumukit-sync"
+  spec.version       = Mumukit::Sync::VERSION
+  spec.authors       = ["Franco Bulgarelli"]
+  spec.email         = ["franco@mumuki.org"]
+
+  spec.summary       = %q{Synchronization tool for resources}
+  spec.description   = %q{Library for importing and exporting things within Mumuki}
+  spec.homepage      = 'https://mumuki.org'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'mumukit-core', '~> 1.7'
+  spec.add_dependency 'mumukit-bridge', '~> 3.5'
+  spec.add_dependency 'mumukit-auth', '~> 7.0'
+
+  spec.add_dependency 'git', '~> 1.5'
+  spec.add_dependency 'octokit', '~> 4.1'
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end