contentfs 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9dd7fc4b06ab77f27e8998c275cb3d4659dc450d013ebf2df47fd5609d9fe322
+  data.tar.gz: d289facaae4ca3c791054b632397efb2e2286c964602885888215b5584e06d4d
+SHA512:
+  metadata.gz: dedfb6034eb79b0b09bbbb9645c8de6f04b9a8e6ff78a31186c11798317ca02807e00eed644bd980f57cb5407d13843d7cec1d0c6a3ec5efa8a0a755865c752a
+  data.tar.gz: 8a9010f2faf608345653e321310208dc2b85afafbc2985a6c9392ddccbfe548e6f500b146a66525aa3adda88320913544e9605ac4f5348de9598f276c6f7f8b1

data/LICENSE

@@ -0,0 +1,22 @@
+This software is licensed under the MIT License.
+
+Copyright 2020 Metabahn.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,92 @@
+# contentfs
+
+A structured content file system.
+
+## Install
+
+```
+gem install contentfs
+```
+
+## Usage
+
+Content can be defined in a structure like this:
+
+```
+docs/
+  api/
+    application/
+      content.md
+
+      class_api/
+        new.md
+      instance_api/
+        ...
+  guides/
+    ...
+```
+
+Once defined, content can be accessed through ContentFS:
+
+```ruby
+require "contentfs"
+
+database = ContentFS::Database.load("path/to/docs")
+
+database.docs.api.application.render
+```
+
+The `content` name is special in that it defines content for the containing folder.
+
+### Formats
+
+Markdown is supported by default. Simply add the `redcarpet` gem to your project's `Gemfile`. For automatic syntax highlighting, add the `rouge` to your `Gemfile` as well.
+
+Unknown formats default to plain text.
+
+### Metadata
+
+Metadata can be defined on content through front-matter:
+
+```
+---
+option: value
+---
+
+...
+```
+
+Metadata can be applied to all content in a folder by defining a `_metadata.yml` file. The folder's metadata is merged with metadata defined in front-matter, with precedence given to the front-matter metadata values.
+
+### Filtering
+
+Content can be filtered by one or more metadata values:
+
+```ruby
+database.filter(option: "value") do |content|
+  ...
+end
+```
+
+### Iterating
+
+Iterate over content using the `all` method:
+
+```ruby
+database.content.all do |content|
+  ...
+end
+```
+
+### Prefixes
+
+Both folders and content can be defined with prefixes, useful for ordering:
+
+```
+docs/
+  api/
+    0000__application/
+      ...
+```
+
+Characters up to `__` (double underscore) are considered part of the prefix.

data/lib/contentfs.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "contentfs/database"

data/lib/contentfs/content.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "yaml"
+
+require_relative "renderers"
+require_relative "prefix"
+require_relative "slug"
+
+module ContentFS
+  # Structured content, loaded from the filesystem and usually exposed through a database.
+  #
+  class Content
+    class << self
+      def load(path, metadata: {})
+        new(path: path, metadata: metadata)
+      end
+    end
+
+    FRONT_MATTER_REGEXP = /\A---\s*\n(.*?\n?)^---\s*$\n?/m
+
+    attr_reader :format, :prefix, :slug, :metadata
+
+    def initialize(path:, metadata: {})
+      path = Pathname.new(path)
+      extname = path.extname
+      name = path.basename(extname)
+      prefix, remainder = Prefix.build(name)
+      @prefix = prefix
+      @format = extname.to_s[1..-1]&.to_sym
+      @slug = Slug.build(remainder)
+      @content = path.read
+      @metadata = metadata.merge(parse_metadata(@content))
+    end
+
+    def to_s
+      @content
+    end
+
+    def render
+      if @format && (renderer = Renderers.resolve(@format))
+        renderer.render(@content)
+      else
+        to_s
+      end
+    end
+
+    private def parse_metadata(content)
+      if (match = content.match(FRONT_MATTER_REGEXP))
+        YAML.safe_load(match.captures[0]).to_h
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/contentfs/database.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require_relative "content"
+require_relative "prefix"
+require_relative "slug"
+
+module ContentFS
+  # Structured content database, loaded from the filesystem.
+  #
+  class Database
+    class << self
+      def load(path)
+        new(path: path)
+      end
+    end
+
+    METADATA_FILE = "_metadata.yml"
+
+    attr_reader :prefix, :slug
+
+    def initialize(path:)
+      path = Pathname.new(path)
+      name = path.basename(path.extname)
+      prefix, remainder = Prefix.build(name)
+      @prefix = prefix
+      @slug = Slug.build(remainder)
+      @children = {}
+      @nested = {}
+
+      metadata_path = path.join(METADATA_FILE)
+
+      metadata = if metadata_path.exist?
+        YAML.safe_load(metadata_path.read).to_h
+      else
+        {}
+      end
+
+      Pathname.new(path).glob("*") do |path|
+        next if path.basename.to_s.start_with?("_")
+
+        if path.directory?
+          database = Database.load(path)
+          @nested[database.slug] = database
+        else
+          content = Content.load(path, metadata: metadata)
+
+          if content.slug == :content
+            @content = content
+          else
+            @children[content.slug] = content
+          end
+        end
+      end
+    end
+
+    def all
+      return to_enum(:all) unless block_given?
+
+      @children.each_value do |value|
+        yield value
+      end
+    end
+
+    def filter(**filters)
+      return to_enum(:filter, **filters) unless block_given?
+
+      filters = filters.each_with_object({}) { |(key, value), hash|
+        hash[key.to_s] = value
+      }
+
+      @children.each_value.select { |content|
+        yield content if content.metadata.all? { |key, value|
+          filters[key] == value
+        }
+      }
+    end
+
+    def to_s
+      @content&.to_s.to_s
+    end
+
+    def render
+      @content&.render
+    end
+
+    def method_missing(name, *nested, **)
+      if @children.key?(name)
+        @children[name]
+      elsif @nested.key?(name)
+        nested.inject(@nested[name]) { |database, next_nested|
+          database.public_send(next_nested.to_sym)
+        }
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, *)
+      @children.key?(name) || super
+    end
+  end
+end

data/lib/contentfs/prefix.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ContentFS
+  # @api private
+  class Prefix
+    class << self
+      def build(value)
+        parts = value.to_s.split("__", 2)
+
+        case parts.length
+        when 2
+          parts
+        when 1
+          [nil, parts[0]]
+        end
+      end
+    end
+  end
+end

data/lib/contentfs/renderers.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ContentFS
+  module Renderers
+    class << self
+      def resolve(format)
+        renderers[format.to_sym].to_a.each do |renderer|
+          if (resolved = try(renderer))
+            return resolved
+          end
+        end
+
+        nil
+      end
+
+      def register(name, format:, constant:, path:)
+        (renderers[format.to_sym] ||= []) << {
+          name: name.to_sym,
+          constant: constant.to_s,
+          path: Pathname.new(path)
+        }
+      end
+
+      # @api private
+      private def try(renderer)
+        require(renderer[:path])
+        const_get(renderer[:constant])
+      rescue LoadError
+        # swallow load errors
+      rescue NameError
+        # TODO: maybe print name errors
+      rescue
+        # TODO: maybe print other errors
+      end
+
+      # @api private
+      private def renderers
+        @_renderers ||= {}
+      end
+    end
+  end
+end
+
+ContentFS::Renderers.register(
+  :markdown_code,
+  format: :md,
+  constant: "ContentFS::Renderers::Markdown::Code",
+  path: File.expand_path("../renderers/markdown/code", __FILE__)
+)
+
+ContentFS::Renderers.register(
+  :markdown,
+  format: :md,
+  constant: "ContentFS::Renderers::Markdown",
+  path: File.expand_path("../renderers/markdown", __FILE__)
+)

data/lib/contentfs/renderers/markdown.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "redcarpet"
+
+module ContentFS
+  module Renderers
+    # @api private
+    class Markdown
+      class << self
+        OPTIONS = {
+          autolink: true,
+          footnotes: true,
+          fenced_code_blocks: true,
+          tables: true
+        }.freeze
+
+        def render(content)
+          renderer.render(content)
+        end
+
+        def options
+          OPTIONS
+        end
+
+        private def renderer
+          @_renderer ||= Redcarpet::Markdown.new(Renderer, options)
+        end
+      end
+
+      class Renderer < Redcarpet::Render::HTML
+        def block_quote(quote)
+          if (match = quote.match(/<p>\[(.*)\]/))
+            %(<blockquote class="#{match[1]}">#{quote.gsub("[#{match[1]}]", "")}</blockquote>)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/contentfs/renderers/markdown/code.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rouge"
+require "rouge/plugins/redcarpet"
+
+require_relative "../markdown"
+
+module ContentFS
+  module Renderers
+    class Markdown
+      # @api private
+      class Code
+        class << self
+          def render(content)
+            renderer.render(content)
+          end
+
+          private def renderer
+            @_renderer ||= Redcarpet::Markdown.new(Renderer, Markdown.options)
+          end
+        end
+
+        class Renderer < Markdown::Renderer
+          include Rouge::Plugins::Redcarpet
+        end
+      end
+    end
+  end
+end

data/lib/contentfs/slug.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module ContentFS
+  # @api private
+  class Slug
+    class << self
+      SPECIAL_CHARACTER_REGEXP = /[^a-zA-Z0-9\-_]*/
+
+      def build(value)
+        value.to_s.gsub(SPECIAL_CHARACTER_REGEXP, "").to_sym
+      end
+    end
+  end
+end

data/lib/contentfs/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module ContentFS
+  VERSION = "0.0.0"
+
+  def self.version
+    VERSION
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: contentfs
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Bryan Powell
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-11-12 00:00:00.000000000 Z
+dependencies: []
+description: A structured content file system.
+email: bryan@metabahn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/contentfs.rb
+- lib/contentfs/content.rb
+- lib/contentfs/database.rb
+- lib/contentfs/prefix.rb
+- lib/contentfs/renderers.rb
+- lib/contentfs/renderers/markdown.rb
+- lib/contentfs/renderers/markdown/code.rb
+- lib/contentfs/slug.rb
+- lib/contentfs/version.rb
+homepage: https://github.com/metabahn/contentfs/
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: A structured content file system.
+test_files: []