yarrow 0.7.1 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95557525739422605b678c010cad87b67b3e01e1382a9a7b65b032cd7ccfdceb
-  data.tar.gz: 90bd1dfc26fc41c8aee75586f760b05d0b122fe1868cb061b29a7344a0627165
+  metadata.gz: 0c49c3ae295fd127f7533a0af4c543d5315a2929a580a21b6b4c26379e519490
+  data.tar.gz: 6867e3004c89dc7362a83378f3b0d55a14803d513cc77445c7893a31ffb4e4bd
 SHA512:
-  metadata.gz: cb128a24a28ad30bef33b1db635e952a3c4930d75094ce5434fe3cbeb890644fb1704a4d619144a915b0e71cc41c333d8ce3186fb2b8d5e3eee334bb68aa8b9d
-  data.tar.gz: ee6767873b4afa6270b7a8e21dc096eac492624d47063e7d742d81cdc3e5b2608595f8ce945f299e036cb19245b980df56322a768d225731f16275088bd54dd3
+  metadata.gz: '0056694b64f9ac4d000e85341570b4a5b630f27b5de15d5dcf12eeae1dc3625368abfd1d65a6c0a26f9793cbd6993e076c7e46d76ef97007874e8dddfd75c7af'
+  data.tar.gz: fa5469997f6e674f3f2b1daf8bbc525637b2cbb2db7b9a8a1d494c85b1ce4d2725753ece2a2d114a905b994fe96f99e9db09178fa6f92483d4ee5d6208a500ad

data/.github/workflows/ruby.yml

@@ -10,7 +10,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest]
-        ruby: [2.7, '3.0', jruby-head]
+        ruby: [2.7, '3.0', 3.1, head]
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v2

data/.gitignore

@@ -6,3 +6,4 @@ Gemfile.lock
 yarrow-*.gem
 coverage
 bin/scripts
+.DS_Store

data/lib/yarrow/config.rb

@@ -42,19 +42,21 @@ module Yarrow
       :root_dir
     )
 
-    # Top level root config namespace. Source, content and output are directory
-    # paths and should be the only required defaults for a complete batch run.
+    # Top level root config namespace.
+    #
+    # `content_dir` and `output_dir` are placeholders and should be overriden
+    # with more fine-grained config for web and book outputs in future.
     #
     # Additional server config is optional and only needed if running the dev
     # server locally.
     #
     # TODO: meta should be union of Type::Optional and Config::Meta
     Instance = Yarrow::Schema::Value.new(
-      source: Pathname,
-      content: Pathname,
-      output_dir: Pathname,
-      meta: Yarrow::Schema::Type::Any,
-      server: Yarrow::Schema::Type::Any
+      project_dir: :path,
+      content_dir: :path,
+      output_dir: :path,
+      meta: :any,
+      server: :any
     )
   end
 end

data/lib/yarrow/configuration.rb

@@ -52,13 +52,13 @@ module Yarrow
         # automated as part of the schema types or a default value should be
         # generated here (eg: `"#{Dir.pwd}/docs"`)
         out_dir_or_string = config[:output_dir] || ""
-        source_dir_or_string = config[:source] || ""
-        content_dir_or_string = config[:content] || ""
+        source_dir_or_string = config[:project_dir] || ""
+        content_dir_or_string = config[:content_dir] || ""
 
         Yarrow::Config::Instance.new(
           output_dir: Pathname.new(File.expand_path(out_dir_or_string)),
-          source: Pathname.new(File.expand_path(source_dir_or_string)),
-          content: Pathname.new(File.expand_path(content_dir_or_string)),
+          project_dir: Pathname.new(File.expand_path(source_dir_or_string)),
+          content_dir: Pathname.new(File.expand_path(content_dir_or_string)),
           meta: meta_obj,
           server: server_obj
         )

data/lib/yarrow/console_runner.rb

@@ -1,5 +1,4 @@
 module Yarrow
-
   class ConsoleRunner
 
     SUCCESS = 0
@@ -100,7 +99,6 @@ module Yarrow
     end
 
     def normalize_theme_path
-
       # noop
     end
 
@@ -139,12 +137,11 @@ module Yarrow
       @options.has_key? option
     end
 
-    def run_input_process
-      # noop
-    end
-
-    def run_output_process
-      # noop
+    def run_generation_process
+      generator = Generator.new(@config)
+      generator.process do |manifest|
+        p manifest
+      end
     end
 
     def print_header

data/lib/yarrow/content/expansion.rb

@@ -0,0 +1,16 @@
+module Yarrow
+  module Content
+    class Expansion
+      def initialize(model)
+        @model = model
+      end
+
+      def expand(graph)
+        @model.each_policy do |policy|
+          strategy = TreeExpansion.new(graph)
+          strategy.expand(policy)
+        end
+      end
+    end
+  end
+end

data/lib/yarrow/content/expansion_strategy.rb

@@ -0,0 +1,51 @@
+module Yarrow
+  module Content
+    class ExpansionStrategy
+      include Yarrow::Tools::FrontMatter
+
+      attr_reader :graph
+
+      def initialize(graph)
+        @graph = graph
+      end
+
+      # Extract collection level configuration/metadata from the root node for
+      # this content type.
+      def extract_metadata(node, type)
+        # TODO: support _index or _slug convention as well
+        meta_file = node.out(slug: type.to_s).first
+
+        if meta_file
+          # Process metadata and add it to the collection node
+          # TODO: pass in content converter object
+          # TODO: index/body content by default if extracted from frontmatter
+          body, data = process_content(meta_file.props[:entry])
+        else
+          # Otherwise, assume default collection behaviour
+          data = {}
+        end
+
+        # Generate a default title if not provided in metadata
+        unless data.key?(:title)
+          data[:title] = type.to_s.capitalize
+        end
+
+        data
+      end
+
+      # Workaround for handling meta and content source in multiple files or a single
+      # file with front matter.
+      def process_content(path)
+        case path.extname
+        when '.htm', '.md'
+          read_split_content(path.to_s, symbolize_keys: true)
+        # when '.md'
+        #   body, data = read_split_content(path.to_s, symbolize_keys: true)
+        #   [Kramdown::Document.new(body).to_html, data]
+        when '.yml'
+          [nil, YAML.load(File.read(path.to_s), symbolize_names: true)]
+        end
+      end
+    end
+  end
+end

data/lib/yarrow/content/graph.rb

@@ -2,9 +2,12 @@ module Yarrow
   module Content
     # A directed graph of every element of content in the project.
     class Graph
-      # Construct a graph collected from source content files.
+      # Construct a graph collected from files and directories in the configured
+      # content directory.
+      #
+      # @return [Yarrow::Content::Graph]
       def self.from_source(config)
-        new(SourceCollector.collect(config.source), config)
+        new(Source.collect(config.content_dir), config)
       end
 
       attr_reader :graph, :config
@@ -15,7 +18,7 @@ module Yarrow
       end
 
       def expand_pages
-        expander = Yarrow::Content::CollectionExpander.new
+        expander = Yarrow::Content::Expansion.new(Yarrow::Content::Model.new)
         expander.expand(graph)
       end
 
@@ -28,6 +31,16 @@ module Yarrow
       def directories
         graph.nodes(:directory)
       end
+
+      # List of mapped content object collections
+      def collections
+        graph.nodes(:collection)
+      end
+
+      # List of mapped content object items
+      def items
+        graph.nodes(:item)
+      end
     end
   end
 end

data/lib/yarrow/content/manifest.rb

@@ -0,0 +1,61 @@
+module Yarrow
+  module Content
+    class Manifest
+      def self.build(graph)
+        manifest = new
+
+        graph.n(:collection).each do |collection|
+
+          unless collection.props[:content_only]
+            manifest.add_document(collection_context(collection))
+          end
+
+          unless collection.props[:index_only]
+            collection.out(:item).each do |item|
+              #if item[:entity].status.to_sym == :published
+              manifest.add_document(item_context(item))
+              #end
+            end
+          end
+        end
+
+        manifest
+      end
+
+      attr_reader :documents, :assets
+
+      def initialize
+        @documents = []
+        @assets = []
+      end
+
+      def self.collection_context(collection)
+        Yarrow::Output::Context.new(
+          parent: collection.in(:collection).first,
+          name: collection.props[:name],
+          #url: collection.props[:url],
+          title: collection.props[:title],
+          type: collection.props[:type]
+        )
+      end
+
+      def self.item_context(item)
+        Yarrow::Output::Context.new(
+          parent: item.in(:collection).first,
+          name: item.props[:name],
+          #url: item.props[:url],
+          title: item.props[:title],
+          type: item.props[:type]
+        )
+      end
+
+      def add_document(document)
+        @documents << document
+      end
+
+      def add_asset(asset)
+        @assets << asset
+      end
+    end
+  end
+end

data/lib/yarrow/content/model.rb

@@ -0,0 +1,46 @@
+module Yarrow
+  module Content
+    ContentSpec = Yarrow::Schema::Value.new(:namespace, :model) do
+      def to_world
+        "world"
+      end
+    end
+
+    ContentPolicy = Yarrow::Schema::Value.new(
+      :dir,
+      :file,
+      :expansion,
+      :container,
+      :record
+    )
+
+    class Model
+      def initialize(spec=nil, namespace=nil)
+        @namespace = []
+        @namespace << namespace unless namespace.nil?
+
+        @policies = if spec.nil?
+          spec = {
+            root: ContentPolicy.new(
+              expansion: :tree,
+              dir: "*",
+              file: "*.md",
+              :container => :pages,
+              :record => :page
+            )
+          }
+        else
+          spec.model
+        end
+      end
+
+      def each_policy(&block)
+        @policies.each_value(&block)
+      end
+
+      def policy_for(policy_key)
+        @policies[policy_key]
+      end
+    end
+  end
+end

data/lib/yarrow/content/policy.rb

@@ -0,0 +1,48 @@
+module Yarrow
+  module Content
+    class Policy
+      Options = Yarrow::Schema::Value.new(
+        :container,
+        :entity,
+        :extensions,
+        :match_path
+      )
+
+      DEFAULT_EXTENSIONS = [".md", ".yml", ".htm"]
+
+      DEFAULT_MATCH_PATH = "."
+
+      def self.from_name(name)
+        new(Options.new(container: name.to_sym))
+      end
+
+      def initialize(properties)
+        unless properties.respond_to?(:container) || properties.respond_to?(:entity)
+          raise "Must provide a container name or entity name"
+        end
+
+        @properties = properties
+      end
+
+      def container
+        return @properties.container if @properties.container
+        Yarrow::Symbols.to_plural(@properties.entity)
+      end
+
+      def entity
+        return @properties.entity if @properties.entity
+        Yarrow::Symbols.to_singular(@properties.container)
+      end
+
+      def extensions
+        return @properties.extensions if @properties.extensions
+        DEFAULT_EXTENSIONS
+      end
+
+      def match_path
+        return @properties.match_path if @properties.match_path
+        DEFAULT_MATCH_PATH
+      end
+    end
+  end
+end

data/lib/yarrow/content/resource.rb

@@ -0,0 +1,29 @@
+module Yarrow
+  module Content
+    class Resource < Schema::Entity
+      attribute :id, :string
+      attribute :name, :string
+      attribute :title, :string
+      attribute :url, :string
+      attribute :content, :string
+
+      def self.from_frontmatter_url(data, url_field)
+        new({
+          id: data[:id],
+          name: data[:name],
+          title: data[:title],
+          content: data[:content],
+          url: data[url_field]
+        })
+      end
+
+      def self.from_template_url(data, template, &block)
+
+      end
+
+      def self.from_source_path(data, &block)
+
+      end
+    end
+  end
+end

data/lib/yarrow/content/source.rb

@@ -1,10 +1,77 @@
 module Yarrow
   module Content
+    # Collects a digraph of all directories and files underneath the given input
+    # directory.
     class Source
-      attr_reader :input_dir
+      def self.collect(input_dir)
+        Mementus::Graph.new(is_mutable: true) do
+          root = create_node do |root|
+            root.label = :root
+          end
 
-      def initialize(config)
-        @input_dir = config[:input_dir]
+          root_dir_entry = Pathname.new(input_dir)
+
+          root_dir = create_node do |dir|
+            dir.label = :directory
+            dir.props = {
+              name: root_dir_entry.basename.to_s,
+              path: root_dir_entry.to_s,
+              entry: root_dir_entry
+            }
+          end
+
+          create_edge do |child|
+            child.label = :child
+            child.from = root.id
+            child.to = root_dir.id
+          end
+
+          directories = {
+            root_dir_entry.to_s => root_dir.id
+          }
+
+          Pathname.glob("#{input_dir}/**/**").each do |entry|
+            if entry.directory?
+              content_node = create_node do |dir|
+                dir.label = :directory
+                # dir.props[:name] = entry.basename.to_s
+                # dir.props[:slug] = entry.basename.to_s
+                # dir.props[:path] = entry.to_s
+                # dir.props[:entry] = entry
+                dir.props = {
+                  name: entry.basename.to_s,
+                  path: entry.to_s,
+                  entry: entry
+                }
+              end
+
+              directories[entry.to_s] = content_node.id
+            else
+              content_node = create_node do |file|
+                file.label = :file
+                # file.props[:name] = entry.basename.to_s
+                # file.props[:slug] = entry.basename.sub_ext('').to_s
+                # file.props[:path] = entry.to_s
+                # file.props[:entry] = entry
+
+                file.props = {
+                  name: entry.basename.to_s,
+                  ext: entry.extname.to_s,
+                  path: entry.to_s,
+                  entry: entry
+                }
+              end
+            end
+
+            if directories.key?(entry.dirname.to_s)
+              create_edge do |edge|
+                edge.label = :child
+                edge.from = directories[entry.dirname.to_s]
+                edge.to = content_node
+              end
+            end
+          end
+        end
       end
     end
   end

data/lib/yarrow/content/tree_expansion.rb

@@ -0,0 +1,92 @@
+module Yarrow
+  module Content
+    class TreeExpansion < ExpansionStrategy
+      def expand(policy)
+        #p graph.n(:root).out(:directory).to_a.count
+        #policy.match()
+
+        #p graph.n(:root).out(:directory).first.props[:name]
+
+        expand_impl(policy)
+      end
+
+      def expand_impl(policy)
+        type = policy.container
+
+        # If match path represents entire content dir, then include the entire
+        # content dir instead of scanning from a subfolder matching the name of
+        # the collection.
+        #start_node = if policy.match_path == "."
+        start_node = if true
+          graph.n(:root)
+        else
+          graph.n(:root).out(name: type.to_s)
+        end
+
+        # Extract metadata from given start node
+        collection_metadata = extract_metadata(start_node, type)
+
+        # Collect all nested collections in the subgraph for this content type
+        subcollections = {}
+        item_links = []
+        index = nil
+
+        # Scan and collect all nested files from the root
+        start_node.depth_first.each do |node|
+          if node.label == :directory
+            # Create a collection node representing a collection of documents
+            index = graph.create_node do |collection_node|
+              collection_node.label = :collection
+              collection_node.props[:type] = type
+              collection_node.props[:name] = node.props[:name]
+
+              # TODO: title needs to be defined from metadata
+              collection_node.props[:title] = node.props[:name].capitalize
+            end
+
+            # Add this collection id to the lookup table for edge construction
+            subcollections[node.props[:path]] = index
+
+            # Join the collection to its parent
+            unless node.props[:slug] == type.to_s || !subcollections.key?(node.props[:entry].parent.to_s)
+              graph.create_edge do |edge|
+                edge.label = :child
+                edge.from = subcollections[node.props[:entry].parent.to_s].id
+                edge.to = index.id
+              end
+            end
+          elsif node.label == :file
+            body, meta = process_content(node.props[:entry])
+
+            # Create an item node representing a file mapped to a unique content object
+            item = graph.create_node do |item_node|
+              item_node.label = :item
+              item_node.props[:type] = policy.record
+              item_node.props[:name] = node.props[:entry].basename(node.props[:entry].extname).to_s
+              item_node.props[:body] = body if body
+              item_node.props[:title] = meta[:title] if meta
+              # TODO: better handling of metadata on node props
+            end
+
+            # We may not have an expanded node for the parent collection if this is a
+            # preorder traversal so save it for later
+            item_links << {
+              parent_path: node.props[:entry].parent.to_s,
+              item_id: item.id
+            }
+          end
+        end
+
+        # Once all files and directories have been expanded, connect all the child
+        # edges between collections and items
+        item_links.each do |item_link|
+          graph.create_edge do |edge|
+            edge.label = :child
+            edge.from = subcollections[item_link[:parent_path]].id
+            edge.to = item_link[:item_id]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yarrow/generator.rb

@@ -1,27 +1,57 @@
 module Yarrow
+  class ScanSource < Process::StepProcessor
+    accepts Config::Instance
+    provides Content::Graph
+
+    def step(config)
+      Yarrow::Content::Graph.from_source(config)
+    end
+  end
+
+  class ExpandCollections < Process::StepProcessor
+    accepts Content::Graph
+    provides Content::Graph
+
+    def step(content)
+      expander = Content::Expansion.new(Yarrow::Content::Model.new)
+      expander.expand(content.graph)
+      content
+    end
+  end
+
+  class FlattenManifest < Process::StepProcessor
+    accepts Content::Graph
+    provides Content::Manifest
+
+    def step(content)
+      Content::Manifest.build(content.graph)
+    end
+  end
+
+  class BuildOutput < Process::StepProcessor
+    accepts Content::Manifest
+    provides Output::Result
+  end
 
   # Generates documentation from a model.
-  #
-  # Subclasses of Generator need to override the template methods,
-  # to specify a particular file structure to output.
   class Generator
-  
-    def initialize(target, site_tree)
-      ensure_dir_exists! target
-      @target = target
-      @site_tree = site_tree
+    def initialize(config)
+      @config = config
+      @workflow = Process::Workflow.new(config)
     end
-  
-    def ensure_dir_exists!(target)
-      unless File.directory? target
-        Dir.mkdir target
+
+    def process(&block)
+      workflow.connect(ScanSource.new)
+      workflow.connect(ExpandCollections.new)
+      workflow.connect(FlattenManifest.new)
+
+      workflow.process do |result|
+        block.call(result)
       end
     end
-    
-    def build_docs
-      
-    end
-  
-  end
 
-end
+    private
+
+    attr_reader :config, :workflow
+  end
+end

data/lib/yarrow/output/result.rb

@@ -0,0 +1,13 @@
+module Yarrow
+  module Output
+    class Log
+      
+    end
+
+    class Result
+      def initialize
+
+      end
+    end
+  end
+end

data/lib/yarrow/output/web/indexed_file.rb

@@ -27,12 +27,18 @@ module Yarrow
 
           target_path = Pathname.new("#{docroot}#{path}")
 
-          FileUtils.mkdir_p(target_path.dirname)
+          ensure_dir_exists!(target_path.dirname)
 
           File.open(target_path.to_s, WRITE_MODE) do |file|
             file.puts(content)
           end
         end
+
+        def ensure_dir_exists!(target)
+          unless File.directory?(target)
+            FileUtils.mkdir_p(target)
+          end
+        end
       end
     end
   end