paneron-register 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 905511b3f9edd9a791524a1ef3093d5d51cd9c30732e9064098fd56eb513a966
-  data.tar.gz: '094f4ac891e8f7501c9f07e33bbf26999945a90079ce1314a4cb643ee1363162'
+  metadata.gz: 52d7cfff231080db14c14453bd757db38f58b35ffcdbe69588c34fc97facc331
+  data.tar.gz: f5d14ee0605cc362800849f463a08bacf6cf2e1ef3a055244425b7264933bdf1
 SHA512:
-  metadata.gz: a168bfaa534e93b2309e014b9329ad03701eae24504904aa52c78cf07322e321f9064bf3955e61c45a5acf655df359437a5b35ae98480ff47d60d1fbe964c4aa
-  data.tar.gz: d3cfccc0ada0807ade6be6adb3104c619549991e1a46bd147b587a1d1deabde551cdb74080fa44c78f39d8d825205ffc3fae2e5e69df8e6b0dac4999807f017d
+  metadata.gz: 5a8588a75ec028ce6faa1083f615c120ed289a31924a19276383e8309ac40c2aa0733b299de94d1af23d98406faf67b06548351a605f2ead260ee1f927be30e7
+  data.tar.gz: '049798fcb8d8308ada3f45ce7effb8d960e3546890c5780c34178c5ad2bd94653f82be52f63a29945d3cf3b98d1b1a251055a1dec529b8056103c8da1ac5b268'

data/.rubocop.yml

@@ -7,10 +7,16 @@ inherit_from:
 Layout/LineLength:
   Enabled: true
   AllowedPatterns: ["^\\s*#"]
+  Max: 95
 
 Metrics/MethodLength:
   Enabled: true
   CountAsOne: ["array", "hash", "heredoc", "method_call"]
+  Max: 35
+
+Metrics/AbcSize:
+  Enabled: true
+  Max: 20
 
 Metrics/BlockLength:
   Enabled: true

data/README.adoc

@@ -18,31 +18,70 @@ gem install paneron-register
 ```ruby
 require "paneron/register"
 
-# Initialize a new register
-# This example uses a working copy of Paneron's register.
-register = Paneron::Register::Register.new(
+# Initialize a new data set
+# This example uses a working copy of Paneron's data set.
+# => Paneron::Register::Raw::DataSet
+raw_data_set = Paneron::Register::Raw::DataSet.new(
   "/Users/username/Library/Application Support/Electron/working_copies/00000000-0001-0000-0000-000000000001",
-  "register_name-1"
+  "data_set_name-1"
 )
 
-# Alternatively, initialize a new register root:
-root = Paneron::Register::RegisterRoot.new(
+# => Paneron::Register::DataSet < Lutaml::Model::Serializable
+data_set = raw_data_set.to_lutaml
+
+# Alternatively, initialize a new register:
+# => Paneron::Register::Raw::Register
+raw_register = Paneron::Register::Raw::Register.new(
   "/Users/username/Library/Application Support/Electron/working_copies/00000000-0001-0000-0000-000000000001",
 )
-register = root.registries("register_name-1")
+
+# This example uses a Git URL
+# => Paneron::Register::Raw::Register
+raw_register = Paneron::Register::Raw::Register.from_git(
+  "https://github.com/isogr/registry",
+
+  # optional.  For previously cloned repos, pulls from repo iff true.
+  # update: true,
+)
+
+# => Paneron::Register::Raw::DataSet
+raw_data_set = raw_register.data_sets("data_set_name-1")
+
+# => Paneron::Register::DataSet < Lutaml::Model::Serializable
+data_set = raw_data_set.to_lutaml
 
 # Get all item class objects
-register.item_classes
+# => { item-class-name: Paneron::Register::Raw::ItemClass }
+raw_data_set.item_classes
+
+# => [ Paneron::Register::ItemClass ]
+data_set.item_classes
 
 # Get a specific item class object
-item_class = register.item_classes("item-class-1")
+# => Paneron::Register::Raw::ItemClass
+raw_item_class = raw_data_set.item_classes("item-class-1")
+
+# => Paneron::Register::ItemClass < Lutaml::Model::Serializable
+item_class = raw_item_class.to_lutaml
 
-# Get all item class objects in Ruby Hash format
-item_class.items_yamls
+# Get all item objects in Ruby Hash format
+# => { item-uuid: Paneron::Register::Raw::Item }
+raw_item_class.items
+
+# => [ Paneron::Register::Item ]
+item_class.items
 
 # Get a specific item property, using normal Ruby Hash methods
-id = item_class.items_yamls["id"]
-blob1 = item_class.items_yamls["data"]["blob1"]
+# => Paneron::Register::Raw::Item
+raw_item = raw_item_class.items["00000000-0000-0000-0000-000000000001"]
+id = raw_item["id"]
+blob1 = raw_item["data"]["blob1"]
+
+# Get a specific item property, from a Lutaml object
+# => Paneron::Register::Item < Lutaml::Model::Serializable
+item = raw_item.to_lutaml
+id = item.to_h["id"]
+blob1 = item.to_h["data"]["blob1"]
 ```
 
 == License

data/lib/paneron/register/data_set.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Paneron
+  module Register
+    class DataSet < Lutaml::Model::Serializable
+      attribute :name, Lutaml::Model::Type::String
+      attribute :item_classes, Paneron::Register::ItemClass, collection: true
+    end
+  end
+end

data/lib/paneron/register/item.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Paneron
+  module Register
+    class Item < Lutaml::Model::Serializable
+      # 'id' is a UUID
+      attribute :id, Lutaml::Model::Type::String
+
+      # TODO: data is free form object
+      attribute :data, Lutaml::Model::Type::String
+      attribute :status, Paneron::Register::ItemStatus, values:
+        Paneron::Register::ITEM_STATUSES.values
+      attribute :date_accepted, Lutaml::Model::Type::DateTime
+    end
+  end
+end

data/lib/paneron/register/item_class.rb

@@ -1,51 +1,12 @@
-require "yaml"
+# frozen_string_literal: true
+
+require "lutaml/model"
 
 module Paneron
   module Register
-    class ItemClass
-      attr_reader :register_path, :register_root_path, :register_yaml_path,
-                  :item_class_name, :item_class_path, :register_name
-
-      def initialize(register_root_path, register_name, item_class_name)
-        File.join(register_root_path, register_name)
-        item_class_path = File.join(register_root_path, register_name,
-                                    item_class_name)
-        self.class.validate_item_class_path(item_class_path)
-        @item_class_path = item_class_path
-        @items_uuids = nil
-        @items = {}
-      end
-
-      def self.validate_item_class_path(path)
-        unless File.exist?(path)
-          raise Paneron::Register::Error,
-                "Item class path does not exist"
-        end
-        unless File.directory?(path)
-          raise Paneron::Register::Error,
-                "Item class path is not a directory"
-        end
-      end
-
-      def item_uuids
-        @item_uuids ||= Dir.glob(File.join(item_class_path, "*.yaml"))
-          .map { |file| File.basename(file, ".yaml") }
-      end
-
-      def item_yamls(uuid = nil)
-        if uuid.nil?
-          item_uuids.reduce({}) do |acc, uuid|
-            acc[uuid] = item_yamls(uuid)
-            acc
-          end
-        else
-          @items[uuid] ||=
-            YAML.safe_load_file(
-              File.join(item_class_path, "#{uuid}.yaml"),
-              permitted_classes: [Time],
-            )
-        end
-      end
+    class ItemClass < Lutaml::Model::Serializable
+      attribute :name, Lutaml::Model::Type::String
+      attribute :items, Paneron::Register::Item, collection: true
     end
   end
 end

data/lib/paneron/register/item_status.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Paneron
+  module Register
+    class ItemStatus < Lutaml::Model::Serializable
+      attribute :state, :string
+    end
+  end
+end

data/lib/paneron/register/item_statuses.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Paneron
+  module Register
+    # From registry-kit
+    ITEM_STATUSES = {
+      INVALID: "invalid",
+      RETIRED: "retired",
+      SUBMITTED: "submitted",
+      SUPERSEDED: "superseded",
+      VALID: "valid",
+    }
+      .transform_values { |v| Paneron::Register::ItemStatus.new(state: v) }
+      .freeze
+  end
+end

data/lib/paneron/register/proposal.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Paneron
+  module Register
+    class Proposal < Lutaml::Model::Serializable
+      attribute :uuid, Lutaml::Model::Type::String
+      attribute :date_accepted, Lutaml::Model::Type::DateTime
+      attribute :state, Paneron::Register::ProposalState, values:
+        Paneron::Register::PROPOSAL_STATES.values
+    end
+  end
+end

data/lib/paneron/register/proposal_state.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Paneron
+  module Register
+    class ProposalState < Lutaml::Model::Serializable
+      attribute :state, :string
+    end
+  end
+end

data/lib/paneron/register/proposal_states.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Paneron
+  module Register
+    # From registry-kit
+    PROPOSAL_STATES = {
+      DRAFT: "draft",
+      PROPOSED: "proposed",
+      SUBMITTED_FOR_CONTROL_BODY_REVIEW: "pending-control-body-review",
+      RETURNED_FOR_CLARIFICATION: "returned-for-clarification",
+      ACCEPTED: "accepted",
+      REJECTED: "rejected",
+      APPEALED: "rejection-appealed-to-owner",
+      WITHDRAWN: "withdrawn",
+      ACCEPTED_ON_APPEAL: "accepted-on-appeal",
+      REJECTION_UPHELD_ON_APPEAL: "rejection-upheld-on-appeal",
+      APPEAL_WITHDRAWN: "appeal-withdrawn",
+    }
+      .transform_values { |v| Paneron::Register::ProposalState.new(state: v) }
+      .freeze
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Paneron
+  module Register
+    module Raw
+      class DataSet
+        attr_reader :data_set_path, :register_path, :data_set_yaml_path,
+                    :data_set_name, :extension
+
+        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)
+
+          @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
+          @metadata = nil
+        end
+
+        DATA_SET_METADATA_FILENAME = "/register.yaml"
+
+        def self.validate_data_set_path(data_set_path)
+          unless File.exist?(data_set_path)
+            raise Paneron::Register::Error,
+                  "Data Set path does not exist"
+          end
+          unless File.directory?(data_set_path)
+            raise Paneron::Register::Error,
+                  "Data Set path is not a directory"
+          end
+          unless File.exist?(File.join(
+                               data_set_path, DATA_SET_METADATA_FILENAME
+                             ))
+            raise Paneron::Register::Error,
+                  "Data Set metadata file does not exist"
+          end
+        end
+
+        def to_lutaml
+          Paneron::Register::DataSet.new(
+            name: data_set_name,
+            item_classes: item_class_lutamls,
+          )
+        end
+
+        def item_class_lutamls
+          item_classes.map do |_item_class_name, item_class|
+            item_class.to_lutaml
+          end
+        end
+
+        def item_classes(item_class_name = nil)
+          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
+          else
+            @item_classes[item_class_name] ||=
+              Paneron::Register::Raw::ItemClass.new(
+                data_set_path, item_class_name
+              )
+          end
+        end
+
+        def item_class_names
+          @item_class_names ||=
+            Dir.glob(File.join(data_set_path, "*/*.#{extension}"))
+              .map { |file| File.basename(File.dirname(file)) }.uniq
+        end
+
+        def item_uuids
+          item_classes.values.map(&:item_uuids).flatten
+        end
+
+        def metadata
+          @metadata ||= YAML.safe_load_file(
+            data_set_yaml_path,
+            permitted_classes: [Time],
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Paneron
+  module Register
+    module Raw
+      class Item
+        attr_reader :item_class_path,
+                    :item_id,
+                    :item_path,
+                    :extension
+
+        def initialize(
+          item_class_path,
+          item_id,
+          extension = "yaml"
+        )
+          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
+          @extension = extension
+          @to_h = nil
+        end
+
+        def self.validate_item_path(path)
+          unless File.exist?(path)
+            raise Paneron::Register::Error,
+                  "Item path does not exist"
+          end
+          unless File.file?(path)
+            raise Paneron::Register::Error,
+                  "Item 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,
+          )
+        end
+
+        def to_h
+          @to_h ||=
+            YAML.safe_load_file(
+              File.join(item_path),
+              permitted_classes: [Time],
+            )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Paneron
+  module Register
+    module Raw
+      class ItemClass
+        attr_reader :data_set_path,
+                    :item_class_name, :item_class_path, :extension
+
+        def initialize(
+          data_set_path,
+          item_class_name,
+          extension = "yaml"
+        )
+          item_class_path = File.join(data_set_path, item_class_name)
+          self.class.validate_item_class_path(item_class_path)
+          @extension = extension
+          @data_set_path = data_set_path
+          @item_class_name = item_class_name
+          @item_class_path = item_class_path
+          @items_uuids = nil
+          @items = {}
+        end
+
+        def self.validate_item_class_path(path)
+          unless File.exist?(path)
+            raise Paneron::Register::Error,
+                  "Item class path does not exist"
+          end
+          unless File.directory?(path)
+            raise Paneron::Register::Error,
+                  "Item class path is not a directory"
+          end
+        end
+
+        def to_lutaml
+          Paneron::Register::ItemClass.new(
+            name: item_class_name,
+            items: item_lutamls,
+          )
+        end
+
+        def item_uuids
+          @item_uuids ||= Dir.glob(File.join(item_class_path, "*.#{extension}"))
+            .map { |file| File.basename(file, ".#{extension}") }
+        end
+
+        def items(uuid = nil)
+          if uuid.nil?
+            item_uuids.reduce({}) do |acc, uuid|
+              acc[uuid] = items(uuid)
+              acc
+            end
+          else
+            @items[uuid] ||=
+              Paneron::Register::Raw::Item.new(
+                item_class_path, uuid
+              )
+          end
+        end
+
+        def item_lutamls
+          items.values.map(&:to_lutaml)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Paneron
+  module Register
+    module Raw
+      class Register
+        attr_reader :register_path, :register_yaml_path
+
+        def initialize(register_path)
+          self.class.validate_path(register_path)
+          @register_path = register_path
+          @register_yaml_path = File.join(register_path,
+                                          REGISTER_METADATA_FILENAME)
+          @data_set_names = nil
+          @data_sets = {}
+          @metadata = nil
+        end
+
+        def self.local_cache_path
+          case RUBY_PLATFORM
+          when /darwin/
+            File.join(
+              `command getconf DARWIN_USER_CACHE_DIR`.chomp,
+              "com.paneron.ruby-paneron-register",
+            )
+          else
+            File.join(
+              Dir.exist?(ENV["XDG_CACHE_HOME"]) ? ENV["XDG_CACHE_HOME"] : "~/.cache",
+              "ruby-paneron-register",
+            )
+          end
+        end
+
+        def self.setup_cache_path
+          if !Dir.exist?(local_cache_path)
+            require "fileutils"
+            FileUtils.mkdir_p(local_cache_path)
+          end
+        end
+
+        def self.calculate_repo_cache_hash(repo_url)
+          require "digest"
+          require "base64"
+          digest = [Digest::SHA1.hexdigest(repo_url)].pack("H*")
+          Base64.encode64(digest).tr("+/= ", "_-")[0..16]
+        end
+
+        def self.from_git(repo_url, update: true)
+          require "git"
+          setup_cache_path
+          repo_cache_name =
+            "#{File.basename(repo_url)}-#{calculate_repo_cache_hash(repo_url)}"
+
+          # Check if repo is already cloned
+          full_local_cache_path = File.join(local_cache_path, repo_cache_name)
+          g = begin
+            if File.exist?(full_local_cache_path)
+              _g = Git.open(full_local_cache_path)
+
+              # Pull-rebase to update it
+              if update
+                _g.pull(
+                  nil, nil, rebase: true
+                )
+              end
+              _g
+            else
+              Git.clone(
+                repo_url,
+                repo_cache_name,
+                path: local_cache_path,
+                # timeout: 30,
+              )
+            end
+          rescue Git::TimeoutError => e
+            e.result.tap do |_r|
+              warn "Timed out trying to clone #{repo_url}."
+              raise e
+            end
+          end
+
+          new(g.dir.path)
+        end
+
+        REGISTER_METADATA_FILENAME = "/paneron.yaml"
+
+        def self.validate_path(register_path)
+          unless File.exist?(register_path)
+            raise Paneron::Register::Error,
+                  "Register path does not exist"
+          end
+          unless File.directory?(register_path)
+            raise Paneron::Register::Error,
+                  "Register path is not a directory"
+          end
+          unless File.exist?(File.join(
+                               register_path, REGISTER_METADATA_FILENAME
+                             ))
+            raise Paneron::Register::Error,
+                  "Register metadata file does not exist"
+          end
+        end
+
+        def to_lutaml
+          Paneron::Register::Register.new(
+            data_sets: data_set_lutamls,
+            metadata: metadata.to_json,
+          )
+        end
+
+        def data_set_names
+          @data_set_names ||= Dir.glob(
+            File.join(
+              register_path,
+              "*#{Paneron::Register::Raw::DataSet::DATA_SET_METADATA_FILENAME}",
+            ),
+          )
+            .map do |file|
+              File.basename(File.dirname(file))
+            end
+        end
+
+        def data_set_path(data_set_name)
+          File.join(register_path, data_set_name)
+        end
+
+        def metadata
+          @metadata ||= YAML.safe_load_file(register_yaml_path)
+        end
+
+        def data_sets(data_set_name = nil)
+          if data_set_name.nil?
+            data_set_names.reduce({}) do |acc, data_set_name|
+              acc[data_set_name] = data_sets(data_set_name)
+              acc
+            end
+          else
+            @data_sets[data_set_name] ||=
+              Paneron::Register::Raw::DataSet.new(register_path,
+                                                  data_set_name)
+          end
+        end
+
+        def data_set_lutamls
+          data_sets.map do |_data_set_name, data_set|
+            data_set.to_lutaml
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paneron/register/raw.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Paneron::Register::Raw module
+module Paneron
+  module Register
+    module Raw; end
+  end
+end

data/lib/paneron/register/register.rb

@@ -1,73 +1,14 @@
+# frozen_string_literal: true
+
 require "yaml"
 
+require "lutaml/model"
+
 module Paneron
   module Register
-    class Register
-      attr_reader :register_path, :register_root_path, :register_yaml_path,
-                  :register_name
-
-      def initialize(register_root_path, register_name)
-        register_path = File.join(register_root_path, register_name)
-        self.class.validate_register_path(register_path)
-        @register_name = register_name
-        @register_root_path = register_root_path
-        @register_path = register_path
-        @register_yaml_path = File.join(register_path,
-                                        REGISTER_METADATA_FILENAME)
-        @item_classes = {}
-        @item_class_names = nil
-        @item_uuids = nil
-      end
-
-      REGISTER_METADATA_FILENAME = "/register.yaml".freeze
-
-      def self.validate_register_path(register_path)
-        unless File.exist?(register_path)
-          raise Paneron::Register::Error,
-                "Register path does not exist"
-        end
-        unless File.directory?(register_path)
-          raise Paneron::Register::Error,
-                "Register path is not a directory"
-        end
-        unless File.exist?(File.join(
-                             register_path, REGISTER_METADATA_FILENAME
-                           ))
-          raise Paneron::Register::Error,
-                "Register metadata file does not exist"
-        end
-      end
-
-      def item_classes(item_class_name = nil)
-        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
-        else
-          @item_classes[item_class_name] ||=
-            Paneron::Register::ItemClass.new(
-              register_root_path, register_name, item_class_name
-            )
-        end
-      end
-
-      def item_class_names
-        @item_class_names ||=
-          Dir.glob(File.join(register_path, "*/*.yaml"))
-            .map { |file| File.basename(File.dirname(file)) }.uniq
-      end
-
-      def item_uuids
-        item_classes.values.map(&:item_uuids).flatten
-      end
-
-      def get_metadata_yaml
-        YAML.safe_load_file(
-          register_yaml_path,
-          permitted_classes: [Time],
-        )
-      end
+    class Register < Lutaml::Model::Serializable
+      attribute :data_sets, Paneron::Register::DataSet, collection: true
+      attribute :metadata, Lutaml::Model::Type::String
     end
   end
 end

data/lib/paneron/register/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Paneron
   module Register
-    VERSION = "0.1.0".freeze
+    VERSION = "0.2.0"
   end
 end

data/lib/paneron/register.rb

@@ -2,9 +2,20 @@
 
 require "paneron/register/version"
 require "paneron/register/error"
-require "paneron/register/register"
-require "paneron/register/register_root"
+
+require "paneron/register/raw/item"
+require "paneron/register/raw/item_class"
+require "paneron/register/raw/data_set"
+require "paneron/register/raw/register"
+
+require "paneron/register/proposal_state"
+require "paneron/register/proposal_states"
+require "paneron/register/item_status"
+require "paneron/register/item_statuses"
+require "paneron/register/item"
 require "paneron/register/item_class"
+require "paneron/register/data_set"
+require "paneron/register/register"
 
 # Paneron::Register module
 module Paneron

data/lib/paneron.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 module Paneron; end

data/paneron-register.gemspec

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "paneron/register/version"
@@ -25,6 +27,9 @@ Gem::Specification.new do |spec|
 
   # spec.add_runtime_dependency "yaml"
 
+  spec.add_runtime_dependency "git", "~> 2.3.1"
+  spec.add_runtime_dependency "lutaml-model", "~> 0.3.18"
+
   spec.add_development_dependency "debug"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rake", "~> 13.0"

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: paneron-register
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-17 00:00:00.000000000 Z
+date: 2024-10-29 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.1
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.18
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.18
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -178,10 +206,21 @@ files:
 - flake.nix
 - lib/paneron.rb
 - lib/paneron/register.rb
+- lib/paneron/register/data_set.rb
 - lib/paneron/register/error.rb
+- lib/paneron/register/item.rb
 - lib/paneron/register/item_class.rb
+- lib/paneron/register/item_status.rb
+- lib/paneron/register/item_statuses.rb
+- lib/paneron/register/proposal.rb
+- lib/paneron/register/proposal_state.rb
+- lib/paneron/register/proposal_states.rb
+- lib/paneron/register/raw.rb
+- lib/paneron/register/raw/data_set.rb
+- lib/paneron/register/raw/item.rb
+- lib/paneron/register/raw/item_class.rb
+- lib/paneron/register/raw/register.rb
 - lib/paneron/register/register.rb
-- lib/paneron/register/register_root.rb
 - lib/paneron/register/version.rb
 - paneron-register.gemspec
 homepage: https://github.com/paneron/ruby-paneron-register

data/lib/paneron/register/register_root.rb

@@ -1,79 +0,0 @@
-require "yaml"
-
-module Paneron
-  module Register
-    class RegisterRoot
-      attr_reader :register_root_path, :register_root_yaml_path
-
-      def initialize(register_root_path)
-        self.class.validate_root_path(register_root_path)
-        @register_root_path = register_root_path
-        @register_root_yaml_path = File.join(register_root_path,
-                                             REGISTER_ROOT_METADATA_FILENAME)
-        @register_names = nil
-        @registries = {}
-      end
-
-      REGISTER_ROOT_METADATA_FILENAME = "/paneron.yaml".freeze
-
-      def self.validate_root_path(register_root_path)
-        unless File.exist?(register_root_path)
-          raise Paneron::Register::Error,
-                "Register root path does not exist"
-        end
-        unless File.directory?(register_root_path)
-          raise Paneron::Register::Error,
-                "Register root path is not a directory"
-        end
-        unless File.exist?(File.join(
-                             register_root_path, REGISTER_ROOT_METADATA_FILENAME
-                           ))
-          raise Paneron::Register::Error,
-                "Register root metadata file does not exist"
-        end
-      end
-
-      def register_names
-        @register_names ||= Dir.glob(
-          File.join(
-            register_root_path,
-            "*#{Paneron::Register::Register::REGISTER_METADATA_FILENAME}",
-          ),
-        )
-          .map do |file|
-            File.basename(File.dirname(file))
-          end
-      end
-
-      def register_path(register_name)
-        File.join(register_root_path, register_name)
-      end
-
-      def get_root_metadata
-        YAML.safe_load_file(register_root_yaml_path)
-      end
-
-      def registries(register_name = nil)
-        if register_name.nil?
-          register_names.reduce({}) do |acc, register_name|
-            acc[register_name] = registries(register_name)
-            acc
-          end
-        else
-          @registries[register_name] ||=
-            Paneron::Register::Register.new(register_root_path,
-                                            register_name)
-        end
-      end
-
-      def register_metadata_yaml(register_name)
-        registires(register_name).get_metadata_yaml
-
-        YAML.safe_load_file(
-          register_yaml_path(register_name),
-          permitted_classes: [Time],
-        )
-      end
-    end
-  end
-end