meibo 0.1.0

data/lib/meibo/builder/user_profile_builder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Meibo
+  class Builder
+    module UserProfileBuilder
+      extend BaseBuilder
+
+      def self.builder_attribute_names
+        [:builder, :user]
+      end
+
+      def initialize(builder:, sourced_id: SecureRandom.uuid, user:, **kw)
+        super(sourced_id: sourced_id, user_sourced_id: user.sourced_id, **kw)
+        @builder = builder
+        @user = user
+        builder.user_profiles << self
+      end
+    end
+  end
+end

data/lib/meibo/builder.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Meibo
+  class Builder
+    extend Forwardable
+
+    attr_reader :package, :profile
+
+    def_delegators :@package, :academic_sessions, :classes, :courses, :demographics, :enrollments, :organizations, :roles, :users, :user_profiles
+
+    def initialize(package:, profile: BaseProfile)
+      @package = package
+      @profile = profile
+    end
+
+    def build_academic_session(**kw)
+      builder_for(:academic_session).new(builder: self, **kw)
+    end
+
+    def build_classroom(**kw)
+      builder_for(:class).new(builder: self, **kw)
+    end
+
+    def build_course(**kw)
+      builder_for(:course).new(builder: self, **kw)
+    end
+
+    def build_demographic(**kw)
+      builder_for(:demographic).new(builder: self, **kw)
+    end
+
+    def build_enrollment(**kw)
+      builder_for(:enrollment).new(builder: self, **kw)
+    end
+
+    def build_organization(**kw)
+      builder_for(:org).new(builder: self, **kw)
+    end
+
+    def build_role(**kw)
+      builder_for(:role).new(builder: self, **kw)
+    end
+
+    def build_user(**kw)
+      builder_for(:user).new(builder: self, **kw)
+    end
+
+    def build_user_profile(**kw)
+      builder_for(:user_profile).new(builder: self, **kw)
+    end
+
+    private
+
+    def builder_for(key)
+      profile.builder_for(key)
+    end
+  end
+end

data/lib/meibo/classroom.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Meibo
+  class Classroom
+    TYPES = {
+      homeroom: 'homeroom',
+      scheduled: 'scheduled'
+    }.freeze
+
+    DataModel.define(
+      self,
+      attribute_name_to_header_field_map: {
+        sourced_id: 'sourcedId',
+        status: 'status',
+        date_last_modified: 'dateLastModified',
+        title: 'title',
+        grades: 'grades',
+        course_sourced_id: 'courseSourcedId',
+        class_code: 'classCode',
+        class_type: 'classType',
+        location: 'location',
+        school_sourced_id: 'schoolSourcedId',
+        term_sourced_ids: 'termSourcedIds',
+        subjects: 'subjects',
+        subject_codes: 'subjectCodes',
+        periods: 'periods'
+      }.freeze,
+      converters: {
+        datetime: [:date_last_modified].freeze,
+        enum: {
+          class_type: [*TYPES.values, ENUM_EXT_PATTERN].freeze
+        }.freeze,
+        list: [
+          :grades,
+          :term_sourced_ids,
+          :subjects,
+          :subject_codes,
+          :periods
+        ].freeze,
+        required: [:sourced_id, :title, :class_type, :course_sourced_id, :term_sourced_ids, :school_sourced_id].freeze,
+        status: [:status].freeze
+      }
+    )
+
+    def initialize(sourced_id:, status: nil, date_last_modified: nil, title:, grades: [], course_sourced_id:, class_code: nil, class_type:, location: nil, school_sourced_id:, term_sourced_ids:, subjects: [], subject_codes: [], periods: [], **extension_fields)
+      unless subjects.is_a?(Array) && subject_codes.is_a?(Array) && subjects.size == subject_codes.size
+        raise InvalidDataTypeError
+      end
+
+      @sourced_id = sourced_id
+      @status = status
+      @date_last_modified = date_last_modified
+      @title = title
+      @grades = grades
+      @course_sourced_id = course_sourced_id
+      @class_code = class_code
+      @class_type = class_type
+      @location = location
+      @school_sourced_id = school_sourced_id
+      @term_sourced_ids = term_sourced_ids
+      @subjects = subjects
+      @subject_codes = subject_codes
+      @periods = periods
+      @extension_fields = extension_fields
+    end
+  end
+end

data/lib/meibo/classroom_set.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Meibo
+  class ClassroomSet < DataSet
+    def initialize(data, academic_session_set:, course_set:, organization_set:)
+      super(data)
+      @academic_session_set = academic_session_set
+      @course_set = course_set
+      @organization_set = organization_set
+    end
+
+    def check_semantically_consistent
+      super
+
+      each do |classroom|
+        @organization_set.find_by_sourced_id(classroom.school_sourced_id)
+        @course_set.find_by_sourced_id(classroom.course_sourced_id)
+
+        if classroom.term_sourced_ids.empty?
+          raise DataNotFoundError, "termSourcedIdは1つ以上指定してください"
+        end
+
+        classroom.term_sourced_ids.each do |term_sourced_id|
+          @academic_session_set.find_by_sourced_id(term_sourced_id)
+        end
+      end
+    end
+  end
+end

data/lib/meibo/converter.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'time'
+
+module Meibo
+  module Converter
+    TYPES = %i[
+      list
+      required
+      boolean
+      date
+      datetime
+      enum
+      integer
+      status
+      user_ids
+      year
+    ].freeze
+
+    class << self
+      def build_header_field_to_attribute_converter(attribute_name_to_header_field_map)
+        header_field_to_attribute_name_map = attribute_name_to_header_field_map.to_h {|attribute, header_field|
+          [header_field, attribute]
+        }.freeze
+        lambda {|field| header_field_to_attribute_name_map.fetch(field) }
+      end
+
+      def build_parser_converter(fields:, converters:)
+        build_converter(fields: fields, converters: converters, write_or_parser: 'parser')
+      end
+
+      def build_write_converter(fields:, converters:)
+        build_converter(fields: fields, converters: converters, write_or_parser: 'write')
+      end
+
+      private
+
+      def build_converter(fields:, converters:, write_or_parser:)
+        converter_list = TYPES.filter_map do |converter_type|
+          fields_to_be_converted = converters[converter_type]
+          method_name = "build_#{converter_type}_field_#{write_or_parser}_converter"
+          if fields_to_be_converted && respond_to?(method_name, true)
+            if converter_type == :enum
+              enum_definition = fields_to_be_converted.to_h {|field, enum| [fields.index(field), enum] }
+              send(method_name, enum_definition)
+            else
+              indexes = fields_to_be_converted.map {|field| fields.index(field) }
+              send(method_name, indexes)
+            end
+          end
+        end
+        lambda do |field, field_info|
+          # NOTE: convert blank sourcedId to nil
+          if field_info.index.zero?
+            field = nil if field.empty?
+          end
+          converter_list.each {|converter| field = converter[field, field_info] }
+          field
+        end
+      end
+
+      def build_boolean_field_parser_converter(boolean_field_indexes)
+        boolean_field_indexes = boolean_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if boolean_field_indexes.include?(field_info.index)
+            case field
+            when 'true'
+              true
+            when 'false'
+              false
+            when nil
+              nil
+            else
+              raise InvalidDataTypeError
+            end
+          else
+            field
+          end
+        end
+      end
+
+      def build_date_field_write_converter(date_field_indexes)
+        date_field_indexes = date_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if date_field_indexes.include?(field_info.index)
+            field&.iso8601
+          else
+            field
+          end
+        end
+      end
+
+      def build_date_field_parser_converter(date_field_indexes)
+        date_field_indexes = date_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if field && date_field_indexes.include?(field_info.index)
+            begin
+              Date.strptime(field, '%Y-%m-%d')
+            rescue
+              raise InvalidDataTypeError
+            end
+          else
+            field
+          end
+        end
+      end
+
+      def build_datetime_field_write_converter(datetime_field_indexes)
+        datetime_field_indexes = datetime_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if datetime_field_indexes.include?(field_info.index)
+            field&.utc&.iso8601
+          else
+            field
+          end
+        end
+      end
+
+      def build_datetime_field_parser_converter(datetime_field_indexes)
+        datetime_field_indexes = datetime_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if field && datetime_field_indexes.include?(field_info.index)
+            begin
+              Time.iso8601(field)
+            rescue
+              raise InvalidDataTypeError
+            end
+          else
+            field
+          end
+        end
+      end
+
+      def build_enum_field_parser_converter(enum_definition)
+        enum_definition = enum_definition.dup.freeze
+        lambda do |field, field_info|
+          return field unless field
+
+          enum = enum_definition[field_info.index]
+          if enum
+            unless enum.any? {|e| e.match?(field) }
+              raise InvalidDataTypeError
+            end
+          end
+          field
+        end
+      end
+
+      def build_integer_field_parser_converter(integer_field_indexes)
+        integer_field_indexes = integer_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if field && integer_field_indexes.include?(field_info.index)
+            begin
+              Integer(field, 10)
+            rescue
+              raise InvalidDataTypeError
+            end
+          else
+            field
+          end
+        end
+      end
+
+      def build_list_field_write_converter(list_field_indexes)
+        list_field_indexes = list_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if list_field_indexes.include?(field_info.index)
+            if field
+              if field.empty?
+                nil
+              else
+                field.join(',')
+              end
+            end
+          else
+            field
+          end
+        end
+      end
+
+      def build_list_field_parser_converter(list_field_indexes)
+        list_field_indexes = list_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if list_field_indexes.include?(field_info.index)
+            if field
+              field.split(',').map(&:strip)
+            else
+              []
+            end
+          else
+            field
+          end
+        end
+      end
+
+      def build_required_field_parser_converter(required_field_indexes)
+        required_field_indexes = required_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if required_field_indexes.include?(field_info.index)
+            raise MissingDataError if field.nil?
+            raise MissingDataError if field.respond_to?(:empty?) && field.empty?
+          end
+          field
+        end
+      end
+
+      # TODO
+      # def build_role_field_write_converter(role_field_indexes)
+
+      def build_status_field_parser_converter(status_field_indexes)
+        status_field_indexes = status_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if field && status_field_indexes.include?(field_info.index)
+            raise InvalidDataTypeError, "invalid status: #{field}" unless field == 'active' || field == 'tobedeleted'
+          else
+            field
+          end
+        end
+      end
+
+      def build_user_ids_field_parser_converter(user_ids_field_indexes)
+        user_ids_field_indexes = user_ids_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if user_ids_field_indexes.include?(field_info.index)
+            raise InvalidDataTypeError unless field.all? {|user_id| Meibo::User::USER_ID_FORMAT_REGEXP.match?(user_id) }
+          end
+          field
+        end
+      end
+
+      def build_year_field_write_converter(year_field_indexes)
+        year_field_indexes = year_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if year_field_indexes.include?(field_info.index)
+            field && ("%04d" % field)
+          else
+            field
+          end
+        end
+      end
+
+      def build_year_field_parser_converter(year_field_indexes)
+        year_field_indexes = year_field_indexes.dup.freeze
+        lambda do |field, field_info|
+          if field && year_field_indexes.include?(field_info.index)
+            begin
+              Integer(field, 10)
+            rescue
+              raise InvalidDataTypeError
+            end
+          else
+            field
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meibo/course.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Meibo
+  class Course
+    DataModel.define(
+      self,
+      attribute_name_to_header_field_map: {
+        sourced_id: 'sourcedId',
+        status: 'status',
+        date_last_modified: 'dateLastModified',
+        school_year_sourced_id: 'schoolYearSourcedId',
+        title: 'title',
+        course_code: 'courseCode',
+        grades: 'grades',
+        org_sourced_id: 'orgSourcedId',
+        subjects: 'subjects',
+        subject_codes: 'subjectCodes'
+      },
+      converters: {
+        datetime: [:date_last_modified],
+        list: [:grades, :subjects, :subject_codes],
+        required: [:sourced_id, :title, :org_sourced_id],
+        status: [:status]
+      }
+    )
+
+    def initialize(sourced_id:, status: nil, date_last_modified: nil, school_year_sourced_id: nil, title:, course_code: nil, grades: [], org_sourced_id:, subjects: [], subject_codes: [], **extension_fields)
+      unless subjects.is_a?(Array) && subject_codes.is_a?(Array) && subjects.size == subject_codes.size
+        raise InvalidDataTypeError
+      end
+
+      @sourced_id = sourced_id
+      @status = status
+      @date_last_modified = date_last_modified
+      @school_year_sourced_id = school_year_sourced_id
+      @title = title
+      @course_code = course_code
+      @grades = grades
+      @org_sourced_id = org_sourced_id
+      @subjects = subjects
+      @subject_codes = subject_codes
+      @extension_fields = extension_fields
+    end
+  end
+end

data/lib/meibo/course_set.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Meibo
+  class CourseSet < DataSet
+    def initialize(data, academic_session_set:, organization_set:)
+      super(data)
+      @academic_session_set = academic_session_set
+      @organization_set = organization_set
+    end
+
+    def check_semantically_consistent
+      super
+
+      each do |course|
+        if course.school_year_sourced_id
+          @academic_session_set.find_by_sourced_id(course.school_year_sourced_id)
+        end
+
+        @organization_set.find_by_sourced_id(course.org_sourced_id)
+      end
+    end
+  end
+end

data/lib/meibo/data_model.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Meibo
+  module DataModel
+    module ClassMethods
+      def parse(csv)
+        return to_enum(:parse, csv) unless block_given?
+
+        actual_headers = CSV.parse_line(csv)
+        missing_headers = header_fields - actual_headers
+        unless missing_headers.empty?
+          raise MissingHeadersError, "missing headers: #{missing_headers.join(',')}"
+        end
+        unless actual_headers.take(header_fields.size) == header_fields
+          raise ScrambledHeadersError
+        end
+
+        CSV.parse(csv, encoding: Meibo::CSV_ENCODING, headers: true, converters: parser_converters, header_converters: header_converters).each do |row|
+          yield new(**row.to_h)
+        end
+      end
+    end
+
+    def self.define(klass, attribute_name_to_header_field_map:, converters: {})
+      attribute_name_to_header_field_map = attribute_name_to_header_field_map.dup.freeze
+      attribute_names = attribute_name_to_header_field_map.keys.freeze
+      header_fields = attribute_name_to_header_field_map.values.freeze
+      converters = converters.dup.freeze
+      define_class_attribute(klass, :attribute_name_to_header_field_map, attribute_name_to_header_field_map)
+      define_class_attribute(klass, :attribute_names, attribute_names)
+      define_class_attribute(klass, :header_fields, header_fields)
+      define_class_attribute(klass, :converters, converters)
+
+      define_header_converters(klass, attribute_name_to_header_field_map)
+      define_parser_converters(klass, attribute_names: attribute_names, converters: converters)
+      define_write_converters(klass, attribute_names: attribute_names, converters: converters)
+
+      klass.attr_reader(*attribute_names, :extension_fields)
+      klass.extend(ClassMethods)
+      klass.include(self)
+    end
+
+    def self.define_class_attribute(klass, attribute, value)
+      klass.define_singleton_method(attribute) { value }
+    end
+
+    def self.define_header_converters(klass, attribute_name_to_header_field_map)
+      header_converters = Converter.build_header_field_to_attribute_converter(attribute_name_to_header_field_map)
+      klass.define_singleton_method(:header_converters) { header_converters }
+    end
+
+    def self.define_parser_converters(klass, attribute_names:, converters:)
+      parser_converter = Converter.build_parser_converter(fields: attribute_names, converters: converters)
+      klass.define_singleton_method(:parser_converters) { parser_converter }
+    end
+
+    def self.define_write_converters(klass, attribute_names:, converters:)
+      write_converter = Converter.build_write_converter(fields: attribute_names, converters: converters)
+      klass.define_singleton_method(:write_converters) { write_converter }
+    end
+
+    def to_csv(...)
+      to_a.to_csv(...)
+    end
+
+    def deconstruct
+      to_a
+    end
+
+    def deconstruct_keys(_keys)
+      to_h
+    end
+
+    def to_a
+      self.class.attribute_names.map {|attribute| public_send(attribute) }
+    end
+
+    def to_h
+      self.class.attribute_names.zip(to_a).to_h
+    end
+  end
+end

data/lib/meibo/data_set.rb

@@ -0,0 +1,44 @@
+module Meibo
+  class DataSet
+    def initialize(data)
+      @data = data
+      @data_hash = data.to_h {|datum| [datum.sourced_id, datum] }
+    end
+
+    def <<(new_data)
+      raise DataNotFoundError, "sourcedIdがありません" unless new_data.sourced_id
+      raise SourcedIdDuplicatedError, 'sourcedIdが重複しています' if @data_hash.key?(new_data.sourced_id)
+
+      @data << new_data
+      @data_hash[new_data.sourced_id] = new_data
+    end
+
+    def check_semantically_consistent
+      unless @data.size == @data_hash.size
+        raise SourcedIdDuplicatedError, 'sourcedIdが重複しています'
+      end
+
+      unless @data_hash[nil].nil?
+        raise DataNotFoundError, "sourcedIdがありません"
+      end
+    end
+
+    def each(...)
+      @data.each(...)
+    end
+
+    def empty?
+      @data.empty?
+    end
+
+    def find_by_sourced_id(sourced_id)
+      @data_hash.fetch(sourced_id)
+    rescue KeyError
+      raise DataNotFoundError, "sourcedId: #{sourced_id} が見つかりません"
+    end
+
+    def to_a
+      @data
+    end
+  end
+end