ro 4.2.0 → 5.0.0

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
@@ -47,40 +76,42 @@ module Ro
       @attributes = Map.new
 
       _load_base_attributes
+      _load_file_attributes
       _load_asset_attributes
       _load_meta_attributes
-      _load_file_attributes
 
       @attributes
     end
 
+    # T026: Modified to load from external metadata_file (new structure)
     def _load_base_attributes
-      disallowed =
-        %w[
-          assets
-          _meta
-        ]
-
-      glob =
-        "attributes.{yml,yaml,json}"
-
-      @path.glob(glob) do |file|
-        attrs = _render(file)
+      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}"
 
-        disallowed.each do |key|
-          Ro.error!("#{ file } must not contain the key #{key.inspect}") if attrs.has_key?(key)
+        @path.glob(glob) do |file|
+          attrs = _render(file)
+          update_attributes!(attrs, file:)
         end
-
-        @attributes.update(attrs)
       end
     end
 
-
     def _load_asset_attributes
       {}.tap do |hash|
         assets.each do |asset|
           key = asset.name
-          value = { url: asset.url, path: asset.path.relative_to(@root), src: asset.src }
+          url = asset.url
+          path = asset.path.relative_to(@root)
+          src = asset.src
+          img = asset.img
+          size = asset.size
+
+          value = { url:, path:, size:, img:, src: }
+
           hash[key] = value
         end
 
@@ -94,7 +125,9 @@ module Ro
           identifier:,
           type:,
           id:,
-          urls:
+          urls:,
+          created_at:,
+          updated_at:,
         )
 
         @attributes.set(_meta: hash)
@@ -114,17 +147,49 @@ module Ro
         base = basename.split('.', 2).first
         key.push(base)
 
-        if @attributes.has?(key)
-          raise Error.new("#{ @path } clobbers #{ key.inspect }!")
+        value = _render(file)
+
+        if value.is_a?(HTML)
+          attrs = value.front_matter
+          update_attributes!(attrs, file:)
         end
 
-        value = _render(file)
+        if @attributes.has?(key)
+          raise Error.new("path=#{ @path.inspect } masks #{ key.inspect } in #{ @attributes.inspect }!")
+        end
 
         @attributes.set(key => value)
       end
     end
 
+    def update_attributes!(attrs = {}, **context)
+      attrs = Map.for(attrs)
+
+      blacklist = %w[
+        assets
+        _meta
+      ]
+
+      blacklist.each do |key|
+        if attrs.has_key?(key)
+          Ro.error!("#{ key } is blacklisted!", **context)
+        end
+      end
+
+      keys = @attributes.depth_first_keys
+
+      attrs.depth_first_keys.each do |key|
+        if keys.include?(key)
+          Ro.error!("#{ attrs.inspect } clobbers #{ @attributes.inspect }!", **context)
+        end
+      end
+
+      @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
@@ -133,17 +198,23 @@ module Ro
           ./assets/**/**
         ].map do |glob|
           @path.glob(glob).select(&:file?)
-        end
-
-      ignored_files.flatten
+        end.flatten
     end
 
     def _render(file)
+      node = self
+
       value = Ro.render(file, _render_context)
 
-      if value.is_a?(Ro::Template::HTML)
-        html = value
-        value = Ro.expand_asset_urls(html, self)
+      if value.is_a?(HTML)
+        front_matter = value.front_matter
+        html = Ro.expand_asset_urls(value, node)
+        value = HTML.new(html, front_matter:)
+      end
+
+      if value.is_a?(Hash)
+        attributes = value
+        value = Ro.expand_asset_values(attributes, node)
       end
 
       value
@@ -156,6 +227,10 @@ module Ro
       end
     end
 
+    def fetch(*args)
+      attributes.fetch(*args)
+    end
+
     def get(*args)
       attributes.get(*args)
     end
@@ -168,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
 
@@ -219,14 +297,13 @@ module Ro
     end
 
     def url_for(relative_path, options = {})
-      raise ArgumentError, relative_path if Path.absolute?(relative_path)
-
-      fullpath = Path.for(path, relative_path).expand
-      raise ArgumentError, "#{relative_path.inspect} -- DOES NOT EXIST" unless fullpath.exist?
-
       Ro.url_for(self.relative_path, relative_path, options)
     end
 
+    def path_for(...)
+      @path.join(...)
+    end
+
     def src_for(*args)
       key = Path.relative(:assets, :src, args).split('/')
       get(key)
@@ -250,6 +327,10 @@ module Ro
       to_json(...)
     end
 
+    def to_str(...)
+      to_json(...)
+    end
+
     def to_json(...)
       JSON.pretty_generate(to_hash, ...)
     end
@@ -262,12 +343,6 @@ module Ro
       to_hash.to_yaml(...)
     end
 
-    def _mapify(data)
-      converted = 'this_recursively_converts_nested_hashes_into_maps'
-
-      Map.for(converted => data)[converted]
-    end
-
     def files
       path.glob('**/**').select { |entry| entry.file? }.sort
     end
@@ -291,5 +366,13 @@ module Ro
 
       [position, published_at, created_at, name]
     end
+
+    def created_at
+      files.map{|file| File.stat(file).ctime}.min
+    end
+
+    def updated_at
+      files.map{|file| File.stat(file).mtime}.max
+    end
   end
 end

data/lib/ro/path.rb

@@ -221,5 +221,9 @@ module Ro
     def <=>(other)
       sort_key <=> other.sort_key
     end
+
+    def stat
+      File.stat(self)
+    end
   end
 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