yarrow 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 395db81bd349ed8e1a6b5cdc67d0fd191f6ede369bd358483611e0b79fb27cec
-  data.tar.gz: '028961b86756cfc6bc1453c6d3ad7789149e8921066fb5429358e1b3b08393eb'
+  metadata.gz: 0c49c3ae295fd127f7533a0af4c543d5315a2929a580a21b6b4c26379e519490
+  data.tar.gz: 6867e3004c89dc7362a83378f3b0d55a14803d513cc77445c7893a31ffb4e4bd
 SHA512:
-  metadata.gz: f531ff89949b7d1b80e215529f2c6c29d812f958e9af4491d58b7a0f10f9419a9ee26385ac58891cc435053fff31123d2dcfed0e02c8dcd48927d0b47c312f9f
-  data.tar.gz: 8a5bb918411a04ac7d5e8b3c649501346e94d3cc76c17097ec9eed436685b163a04294b40491b38f0ea8539a28722bc8e77043bdab81aec493e04d5ccc0b6e0e
+  metadata.gz: '0056694b64f9ac4d000e85341570b4a5b630f27b5de15d5dcf12eeae1dc3625368abfd1d65a6c0a26f9793cbd6993e076c7e46d76ef97007874e8dddfd75c7af'
+  data.tar.gz: fa5469997f6e674f3f2b1daf8bbc525637b2cbb2db7b9a8a1d494c85b1ce4d2725753ece2a2d114a905b994fe96f99e9db09178fa6f92483d4ee5d6208a500ad

data/.gitignore

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

data/lib/yarrow/config.rb

@@ -52,11 +52,11 @@ module Yarrow
     #
     # TODO: meta should be union of Type::Optional and Config::Meta
     Instance = Yarrow::Schema::Value.new(
-      project_dir: Pathname,
-      content_dir: 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/content/expansion.rb

@@ -1,49 +1,14 @@
 module Yarrow
   module Content
     class Expansion
-      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
+      def initialize(model)
+        @model = model
       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)]
+      def expand(graph)
+        @model.each_policy do |policy|
+          strategy = TreeExpansion.new(graph)
+          strategy.expand(policy)
         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

@@ -7,7 +7,7 @@ module Yarrow
       #
       # @return [Yarrow::Content::Graph]
       def self.from_source(config)
-        new(SourceCollector.collect(config.content_dir), config)
+        new(Source.collect(config.content_dir), config)
       end
 
       attr_reader :graph, :config
@@ -18,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
 

data/lib/yarrow/content/manifest.rb

@@ -22,11 +22,11 @@ module Yarrow
         manifest
       end
 
-      attr_reader :documents, :resources
+      attr_reader :documents, :assets
 
       def initialize
         @documents = []
-        @resources = []
+        @assets = []
       end
 
       def self.collection_context(collection)
@@ -53,8 +53,8 @@ module Yarrow
         @documents << document
       end
 
-      def add_resource(resource)
-        @resources << resource
+      def add_asset(asset)
+        @assets << asset
       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

@@ -1,14 +1,23 @@
 module Yarrow
   module Content
-    class TreeExpansion < Expansion
-      def expand(content_type)
-        type = content_type.collection
-        exts = content_type.extensions
+    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 content_type.match_path == "."
+        #start_node = if policy.match_path == "."
+        start_node = if true
           graph.n(:root)
         else
           graph.n(:root).out(name: type.to_s)
@@ -52,7 +61,7 @@ module Yarrow
             # 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] = content_type.entity
+              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

data/lib/yarrow/generator.rb

@@ -13,7 +13,7 @@ module Yarrow
     provides Content::Graph
 
     def step(content)
-      expander = Content::CollectionExpander.new
+      expander = Content::Expansion.new(Yarrow::Content::Model.new)
       expander.expand(content.graph)
       content
     end

data/lib/yarrow/schema/definitions.rb

@@ -0,0 +1,30 @@
+module Yarrow
+  module Schema
+    module Definitions
+      DEFINED_TYPES = {
+        string: Type::Raw[String],
+        integer: Type::Raw[Integer],
+        path: Type::Raw[Pathname],
+        any: Type::Any
+      }
+
+      def self.register(identifier, type_class)
+        if DEFINED_TYPES.key?(identifier)
+          raise "#{identifier} is already defined"
+        end
+
+        DEFINED_TYPES[identifier] = type_class
+      end
+
+      def resolve_type(identifier)
+        #return identifier unless identifier.is_a?(Symbol)
+
+        unless DEFINED_TYPES.key?(identifier)
+          raise "#{identifier} is not defined"
+        end
+
+        return DEFINED_TYPES[identifier]
+      end
+    end
+  end
+end

data/lib/yarrow/schema/dictionary.rb

@@ -0,0 +1,49 @@
+module Yarrow
+  module Schema
+    # Specifies types plugged into each attribute slot and runs any required
+    # validations and coercions.
+    #
+    # Current design throws on error rather than returns a boolean result.
+    class Dictionary
+      include Definitions
+
+      # @param attrs_spec [Hash] defines the slots in the schema to validate against
+      def initialize(attrs_spec={})
+        @attrs_spec = attrs_spec.reduce({}) do |spec, (name, type_identifier)|
+          spec[name] = resolve_type(type_identifier)
+          spec
+        end
+      end
+
+      def define_attribute(name, type_identifier)
+        @attrs_spec[name] = resolve_type(type_identifier)
+      end
+
+      def attr_names
+        @attrs_spec.keys
+      end
+
+      def check(input)
+        missing_attrs = @attrs_spec.keys.difference(input.keys)
+
+        if missing_attrs.any?
+          missing_attrs.each do |name|
+            raise "wrong number of attributes" unless @attrs_spec[name].eql?(Type::Any)
+          end
+        end
+
+        mismatching_attrs = input.keys.difference(@attrs_spec.keys)
+
+        raise "attribute does not exist" if mismatching_attrs.any?
+
+        input.each do |(name, value)|
+          unless value.is_a?(@attrs_spec[name]) || @attrs_spec[name].eql?(Type::Any)
+            raise "wrong data type"
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/yarrow/schema/entity.rb

@@ -0,0 +1,51 @@
+module Yarrow
+  module Schema
+    # 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)
+          dictionary.define_attribute(name, value_type)
+          attr_reader(name)
+        end
+
+        def dictionary
+          @dictionary ||= Dictionary.new({})
+        end
+      end
+
+      def initialize(config)
+        dictionary.check(config)
+        # dictionary.each_key do |name|
+        #   raise "missing declared attribute #{name}" unless config.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
+
+      def to_h
+        dictionary.attr_names.reduce({}) do |attr_dict, name|
+          attr_dict[name] = instance_variable_get("@#{name}")
+          attr_dict
+        end
+      end
+
+      private
+
+      def dictionary
+        self.class.dictionary
+      end
+    end
+  end
+end

data/lib/yarrow/schema/types.rb

@@ -0,0 +1,73 @@
+module Yarrow
+  module Schema
+    module Types
+      class CastError < TypeError
+        def self.instance_of(t, u)
+          new("#{t} is not an instance of #{u}")
+        end
+
+        def self.kind_of(t, u)
+          new("#{t} is not a subclass of #{u}")
+        end
+      end
+  
+      class TypeClass
+        attr_reader :unit
+  
+        def initialize(unit=nil)
+          @unit = unit
+        end
+  
+        def check_instance_of!(input)
+          unless input.instance_of?(unit)
+            raise CastError.instance_of(input.class, unit)
+          end
+        end
+
+        def check_kind_of!(input)
+          unless input.kind_of?(unit)
+            raise CastError.kind_of(input.class, unit)
+          end
+        end
+
+        def check_respond_to!(input)
+
+        end
+
+        def cast(input); end
+      end
+  
+      class Any < TypeClass
+        def cast(input)
+          input
+        end
+      end
+  
+      class Instance < TypeClass
+        def cast(input)
+          check_instance_of!(input)
+          input
+        end
+      end
+  
+      class Kind
+        def cast(input)
+          check_kind_of!(input)
+          input
+        end
+      end
+  
+      class Interface
+  
+      end
+  
+      class Optional
+  
+      end
+  
+      class Constrained
+  
+      end
+    end
+  end
+end