ro 1.4.6 → 4.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    NGU2NmU2NTUwNTgxZmM3OTUwYzYzNmFiZWQ3NzMyYzc3YmE0ODM2OQ==
-  data.tar.gz: !binary |-
-    YWM3ZjJhOWRmMWZiZWRlZmFmZWMzNTM1NzRlNzNkZTFkZmMxMzFmZA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NmQ3Y2U2NTk3NWJhM2MyY2E0MmE2NWRkZWMwOGUwMGI3ZjMwZjgyNjI1ZjZk
-    NjI1NTJmZWExMzQ5YmY4M2ExZDUwZTE2OTI5NWY3YjM4ODkxNDk1YTc3ZDYw
-    NTZmODg5MjRlYTQzN2MxZGY1NGQxNDk3N2ZlODA5OWNiMGIxMjQ=
-  data.tar.gz: !binary |-
-    ODU5MWMwODIyNTM0NzdhMmFlMjczNjUyNWZjMTdmYzFkMmEwYmMwMWY0ZWUw
-    NTQ5NTE3ZTU0NzUyZTcyM2QyNTFhOTUzYWNlMjhkMzE4Y2JhZjJlMWYwMDM5
-    MGY4NDQxNzQ4NzcwMWIwZDA2MWE3NDFhYzgzOTIyNmJhNTBlMjM=
+SHA256:
+  metadata.gz: 50e5d272b2bdbfe25f9ae109ed44568e71637820c4768ea772e757c7436c38cc
+  data.tar.gz: 84372b1f2cc28f316ed1eff63c0ce6ec4333f18a886a0cc38f4c86617baa0c0a
+SHA512:
+  metadata.gz: e92b12b8067606b5b5ee11a3db65c926e492298aa3bed178459550d578a6b493762acbc3424fc0e2ac259d84d45cab1a69bc5e07e3550e58cbbdd14b18078c11
+  data.tar.gz: 7a587649abd8cb3a79e667d4767b33005a47a860983725546acdae8f97dfadaafe140f49fda93a12000097171ed4aba7fea5507467bd480b9b83496115aa3352

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    ro (2.0.0)
+      ak47 (~> 0.2)
+      kramdown (~> 2.4, >= 2.4.0)
+      kramdown-parser-gfm (~> 1.1, >= 1.1.0)
+      map (~> 6.6, >= 6.6.0)
+      rouge (~> 4.1, >= 4.1.1)
+      webrick (~> 1.8.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ak47 (0.2.5)
+      guard (~> 0.10.0)
+      shell_tools (~> 0.1.0)
+      smart_colored
+    ffi (1.16.3)
+    guard (0.10.0)
+      ffi (>= 0.5.0)
+      thor (~> 0.14.6)
+    kramdown (2.4.0)
+      rexml
+    kramdown-parser-gfm (1.1.0)
+      kramdown (~> 2.0)
+    map (6.6.0)
+    rexml (3.2.6)
+    rouge (4.1.1)
+    shell_tools (0.1.2)
+    smart_colored (1.1.1)
+    thor (0.14.6)
+    webrick (1.8.1)
+
+PLATFORMS
+  arm64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  ro!
+
+BUNDLED WITH
+   2.4.22

data/LICENSE

@@ -0,0 +1 @@
+Ruby

data/README.md

@@ -1,170 +1,178 @@
 NAME
-----
+====
 
-ro
+`ro`
 
+INSTALL
+=======
 
-TL;DR
------
-
-<pre>
-
-    ro
-    ├── people
-    │   ├── ara
-    │   │   ├── assets
-    │   │   │   ├── ara-glacier.jpg
-    │   │   │   └── source
-    │   │   │       └── a.rb
-    │   │   ├── attributes.yml
-    │   │   └── bio.md.erb
-    │   └── noah
-    │       └── attributes.yml
-    └── posts
-        ├── foobar
-        ├── hello-world
-        │   ├── attributes.yml
-        │   └── body.md
-        └── second-awesome-post
-            ├── attributes.yml
-            └── body.md
+as a gem
 
-</pre>
+```sh
+  ~> gem install ro
+```
 
 
-```ruby
+SYNOPSIS
+========
 
-  ro
-    #=> all the content nodes
+keep all your content in git as god intended.
 
-  ro.posts
-    #=> all the post nodes
+even images.
 
-  ro.people                                 
-    #=> all people nodes
+fuck wordpress.
 
-  ro[:people]                               
-    #=> same thing
+# TL;DR;
 
-  ro.people.ara                             
-    #=> data for the person named 'ara'
+`ro` is the world's tiniest, simplest, zero-config, and most bestest headless CMS.
 
-  ro[:people][:ara]                         
-    #=> same thing
+it keeps your content in an on disk bundle that will make sense to an 11 year
 
-  ro['people']['ara']                         
-    #=> same thing
+it depends on nothing but GitHub itself for the storage, management, and
+delivery of rich web content and assets.
 
-  ro.people.ara.first_name                  
-    #=> give you *one* guess ;-) !
+## Storage
 
-  ro.people.ara.url_for('ara-glacier.jpg')  
-    #=> external timestamped  url for this asset
+`ro` keeps your structured web content in a super sane structure, that keeps
+assets close to its related content, allows for structured data to be kept
+along side markdown/html content, and which supports source code as a first
+class citizen.
 
-  ro.people.ara.source('a.rb')              
-    #=> syntax highlighted source yo!
+For example, given:
 
-  ro.posts.find('second-awesome-post').body 
-    #=> html-z yo
+```sh
+    ~> tree ro/data
 
-  ro.people.ara.related(:posts)             
-    #=> all related posts
+    # ro/data
+    # └── posts
+    #     ├── first-post
+    #     │   ├── attributes.yml
+    #     │   └── body.md
+    #     │   ├── blurb.erb.md
+    #     │   ├── assets
+    #     │   │   ├── foo.jpg
+```
 
-  ro.people.ara.related(:featured_posts)    
-    #=> all featured posts
-  
+`ro` will provide an interface logically consistent with:
 
+```ruby
+    node.attributes        #=> any/all the data loaded from 'attributes.yml'
+    node.attributes.body   #=> an HTML representation of 'body.md' 
+    node.attributes.blurb  #=> an HTML representation of 'blurb.md' 
+    node.attributes.assets #=> list of assets with url and path info
 ```
 
-TRY
----
+To learn more, clone this repo, `bundle install`, and fire up a console to
+check play with this idea:
 
-```bash
+eg: [given this node](https://github.com/ahoward/ro/tree/main/ro/data/posts/first-post)
 
-  ~ > git clone https://github.com/ahoward/ro.git
-  ~ > cd ro
-  ~> ./bin/ro console
+```ruby
+    ~> ro console
 
+    ro[./ro/data]:001:0> ro.posts.first_post.title
+    => "First Post"
 
-  a:~/git/ahoward/ro $ ./bin/ro console
-  Ro(./ro):001:0> ro.people
-  => [people/ara, people/noah]
+    ro[./ro/data]:002:0> ro.collections.posts.first_post.assets.first.url
+    => "/ro/posts/first-post/assets/foo.jpg"
 
-  Ro(./ro):002:0> ro.people.ara
-  => people/ara
+    ro[./ro/data]:003:0> ro.collections.posts.first_post.body.slice(0,42)
+    => "<div class='ro markdown'>\n  <ul>\n  <li>one"
+```
 
-  Ro(./ro):003:0> ro.people.ara.first_name
-  => "Ara"
 
-  Ro(./ro):004:0> ro.people.ara.bio
-  => "<ul>\n<li>one</li>\n<li>two</li>\n<li>three</li>\n</ul>\n\n<p>pretty syntax highlighting</p>\n<div class=\"highlight\"><pre>  <span class=\"vi\">@a</span> <span class=\"o\">=</span> <span class=\"mi\">42</span>\n</pre></div>\n<p>Ara</p>\n\n<p>/ro/people/ara/assets/ara-glacier.jpg?_=1382999368</p>\n"
+## Management
 
-  Ro(./ro):005:0> ro.people.ara.url_for('ara-glacier')
-  => "/ro/people/ara/assets/ara-glacier.jpg?_=1382999368"
+Managing `ro` is as simple as using the built-in GitHub Markdown editor.  The
+file system layout, which supports relative asset urls, means the built-in
+editor preview renders just fine.  Of course, you are free to manage content
+programatically as well.  Either way, updates to the the content will result
+in an automated API build of a static API which is then deployed to GitHub
+Pages.
 
-  Ro(./ro):006:0> ro.people.ara.related
-  => [posts/hello-world, posts/second-awesome-post]
+This is made possible by certain design decisions `ro` has made, specifically
+allowing assets/ to be stored and rendered relative to their parent content.
 
-  Ro(./ro):007:0> ro.people.ara.related.posts
-  => [posts/hello-world, posts/second-awesome-post]
+Of course, you have all the power of `git` so other methods of managing the
+content are available, programtic, locally in vs-code, etc.  You have lots of
+simply options, none of which require drivers or databases, and all of which
+provide perfect history over your valuable web content and assets.
 
-  Ro(./ro):008:0> ro.people.ara.related(:featured_posts)
-  => [posts/second-awesome-post]
+A word on managing assets, if you plan to have many large images, you probably
+want to enable GitLFS on your content repository, `ro` plays perfectly with
+it.
 
-```
 
-DESCRIPTION
------------
+## Delivery
 
-ro is library for managing your site's content in git, as god intended.
+Delivery of `ro` content, to remote clients, is via http+json.  To output your
+content as json, you simply need to run
 
-it features:
+```sh
+    ~>  ro build
 
-- super fast loading via a robust caching/promise strategy
-- *all* teh templates supported via tilt (https://github.com/rtomayko/tilt)
-- the awesomest markdown ever, with syntax highlighting and even erb evaluation
-- an awesome command line tool for introspecting your data (./ro console)
-- data driven relationships
+		ro.build: public/ro -> public/api/ro
+		ro.build: public/api/ro/posts/first_post/index.json
+		ro.build: public/api/ro/posts/second_post/index.json
+		ro.build: public/api/ro/posts/third_post/index.json
+		ro.build: public/api/ro/posts/index/0.json
+		ro.build: public/api/ro/posts/index.json
+		ro.build: public/api/ro/index/0.json
+		ro.build: public/api/ro/index.json
+		ro.build: public/api/ro/index.html
+		ro.build: public/ro -> public/api/ro in 0.08s
 
+```
 
-ro is the *perfect* companion to a site built by a static site generator such
-as middleman (http://middlemanapp.com/).  especially a middleman site with a
-companion rails' application doing concurrent modifications of the site's
-content... (ref: http://dojo4.com/blog/static-is-the-new-black) ;-)
+During the build, assets are expanded to be the full URL of the final
+deployment destination.  This is done via the RO_URL environment variable, and
+automatically with a pre-build GitHub Action that will deploy your content via
+GitHub Pages. See
+https://github.com/ahoward/ro/blob/main/.github/workflows/gh-pages.yml#L55 for
+more details.
 
+You can view sample output from this Action, deployed to GH Pages here: https://ahoward.github.io/ro
 
-INSTALL
--------
 
-gem install ro
 
+# USAGE
 
-CONFIG
-------
+#### WRITE-ME // #TODO
 
-if you are using the url methods you'll need to make sure your application can
-route to the assets.  by default ro assumes that the urls it generates are
-routeable under '/ro' so it is up to you to make sure this works.
+## API // Javascript
 
-for a rails app this might mean writing a 'RoController' or, more simply, just
-putting your ro data in ./public/ro.
+#### WRITE-ME // #TODO
 
-for a middleman app this might mean putting your ro data in ./source/ro.
+## CLI
 
-if you choose a non-standard approach you'll need to
+#### WRITE-ME // #TODO
 
-```
+## Programatic // Ruby
 
-  Ro.route = '/my-custom-route'
+#### WRITE-ME // #TODO
 
+## Via Repository
 
-```
+#### WRITE-ME // #TODO
 
-in all cases ro urls will be prefixed by the route, so be sure that this prefix
-is either automatically, or manually, exposed.
+- note on http vs https
 
+SAMPLES
+=======
+  #### <========< [samples/a.rb](https://github.com/ahoward/ro/blob/main/samples/a.rb) >========>
+```sh
+  ~ > cat samples/a.rb
+```
+```ruby
+    require 'ro'
+    
+    p 42
+```
 
-DOCS
-----
+```sh
+  ~ > ruby samples/a.rb
+```
+```txt
+    42
+```
 
-RTFC

data/README.md.erb

@@ -0,0 +1,159 @@
+NAME
+====
+
+`ro`
+
+INSTALL
+=======
+
+as a gem
+
+```sh
+  ~> gem install ro
+```
+
+
+SYNOPSIS
+========
+
+keep all your content in git as god intended.
+
+even images.
+
+fuck wordpress.
+
+# TL;DR;
+
+`ro` is the world's tiniest, simplest, zero-config, and most bestest headless CMS.
+
+it keeps your content in an on disk bundle that will make sense to an 11 year
+
+it depends on nothing but GitHub itself for the storage, management, and
+delivery of rich web content and assets.
+
+## Storage
+
+`ro` keeps your structured web content in a super sane structure, that keeps
+assets close to its related content, allows for structured data to be kept
+along side markdown/html content, and which supports source code as a first
+class citizen.
+
+For example, given:
+
+```sh
+    ~> tree ro/data
+
+    # ro/data
+    # └── posts
+    #     ├── first-post
+    #     │   ├── attributes.yml
+    #     │   └── body.md
+    #     │   ├── blurb.erb.md
+    #     │   ├── assets
+    #     │   │   ├── foo.jpg
+```
+
+`ro` will provide an interface logically consistent with:
+
+```ruby
+    node.attributes        #=> any/all the data loaded from 'attributes.yml'
+    node.attributes.body   #=> an HTML representation of 'body.md' 
+    node.attributes.blurb  #=> an HTML representation of 'blurb.md' 
+    node.attributes.assets #=> list of assets with url and path info
+```
+
+To learn more, clone this repo, `bundle install`, and fire up a console to
+check play with this idea:
+
+eg: [given this node](https://github.com/ahoward/ro/tree/main/ro/data/posts/first-post)
+
+```ruby
+    ~> ro console
+
+    ro[./ro/data]:001:0> ro.posts.first_post.title
+    => "First Post"
+
+    ro[./ro/data]:002:0> ro.collections.posts.first_post.assets.first.url
+    => "/ro/posts/first-post/assets/foo.jpg"
+
+    ro[./ro/data]:003:0> ro.collections.posts.first_post.body.slice(0,42)
+    => "<div class='ro markdown'>\n  <ul>\n  <li>one"
+```
+
+
+## Management
+
+Managing `ro` is as simple as using the built-in GitHub Markdown editor.  The
+file system layout, which supports relative asset urls, means the built-in
+editor preview renders just fine.  Of course, you are free to manage content
+programatically as well.  Either way, updates to the the content will result
+in an automated API build of a static API which is then deployed to GitHub
+Pages.
+
+This is made possible by certain design decisions `ro` has made, specifically
+allowing assets/ to be stored and rendered relative to their parent content.
+
+Of course, you have all the power of `git` so other methods of managing the
+content are available, programtic, locally in vs-code, etc.  You have lots of
+simply options, none of which require drivers or databases, and all of which
+provide perfect history over your valuable web content and assets.
+
+A word on managing assets, if you plan to have many large images, you probably
+want to enable GitLFS on your content repository, `ro` plays perfectly with
+it.
+
+
+## Delivery
+
+Delivery of `ro` content, to remote clients, is via http+json.  To output your
+content as json, you simply need to run
+
+```sh
+    ~>  ro build
+
+		ro.build: public/ro -> public/api/ro
+		ro.build: public/api/ro/posts/first_post/index.json
+		ro.build: public/api/ro/posts/second_post/index.json
+		ro.build: public/api/ro/posts/third_post/index.json
+		ro.build: public/api/ro/posts/index/0.json
+		ro.build: public/api/ro/posts/index.json
+		ro.build: public/api/ro/index/0.json
+		ro.build: public/api/ro/index.json
+		ro.build: public/api/ro/index.html
+		ro.build: public/ro -> public/api/ro in 0.08s
+
+```
+
+During the build, assets are expanded to be the full URL of the final
+deployment destination.  This is done via the RO_URL environment variable, and
+automatically with a pre-build GitHub Action that will deploy your content via
+GitHub Pages. See
+https://github.com/ahoward/ro/blob/main/.github/workflows/gh-pages.yml#L55 for
+more details.
+
+You can view sample output from this Action, deployed to GH Pages here: https://ahoward.github.io/ro
+
+
+
+# USAGE
+
+#### WRITE-ME // #TODO
+
+## API // Javascript
+
+#### WRITE-ME // #TODO
+
+## CLI
+
+#### WRITE-ME // #TODO
+
+## Programatic // Ruby
+
+#### WRITE-ME // #TODO
+
+## Via Repository
+
+#### WRITE-ME // #TODO
+
+- note on http vs https
+