paneron-register 0.2.0 → 0.3.0

data/lib/paneron/register/raw/data_set.rb

@@ -6,41 +6,179 @@ module Paneron
   module Register
     module Raw
       class DataSet
-        attr_reader :data_set_path, :register_path, :data_set_yaml_path,
+        include Writeable
+        include Validatable
+        include RootFinder
+
+        attr_reader :register_path,
                     :data_set_name, :extension
+        attr_accessor :register
+
+        def initialize(
+          data_set_path = nil,
+          extension = "yaml",
+          register: nil
+        )
+
+          unless data_set_path.nil?
+            register_path, new_data_set_name = Hierarchical.split_path(data_set_path)
+          end
 
-        def initialize(register_path, data_set_name, extension = "yaml")
-          data_set_path = File.join(register_path, data_set_name)
-          self.class.validate_data_set_path(data_set_path)
+          # Deduce parent from self path,
+          # if only self path is specified.
+          @register = if register.nil?
+                        Paneron::Register::Raw::Register.new(
+                          register_path,
+                        )
+                      else
+                        register
+                      end
+
+          if register_path != @register.register_path
+            raise Paneron::Register::Error,
+                  "Register path mismatch:\n" \
+                  "Expected passed in register to align with data set's parent:\n" \
+                  "#{@register.register_path} != #{register_path}"
+          end
 
-          @register_path = register_path
-          @data_set_name = data_set_name
           @extension = extension
-          @data_set_path = data_set_path
-          @data_set_yaml_path = File.join(data_set_path,
-                                          DATA_SET_METADATA_FILENAME)
           @item_classes = {}
-          @item_class_names = nil
-          @item_uuids = nil
+          @items = {}
           @metadata = nil
+          @paneron_metadata = nil
+          self.data_set_name = new_data_set_name
+          @old_name = @data_set_name
+          # {
+          #   "title" => data_set_name,
+          # }
         end
 
         DATA_SET_METADATA_FILENAME = "/register.yaml"
+        PANERON_METADATA_FILENAME = "/panerondataset.yaml"
+
+        def data_set_path
+          File.join(register_path, data_set_name)
+        end
+
+        def data_set_name=(new_data_set_name)
+          if new_data_set_name.nil? || new_data_set_name.empty?
+            raise Paneron::Register::Error, "Data set name cannot be empty"
+          end
+
+          unless new_data_set_name.is_a?(String)
+            raise Paneron::Register::Error, "Data set name must be a string"
+          end
+
+          @data_set_name = new_data_set_name
+          self.title = new_data_set_name
+        end
+
+        def data_set_yaml_path
+          File.join(data_set_path,
+                    DATA_SET_METADATA_FILENAME)
+        end
+
+        def paneron_yaml_path
+          File.join(data_set_path,
+                    PANERON_METADATA_FILENAME)
+        end
+
+        def parent
+          register
+        end
+
+        def self.name
+          "Data set"
+        end
+
+        # Important that the parent paths are existent.
+        def save_sequence
+          # Save self
+          require "fileutils"
+
+          # Move old data set to new path
+          old_path = File.join(register_path, @old_name)
+          if File.directory?(old_path) && @old_name != data_set_name
+            FileUtils.mv(old_path, self_path)
+            @old_name = data_set_name
+          else
+            FileUtils.mkdir_p(self_path)
+          end
+
+          # TODO: populate template with sensible defaults
+          if @metadata.nil? || @metadata.empty?
+            File.write(data_set_yaml_path, self.class.metadata_template.to_yaml)
+          else
+            File.write(data_set_yaml_path, metadata.to_yaml)
+          end
+
+          # TODO: populate template with sensible defaults
+          if @paneron_metadata.nil? || @paneron_metadata.empty?
+            File.write(paneron_yaml_path,
+                       self.class.paneron_metadata_template(data_set_name).to_yaml)
+          else
+            File.write(paneron_yaml_path, paneron_metadata.to_yaml)
+          end
+
+          # Save item classes
+          item_class_names.each do |item_class_name|
+            new_thing = item_classes(item_class_name)
+            new_thing.data_set = self
+            new_thing.save
+          end
+
+          # # Save proposals
+          # proposal_uuids.each do |proposal_uuid|
+          #   proposals(proposal_uuid).save
+          # end
+        end
+
+        def self_path
+          data_set_path
+        end
 
-        def self.validate_data_set_path(data_set_path)
-          unless File.exist?(data_set_path)
+        def is_valid?
+          self.data_set_name = data_set_name
+          register.valid?
+        end
+
+        def set_register(new_register)
+          @register = new_register
+        end
+
+        def register_path
+          @register.register_path
+        end
+
+        def add_item_classes(*new_item_classes)
+          new_item_classes = [new_item_classes] unless new_item_classes.is_a?(Enumerable)
+          new_item_classes.each do |item_class|
+            item_class.set_data_set(self)
+            @item_classes[item_class.item_class_name] = item_class
+          end
+        end
+
+        def self.validate_path_before_saving
+          true
+        end
+
+        def self.validate_path(path)
+          unless File.exist?(path)
             raise Paneron::Register::Error,
-                  "Data Set path does not exist"
+                  "#{name} path (#{path}) does not exist"
           end
-          unless File.directory?(data_set_path)
+
+          unless File.directory?(path)
             raise Paneron::Register::Error,
-                  "Data Set path is not a directory"
+                  "#{name} path (#{path}) is not a directory"
           end
-          unless File.exist?(File.join(
-                               data_set_path, DATA_SET_METADATA_FILENAME
-                             ))
+
+          data_set_file = File.join(
+            path, DATA_SET_METADATA_FILENAME
+          )
+          unless File.exist?(data_set_file)
             raise Paneron::Register::Error,
-                  "Data Set metadata file does not exist"
+                  "Data Set metadata file (#{data_set_file}) does not exist"
           end
         end
 
@@ -57,35 +195,212 @@ module Paneron
           end
         end
 
-        def item_classes(item_class_name = nil)
+        def item_classes(item_class_name = nil, refresh: false)
           if item_class_name.nil?
-            item_class_names.reduce({}) do |acc, item_class_name|
-              acc[item_class_name] = item_classes(item_class_name)
-              acc
-            end
+            @item_classes = if !refresh && !@item_classes.empty?
+                              @item_classes
+                            else
+                              item_class_names(refresh: refresh).reduce({}) do |acc, item_class_name|
+                                acc[item_class_name] = item_classes(item_class_name)
+                                acc
+                              end
+                            end
+          elsif refresh
+            item_classes[item_class_name]
           else
             @item_classes[item_class_name] ||=
               Paneron::Register::Raw::ItemClass.new(
-                data_set_path, item_class_name
+                File.join(data_set_path, item_class_name),
+                data_set: self,
               )
           end
         end
 
-        def item_class_names
-          @item_class_names ||=
+        def spawn_item_class(item_class_name, metadata: {})
+          new_item_class = Paneron::Register::Raw::ItemClass.new(
+            File.join(data_set_path, item_class_name),
+            data_set: self,
+          )
+
+          add_item_classes(new_item_class)
+
+          new_item_class
+        end
+
+        def item_class_names(refresh: false)
+          if refresh || @item_classes.empty?
             Dir.glob(File.join(data_set_path, "*/*.#{extension}"))
-              .map { |file| File.basename(File.dirname(file)) }.uniq
+              .map { |file| File.basename(File.dirname(file)) }.to_set
+          else
+            @item_classes.keys
+          end
         end
 
         def item_uuids
-          item_classes.values.map(&:item_uuids).flatten
+          item_classes.values.map(&:item_uuids).to_set.flatten
+        end
+
+        def items(uuid = nil, item_class_name = nil, refresh: false)
+          if uuid.nil?
+            @items = if !refresh && !@items.empty?
+                       @items
+                     else
+                       item_classes.reduce({}) do |acc, (item_klass_name, item_klass)|
+                         item_klass.item_uuids.each do |item_uuid|
+                           acc[item_uuid] = items(item_uuid, item_klass_name)
+                         end
+                         acc
+                       end
+                     end
+          elsif refresh
+            items[uuid]
+          else
+            @items[uuid] ||=
+              Paneron::Register::Raw::Item.new(
+                uuid,
+                File.join(data_set_path, item_class_name),
+                item_class: item_classes[item_class_name],
+              )
+          end
+        end
+
+        # TODO: Add validation to register.yaml fields
+        # name: Full Name of Data Set
+        # stakeholders: [ { roles, name, gitServerUsername, affiliations, contacts } ]
+        # version: { id, timestamp }
+        # contentSummary:
+        # operatingLanguage: { name, country, language }
+        # organizations: { uuid..: { name, logoURL } }
+        # TODO: Add support to read/write panerondataset.yaml
+        # title: short-name
+        #   type:
+        #     id: 'npm-paneron-extension-name'
+        #     version: 0.0.1-alpha1
+        def paneron_metadata
+          @paneron_metadata ||= begin
+            YAML.safe_load_file(
+              paneron_yaml_path,
+              permitted_classes: [Time, Date, DateTime],
+            )
+          rescue Errno::ENOENT
+            {}
+          end
+        end
+
+        def merge_paneron_metadata(other)
+          paneron_metadata.merge!(other)
+        end
+
+        def paneron_metadata=(new_paneron_metadata)
+          @paneron_metadata = new_paneron_metadata
         end
 
         def metadata
-          @metadata ||= YAML.safe_load_file(
-            data_set_yaml_path,
-            permitted_classes: [Time],
-          )
+          @metadata ||= begin
+            YAML.safe_load_file(
+              data_set_yaml_path,
+              permitted_classes: [Time, Date, DateTime],
+            )
+          rescue Errno::ENOENT
+            {}
+          end
+        end
+
+        def merge_metadata(other)
+          metadata.merge!(other)
+        end
+
+        def metadata=(metadata)
+          @metadata = metadata
+        end
+
+        def name=(new_name)
+          metadata["name"] = new_name.to_s
+        end
+
+        # This is really just data_set_name
+        def title=(new_title)
+          paneron_metadata["title"] = new_title.to_s
+        end
+        private :title=
+
+        def title
+          paneron_metadata["title"]
+        end
+
+        def stakeholders
+          metadata["stakeholders"] || []
+        end
+
+        def stakeholders=(new_stakeholders)
+          metadata["stakeholders"] ||= new_stakeholders
+        end
+
+        def content_summary
+          metadata["contentSummary"] || ""
+        end
+
+        def content_summary=(new_content_summary)
+          metadata["contentSummary"] = new_content_summary.to_s
+        end
+
+        def operating_language
+          metadata["operatingLanguage"] || {}
+        end
+
+        def operating_language=(name: "", country: "", language: "")
+          metadata["operatingLanguage"] = {
+            "name" => name.to_s,
+            "country" => country.to_s,
+            "language" => language.to_s,
+          }
+        end
+
+        def organizations
+          metadata["organizations"] || {}
+        end
+
+        def organizations=(new_organizations)
+          metadata["organizations"] = case new_organizations
+                                      when Hash then new_organizations
+                                      else
+                                        raise Paneron::Register::Error, "organizations must be a hash"
+                                      end
+        end
+
+        def self.metadata_template
+          {
+            "name" => "",
+            "stakeholders" => [
+              # {
+              #   "roles" => [],
+              #   "name" => "",
+              #   "gitServerUsername" => "",
+              #   "affiliations" => [],
+              #   "contacts" => [],
+              # },
+            ],
+            "version" => nil, # { "id" => "", "timestamp" => "" },
+            "contentSummary" => "",
+            "operatingLanguage" => {
+              "name" => "English",
+              "country" => "N/A",
+              "language" => "eng",
+            },
+            "organizations" => {
+              # "uuid" => { "name" => "", "logoURL" => "" },
+            },
+          }
+        end
+
+        def self.paneron_metadata_template(title: "")
+          {
+            "title" => "",
+            "type" => {
+              "id" => "",
+              "version" => "",
+            },
+          }
         end
       end
     end

data/lib/paneron/register/raw/item.rb

@@ -6,51 +6,175 @@ module Paneron
   module Register
     module Raw
       class Item
-        attr_reader :item_class_path,
-                    :item_id,
-                    :item_path,
+        include Writeable
+        include Validatable
+        include RootFinder
+
+        attr_reader :item_uuid,
                     :extension
+        attr_accessor :item_class
 
         def initialize(
-          item_class_path,
-          item_id,
-          extension = "yaml"
+          item_uuid = nil,
+          item_class_path = nil,
+          extension = "yaml",
+          item_class: nil
         )
-          item_path = File.join(item_class_path, "#{item_id}.#{extension}")
-          self.class.validate_item_path(item_path)
-          @item_class_path = item_class_path
-          @item_id = item_id
-          @item_path = item_path
+          # Deduce parent from self path,
+          # if only self path is specified.
+          @item_class = if item_class.nil?
+                          Paneron::Register::Raw::ItemClass.new(
+                            item_class_path,
+                          )
+                        else
+                          item_class
+                        end
+
+          require "securerandom"
+          require "uuid"
+
+          @item_uuid = if item_uuid.nil? || item_uuid.empty?
+                         SecureRandom.uuid
+                       elsif UUID.validate(item_uuid)
+                         item_uuid
+                       else
+                         raise Paneron::Register::Error,
+                               "Specified UUID not valid (#{item_uuid})"
+                       end
+
           @extension = extension
           @to_h = nil
+          @status = nil
+          @data = nil
+          @date_accepted = nil
+        end
+
+        def item_path
+          File.join(item_class_path, "#{item_uuid}.#{extension}")
+        end
+
+        def item_class_path
+          @item_class.item_class_path
+        end
+
+        def set(
+          status: nil,
+          data: nil,
+          date_accepted: nil
+        )
+          self.status = status
+          self.data = data
+          self.date_accepted = date_accepted
         end
 
-        def self.validate_item_path(path)
+        def uuid
+          @item_uuid
+        end
+
+        def status
+          @status ||= disk_to_h["status"]
+        end
+
+        def status=(new_status)
+          @status = new_status
+        end
+
+        def data
+          @data ||= disk_to_h["data"]
+        end
+
+        def data=(new_data)
+          @data = new_data
+        end
+
+        # Default is now
+        def date_accepted
+          @date_accepted ||= disk_to_h["dateAccepted"] || DateTime.now
+        end
+
+        def date_accepted=(new_date_accepted)
+          @date_accepted = case new_date_accepted
+                           when String then DateTime.parse(new_date_accepted)
+                           when DateTime then new_date_accepted
+                           when Time, Date then new_date_accepted.to_datetime
+                           when NilClass then nil
+                           else
+                             raise Paneron::Register::Error,
+                                   "Invalid date: #{new_date_accepted}"
+                           end
+        end
+
+        def parent
+          item_class
+        end
+
+        def self.name
+          "Item"
+        end
+
+        def save_sequence
+          # Save self
+          require "fileutils"
+          FileUtils.mkdir_p(item_class_path)
+
+          File.write(item_path, to_h.to_yaml)
+        end
+
+        def self_path
+          item_path
+        end
+
+        def is_valid?
+          item_class.valid?
+        end
+
+        def set_item_class(new_item_class)
+          @item_class = new_item_class
+        end
+
+        def self.validate_path_before_saving
+          true
+        end
+
+        def self.validate_path(path)
           unless File.exist?(path)
             raise Paneron::Register::Error,
-                  "Item path does not exist"
+                  "Item path (#{path}) does not exist"
           end
           unless File.file?(path)
             raise Paneron::Register::Error,
-                  "Item path is not a file"
+                  "Item path (#{path}) is not a file"
           end
         end
 
         def to_lutaml
           Paneron::Register::Item.new(
-            id: item_id,
-            data: to_h["data"],
-            status: Paneron::Register::ItemStatus.new(state: to_h["status"]),
-            date_accepted: to_h["dateAccepted"].to_s,
+            id: item_uuid,
+            data: data,
+            status: Paneron::Register::ItemStatus.new(state: status),
+            date_accepted: date_accepted.to_s,
           )
         end
 
         def to_h
-          @to_h ||=
-            YAML.safe_load_file(
-              File.join(item_path),
-              permitted_classes: [Time],
-            )
+          {
+            "id" => item_uuid,
+            "data" => data,
+            "status" => status,
+            "dateAccepted" => date_accepted,
+          }
+        end
+
+        def disk_to_h
+          if File.exist?(item_path)
+            @disk_to_h ||=
+              YAML.safe_load_file(
+                item_path,
+                permitted_classes: [Time, Date, DateTime],
+              )
+          else
+            {}
+          end
         end
       end
     end