yarrow 0.5.0 → 0.6.3

data/lib/yarrow/content/content_type.rb

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

data/lib/yarrow/content/graph.rb

@@ -1,22 +1,22 @@
-require "mementus"
-
-module Mementus
-  module Pipeline
-    class Step
-      # Monkeypatch extension to ensure each pipeline step supports enumerable
-      # methods. Mostly used for #map. API needs to be fixed in the gem itself.
-      include Enumerable
-    end
-  end
-end
-
 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.
       def self.from_source(config)
-        new(SourceCollector.collect(config.input_dir))
+        new(SourceCollector.collect(config.source), config)
+      end
+
+      attr_reader :graph, :config
+
+      def initialize(graph, config)
+        @graph = graph
+        @config = config
+      end
+
+      def expand_pages
+        expander = Yarrow::Content::CollectionExpander.new
+        expander.expand(graph)
       end
 
       # List of source files.
@@ -28,14 +28,6 @@ module Yarrow
       def directories
         graph.nodes(:directory)
       end
-
-      private
-
-      def initialize(graph)
-        @graph = graph
-      end
-
-      attr_reader :graph
     end
   end
 end

data/lib/yarrow/content/source.rb

@@ -0,0 +1,11 @@
+module Yarrow
+  module Content
+    class Source
+      attr_reader :input_dir
+
+      def initialize(config)
+        @input_dir = config[:input_dir]
+      end
+    end
+  end
+end

data/lib/yarrow/extensions.rb

@@ -0,0 +1 @@
+require "yarrow/extensions/mementus"

data/lib/yarrow/extensions/mementus.rb

@@ -0,0 +1,24 @@
+require "mementus"
+
+module Mementus
+  module Pipeline
+    class Step
+      # Monkeypatch extension to ensure each pipeline step supports enumerable
+      # methods. Mostly used for #map. API needs to be fixed in the gem itself.
+      include Enumerable
+    end
+  end
+  module Structure
+    class IncidenceList
+      def inspect
+        "<Mementus::Structure::IncidenceList>"
+      end
+    end
+  end
+  class Graph
+    def inspect
+      "<Mementus::Graph @structure=#{@structure.inspect} " +
+        "nodes_count=#{nodes_count} edges_count=#{edges_count}>"
+    end
+  end
+end

data/lib/yarrow/output/context.rb

@@ -4,11 +4,7 @@ module Yarrow
     #
     # Methods provided by this class become available as named variables in
     # Mustache templates.
-    #
-    # Includes the library of helpers for dynamically generating HTML tags.
     class Context
-      include Yarrow::HTML::AssetTags
-
       def initialize(attributes)
         metaclass = class << self; self; end
         attributes.each do |name, value|

data/lib/yarrow/output/generator.rb

@@ -8,12 +8,12 @@ module Yarrow
 
       # Mapping between template types and provided object model
       def object_map
-        @config.output.object_map
+        @config[:output][:object_map]
       end
 
       # Mapping between template types and provided output templates.
       def template_map
-        
+
       end
 
       # Template converter used by this generator instance.

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

@@ -0,0 +1,39 @@
+module Yarrow
+  module Output
+    module Web
+      class IndexedFile
+        WRITE_MODE = 'w+:UTF-8'.freeze
+
+        # @return [String] Basename reflecting the server convention (usually: index.html)
+        def index_name
+          @index_name ||= config.index_name || 'index.html'
+        end
+
+        # @return [String] Docroot of the output target
+        def docroot
+          @docroot ||= config.output_dir || 'public'
+        end
+
+        # Write an output file to the specified path under the docroot.
+        #
+        # @param path [String]
+        # @param content [String]
+        def write(path, content)
+          # If the target path is a directory,
+          # generate a default index filename.
+          if path[path.length-1] == '/'
+            path = "#{path}#{index_name}"
+          end
+
+          target_path = Pathname.new("#{docroot}#{path}")
+
+          FileUtils.mkdir_p(target_path.dirname)
+
+          File.open(target_path.to_s, WRITE_MODE) do |file|
+            file.puts(content)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yarrow/process/expand_content.rb

@@ -0,0 +1,12 @@
+module Yarrow
+  module Process
+    class ExpandContent < StepProcessor
+      accepts String
+      provides String
+
+      def step(source)
+        "#{source} | ExpandContent::Result"
+      end
+    end
+  end
+end

data/lib/yarrow/process/extract_source.rb

@@ -0,0 +1,12 @@
+module Yarrow
+  module Process
+    class ExtractSource < StepProcessor
+      accepts String
+      provides String
+
+      def step(source)
+        "#{source} | ExtractSource::Result"
+      end
+    end
+  end
+end

data/lib/yarrow/process/project_manifest.rb

@@ -0,0 +1,20 @@
+module Yarrow
+  module Process
+    class ProjectManifest < StepProcessor
+      accepts String
+      provides String
+
+      def before_step(content)
+
+      end
+
+      def step(content)
+        "#{content} | ProjectManifest::Result"
+      end
+
+      def after_step(content)
+
+      end
+    end
+  end
+end

data/lib/yarrow/process/step_processor.rb

@@ -0,0 +1,43 @@
+module Yarrow
+  module Process
+    class StepProcessor
+      attr_reader :source
+
+      class << self
+        attr_reader :accepted_input, :provided_output
+
+        def accepts(input_const)
+          @accepted_input = input_const.to_s
+        end
+
+        def provides(output_const)
+          @provided_output = output_const.to_s
+        end
+      end
+
+      def initialize
+        @source = nil
+      end
+
+      def accepts
+        self.class.accepted_input
+      end
+
+      def provides
+        self.class.provided_output
+      end
+
+      def can_accept?(provided)
+        accepts == provided
+      end
+
+      def process(source)
+        # begin
+        result = step(source)
+        # log.info("<Result source=#{result}>")
+        # rescue
+        result
+      end
+    end
+  end
+end

data/lib/yarrow/process/workflow.rb

@@ -0,0 +1,36 @@
+module Yarrow
+  module Process
+    class Workflow
+      def initialize(input)
+        @input = input
+        @processors = []
+      end
+
+      def connect(processor)
+        provided_input = if @processors.any?
+          @processors.last.provides
+        else
+          @input.class.to_s
+        end
+
+        if processor.can_accept?(provided_input)
+          @processors << processor
+        else
+          raise ArgumentError.new(
+            "`#{processor.class}` accepts `#{processor.accepts}` but was connected to `#{provided_input}`"
+          )
+        end
+      end
+
+      def process(&block)
+        result = @input
+
+        @processors.each do |processor|
+          result = processor.process(result)
+        end
+
+        block.call(result)
+      end
+    end
+  end
+end

data/lib/yarrow/schema.rb

@@ -0,0 +1,132 @@
+module Yarrow
+  module Schema
+    module Type
+      class Any
+      end
+    end
+
+    ##
+    # Checks values plugged into each slot and runs any required validations
+    # (validations not yet implemented).
+    #
+    # Current design throws on error rather than returns a boolean result.
+    class Validator
+      # @param fields_spec [Hash] defines the slots in the schema to validate against
+      def initialize(fields_spec)
+        @spec = fields_spec
+      end
+
+      def check(fields)
+        missing_fields = @spec.keys.difference(fields.keys)
+
+        if missing_fields.any?
+          missing_fields.each do |field|
+            raise "wrong number of args" unless @spec[field].eql?(Type::Any)
+          end
+        end
+
+        mismatching_fields = fields.keys.difference(@spec.keys)
+
+        raise "key does not exist" if mismatching_fields.any?
+
+        fields.each do |(field, value)|
+          raise "wrong data type" unless value.is_a?(@spec[field]) || @spec[field].eql?(Type::Any)
+        end
+
+        true
+      end
+    end
+
+    ##
+    # Value object (with comparison by value equality). This just chucks back a
+    # Ruby struct but wraps the constructor with method advice that handles
+    # validation (and eventually type coercion if !yagni).
+    class Value
+      def self.new(*slots, **fields, &block)
+        factory(*slots, **fields, &block)
+      end
+
+      def self.factory(*slots, **fields, &block)
+        if slots.empty? && fields.empty?
+          raise ArgumentError.new("missing attribute definition")
+        end
+
+        slots_spec, fields_spec = if fields.any?
+          raise ArgumentError.new("cannot use slots when field map is supplied") if slots.any?
+          [fields.keys, fields]
+        else
+          [slots, Hash[slots.map { |s| [s, Type::Any]}]]
+        end
+
+        validator = Validator.new(fields_spec)
+
+        struct = Struct.new(*slots_spec, keyword_init: true, &block)
+
+        struct.define_method :initialize do |*args, **kwargs|
+          attr_values = if args.any?
+            raise ArgumentError.new("cannot mix slots and kwargs") if kwargs.any?
+            Hash[slots.zip(args)]
+          else
+            kwargs
+          end
+
+          validator.check(attr_values)
+          # TODO: type coercion or mapping decision goes here
+          super(**attr_values)
+
+          freeze
+        end
+
+        struct
+      end
+    end
+
+    ##
+    # Entity with comparison by reference equality. Generates attribute helpers
+    # for a declared set of props. Used to replace Hashie::Mash without dragging
+    # in a whole new library.
+    class Entity
+      class << self
+        def attribute(name, value_type)
+          # define_method("map_#{name}".to_sym) do |input|
+          #   value_type.coerce(input)
+          # end
+          dictionary[name] = value_type
+          attr_reader(name)
+        end
+
+        def dictionary
+          @dictionary ||= Hash.new
+        end
+      end
+
+      def dictionary
+        self.class.dictionary
+      end
+
+      def initialize(config)
+        dictionary.each_key do |name|
+          raise "missing declared attribute #{name}" unless dictionary.key?(name)
+        end
+
+        config.each_pair do |key, value|
+          raise "#{key} not a declared attribute" unless dictionary.key?(key)
+
+          defined_type = dictionary[key]
+
+          unless value.is_a?(defined_type)
+            raise "#{key} accepts #{defined_type} but #{value.class} given"
+          end
+
+          instance_variable_set("@#{key}", value)
+        end
+      end
+    end
+
+    def to_h
+      dictionary.keys.reduce({}) do |h, name|
+        h[name] = instance_variable_get("@#{name}")
+      end
+    end
+  end
+end