ro 1.4.6 → 4.4.0

data/lib/ro/node.rb

@@ -1,478 +1,338 @@
 module Ro
   class Node
-    fattr :root
-    fattr :path
-    fattr :type
-    fattr :loaded
-    fattr :fields
+    include Klass
+
+    attr_reader :path, :root
 
     def initialize(path)
-      @path = Ro.realpath(path.to_s)
-      @id   = File.basename(@path)
-      @slug = Slug.for(@id)
-      @type = File.basename(File.dirname(@path))
-      @root = Ro::Root.new(File.dirname(File.dirname(@path)))
-      @loaded = false
-      @loading = false
-      @attributes = Map.new
-      @fields = Map.new
+      @path = Path.for(path)
+      @root = Root.for(@path.parent.parent)
+      @attributes = :lazyload
     end
 
-    def id
-      @id
+    def name
+      @path.name
     end
 
-    def _id
-      @id
+    def id
+      name
     end
 
     def type
-      attributes[:type] || @type
+      @path.parent.name
     end
 
-    def _type
-      @type
-    end
-
-    def path
-      attributes[:path] || @path
+    def identifier
+      File.join(type, id)
     end
 
-    def _path
-      @path
+    def inspect
+      identifier
     end
 
-    def slug
-      attributes[:slug] || @slug
+    def collection
+      @root.collection_for(type)
     end
 
-    def _slug
-      @slug
+    def attributes
+      load_attributes
+      @attributes
     end
 
-    def identifier
-      "#{ _type }/#{ _id }"
+    def load_attributes
+      load_attributes! if @attributes == :lazyload
     end
 
-    def hash
-      identifier.hash
-    end
+    def load_attributes!
+      @attributes = Map.new
 
-    def ==(other)
-      attributes == other.attributes
-    end
+      _load_base_attributes
+      _load_file_attributes
+      _load_asset_attributes
+      _load_meta_attributes
 
-    def inspect
-      identifier
+      @attributes
     end
 
-    def to_s
-      inspect
-    end
+    def _load_base_attributes
+      glob = "attributes.{yml,yaml,json}"
 
-    def basename
-      name
+      @path.glob(glob) do |file|
+        attrs = _render(file)
+        update_attributes!(attrs, file:)
+      end
     end
 
-    def node
-      self
-    end
+    def _load_asset_attributes
+      {}.tap do |hash|
+        assets.each do |asset|
+          key = asset.name
+          url = asset.url
+          path = asset.path.relative_to(@root)
+          src = asset.src
+          img = asset.img
+          size = asset.size
 
-    def get(*args)
-      attributes.get(*args)
-    end
-
-    def [](*args)
-      attributes.get(*args)
-    end
+          value = { url:, path:, size:, img:, src: }
 
-    def asset_path(*args, &block)
-      File.join(relative_path, 'assets')
-    end
+          hash[key] = value
+        end
 
-    def asset_dir
-      File.join(path, 'assets')
+        @attributes.set(assets: hash)
+      end
     end
 
-    def asset_paths
-      Dir.glob("#{ asset_dir }/**/**").select{|entry| test(?f, entry)}
-    end
+    def _load_meta_attributes
+      {}.tap do |hash|
+        hash.update(
+          identifier:,
+          type:,
+          id:,
+          urls:,
+          created_at:,
+          updated_at:,
+        )
 
-    def assets
-      asset_paths.map do |path|
-        name = path.sub(asset_dir + "/", "")
-        path_info = path.gsub(/^#{ Regexp.escape(Ro.root) }/, '')
-        url = File.join(Ro.route, path_info)
-        Asset.new(name, :path => path, :url => url)
+        @attributes.set(_meta: hash)
       end
     end
 
-    def asset_urls
-      assets.map(&:url)
-    end
+    def _load_file_attributes
+      ignored = _ignored_files
 
-    def asset_for(*args, &block)
-      options = Map.options_for!(args)
+      @path.files.each do |file|
+        next if ignored.include?(file)
 
-      path_info = Ro.relative_path_for(args)
+        rel = file.relative_to(@path)
 
-      path = File.join(@path.to_s, 'assets', path_info)
+        key = rel.parts
+        basename = key.pop
+        base = basename.split('.', 2).first
+        key.push(base)
 
-      glob = path_info.gsub(/[_-]/, '[_-]')
+        value = _render(file)
 
-      globs = 
-        [
-          File.join(@path.to_s, 'assets', "#{ glob }"),
-          File.join(@path.to_s, 'assets', "#{ glob }*"),
-          File.join(@path.to_s, 'assets', "**/#{ glob }*")
-        ]
-
-      candidates = globs.map{|glob| Dir.glob(glob, ::File::FNM_CASEFOLD)}.flatten.compact.uniq
-
-      case candidates.size
-        when 0
-          raise ArgumentError.new("no asset matching #{ globs.inspect }")
-        else
-          path = candidates.first
-          name = path.sub(asset_dir + "/", "")
-          path_info = path.gsub(/^#{ Regexp.escape(Ro.root) }/, '')
-          url = File.join(Ro.route, path_info)
-      end
+        if value.is_a?(HTML)
+          attrs = value.front_matter
+          update_attributes!(attrs, file:)
+        end
 
-      Asset.new(name, :path => path, :url => url)
-    end
+        if @attributes.has?(key)
+          raise Error.new("path=#{ @path.inspect } masks #{ key.inspect } in #{ @attributes.inspect }!")
+        end
 
-    def asset_for?(*args, &block)
-      begin
-        asset_for(*args, &block)
-      rescue
-        nil
+        @attributes.set(key => value)
       end
     end
 
-    class Asset < ::String
-      fattr(:path)
-      fattr(:url)
+    def update_attributes!(attrs = {}, **context)
+      attrs = Map.for(attrs)
 
-      def initialize(name, options = {})
-        super(name)
-      ensure
-        options = Map.for(options)
+      blacklist = %w[
+        assets
+        _meta
+      ]
 
-        Asset.fattrs.each do |attr|
-          if options.has_key?(attr)
-            value = options[attr]
-            send(attr, value)
-          end
+      blacklist.each do |key|
+        if attrs.has_key?(key)
+          Ro.error!("#{ key } is blacklisted!", **context)
         end
       end
 
-      def name
-        self
-      end
-
-      IMAGE_RE = %r/[.](jpg|jpeg|png|gif|tif|tiff)$/i
-
-      def image?
-        !!(self =~ IMAGE_RE)
-      end
+      keys = @attributes.depth_first_keys
 
-      def extension
-        base, ext = basename.split('.', 2)
-        ext
+      attrs.depth_first_keys.each do |key|
+        if keys.include?(key)
+          Ro.error!("#{ attrs.inspect } clobbers #{ @attributes.inspect }!", **context)
+        end
       end
-      alias_method(:ext, :extension)
 
-      def basename
-        File.basename(path.to_s)
-      end
+      @attributes.update(attrs)
     end
 
-    def url_for(*args, &block)
-      options = Map.options_for!(args)
-
-      opts = Map.new
+    def _ignored_files
+      ignored_files =
+        %w[
+          attributes.yml
+          attributes.yaml
+          attributes.json
+          ./assets/**/**
+        ].map do |glob|
+          @path.glob(glob).select(&:file?)
+        end
 
-      opts[:timestamp] = options.delete(:timestamp)
+      ignored_files.flatten
+    end
 
-      args.push(options)
+    def _render(file)
+      node = self
 
-      asset = asset_for(*args, &block)
+      value = Ro.render(file, _render_context)
 
-      if ts = opts.delete(:timestamp)
-        if ts == true
-          opts[:_] = File.stat(asset.path).mtime.utc.to_i
-        else
-          opts[:_] = ts
-        end
+      if value.is_a?(HTML)
+        front_matter = value.front_matter
+        html = Ro.expand_asset_urls(value, node)
+        value = HTML.new(html, front_matter:)
       end
 
-      if opts.empty?
-        asset.url
-      else
-        query_string = Ro.query_string_for(opts)
-        "#{ asset.url }?#{ query_string }"
+      if value.is_a?(Hash)
+        attributes = value
+        value = Ro.expand_asset_values(attributes, node)
       end
+
+      value
     end
 
-    def url_for?(*args, &block)
-      begin
-        url_for(*args, &block)
-      rescue
-        nil
+    def _render_context
+      to_hash.tap do |context|
+        context[:ro] ||= root
+        context[:collection] ||= collection
       end
     end
 
-    def source_for(*args)
-      key = Ro.relative_path_for(:assets, :source, args).split('/')
-      get(key)
+    def fetch(*args)
+      attributes.fetch(*args)
     end
 
-    def route(*args)
-      path_info = Ro.absolute_path_for(Ro.route, relative_path)
-      [Ro.asset_host, path_info].compact.join('/')
+    def get(*args)
+      attributes.get(*args)
     end
 
-    def relative_path
-      re = /^#{ Regexp.escape(Ro.root) }/
-      @path.to_s.gsub(re, '')
+    def [](*args)
+      attributes.get(*args)
     end
 
-    def method_missing(method, *args, &block)
-      super if method.to_s == 'to_ary'
-
-      Ro.log "Ro::Node(#{ identifier })#method_missing(#{ method.inspect }, #{ args.inspect })"
-
-      key = method.to_s
-
-      if @attributes.has_key?(key)
-        return @attributes[key]
-      end
+    def relative_path
+      path.relative_to(root)
+    end
 
-      _load do
-        return(
-          if @attributes.has_key?(key)
-            @attributes[key]
-          else
-            super
-          end
-        )
-      end
+    def asset_dir
+      path.join('assets')
     end
 
-    def attributes
-      _load{ @attributes }
+    def asset_paths
+      asset_dir.select { |entry| entry.file? }.sort
     end
 
-    def attributes=(attributes)
-      @attributes = attributes
+    def assets
+      asset_paths.map { |path| Asset.for(path, node: self) }
     end
-    
-    def instance_eval(*args, &block)
-      _load{ super }
+
+    def asset_urls
+      assets.map(&:url)
     end
 
-    def related(*args, &block)
-      _load{
-        related = @attributes.get(:related) || Map.new
-        nodes = List.new(root)
-        list = root.nodes
-        which = Coerce.list_of_strings(args) 
+    def asset_for(*args)
+      options = Map.options_for!(args)
 
-        related.each do |relationship, value|
-          unless which.empty?
-            next unless which.include?(relationship.to_s)
-          end
+      path_info = Path.relative(args)
 
-          type, names =
-            case value
-              when Hash
-                value.to_a.first
-              else
-                [relationship, value]
-            end
+      path = @path.join('assets', path_info)
 
-          names = Coerce.list_of_strings(names)
+      glob = path_info.gsub(/[_-]/, '[_-]')
 
-          names.each do |name|
-            identifier = "#{ type }/#{ name }"
-            node = list.index[identifier]
-            node._load{ nodes.add(node) }
-          end
-        end
+      globs =
+        [
+          @path.call('assets', "#{glob}"),
+          @path.call('assets', "#{glob}*"),
+          @path.call('assets', "**/#{glob}*")
+        ]
 
-        case
-          when block.nil?
-            nodes
+      candidates = globs.map { |glob| Dir.glob(glob, ::File::FNM_CASEFOLD) }.flatten.compact.uniq.sort
 
-          when block
-            nodes.where(&block)
-        end
-      }
-    end
+      case candidates.size
+      when 0
+        raise ArgumentError, "no asset matching #{globs.inspect}"
+      else
+        path = candidates.last
+      end
 
-    def reload(&block)
-      @loaded = false
-      _load(&block)
+      Asset.for(path, node: self)
     end
 
-    def loaded
-      attributes
+    def asset_for?(*args, &block)
+      asset_for(*args, &block)
+    rescue StandardError
+      nil
     end
 
-    def load!(&block)
-      _load(&block)
+    def url_for(relative_path, options = {})
+      Ro.url_for(self.relative_path, relative_path, options)
     end
 
-    def _load(&block)
-      unless @loaded
-        if @loading
-          return(block ? block.call : :loading)
-        end
-
-        @loading = true
-        @loaded = _load_from_cache_or_disk
-        @loading = false
-      end
-
-      block ? block.call : @loaded
+    def path_for(...)
+      @path.join(...)
     end
 
-    def _load_from_cache_or_disk
-      cache_key = _cache_key
-
-      cached = Ro.cache.read(cache_key)
-
-      if cached
-        Ro.log "loading #{ identifier } from cache"
+    def src_for(*args)
+      key = Path.relative(:assets, :src, args).split('/')
+      get(key)
+    end
 
-        @attributes = Map.new.update(cached)
+    def method_missing(method, *args, &block)
+      key = method.to_s
 
-        return :cache
+      if attributes.has_key?(key)
+        attributes[key]
       else
-        Ro.log "loading #{ identifier } from disk"
-
-        @attributes = Map.new
-
-        _load_attributes_yml
-        _load_attribute_files
-        _load_sources
-        _load_assets
-
-        Ro.cache.write(cache_key, @attributes)
-
-        return :disk
+        super
       end
     end
 
-    def _load_attributes_yml
-      if test(?s, _attributes_yml)
-        buf = IO.binread(_attributes_yml)
-        data = YAML.load(buf)
-        data = data.is_a?(Hash) ? data : {'_' => data}
-
-        @attributes.update(data)
-
-        %w( assets ).each do |key|
-          raise ArgumentError.new("attributes.yml may not contain the key '#{ key }'") if @attributes.has_key?(key)
-        end
-
-        @attributes
-      end
+    def to_hash
+      attributes.to_hash
     end
 
-    def _load_attribute_files
-      glob = File.join(@path, '**/**')
-      node = self
-
-      Dir.glob(glob) do |path|
-        next if test(?d, path)
-
-        basename = File.basename(path)
-        next if basename == 'attributes.yml'
-
-        relative_path = Ro.relative_path(path, :to => @path)
-        next if relative_path =~ /^assets\//
-
-        key = relative_path.split('.', 2).first.split('/')
-
-        html = Ro.render(path, node)
-        html = Ro.expand_asset_urls(html, node)
-
-        @attributes.set(key => html)
-      end
+    def to_s(...)
+      to_json(...)
     end
 
-    def _load_sources
-      glob = File.join(@path, 'assets/source/*')
-      node = self
-
-      Dir.glob(glob) do |path|
-        next if test(?d, path)
-
-        basename = File.basename(path)
-        key, ext = basename.split('.', 2)
-
-        next if basename == 'attributes.yml'
-
-        value = Ro.render_source(path, node)
-        @attributes.set([:assets, :source, basename] => value)
-      end
+    def to_str(...)
+      to_json(...)
     end
 
-    def _load_assets
-      glob = File.join(@path, 'assets/**/**')
-      node = self
-
-      Dir.glob(glob) do |path|
-        next if test(?d, path)
-
-        relative_path = Ro.relative_path(path, :to => "#{ @path }/assets")
-
-        url = url_for(relative_path)
-        key = relative_path.split('/')
-
-        key.unshift('urls')
-
-        @attributes.set(key => url)
-      end
+    def to_json(...)
+      JSON.pretty_generate(to_hash, ...)
     end
 
-    def _binding
-      Kernel.binding
+    def as_json(...)
+      to_hash.as_json(...)
     end
 
-    def _cache_key
-      glob = File.join(@path, '**/**')
+    def to_yaml(...)
+      to_hash.to_yaml(...)
+    end
 
-      entries = []
+    def files
+      path.glob('**/**').select { |entry| entry.file? }.sort
+    end
 
-      Dir.glob(glob) do |entry|
-        stat =
-          begin
-            File.stat(entry)
-          rescue
-            next
-          end
+    def urls
+      files.map { |file| url_for(file.relative_to(@path)) }.sort
+    end
 
-        timestamp = [stat.ctime, stat.mtime].max
-        relative_path = Ro.relative_path(entry, :to => @path)
-        entries.push([relative_path, timestamp.iso8601(2)]) 
-      end
+    def <=>(other)
+      sort_key <=> other.sort_key
+    end
 
-      fingerprint = entries.map{|pair| pair.join('@')}.join(', ')
+    def sort_key
+      default_sort_key
+    end
 
-      md5 = Ro.md5(fingerprint)
+    def default_sort_key
+      position = (attributes[:position] ? Float(attributes[:position]) : 0.0)
+      published_at = (attributes[:published_at] ? Time.parse(attributes[:published_at].to_s) : Time.at(0)).utc.iso8601
+      created_at = (attributes[:created_at] ? Time.parse(attributes[:created_at].to_s) : Time.at(0)).utc.iso8601
 
-      [@path, md5]
+      [position, published_at, created_at, name]
     end
 
-    def _load_from_cache
-      false
+    def created_at
+      files.map{|file| File.stat(file).ctime}.min
     end
 
-    def _attributes_yml
-      File.join(@path, 'attributes.yml')
+    def updated_at
+      files.map{|file| File.stat(file).mtime}.max
     end
   end
 end