ro 4.2.0 → 5.0.0

data/lib/ro/script/migrate.rb

@@ -0,0 +1,204 @@
+module Ro
+  class Script::Migrate
+      def self.run!(script:)
+        new(script: script).run!
+      end
+
+      attr_accessor :script
+
+      def initialize(script:)
+        @script = script
+      end
+
+      def run!
+        parse_options!
+
+        root_path = get_root_path
+
+        show_banner(root_path)
+
+        migrator = Ro::Migrator.new(root_path, @options)
+
+        validate_and_report(migrator)
+
+        return if @options[:dry_run]
+
+        confirm_unless_forced!
+
+        execute_migration(migrator)
+      end
+
+      private
+
+      def parse_options!
+        @options = {
+          dry_run: false,
+          backup: true,
+          verbose: false,
+          force: false
+        }
+
+        # Use ARGV directly because the Ro.script DSL may have consumed flags
+        # We need to find 'migrate' in ARGV and parse everything after it
+        argv = []
+        found_migrate = false
+        ARGV.each do |arg|
+          if arg == 'migrate'
+            found_migrate = true
+            next
+          end
+          argv << arg if found_migrate
+        end
+
+        while argv.any?
+          arg = argv.shift
+          case arg
+          when '-d', '--dry-run'
+            @options[:dry_run] = true
+            @options[:verbose] = true
+          when '-b', '--backup'
+            @options[:backup] = true
+          when '--no-backup'
+            @options[:backup] = false
+          when '-v', '--verbose'
+            @options[:verbose] = true
+          when '-f', '--force'
+            @options[:force] = true
+          when '-h', '--help'
+            show_help
+            exit 0
+          else
+            argv.unshift(arg)
+            break
+          end
+        end
+
+        @script.argv.replace(argv)
+      end
+
+      def get_root_path
+        if @script.argv.any?
+          Pathname.new(@script.argv.first).expand_path
+        else
+          Ro.config.root.expand
+        end
+      end
+
+      def show_banner(root_path)
+        puts "Ro Asset Structure Migration Tool"
+        puts "=" * 50
+        puts "Root: #{root_path}"
+        puts "Options: #{@options.inspect}" if @options[:verbose]
+        puts ""
+      end
+
+      def validate_and_report(migrator)
+        puts "Validating structure..."
+        validation = migrator.validate
+
+        puts "Collections found: #{validation[:collections].size}"
+        puts "Old structure nodes: #{validation[:old_nodes].size}"
+        puts "New structure nodes: #{validation[:new_nodes].size}"
+        puts ""
+
+        if validation[:old_nodes].empty?
+          puts "✓ No old structure nodes found - migration not needed"
+          exit 0
+        end
+
+        if validation[:has_new_structure]
+          if @options[:force]
+            puts "⚠ Warning: Both old and new structures detected!"
+            puts "Proceeding with partial migration (--force enabled)..."
+            puts ""
+          else
+            puts "⚠ Warning: Both old and new structures detected!"
+            puts "This may indicate a partial migration."
+            puts "Use --force to proceed anyway, or check your data first."
+            exit 1
+          end
+        end
+
+        if @options[:dry_run] || @options[:verbose]
+          show_preview(migrator)
+        end
+
+        if @options[:dry_run]
+          puts "✓ Dry run complete - no changes made"
+          exit 0
+        end
+      end
+
+      def show_preview(migrator)
+        puts "Migration plan:"
+        puts "-" * 50
+        plan = migrator.preview
+        plan.each_with_index do |step, i|
+          puts "\n#{i + 1}. #{step[:collection]}/#{step[:node_id]}"
+          step[:actions].each do |action|
+            puts "   - #{action}"
+          end
+        end
+        puts ""
+      end
+
+      def confirm_unless_forced!
+        return if @options[:force]
+
+        print "Proceed with migration? [y/N] "
+        response = STDIN.gets.chomp
+        unless response.downcase == 'y'
+          puts "Migration cancelled"
+          exit 0
+        end
+      end
+
+      def execute_migration(migrator)
+        puts "\nStarting migration..."
+        result = migrator.migrate
+
+        if result[:success]
+          puts "\n✓ Migration complete!"
+          puts "  Nodes migrated: #{result[:nodes_migrated]}"
+          puts "  Collections migrated: #{result[:collections_migrated]}"
+
+          if @options[:backup]
+            puts "\n  Backup created - rollback available if needed"
+          end
+        else
+          puts "\n✗ Migration failed"
+          exit 1
+        end
+      end
+
+      def show_help
+        puts <<~HELP
+          Usage: ro migrate [options] [ROOT_PATH]
+
+          Migrates Ro assets from old structure to new simplified structure
+
+          Options:
+            -d, --dry-run           Preview migration without making changes
+            -b, --[no-]backup       Create backup before migrating (default: true)
+            -v, --verbose           Show detailed progress
+            -f, --force             Force migration even if new structure detected
+            -h, --help              Show this help message
+
+          Examples:
+            # Preview migration
+            ro migrate --dry-run
+
+            # Migrate with backup (default)
+            ro migrate
+
+            # Migrate without backup
+            ro migrate --no-backup
+
+            # Force migration in mixed structure
+            ro migrate --force
+
+          See MIGRATION.md for more details.
+        HELP
+      end
+  end
+end

data/lib/ro/script/server.rb

@@ -9,7 +9,7 @@ module Ro
     def initialize(script:)
       @script = script
 
-      @port = @script.opts.fetch(:port)
+      @port = @script.options.fetch(:port, Ro.defaults.port)
     end
 
     def run!

data/lib/ro/template.rb

@@ -5,16 +5,14 @@ module Ro
     require 'kramdown'
     require 'kramdown-parser-gfm'
 
+    require_relative 'html.rb'
     require_relative 'template/rouge_formatter.rb'
 
-    class HTML < ::String
-    end
-
-    def self.render(*args, &block)
+    def Template.render(*args, &block)
       render_file(*args, &block)
     end
 
-    def self.render_file(path, options = {})
+    def Template.render_file(path, options = {})
       path = File.expand_path(path.to_s.strip)
       options = Map.for(options.is_a?(Hash) ? options : { context: options })
 
@@ -22,10 +20,15 @@ module Ro
       engines = File.basename(path).split('.')[1..-1]
       context = options[:context]
 
-      render_string(content, path: path, engines: engines, context: context)
+      begin
+        render_string(content, path: path, engines: engines, context: context)
+      rescue Ro::Error => e
+        msg = e.message
+        Ro.error! "failed to render #{ path } with `#{ msg }`"
+      end
     end
 
-    def self.render_string(content, options = {})
+    def Template.render_string(content, options = {})
       content = String(content).force_encoding('utf-8')
       options = Map.for(options.is_a?(Hash) ? options : { context: options })
       engines = Array(options.fetch(:engines) { ['md'] }).flatten.compact
@@ -39,22 +42,22 @@ module Ro
 
         content =
           case engine
-            when 'txt', 'text', 'html'
-              content
+            when 'html'
+              render_html(content)
+            when 'txt', 'text'
+              render_text(content)
             when 'erb'
               render_erb(content, context:)
             when 'md', 'markdown'
               render_markdown(content)
-            when 'yml'
-              data = YAML.load(content)
-              pod = Ro.pod(data)
-              Ro.mapify(data)
+            when 'yml', 'yaml'
+              render_yaml(content)
             when 'json'
-              data = JSON.parse(content)
-              pod = Ro.pod(data)
-              Ro.mapify(data)
+              render_json(content)
             when 'rb'
-              eval(content)
+              render_ruby(content)
+            when 'txt', 'text'
+              render_text(content)
             else
               Ro.error!("no engine found for engine=#{ engine.inspect } engines=#{ engines.inspect }")
           end
@@ -63,7 +66,36 @@ module Ro
       content
     end
 
-    def self.render_erb(content, options = {})
+    def Template.render_html(html)
+      HTML.new(html)
+    end
+
+    def Template.render_json(json)
+      data = JSON.parse(json)
+      Ro.mapify(data)
+    end
+
+    def Template.render_yaml(yaml)
+      data = YAML.load(yaml)
+      Ro.mapify(data)
+    end
+
+    def Template.render_ruby(code)
+      string = IO.popen('ruby', 'w+'){|ruby| ruby.puts(code); ruby.close_write; ruby.read}
+
+      if $? == 0
+        string
+      else
+        Ro.error!("ruby:\n\n#{ code }")
+      end
+    end
+
+    def Template.render_text(text)
+      html = Text.render(text)
+      HTML.new(html)
+    end
+
+    def Template.render_erb(content, options = {})
       content = String(content).force_encoding('utf-8')
       options = Map.for(options.is_a?(Hash) ? options : { context: options })
       context = options[:context]
@@ -82,27 +114,35 @@ module Ro
       HTML.new(html)
     end
 
-    def self.render_markdown(content, options = {})
+    def Template.render_markdown(content, options = {})
       content = String(content).force_encoding('utf-8')
       options = Map.for(options.is_a?(Hash) ? options : { context: options })
 
       theme = options.fetch(:theme) { Ro.config.md_theme }
 
+      parsed = FrontMatterParser::Parser.new(:md).call(content)
+      front_matter = parsed.front_matter
+      content = parsed.content
+
       opts = {
         input: 'GFM',
+        hard_wrap: false,
         syntax_highlighter_opts: { formatter: RougeFormatter, theme: theme }
       }
 
-      HTML.new(
+      div =
         <<~_____
           <div class="ro markdown">
             #{ ::Kramdown::Document.new(content, opts).to_html }
           </div>
         _____
-      )
+
+      html = Rinku.auto_link(div, :all, 'target="_blank"')
+
+      HTML.new(html, front_matter:)
     end
 
-    def self.render_src(path, options = {})
+    def Template.render_src(path, options = {})
       path = File.expand_path(path.to_s.strip)
       options = Map.for(options.is_a?(Hash) ? options : { context: options })
 

data/lib/ro/text.rb

@@ -0,0 +1,120 @@
+module Ro
+  require 'cgi'
+
+  module Text
+    def render(text)
+      text = text.to_s.strip
+      return '' if text.empty?
+
+      text = escape_html(text)
+      text = auto_link_urls(text)
+      text = auto_link_email_addresses(text)
+      text = paragraphs_for(text)
+
+      return text
+    end
+
+    def paragraphs_for(text)
+      paragraphs = text.split(%r`\n\n+`).map{|chunk| lines_for(chunk)}
+      paragraphs.map{|p| "<p>\n#{ p }\n</p>"}.join("\n\n").strip
+    end
+
+    def lines_for(text)
+      text.strip.gsub(/\n/, "<br />\n")
+    end
+
+    def escape_html(text)
+      CGI.escapeHTML(text)
+    end
+
+    AUTO_LINK_RE = %r{
+        (?: ((?:ed2k|ftp|http|https|irc|mailto|news|gopher|nntp|telnet|webcal|xmpp|callto|feed|svn|urn|aim|rsync|tag|ssh|sftp|rtsp|afs|file):)// | www\.\w )
+        [^\s<\u00A0"]+
+      }ix
+
+    # regexps for determining context, used high-volume
+    AUTO_LINK_CRE = [/<[^>]+$/, /^[^>]*>/, /<a\b.*?>/i, /<\/a>/i]
+
+    AUTO_EMAIL_LOCAL_RE = /[\w.!#\$%&'*\/=?^`{|}~+-]/
+    AUTO_EMAIL_RE = /(?<!#{AUTO_EMAIL_LOCAL_RE})[\w.!#\$%+-]\.?#{AUTO_EMAIL_LOCAL_RE}*@[\w-]+(?:\.[\w-]+)+/
+
+    BRACKETS = { ']' => '[', ')' => '(', '}' => '{' }
+
+    WORD_PATTERN = '\p{Word}'
+
+    # Turns all urls into clickable links.  If a block is given, each url
+    # is yielded and the result is used as the link text.
+    def auto_link_urls(text)
+      text.gsub(AUTO_LINK_RE) do
+        scheme, href = $1, $&
+        punctuation = []
+        trailing_gt = ""
+
+        if auto_linked?($`, $')
+          # do not change string; URL is already linked
+          href
+        else
+          # don't include trailing punctuation character as part of the URL
+          while href.sub!(/[^#{WORD_PATTERN}\/\-=;]$/, '')
+            punctuation.push $&
+            if opening = BRACKETS[punctuation.last] and href.scan(opening).size > href.scan(punctuation.last).size
+              href << punctuation.pop
+              break
+            end
+          end
+
+          # don't include trailing &gt; entities as part of the URL
+          trailing_gt = $& if href.sub!(/&gt;$/, '')
+          href = 'http://' + href unless scheme
+          link = escape_html(href)
+          "<a href='#{ link }'>#{ link }</a>" + punctuation.reverse.join('') + trailing_gt
+        end
+      end
+    end
+
+    # Turns all email addresses into clickable links.  If a block is given,
+    # each email is yielded and the result is used as the link text.
+    def auto_link_email_addresses(text)
+      text.gsub(AUTO_EMAIL_RE) do
+        text = $&
+
+        if auto_linked?($`, $')
+          text
+        else
+          email = escape_html(text)
+          "<a href='mailto:#{ email }'>#{ email }</a>"
+        end
+      end
+    end
+
+    # Detects already linked context or position in the middle of a tag
+    def auto_linked?(left, right)
+      (left =~ AUTO_LINK_CRE[0] and right =~ AUTO_LINK_CRE[1]) or
+        (left.rindex(AUTO_LINK_CRE[2]) and $' !~ AUTO_LINK_CRE[3])
+    end
+
+    extend self
+  end
+end
+
+
+if $0 == __FILE__
+  text = <<~____
+    this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long
+    this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long
+
+    this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long this is a paragraph that is very long
+
+    - a
+    - b
+    - c
+
+    & < > me
+
+    http://drawohara.io>
+
+    ara.t.howard@gmail.com
+  ____
+
+  puts Ro::Text.render(text)
+end

data/lib/ro.rb

@@ -31,6 +31,7 @@ module Ro
         :root      => ENV['RO_ROOT'],
         :build     => ENV['RO_BUILD'],
         :url       => ENV['RO_URL'],
+        :img_url   => ENV['RO_IMG_URL'],
         :page_size => ENV['RO_PAGE_SIZE'],
         :log       => ENV['RO_LOG'],
         :debug     => ENV['RO_DEBUG'],
@@ -44,6 +45,7 @@ module Ro
         :root      => './public/ro',
         :build     => './public/api/ro',
         :url       => "/ro",
+        :img_url   => "/ro",
         :page_size => 42,
         :log       => nil,
         :debug     => nil,
@@ -61,10 +63,12 @@ module Ro
     # v
     def initialize!
       Ro.load %w[
+        html.rb
         error.rb
         klass.rb
         slug.rb
         path.rb
+        text.rb
         template.rb
         methods.rb
         config.rb
@@ -73,6 +77,7 @@ module Ro
         collection/list.rb
         node.rb
         asset.rb
+        migrator.rb
       ]
 
       if defined?(ActiveModel)