ro 1.4.6 → 4.2.0

data/bin/ro

@@ -1,102 +1,275 @@
 #! /usr/bin/env ruby
+# encoding: utf-8
 
-Main {
+Ro.script do
+  help <<~____
+    NAME
+    ----
+      ro
+      
+    SYNOPSIS
+    --------
+      * boot an interactive r.e.p.l. over yer ro data
+      * build a json api for your ro data
+      * run a local dev server for your ro data
 
-  argument('root'){
-    optional
-  }
+    TL;DR;
+    ------
+      # boot a console for the ro a ./public/ro (the default)
+      #
+        ~> ro console
 
-  def run
+      # build a static API into ./public/api/ro (the default)
+      #
+        ~> ro build
+
+      # keep building that static a.p.i when any file changes
+      #
+        ~> ro watch
+
+      # run a local http server that re-builds that static a.p.i on change
+      #
+        ~> ro server
+
+      # show defaults
+      #
+        ~> ro defaults
+
+      # show env
+      #
+        ~> ro env
+
+      # show config
+      #
+        ~> ro config
+
+    ENV
+    ---
+      - all sub commands can be affect by the following env vars
+      - 12 factor ftw
+
+      - RO_ROOT
+        - the root directory of your ro data
+      - RO_BUILD
+        - the build directory for your ro data api
+      - RO_URL
+        - the url prefix where your ro data will be found on the interwebs
+        - you may use a relative or absolute url
+        - please make sure this will resolve
+      - RO_PAGE_SIZE
+        - the built a.p.i.'s page size
+      - RO_LOG
+        - log on, or log off
+      - RO_DEBUG
+        - debug or no debug
+      - RO_PORT
+        - le port to to serve on
+
+      ARGV
+      ----
+        - for *all* sub commands
+        - you may also specifiy RO_ROOT as the 1'st argument
+        - you may also specifiy RO_BUILD as the 2'nd argument
+        - you may specify env vars in argv as 'RO_XXX=YYY' pairs, for example:
+          ~ `ro console RO_ROOT=./public/ro`
+            - or
+          ~ `ro console ro_root=./public/ro`
+
+      API
+        - the a.p.i is trivially simple, examine the output.
+        - if you can't figure out how to use it your probably should not.
+  ____
+
+  run do
     help!
   end
 
-  mode(:console){
-    def run
-      if params['root'].given?
-        Ro.root = params['root'].value 
-      else
-        if ENV['RO_ROOT']
-          Ro.root = ENV['RO_ROOT']
-        else
-          Ro.root = './ro'
-        end
-      end
+  run(:console) do
+    setup!(:root)
 
-      basename = File.basename(Ro.root) 
+    console!
+  end
 
-      ARGV.clear
-      require 'irb'
+  run(:build) do
+    setup!(:root, :build)
 
-      Kernel.module_eval do
-        def reload!
-          Object.send(:remove_const, :Ro)
-          load "#{ $libdir }/ro.rb" 
-          "#{ $libdir }/ro.rb" 
-        end
-      end
+    build!
+  end
 
-      $HACK = IRB.method(:load_modules)
+  run(:watch) do
+    setup!(:root, :build)
 
-      def IRB.load_modules
-        $HACK.call()
+    watch!
+  end
+
+  run(:server) do
+    setup!(:root, :build)
 
-        basename = File.basename(Ro.root)
+    server!
+  end
 
-        IRB.conf[:PROMPT][:RO] = {
-          :PROMPT_I=>"Ro(./#{ basename }):%03n:%i> ",
-          :PROMPT_N=>"Ro(./#{ basename }):%03n:%i> ",
-          :PROMPT_S=>"Ro(./#{ basename }):%03n:%i%l ",
-          :PROMPT_C=>"Ro(./#{ basename }):%03n:%i* ",
-          :RETURN=>"=> %s\n"
-        }
+  run(:defaults) do
+    setup!
 
-        IRB.conf[:PROMPT_MODE] = :RO
-        IRB.conf[:AUTO_INDENT] = true
-      end
+    defaults!
+  end
+
+  run(:env) do
+    setup!
+
+    env!
+  end
+
+  run(:config) do
+    setup!
+
+    config!
+  end
+
+  run(:site) do
+    site!
+  end
 
+  def setup!(*which)
+    setup_env!
 
-      ::IRB.start
+    parse_argv!(*which)
+
+    validate!
+
+    if which.include?(:ro)
+      @ro = Ro.root
     end
+  end
 
-=begin
-    module Console
-      def reload!
-        Object.send(:remove_const, :Ro)
-        load "#{ $libdir }/ro.rb" 
-        "#{ $libdir }/ro.rb" 
+  attr_reader :ro
+
+  def parse_argv!(*which)
+    if which.include?(:root)
+      if argv.size > 0
+        Ro.config.root = argv.shift
       end
     end
-=end
 
-    class Console < Ro::BlankSlate
-      def initialize(nodes)
-        @nodes = nodes
+    if which.include?(:build)
+      if argv.size > 0
+        Ro.config.build = argv.shift
       end
+    end
+  end
 
-      def binding
-        Kernel.binding
-      end
+  def setup_env!
+    argv.dup.each_with_index do |arg, i|
+      key, val = arg.split('=', 2)
 
-      def reload!
-        Object.send(:remove_const, :Ro)
-        load "#{ $libdir }/ro.rb" 
-        "#{ $libdir }/ro.rb" 
-      end
+      if key && val 
+        ENV[key.upcase] = val
 
-      def method_missing(method, *args, &block)
-        @nodes.send(method, *args, &block)
+        argv.delete_at(i)
       end
     end
-  }
 
-}
+    if ENV['PORT']
+      Ro.config.port = ENV['PORT']
+    end
+  end
+
+  def validate!
+    abort("Ro.root = #{ Ro.config.root.expand } is not a directory") unless test(?d, Ro.config.root)
+    abort("Ro.root = #{ Ro.config.root.expand } is empty") unless test(?s, Ro.config.root)
+  end
+
+  def console!
+    require "#{$libdir}/ro/script/console.rb"
+
+    Ro::Script::Console.run!(script: self)
+  end
+
+  def build!
+    require "#{$libdir}/ro/script/builder.rb"
+
+    Ro::Script::Builder.run!(script: self)
+  end
+
+  def server!
+    require "#{$libdir}/ro/script/server.rb"
+
+    Ro::Script::Server.run!(script: self)
+  end
+
+  def watch!
+    watch(Ro.config.root) { build! }
+  end
+
+  def watch(directory, &block)
+    require 'ak47'
+
+    def File.exists?(...) # monkey patch for Ak47 ;-/
+      File.exist?(...)
+    end
+
+    Ak47(watch_dirs: directory) do
+      block.call
+    end
+  end
+
+  def show(hash)
+    puts JSON.parse(hash.to_json).to_yaml
+  end
+
+  def defaults!
+    show Ro.defaults
+  end
+
+  def env!
+    show Ro.env
+  end
+
+  def config!
+    show Ro.config
+  end
+
+  def site!
+    document_root = Ro::Path.for(argv[0] || './public')
+
+    files = document_root.files.sort
+    hrefs = files.map{|file| file.relative_to(document_root).relative}
+    anchors = hrefs.map{|href| "<a href='./#{ href }' target='_blank'>./#{ href }</a>"}
+    lis = anchors.map{|anchor| "<li>#{ anchor }</li>"}
+
+    html = <<-____
+      <html>
+        <body style='padding:2em;'>
+          <br><br>
+          <strong>tl;dr;</strong>
+          <br><br>
+          <em>
+            see <a href="#{ Ro.repo }">#{ Ro.repo }</a> for moar deets
+          </em>
+          <br><br>
+          <hr><hr>
+          <ul>
+            #{ lis.join("\n") }
+          </ul>
+        </body>
+      </html>
+    ____
+
+    index_html = document_root.join('index.html')
+    index_html.binwrite(html)
+    puts index_html
+  end
+end
 
 BEGIN {
-  require 'main'
+  $stdout.sync = true
+  $stderr.sync = true
 
-  $bindir = File.dirname(__FILE__)
-  $libdir = File.expand_path("#{ $bindir }/../lib/")
+  $script = File.expand_path(__FILE__)
+  $bindir = File.dirname($script)
+  $root = File.dirname($bindir)
+  $libdir = File.join($root, 'lib')
 
-  require "#{ $libdir }/ro.rb" 
+  require "#{$libdir}/ro"
+  require "#{$libdir}/ro/script.rb"
 }
-

data/lib/ro/_lib.rb

@@ -0,0 +1,95 @@
+module Ro
+  VERSION = '4.2.0' unless defined?(VERSION)
+
+  class << self
+    def version
+      VERSION
+    end
+
+    def repo
+      'https://github.com/ahoward/ro'
+    end
+
+    def summary
+      <<~____
+        all your content in github, as god intended
+      ____
+    end
+
+    def description
+      <<~____
+        the worlds tiniest, bestest, most minmialist headless cms - powered by github
+
+        ro is a minimalist toolkit for managing heterogeneous collections of rich web
+        content on github, and providing both programatic and api access to it with zero
+        heavy lifting
+      ____
+    end
+
+    def libs
+      %w[
+        fileutils pathname yaml json logger erb cgi rexml time date thread
+      ]
+    end
+
+    def dependencies
+      {
+        'map' =>
+          ['map', '~> 6.6', '>= 6.6.0'],
+
+        'kramdown' =>
+          ['kramdown', '~> 2.4', ' >= 2.4.0'],
+
+        'kramdown-parser-gfm' =>
+          ['kramdown-parser-gfm', '~> 1.1', ' >= 1.1.0'],
+
+        'rouge' =>
+          ['rouge', '~> 4.1', ' >= 4.1.1'],
+
+        'ak47' =>
+          ['ak47', '~> 0.2'],
+
+        'webrick' =>
+          ['webrick', '~> 1.8.1'],
+      }
+    end
+
+    def libdir(*args, &block)
+      @libdir ||= File.dirname(File.expand_path(__FILE__))
+      args.empty? ? @libdir : File.join(@libdir, *args)
+    ensure
+      if block
+        begin
+          $LOAD_PATH.unshift(@libdir)
+          block.call
+        ensure
+          $LOAD_PATH.shift
+        end
+      end
+    end
+
+    def load(*libs)
+      libs = libs.join(' ').scan(/[^\s+]+/)
+      libdir { libs.each { |lib| Kernel.load(lib) } }
+    end
+
+    def load_dependencies!
+      libs.each do |lib|
+        require lib
+      end
+
+      begin
+        require 'rubygems'
+      rescue LoadError
+        nil
+      end
+
+      has_rubygems = defined?(gem)
+
+      dependencies.each do |lib, dependency|
+        gem(*dependency) if has_rubygems
+        require(lib)
+      end
+    end
+  end
+end

data/lib/ro/asset.rb

@@ -0,0 +1,45 @@
+module Ro
+  class Asset < ::String
+    include Klass
+
+    DEFAULT_IMAGE_PATTERNS = [
+      /[.](webp|jpg|jpeg|png|gif|tif|tiff|svg)$/i
+    ]
+
+    def Asset.image_patterns
+      @image_patterns ||= DEFAULT_IMAGE_PATTERNS.dup
+    end
+
+    attr_reader :path, :node, :relative_path, :name, :url
+
+    def initialize(arg, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+
+      @path = Path.for(arg, *args)
+
+      @node = options.fetch(:node) { Node.for(@path.split('/assets/').first) }
+
+      @relative_path = @path.relative_to(@node.path)
+
+      @name = @relative_path
+
+      @url = @node.url_for(@relative_path)
+
+      super(@path)
+    end
+
+    def image?
+      @path.file? && Asset.image_patterns.any? { |pattern| pattern === @path.basename }
+    end
+
+    def src
+      key = relative_path.parts
+      subdir = key.size > 2 ? key[1] : nil
+      is_src = subdir == 'src'
+
+      return unless is_src
+
+      Ro.render_src(path, node)
+    end
+  end
+end

data/lib/ro/collection/list.rb

@@ -0,0 +1,23 @@
+module Ro
+  class Collection
+    class List < ::Array
+      include Klass
+
+      attr_reader :root
+
+      def initialize(root, ...)
+        @root = root
+        super(...)
+      end
+
+      def get(name)
+        @root.get(name)
+      end
+
+      def [](index, ...)
+        return get(index) if [String, Symbol].include?(index.class)
+        super(index, ...)
+      end
+    end
+  end
+end

data/lib/ro/collection.rb

@@ -0,0 +1,168 @@
+module Ro
+  class Collection
+    include Klass
+    include Enumerable
+
+    attr_reader :path, :root
+
+    def initialize(path)
+      @path = Path.for(path)
+      @root = Root.for(@path.parent)
+    end
+
+    def name
+      @path.name
+    end
+
+    def id
+      name
+    end
+
+    def type
+      name
+    end
+
+    def identifier
+      type
+    end
+
+    def inspect
+      identifier
+    end
+
+    def node_for(path)
+      Node.new(path)
+    end
+
+    def subdirectories(...)
+      @path.subdirectories(...)
+    end
+
+    def subdirectory_for(name)
+      @path.subdirectory_for(name)
+    end
+
+    def each(&block)
+      accum = []
+
+      subdirectories do |subdirectory|
+        node = node_for(subdirectory)
+
+        block ? block.call(node) : accum.push(node)
+      end
+
+      block ? self : accum
+    end
+
+    def load(&block)
+      n = 8
+      q = Queue.new # FIXME
+      o = Queue.new # FIXME
+
+      producer =
+        Thread.new do
+          Thread.current.abort_on_exception = true
+
+          subdirectories do |subdirectory|
+            q.push(subdirectory)
+          end
+        end
+
+      loaders =
+        n.times.map do
+          Thread.new do
+            Thread.current.abort_on_exception = true
+
+            loop do
+              subdirectory = q.pop
+
+              begin
+                node = node_for(subdirectory)
+                o.push(node)
+              rescue => e
+                o.push(e) # FIXME
+                nil # FIXME
+              end
+            end
+          end
+        end
+
+        accum = []
+
+        consumer =
+          Thread.new do
+            Thread.current.abort_on_exception = true
+              loop do
+                node = o.pop
+                block ? block.call(node) : accum.push(node)
+              end
+          end
+
+        producer.join
+        loaders.map{|loader| loader.join}
+        consumer.join
+
+        block ? self : accum
+    end
+
+    def to_array(...)
+      each(...)
+    end
+
+    alias to_a to_array
+
+    alias all to_array
+
+    alias nodes to_array
+
+    def first(*args)
+      if args.size.zero?
+        node_for(subdirectories.first)
+      else
+        subdirectories.first(*args).map{|subdirectory| node_for(subdirectory)}
+      end
+    end
+
+    def last(*args)
+      if args.size.zero?
+        node_for(subdirectories.last)
+      else
+        subdirectories.last(*args).map{|subdirectory| node_for(subdirectory)}
+      end
+    end
+
+    def size
+      subdirectories.size
+    end
+
+    def paths_for(name)
+      [
+        subdirectory_for(name),
+        subdirectory_for(Slug.for(name, :join => '-')),
+        subdirectory_for(Slug.for(name, :join => '_')),
+      ]
+    end
+
+    def get(name)
+      paths_for(name).each do |path|
+        next unless path.exist?
+
+        return node_for(path)
+      end
+
+      nil
+    end
+
+    def [](name)
+      get(name)
+    end
+
+    def slice(...)
+      subdirectories.slice(...).map{|subdirectory| node_for(subdirectory)}
+    end
+
+    def method_missing(name, *args, **kws, &block)
+      get(name) || super
+    end
+  end
+end