ro 4.4.0 → 5.0.0

data/lib/ro/collection.rb

@@ -34,6 +34,20 @@ module Ro
       Node.new(path)
     end
 
+    # T021: Scan for metadata files in new structure format
+    def metadata_files
+      extensions = %w[yml yaml json toml]
+      files = []
+
+      extensions.each do |ext|
+        @path.glob("*.#{ext}").each do |file|
+          files << file if file.file?
+        end
+      end
+
+      files.sort
+    end
+
     def subdirectories(...)
       @path.subdirectories(...)
     end
@@ -42,28 +56,33 @@ module Ro
       @path.subdirectory_for(name)
     end
 
+    # T020: Modified to discover nodes from metadata files (new structure)
     def each(offset:nil, limit:nil, &block)
-      accum = []
+      # Return enumerator if no block given and no offset/limit
+      return to_enum(:each, offset: offset, limit: limit) unless block_given?
+
+      # Use metadata files for new structure instead of subdirectories
+      files = metadata_files
 
       if offset
         i = -1
         n = 0
-        subdirectories do |subdirectory|
+        files.each do |metadata_file|
           i += 1
           next if i < offset
-          node = node_for(subdirectory)
-          block ? block.call(node) : accum.push(node)
+          node = Node.new(self, metadata_file)
+          block.call(node)
           n += 1
           break if limit && n >= limit
         end
       else
-        subdirectories do |subdirectory|
-          node = node_for(subdirectory)
-          block ? block.call(node) : accum.push(node)
+        files.each do |metadata_file|
+          node = Node.new(self, metadata_file)
+          block.call(node)
         end
       end
 
-      block ? self : accum
+      self
     end
 
     class Page < ::Array
@@ -148,8 +167,10 @@ module Ro
         block ? self : accum
     end
 
-    def to_array(...)
-      each(...)
+    def to_array(offset: nil, limit: nil)
+      accum = []
+      each(offset: offset, limit: limit) { |node| accum << node }
+      accum
     end
 
     alias to_a to_array
@@ -186,11 +207,28 @@ module Ro
       ]
     end
 
+    # T022: Modified to find nodes by metadata filename
     def get(name)
-      paths_for(name).each do |path|
-        next unless path.exist?
+      # Try to find metadata file for this node ID
+      extensions = %w[yml yaml json toml]
+      extensions.each do |ext|
+        metadata_file = @path.join("#{name}.#{ext}")
+        if metadata_file.exist? && metadata_file.file?
+          return Node.new(self, metadata_file)
+        end
+      end
 
-        return node_for(path)
+      # Also try with slugified versions
+      [
+        Slug.for(name, :join => '-'),
+        Slug.for(name, :join => '_')
+      ].each do |slug|
+        extensions.each do |ext|
+          metadata_file = @path.join("#{slug}.#{ext}")
+          if metadata_file.exist? && metadata_file.file?
+            return Node.new(self, metadata_file)
+          end
+        end
       end
 
       nil

data/lib/ro/migrator.rb

@@ -0,0 +1,285 @@
+module Ro
+  class Migrator
+    attr_reader :root_path, :options
+
+    def initialize(root_path, options = {})
+      @root_path = Path.for(root_path)
+      @options = {
+        dry_run: false,
+        backup: false,
+        verbose: false,
+        force: false
+      }.merge(options)
+    end
+
+    def dry_run?
+      @options[:dry_run]
+    end
+
+    def backup?
+      @options[:backup]
+    end
+
+    def verbose?
+      @options[:verbose]
+    end
+
+    def force?
+      @options[:force]
+    end
+
+    # Validate the structure and return analysis
+    def validate
+      result = {
+        has_old_structure: false,
+        has_new_structure: false,
+        old_nodes: [],
+        new_nodes: [],
+        collections: []
+      }
+
+      root = Root.for(@root_path)
+
+      root.collections.each do |collection|
+        collection_name = collection.name
+        result[:collections] << collection_name
+
+        # Check for new structure (metadata files at collection level)
+        collection.metadata_files.each do |metadata_file|
+          node_id = metadata_file.basename.to_s.sub(/\.(yml|yaml|json|toml)$/, '')
+          result[:new_nodes] << {
+            collection: collection_name,
+            node_id: node_id,
+            metadata_file: metadata_file
+          }
+          result[:has_new_structure] = true
+        end
+
+        # Check for old structure (ALL subdirectories, with or without attributes)
+        # We need to migrate ALL nodes, even those without attributes.yml
+        collection.subdirectories.each do |subdir|
+          node_id = subdir.basename.to_s
+
+          # Skip if this node already has new-structure metadata
+          already_migrated = result[:new_nodes].any? { |n|
+            n[:collection] == collection_name && n[:node_id] == node_id
+          }
+          next if already_migrated
+
+          # Check if there's an attributes file (any format)
+          attributes_file = nil
+          has_attributes = false
+          %w[yml yaml json toml].each do |ext|
+            candidate = subdir.join("attributes.#{ext}")
+            if candidate.exist?
+              attributes_file = candidate
+              has_attributes = true
+              break
+            end
+          end
+
+          result[:old_nodes] << {
+            collection: collection_name,
+            node_id: node_id,
+            old_path: subdir,
+            attributes_file: attributes_file,
+            has_attributes: has_attributes
+          }
+          result[:has_old_structure] = true
+        end
+      end
+
+      result
+    end
+
+    # Preview migration without making changes
+    def preview
+      validation = validate
+      plan = []
+
+      validation[:old_nodes].each do |old_node|
+        collection_name = old_node[:collection]
+        node_id = old_node[:node_id]
+        old_path = old_node[:old_path]
+        has_attributes = old_node[:has_attributes]
+        attributes_file = old_node[:attributes_file]
+
+        collection_path = @root_path.join(collection_name)
+        new_metadata_file = collection_path.join("#{node_id}.yml")
+        new_asset_dir = collection_path.join(node_id)
+
+        actions = []
+        if has_attributes
+          actions << "Move #{attributes_file} → #{new_metadata_file}"
+        else
+          actions << "Create empty #{new_metadata_file} (node has no attributes)"
+        end
+        actions << "Assets remain in #{old_path}/assets/ (no change needed)"
+
+        plan << {
+          node_id: node_id,
+          collection: collection_name,
+          old_path: old_path,
+          new_metadata_file: new_metadata_file,
+          new_asset_dir: new_asset_dir,
+          has_attributes: has_attributes,
+          actions: actions
+        }
+      end
+
+      plan
+    end
+
+    # Migrate a single node
+    def migrate_node(collection_name, node_id)
+      log "Migrating #{collection_name}/#{node_id}..."
+
+      collection_path = @root_path.join(collection_name)
+      old_node_path = collection_path.join(node_id)
+
+      unless old_node_path.directory?
+        return { success: false, error: "Node directory not found: #{old_node_path}" }
+      end
+
+      new_metadata_file = collection_path.join("#{node_id}.yml")
+
+      # Look for attributes file in any format
+      old_attributes_file = nil
+      %w[yml yaml json toml].each do |ext|
+        candidate = old_node_path.join("attributes.#{ext}")
+        if candidate.exist?
+          old_attributes_file = candidate
+          break
+        end
+      end
+
+      unless dry_run?
+        if old_attributes_file
+          # Move existing attributes file to collection level
+          log "  Moving #{old_attributes_file} → #{new_metadata_file}"
+          FileUtils.mv(old_attributes_file.to_s, new_metadata_file.to_s)
+        else
+          # Create empty metadata file for nodes without attributes
+          log "  Creating empty metadata #{new_metadata_file} (node had no attributes)"
+          File.write(new_metadata_file.to_s, {}.to_yaml)
+        end
+      end
+
+      # Assets stay in assets/ subdirectory - no moving needed
+      # Old: collection/identifier/assets/foo.png
+      # New: collection/identifier/assets/foo.png (same location)
+
+      { success: true, node_id: node_id, had_attributes: !old_attributes_file.nil? }
+    end
+
+    # Migrate an entire collection
+    def migrate_collection(collection_name)
+      log "Migrating collection: #{collection_name}"
+
+      validation = validate
+      collection_nodes = validation[:old_nodes].select { |n| n[:collection] == collection_name }
+
+      migrated_count = 0
+      errors = []
+
+      collection_nodes.each do |old_node|
+        result = migrate_node(collection_name, old_node[:node_id])
+        if result[:success]
+          migrated_count += 1
+        else
+          errors << result[:error]
+        end
+      end
+
+      {
+        success: errors.empty?,
+        migrated_count: migrated_count,
+        errors: errors
+      }
+    end
+
+    # Migrate entire root
+    def migrate
+      log "Starting full migration of #{@root_path}"
+
+      if backup?
+        backup_path = backup
+        log "Created backup at #{backup_path}"
+      end
+
+      validation = validate
+
+      if validation[:old_nodes].empty?
+        log "No old structure nodes found to migrate"
+        return { success: true, nodes_migrated: 0, collections_migrated: 0 }
+      end
+
+      collections = validation[:old_nodes].map { |n| n[:collection] }.uniq
+      total_migrated = 0
+      collections_migrated = 0
+
+      collections.each do |collection_name|
+        result = migrate_collection(collection_name)
+        if result[:success]
+          collections_migrated += 1
+          total_migrated += result[:migrated_count]
+        end
+      end
+
+      log "Migration complete! Migrated #{total_migrated} nodes across #{collections_migrated} collections"
+
+      {
+        success: true,
+        nodes_migrated: total_migrated,
+        collections_migrated: collections_migrated
+      }
+    end
+
+    # Create backup
+    def backup
+      timestamp = Time.now.strftime('%Y%m%d%H%M%S')
+      backup_name = "#{@root_path.basename}.backup.#{timestamp}"
+      backup_path = @root_path.parent.join(backup_name)
+
+      log "Creating backup: #{backup_path}"
+
+      unless dry_run?
+        FileUtils.cp_r(@root_path.to_s, backup_path.to_s)
+      end
+
+      backup_path
+    end
+
+    # Rollback from backup
+    def rollback
+      # Find most recent backup
+      backup_pattern = "#{@root_path.basename}.backup.*"
+      backups = @root_path.parent.glob(backup_pattern).sort.reverse
+
+      if backups.empty?
+        return { success: false, error: "No backups found" }
+      end
+
+      backup_path = backups.first
+      log "Rolling back from #{backup_path}"
+
+      unless dry_run?
+        # Remove current root
+        FileUtils.rm_rf(@root_path.to_s)
+        # Restore from backup
+        FileUtils.cp_r(backup_path.to_s, @root_path.to_s)
+      end
+
+      {
+        success: true,
+        restored_from: backup_path
+      }
+    end
+
+    private
+
+    def log(message)
+      puts message if verbose? || dry_run?
+    end
+  end
+end

data/lib/ro/node.rb

@@ -2,16 +2,45 @@ module Ro
   class Node
     include Klass
 
-    attr_reader :path, :root
+    attr_reader :path, :root, :metadata_file
+
+    # T023: Updated to accept (collection, metadata_file) for new structure
+    def initialize(collection_or_path, metadata_file = nil)
+      if metadata_file
+        # New structure: collection + metadata_file
+        @collection = collection_or_path
+        @metadata_file = Path.for(metadata_file)
+
+        # Raise error if metadata file doesn't exist
+        unless @metadata_file.exist?
+          raise Errno::ENOENT, "No such file or directory - #{@metadata_file}"
+        end
+
+        @root = @collection.root
+
+        # Derive node ID from metadata filename (without extension)
+        # T025: ID derived from metadata filename
+        node_id = @metadata_file.basename.to_s.sub(/\.(yml|yaml|json|toml)$/, '')
+
+        # Path is the node directory (sibling to metadata file)
+        @path = @collection.path.join(node_id)
+      else
+        # Old structure compatibility: just a path
+        @path = Path.for(collection_or_path)
+        @root = Root.for(@path.parent.parent)
+        @metadata_file = nil
+      end
 
-    def initialize(path)
-      @path = Path.for(path)
-      @root = Root.for(@path.parent.parent)
       @attributes = :lazyload
     end
 
     def name
-      @path.name
+      if @metadata_file
+        # T025: For new structure, name comes from metadata filename
+        @metadata_file.basename.to_s.sub(/\.(yml|yaml|json|toml)$/, '')
+      else
+        @path.name
+      end
     end
 
     def id
@@ -31,7 +60,7 @@ module Ro
     end
 
     def collection
-      @root.collection_for(type)
+      @collection || @root.collection_for(type)
     end
 
     def attributes
@@ -54,12 +83,20 @@ module Ro
       @attributes
     end
 
+    # T026: Modified to load from external metadata_file (new structure)
     def _load_base_attributes
-      glob = "attributes.{yml,yaml,json}"
+      if @metadata_file && @metadata_file.exist?
+        # New structure: load from explicit metadata file
+        attrs = _render(@metadata_file)
+        update_attributes!(attrs, file: @metadata_file)
+      else
+        # Old structure: search for attributes.yml in node directory
+        glob = "attributes.{yml,yaml,json}"
 
-      @path.glob(glob) do |file|
-        attrs = _render(file)
-        update_attributes!(attrs, file:)
+        @path.glob(glob) do |file|
+          attrs = _render(file)
+          update_attributes!(attrs, file:)
+        end
       end
     end
 
@@ -150,7 +187,9 @@ module Ro
       @attributes.update(attrs)
     end
 
+    # T028: Updated ignore patterns for new structure
     def _ignored_files
+      # Both old and new structure: ignore attributes files and assets/ subdirectory
       ignored_files =
         %w[
           attributes.yml
@@ -159,9 +198,7 @@ module Ro
           ./assets/**/**
         ].map do |glob|
           @path.glob(glob).select(&:file?)
-        end
-
-      ignored_files.flatten
+        end.flatten
     end
 
     def _render(file)
@@ -206,7 +243,10 @@ module Ro
       path.relative_to(root)
     end
 
+    # T027: Updated to return assets/ subdirectory in both old and new structure
     def asset_dir
+      # Both old and new structure use assets/ subdirectory
+      # This prevents files from being rendered as templates
       path.join('assets')
     end
 

data/lib/ro/root.rb

@@ -1,11 +1,18 @@
 module Ro
   class Root < Path
+    @@warned_paths = {}
+
     def identifier
       self
     end
 
+    def initialize(*)
+      super
+      check_for_unmigrated_structure!
+    end
+
     def collections(&block)
-      accum = Collection::List.for(self) 
+      accum = Collection::List.for(self)
 
       subdirectories do |subdirectory|
         collection = collection_for(subdirectory)
@@ -69,5 +76,72 @@ module Ro
     def method_missing(name, *args, **kws, &block)
       get(name) || super
     end
+
+    private
+
+    def check_for_unmigrated_structure!
+      # Use absolute path for deduplication
+      begin
+        path_key = File.expand_path(self.to_s)
+      rescue
+        path_key = self.to_s
+      end
+
+      # Skip if we've already warned for this path
+      return if @@warned_paths[path_key]
+
+      # Mark as checked (even if no warning needed)
+      @@warned_paths[path_key] = true
+
+      # Quick check: look for old structure (subdirs with attributes.yml)
+      # but no new structure (metadata files at collection level)
+      has_old = false
+      has_new = false
+
+      subdirectories.each do |subdir|
+        # Check for new structure (metadata files)
+        has_new = true if subdir.glob('*.{yml,yaml,json,toml}').any? { |f| f.file? }
+
+        # Check for old structure (nested attributes.yml)
+        subdir.subdirectories.each do |node_dir|
+          if (node_dir.join('attributes.yml').exist? ||
+              node_dir.join('attributes.yaml').exist? ||
+              node_dir.join('attributes.json').exist?)
+            has_old = true
+            break
+          end
+        end
+
+        break if has_old && has_new
+      end
+
+      if has_old && !has_new
+        warn_unmigrated_structure!
+      end
+    end
+
+    def warn_unmigrated_structure!
+      $stderr.puts ""
+      $stderr.puts "=" * 70
+      $stderr.puts "⚠️  WARNING: Old Ro asset structure detected!"
+      $stderr.puts "=" * 70
+      $stderr.puts ""
+      $stderr.puts "This Ro root contains assets in the OLD structure format:"
+      $stderr.puts "  • identifier/attributes.yml"
+      $stderr.puts "  • identifier/assets/"
+      $stderr.puts ""
+      $stderr.puts "Ro v5.0 uses a simplified NEW structure:"
+      $stderr.puts "  • identifier.yml"
+      $stderr.puts "  • identifier/"
+      $stderr.puts ""
+      $stderr.puts "Collections will NOT automatically discover old-structure nodes."
+      $stderr.puts ""
+      $stderr.puts "To migrate your data, run:"
+      $stderr.puts "  #{$0.include?('bin/') ? './bin/ro' : 'ro'} migrate #{self}"
+      $stderr.puts ""
+      $stderr.puts "Or see MIGRATION.md for details."
+      $stderr.puts "=" * 70
+      $stderr.puts ""
+    end
   end
 end