ro 1.4.6 → 4.2.0

data/lib/ro/path.rb

@@ -0,0 +1,225 @@
+require 'pathname'
+
+module Ro
+  class Path < ::String
+    include Klass
+
+    class << Path
+      def clean(arg, *args)
+        Pathname.new([arg, *args].join('/')).cleanpath.to_s
+      end
+
+      def expand(arg, *args)
+        new(Pathname.new(clean(arg, *args).expand_path))
+      end
+
+      def absolute(...)
+        new(...).absolute
+      end
+
+      def absolute?(arg, *args)
+        Path.for(arg, *args).absolute?
+      end
+
+      def relative(...)
+        new(...).relative
+      end
+
+      def relative?(arg, *args)
+        Path.for(arg, *args).relative?
+      end
+    end
+
+    def initialize(arg, *args)
+      super Path.clean(arg, *args)
+    end
+
+    def pn
+      Pathname.new(self)
+    end
+
+    def klass
+      self.class
+    end
+
+    {
+      'exist?'     => 'exist?',
+      'file?'      => 'file?',
+      'directory?' => 'directory?',
+      'absolute?'  => 'absolute?',
+      'relative?'  => 'relative?',
+      'expand'     => 'expand_path',
+      'clean'      => 'cleanpath'
+    }.each do |path_method, pathname_method|
+      class_eval <<-____, __FILE__, __LINE__ + 1
+
+        def #{ path_method }(...)
+          result = pn.#{ pathname_method }(...)
+
+          result.is_a?(Pathname) ? klass.for(result) : result
+        end
+
+      ____
+    end
+
+    def absolute
+      Path.new('/' + self)
+    end
+
+    def relative
+      Path.new(absolute.gsub(%r{^/+}, ''))
+    end
+
+    def parts
+      parts = scan(%r`[^/]+`)
+
+      if absolute?
+        %w[ / ] + parts
+      else
+        parts
+      end
+    end
+
+    def key
+      parts
+    end
+
+    def relative_to(other)
+      a = Pathname.new(self).expand_path
+      b = Pathname.new(other).expand_path
+      Path.for(a.relative_path_from(b))
+    end
+
+    def relative_from(...)
+      relative_to(...)
+    end
+
+    def relative_to!(other)
+      a = Pathname.new(self).realpath
+      b = Pathname.new(other).realpath
+
+      Path.for(a.relative_path_from(b))
+    end
+
+    def glob(arg = '**/**', *args, **kws, &block)
+      glob = Path.for(self, arg, *args, **kws)
+
+      accum = []
+
+      Dir.glob(glob) do |entry|
+        path = Path.new(entry)
+        block ? block.call(path) : accum.push(path)
+      end
+
+      accum
+    end
+    alias ls glob
+
+    def files(arg = '**/**', *args, **kws, &block)
+      glob = Path.for(self, arg, *args, **kws)
+
+      accum = []
+
+      Dir.glob(glob) do |entry|
+        next unless test(?f, entry)
+        path = Path.new(entry)
+        block ? block.call(path) : accum.push(path)
+      end
+
+      accum
+    end
+
+    def select(&block)
+      glob.select(&block)
+    end
+
+    def detect(&block)
+      glob.detect(&block)
+    end
+
+    def parent
+      Path.for(File.dirname(self))
+    end
+    alias dirname parent
+
+    def basename
+      Path.for(File.basename(self))
+    end
+    alias name basename
+
+    def base
+      base, ext = basename.split('.', 2)
+      base
+    end
+
+    def extension
+      base, ext = basename.split('.', 2)
+      ext
+    end
+    alias ext extension
+
+    def join(arg, *args)
+      Path.for(self, Path.clean(arg, *args))
+    end
+
+    def binwrite(data)
+      FileUtils.mkdir_p(dirname)
+      IO.binwrite(self, data)
+    end
+
+    def sibling?(other)
+      expand.dirname == Path.for(other).expand.dirname
+    end
+
+    def child?(other)
+      parent = expand
+      child = Path.for(other).expand
+      (parent.size < child.size && child.start_with?(parent))
+    end
+
+    def parent?(other)
+      child = expand
+      parent = Path.for(other).expand
+      (parent.size < child.size && child.start_with?(parent))
+    end
+
+    def file?
+      test(?f, self)
+    end
+
+    def directory?
+      test(?d, self)
+    end
+
+    def subdirectories(&block)
+      accum = []
+
+      glob('*') do |entry|
+        next unless entry.directory?
+        block ? block.call(entry) : accum.push(entry)
+      end
+
+      block ? self : accum
+    end
+    alias subdirs subdirectories 
+
+    def subdirectory_for(subdirectory)
+      join(Path.relative(subdirectory))
+    end
+    alias subdir_for subdirectory_for
+
+    def subdirectory?(subdirectory)
+      subdirectory = join(Path.relative(subdirectory))
+      subdirectory.exist?
+    end
+    alias subdir? subdirectory?
+
+    def sort_key
+      [dirname.to_s, basename.to_s]
+    end
+
+    def <=>(other)
+      sort_key <=> other.sort_key
+    end
+  end
+end

data/lib/ro/root.rb

@@ -1,52 +1,73 @@
 module Ro
-  class Root < ::String
-    def initialize(root)
-      super(Ro.realpath(root.to_s))
-    ensure
-      raise ArgumentError.new("root=#{ root.inspect }") if root.nil?
-      raise ArgumentError.new("root=#{ root.inspect }") unless test(?d, self)
-    end
-
-    def root
+  class Root < Path
+    def identifier
       self
     end
 
-    def nodes
-      Node::List.new(root) do |list|
-        node_directories do |path|
-          list.load(path)
-        end
+    def collections(&block)
+      accum = Collection::List.for(self) 
+
+      subdirectories do |subdirectory|
+        collection = collection_for(subdirectory)
+        block ? block.call(collection) : accum.push(collection)
       end
-    end
 
-    def directories(&block)
-      Dir.glob(File.join(root, '*/'), &block)
+      block ? self : accum
     end
 
-    def node_directories(&block)
-      Dir.glob(File.join(root, '*/*/'), &block)
+    def collection_for(subdirectory)
+      Collection.new(subdirectory)
     end
 
-    def git
-      @git ||= Git.new(self)
+    def paths_for(name)
+      [
+        subdirectory_for(name),
+        subdirectory_for(Slug.for(name, :join => '-')),
+        subdirectory_for(Slug.for(name, :join => '_')),
+      ]
     end
 
-    def patch(*args, &block)
-      git.patch(*args, &block)
+    def get(name)
+      name = name.to_s
+
+      if name.index('/')
+        collection_name, node_name = name.split('/', 2)
+        collection = get(collection_name)
+
+        if collection
+          node = collection.get(node_name)
+          return node
+        else
+          return nil
+        end
+      end
+
+      paths_for(name).each do |path|
+        next unless path.directory?
+        return collection_for(path)
+      end
+
+      nil
     end
 
-    def dotdir
-      File.join(self, '.ro')
+    def [](name)
+      get(name)
     end
 
-    def lockpath
-      File.join(dotdir, 'lock')
+    def nodes(&block)
+      accum = []
+      
+      collections.each do |collection|
+        collection.nodes do |node|
+          block ? block.call(node) : accum.push(node)
+        end
+      end
+
+      block ? self : accum
     end
 
-    def lock(&block)
-      FileUtils.mkdir_p(File.dirname(lockpath))
-      @lock ||= Lock.new(lockpath)
-      block ? @lock.lock(&block) : @lock
+    def method_missing(name, *args, **kws, &block)
+      get(name) || super
     end
   end
 end

data/lib/ro/script/builder.rb

@@ -0,0 +1,221 @@
+module Ro
+  class Script::Builder
+    class << self
+      def run!(...)
+        new(...).run!
+      end
+    end
+
+    def initialize(script:)
+      @script = script
+    end
+
+    def run!
+      @url = Ro.config.url
+      @root = Ro.config.root
+      @directory = Ro.config.build
+      @page_size = Ro.config.page_size
+      @collections = Ro.root.collections.sort_by(&:name)
+
+      @build = {}
+      @nodes = []
+
+      @started_at = Time.now.to_f
+      @finished_at = nil
+      @elapsed = nil
+
+      # for all node collections...
+      #
+      @collections.each do |collection|
+        type = collection.type
+        name = collection.name
+        nodes = nodes_for(collection)
+
+        count = nodes.size
+        last = count - 1
+        page_count = (count / @page_size.to_f).ceil
+        paginator = paginator_for(page_count, @page_size)
+
+        nodes.each_with_index do |node, index|
+          @nodes << node
+          id = node.id
+
+          # enhance with links to next/prev
+          #
+          rel = rel_for(nodes, index)
+          node.attributes[:_meta][:rel] = rel
+
+          # node data
+          #
+          data = data_for(node)
+          _meta = meta_for(type:, id:)
+          path = "#{type}/#{id}/index.json"
+          @build[path] = { data:, _meta: }
+
+          # paginate data
+          #
+          paginator[:data].push(node)
+          generate_page = ((paginator[:data].size == paginator[:size]) || (index == last))
+          next unless generate_page
+
+          page = page_for(paginator)
+          data = data_for(paginator[:data])
+          _meta = meta_for(type:, page:)
+          pageno = page[:index] + 1
+          path = "#{type}/index-#{pageno}.json" # eg. posts/page-$pageno.json
+          @build[path] = { data:, _meta: }
+
+          paginator[:data].clear
+          paginator[:index] += 1
+        end
+
+        data = data_for(nodes)
+        _meta = meta_for(type:)
+        path = "#{type}/index.json" # eg. posts/index.json
+        @build[path] = { data:, _meta: }
+      end
+
+      # annnnd for all nodes...
+      #
+      count = @nodes.size
+      last = count - 1
+      page_count = (count / @page_size.to_f).ceil
+      paginator = paginator_for(page_count, @page_size)
+
+      @nodes.each_with_index do |node, index|
+        # enhance with links to next/prev
+        #
+        rel = rel_for(@nodes, index)
+        node.attributes[:_meta][:rel] = rel
+
+        paginator[:data].push(node)
+        should_generate_page = ((paginator[:data].size == paginator[:size]) || (index == last))
+        next unless should_generate_page
+
+        types = paginator[:data].map(&:type).sort.uniq
+        page = page_for(paginator)
+        data = data_for(paginator[:data])
+        _meta = meta_for(types:, page:)
+
+        pageno = page[:index] + 1
+        path = "index-#{pageno}.json" # eg. page-$pageno.json
+        @build[path] = { data:, _meta: }
+
+        paginator[:data].clear
+        paginator[:index] += 1
+      end
+
+      # index.json
+      #
+      types = @collections.map(&:type).sort
+      data = data_for(@nodes)
+      _meta = meta_for(types:)
+      path = 'index.json'
+      @build[path] = { data:, _meta: }
+
+      # now output the build
+      #
+      @script.say("ro.build: #{@root} -> #{@directory}", color: :magenta)
+
+      FileUtils.rm_rf(@directory)
+      FileUtils.mkdir_p(File.dirname(@directory))
+      #FileUtils.cp_r(@root, @directory)
+
+      Ro::Path.for(@directory).glob('**/**') do |entry|
+        next unless test('f', entry)
+
+        @script.say("ro.build: #{entry}", color: :blue)
+      end
+
+      @build.each do |subpath, data|
+        path = Ro::Path.for(@directory, subpath)
+        @script.say("ro.build: #{path}", color: :yellow)
+        Ro.error! "#{path} would be clobbered" if path.exist?
+
+        if data.is_a?(String)
+          path.binwrite(data)
+        else
+          path.binwrite(JSON.pretty_generate(data))
+        end
+      end
+
+      # show stats
+      #
+      @finished_at = Time.now.to_f
+      @elapsed = (@finished_at - @started_at).round(2)
+
+      @script.say("ro.build: #{@root} -> #{@directory} in #{@elapsed}s", color: :green)
+    end
+
+    def global_meta
+      { url: @url }
+    end
+
+    def meta_for(meta)
+      global_meta.merge(meta)
+    end
+
+    def rel_for(list, index)
+      { curr: list[index].identifier, prev: nil, next: nil }.tap do |rel|
+        rel[:prev] = list[index - 1].identifier if (index - 1) >= 0
+        rel[:next] = list[index + 1].identifier if (index + 1) <= (list.size - 1)
+      end
+    end
+
+    def paginator_for(count, size)
+      {
+        count:,
+        size:,
+        first: 0,
+        last: count - 1,
+        index: 0,
+        data: []
+      }
+    end
+
+    def page_for(paginator)
+      paginator.except(:data).merge(
+        {
+          curr: paginator[:index],
+          prev: ((paginator[:index] - 1) >= paginator[:first] ? (paginator[:index] - 1) : nil),
+          next: ((paginator[:index] + 1) <= paginator[:last] ? (paginator[:index] + 1) : nil)
+        }
+      )
+    end
+
+    def data_for(value)
+      {}.tap do |hash|
+        case value
+        when Array
+          value.each { |node| hash.update(data_for(node)) }
+        when Ro::Node
+          hash[value.identifier] = value.to_hash
+        else
+          raise ArgumentError, "#{value.class}(#{value.inspect})"
+        end
+      end
+    end
+
+    def nodes_for(list)
+      filtered_nodes_for(sorted_nodes_for(list))
+    end
+
+    def sorted_nodes_for(list)
+      list.to_a.sort
+    end
+
+    def filtered_nodes_for(list)
+      list.select { |node| select_node?(node) }
+    end
+
+    def select_node?(node)
+      now = Time.now.utc
+
+      hidden = Ro.cast(:bool, node.attributes.fetch(:hidden) { false })
+      published = Ro.cast(:bool, node.attributes.fetch(:published) { true })
+      published_at = Ro.cast(:time, node.attributes.fetch(:published_at) { now.iso8601 })
+
+      ((not hidden) && (published) && (published_at <= now))
+    end
+  end
+end

data/lib/ro/script/console.rb

@@ -0,0 +1,47 @@
+module Ro
+  class Script::Console
+    class << self
+      def run!(...)
+        new(...).run!
+      end
+    end
+
+    def initialize(script:)
+      @script = script
+    end
+
+    def run!
+      $A_GIANT_FUCKING_HACK_FOR_IBB = ARGV.clear
+
+      require 'irb'
+
+      $GIANT_FUCKING_HACK = IRB.method(:load_modules)
+
+      Kernel.module_eval do
+        def ro
+          Ro.root
+        end
+      end
+
+      def IRB.load_modules
+        $GIANT_FUCKING_HACK.call
+
+        prompt = "ro[./#{Ro.root.relative_to(Dir.pwd)}]"
+
+        IRB.conf[:PROMPT][:RO] = {
+          PROMPT_I: "#{prompt}:%03n:%i> ",
+          PROMPT_N: "#{prompt}:%03n:%i> ",
+          PROMPT_S: "#{prompt}:%03n:%i%l ",
+          PROMPT_C: "#{prompt}:%03n:%i* ",
+          RETURN: "=> %s\n"
+
+        }
+
+        IRB.conf[:PROMPT_MODE] = :RO
+        IRB.conf[:AUTO_INDENT] = true
+      end
+
+      ::IRB.start
+    end
+  end
+end

data/lib/ro/script/server.rb

@@ -0,0 +1,76 @@
+module Ro
+  class Script::Server
+    class << self
+      def run!(...)
+        new(...).run!
+      end
+    end
+
+    def initialize(script:)
+      @script = script
+
+      @port = @script.opts.fetch(:port)
+    end
+
+    def run!
+      Ro.config.set(:url, server_url)
+
+      #build!
+
+      threads = [watcher!, server!]
+
+      trap('INT') do
+        threads.each do |thread|
+          thread.kill
+        rescue StandardError
+          nil
+        end
+        exit
+      end
+
+      sleep
+    end
+
+    def server_url
+      build = Ro.config.build
+      document_root = build.dirname
+      path_info = build.relative_to(document_root)
+      Ro.normalize_url("http://localhost:#{@port}/#{path_info}")
+    end
+
+    def build!
+      system "RO_URL=#{Ro.config.url} RO_ROOT=#{Ro.config.root} ro build"
+    end
+
+    def watcher!
+      Thread.new do
+        Thread.current.abort_on_exception = true
+        system "RO_URL=#{Ro.config.url} RO_ROOT=#{Ro.config.root} ro build --watch"
+      end
+    end
+
+    def server!
+      require 'webrick'
+
+      build = Ro.config.build
+      document_root = build.dirname
+
+      index_url = File.join(server_url, 'index.json')
+
+      @script.say("ro.server: @ #{index_url}", color: :magenta)
+
+      Thread.new do
+        Thread.current.abort_on_exception = true
+
+        server = WEBrick::HTTPServer.new(
+          DocumentRoot: document_root,
+          Port: @port
+        )
+
+        ::Kernel.at_exit { server.shutdown }
+
+        server.start
+      end
+    end
+  end
+end