sitepress 0.1.16

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8a8a7debfe6f2131c3d521a3ad47f9e9d611559
+  data.tar.gz: 7f9484da938a71bbbb513d9534a83637bbcdf3d9
+SHA512:
+  metadata.gz: c11e63ac83610ca7377381a6f8453c021a95385f7134284b16c8dc0d61087d5d2130d5249dfef3c1700be8fa71e023fe7c37ec07d18bb738f6b36cd1a7164228
+  data.tar.gz: d51d1e0f7a0998288b7cb2bc9a6c06f73d67072dd80beda9b516533091b323af55ab789c1df47b69d6b62e1f13998c95ceda9f3eab21bcc2bea596acab09d721

data/lib/sitepress/asset.rb

@@ -0,0 +1,91 @@
+require "mime/types"
+require "forwardable"
+require "pathname"
+
+module Sitepress
+  # Represents a file on a web server that may be parsed to extract
+  # frontmatter or be renderable via a template. Multiple resources
+  # may point to the same asset. Properties of an asset should be mutable.
+  # The Resource object is immutable and may be modified by the Resources proxy.
+  class Asset
+    # If we can't resolve a mime type for the resource, we'll fall
+    # back to this binary octet-stream type so the client can download
+    # the resource and figure out what to do with it.
+    DEFAULT_MIME_TYPE = MIME::Types["application/octet-stream"].first
+
+    attr_reader :path
+
+    extend Forwardable
+    def_delegators :frontmatter, :data, :body
+
+    def initialize(path: , mime_type: nil)
+      # The MIME::Types gem returns an array when types are looked up.
+      # This grabs the first one, which is likely the intent on these lookups.
+      @mime_type = Array(mime_type).first
+      @path = Pathname.new path
+    end
+
+    # List of all file extensions.
+    def extensions
+      path.basename.to_s.split(".").drop(1)
+    end
+
+    # TODO: This is really a "key" or "leafname".
+    def basename
+      path.basename.to_s.split(".").first
+    end
+
+    def format_basename
+      [basename, format_extension].join(".")
+    end
+
+    # Returns the format extension.
+    def format_extension
+      extensions.first
+    end
+
+    # The base name with the format extension.
+    def format_name
+      [basename, format_extension].join(".")
+    end
+
+    # Returns a list of the rendering extensions.
+    def template_extensions
+      extensions.drop(1)
+    end
+
+    # Treat resources with the same request path as equal.
+    def ==(asset)
+      path == asset.path
+    end
+
+    def mime_type
+      @mime_type ||= inferred_mime_type || DEFAULT_MIME_TYPE
+    end
+
+    def exists?
+      File.exists? path
+    end
+
+    # Spits out a reasonable default request path. This may be changed
+    # via Resource#request_path.
+    def to_request_path
+      if ext = format_extension
+        path.dirname.join(basename).sub_ext(".#{ext}").to_s
+      else
+        path.to_s
+      end
+    end
+
+    private
+    def frontmatter
+      Frontmatter.new File.read @path
+    end
+
+    # Returns the mime type of the file extension. If a type can't
+    # be resolved then we'll just grab the first type.
+    def inferred_mime_type
+      MIME::Types.type_for(format_extension).first if format_extension
+    end
+  end
+end

data/lib/sitepress/directory_collection.rb

@@ -0,0 +1,24 @@
+module Sitepress
+  # Maps a directory of assets into a set of routes that correspond with
+  # the `path` root.
+  class DirectoryCollection
+    attr_reader :assets, :path
+
+    def initialize(path: , assets:)
+      @path = path
+      @assets = assets
+    end
+
+    def mount(node)
+      assets.each { |a| node.add path: asset_path_to_request_path(a), asset: a }
+    end
+
+    private
+    # Given a @file_path of `/hi`, this method changes `/hi/there/friend.html.erb`
+    # to an absolute `/there/friend` format by removing the file extensions
+    def asset_path_to_request_path(asset)
+      # Relative path of resource to the file_path of this project.
+      asset.path.dirname.join(asset.format_basename).relative_path_from(path).to_s
+    end
+  end
+end

data/lib/sitepress/extensions/layouts.rb

@@ -0,0 +1,27 @@
+module Sitepress
+  module Extensions
+    # Register layouts with resources that match certain patterns.
+    class Layouts
+      Rule = Struct.new(:layout, :processor)
+
+      def initialize
+        @rules = Array.new
+      end
+
+      # Register a layout for a set of resources.
+      def layout(layout, &block)
+        @rules << Rule.new(layout, block)
+      end
+
+      def process_resources(node)
+        node.flatten.each do |resource|
+          @rules.each do |rule|
+            if rule.processor.call(resource)
+              resource.data["layout"] ||= rule.layout
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sitepress/extensions/proc_manipulator.rb

@@ -0,0 +1,19 @@
+module Sitepress
+  module Extensions
+    class ProcManipulator
+      def initialize(block)
+        @block = block
+      end
+
+      def process_resources(node)
+        node.flatten.each do |resource|
+          if @block.arity == 1
+            @block.call resource
+          else # This will blow up if 0 or greater than 2.
+            @block.call resource, node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sitepress/formats.rb

@@ -0,0 +1,45 @@
+module Sitepress
+  # Manages collections of resources that share the same ResourceNode. Given the files `/a.html` and `/a.gif`,
+  # both of these assets would be stored in the `ResourceNode#name = "a"` under `ResourceNode#formats` with
+  # the extensions `.gif`, and `.html`.
+  class Formats
+    include Enumerable
+
+    extend Forwardable
+    def_delegators :@formats, :size, :clear
+
+    def initialize(node: )
+      @node = node
+      @formats = Hash.new
+    end
+
+    def each(&block)
+      @formats.values.each(&block)
+    end
+
+    def remove(ext)
+      @formats.delete(ext)
+    end
+
+    def ext(ext)
+      @formats[ext]
+    end
+
+    def mime_type(mime_type)
+      find { |f| f.mime_type == mime_type }
+    end
+
+    def add(asset: , ext: )
+      resource = Resource.new(asset: asset, node: @node, ext: ext)
+      if @formats.has_key? ext
+        raise Sitepress::ExistingRequestPathError, "Resource at #{resource.request_path} already set"
+      else
+        @formats[ext] = resource
+      end
+    end
+
+    def inspect
+      "<#{self.class}: resources=#{map(&:request_path)}>"
+    end
+  end
+end

data/lib/sitepress/frontmatter.rb

@@ -0,0 +1,22 @@
+require "yaml"
+
+module Sitepress
+  # Parses metadata from the header of the page.
+
+  # TODO: Redo this to use File readline and pos to
+  # perform faster
+  class Frontmatter
+    DELIMITER = "---".freeze
+    PATTERN = /\A(#{DELIMITER}\n(.+?)\n#{DELIMITER}\n*)?(.+)\Z/m
+
+    attr_reader :body
+
+    def initialize(content)
+      _, @data, @body = content.match(PATTERN).captures
+    end
+
+    def data
+      @data ? YAML.load(@data) : {}
+    end
+  end
+end

data/lib/sitepress/resource.rb

@@ -0,0 +1,88 @@
+require "forwardable"
+
+module Sitepress
+  # Represents the request path of an asset. There may be multiple
+  # resources that point to the same asset. Resources are immutable
+  # and may be altered by the resource proxy.
+  class Resource
+    extend Forwardable
+    def_delegators :asset, :mime_type
+
+    attr_writer :body, :data
+    attr_reader :node, :asset, :ext
+
+    # Default scope for querying parent/child/sibling resources.
+    DEFAULT_FILTER_SCOPE = :same
+
+    def initialize(asset: , node: , ext: "")
+      @asset = asset
+      @node = node
+      @ext = ext # TODO: Meh, feels dirty but I suppose the thingy has to drop it in.
+    end
+
+    def request_path
+      return unless node
+      # TODO: This `compact` makes me nervous. How can we handle this better?
+      lineage = node.parents.reverse.map(&:name).compact
+      file_name = [node.name, @ext].join
+      File.join("/", *lineage, file_name)
+    end
+
+    def data
+      @data ||= asset.data
+    end
+
+    def body
+      @body ||= asset.body
+    end
+
+    def inspect
+      "<#{self.class}:#{object_id} request_path=#{request_path.inspect} asset_path=#{@asset.path.to_s.inspect}>"
+    end
+
+    def parents(**args)
+      filter_resources(**args){ node.parents }
+    end
+
+    def siblings(**args)
+      filter_resources(**args){ node.siblings }
+    end
+
+    def children(**args)
+      filter_resources(**args){ node.children }
+    end
+
+    def ==(resource)
+      resource.request_path == request_path
+    end
+
+    private
+    # Filters parent/child/sibling resources by a type. The default behavior is to only return
+    # resources of the same type. For example given the pages `/a.html`, `/a.gif`, `/a/b.html`,
+    # if you query the parent from page `/a/b.html` you'd only get `/a.html` by default. If you
+    # query the parents via `parents(type: :all)` you'd get get [`/a.html`, `/a.gif`]
+    #
+    # TODO: When `type: :all` is scoped, some queries will mistakenly return single resources.
+    # :all should return an array of arrays to accurately represention levels.
+    #
+    # TODO: Put a better extension/mime_type handler into resource tree, then instead of faltening
+    # below and select, we could call a single map and pull out a resources
+    def filter_resources(type: DEFAULT_FILTER_SCOPE, &block)
+      return [] unless node
+      nodes = block.call
+
+      case type
+      when :all
+        nodes.map(&:formats)
+      when :same
+        nodes.map{ |n| n.formats.ext(ext) }.flatten.compact
+      when String
+        nodes.map{ |n| n.formats.ext(type) }.flatten.compact
+      when MIME::Type
+        nodes.map{ |n| n.formats.mime_type(type) }.flatten.compact
+      else
+        raise ArgumentError, "Invalid type argument #{type}. Must be either :same, :all, an extension string, or a Mime::Type"
+      end
+    end
+  end
+end

data/lib/sitepress/resource_collection.rb

@@ -0,0 +1,33 @@
+module Sitepress
+  # Represents a collection of resources. Provides interfaces to query
+  # resource via globbing, paths, etc.
+  class ResourceCollection
+    extend Forwardable
+    def_delegators :resources, :each, :size
+
+    include Enumerable
+
+    # Used by `#glob` to determine the full path when
+    # given a relative glob pattern.
+    attr_reader :root_path
+
+    def initialize(node: , root_path: ".")
+      @node = node
+      @root_path = Pathname.new(root_path)
+    end
+
+    def glob(pattern)
+      paths = Dir.glob root_path.join(pattern)
+      resources.select { |r| paths.include? r.asset.path.to_s }
+    end
+
+    def get(request_path)
+      @node.get(request_path)
+    end
+
+    private
+    def resources
+      @node.flatten
+    end
+  end
+end

data/lib/sitepress/resources_node.rb

@@ -0,0 +1,135 @@
+module Sitepress
+  # Resource nodes give resources their parent/sibling/child relationships. The relationship are determined
+  # by the `request_path` given to an asset when its added to a node. Given the `request_path` `/foo/bar/biz/buz.html`,
+  # a tree of resource nodes would be built named `foo`, `bar`, `biz`, `buz`. `foo` would be the "root" node and `buz`
+  # a leaf node. The actual `buz.html` asset is then stored on the leaf node as a resource. This tree structure
+  # makes it possible to reason through path relationships from code to build out elements in a website like tree navigation.
+  class ResourcesNode
+    attr_reader :parent, :name
+
+    DELIMITER = "/".freeze
+
+    def initialize(parent: nil, delimiter: ResourcesNode::DELIMITER, name: nil)
+      @parent = parent
+      @name = name.freeze
+      @delimiter = delimiter.freeze
+    end
+
+    def formats
+      @formats ||= Formats.new(node: self)
+    end
+
+    # Returns the immediate children nodes.
+    def children
+      child_nodes.values
+    end
+
+    # Returns sibling nodes.
+    def siblings
+      parent ? parent.children.reject{ |c| c == self } : []
+    end
+
+    # Returns all parents up to the root node.
+    def parents
+      parents = []
+      node = parent
+      while node do
+        parents << node
+        node = node.parent
+      end
+      parents
+    end
+
+    def root?
+      parent.nil?
+    end
+
+    def leaf?
+      child_nodes.empty?
+    end
+
+    def flatten(resources: [])
+      formats.each{ |resource| resources << resource }
+      children.each do |child|
+        child.flatten.each{ |resource| resources << resource }
+      end
+      resources
+    end
+
+    def remove
+      if leaf?
+        # TODO: Check the parents to see if they also need to be removed if
+        # this call orphans the tree up to a resource.
+        parent.remove_child(name)
+      else
+        formats.clear
+      end
+    end
+
+    def add(path: , asset: )
+      head, *path = tokenize(path)
+      if path.empty?
+        # When there's no more paths, we're left with the format (e.g. ".html")
+        formats.add(asset: asset, ext: head)
+      else
+        child_nodes[head].add(path: path, asset: asset)
+      end
+    end
+    alias :[]= :add
+
+    def get(path)
+      *path, ext = tokenize(path)
+      if node = dig(*path)
+        node.formats.ext(ext)
+      end
+    end
+
+    def get_node(path)
+      *path, _ = tokenize(path)
+      dig(*path)
+    end
+    alias :[] :get_node
+
+    def inspect
+      "<#{self.class}: formats=#{formats.map(&:request_path)} children=#{children.map(&:name).inspect}>"
+    end
+
+    # TODO: I don't really like how the path is broken up with the "ext" at the end.
+    # It feels inconsistent. Either make an object/struct that encaspulates this or
+    # just pass `index.html` through to the end.
+    def dig(*args)
+      head, *tail = args
+      if head.nil? and tail.empty?
+        self
+      elsif child_nodes.has_key?(head)
+        child_nodes[head].dig(*tail)
+      else
+        nil
+      end
+    end
+
+    protected
+    def remove_child(path)
+      *_, segment, _ = tokenize(path)
+      child_nodes.delete(segment)
+    end
+
+    private
+    def add_child_node(name)
+      ResourcesNode.new(parent: self, delimiter: @delimiter, name: name)
+    end
+
+    def child_nodes
+      @child_nodes ||= Hash.new { |hash, key| hash[key] = add_child_node(key) }
+    end
+
+    # Returns all of the names for the path along with the format, if set.
+    def tokenize(path)
+      return path if path.respond_to? :to_a
+      path, _, file = path.gsub(/^\//, "").rpartition(@delimiter)
+      ext = File.extname(file)
+      file = File.basename(file, ext)
+      path.split(@delimiter).push(file).push(ext)
+    end
+  end
+end

data/lib/sitepress/resources_pipeline.rb

@@ -0,0 +1,10 @@
+require "forwardable"
+
+module Sitepress
+  # Processes a collection of resources
+  class ResourcesPipeline < Array
+    def process(resources)
+      each{ |processor| processor.process_resources resources }
+    end
+  end
+end

data/lib/sitepress/site.rb

@@ -0,0 +1,65 @@
+require "pathname"
+require "sitepress/extensions/proc_manipulator"
+
+module Sitepress
+  # A collection of pages from a directory.
+  class Site
+    # Default file pattern to pick up in site
+    DEFAULT_GLOB = "**/**".freeze
+
+    # Default root_path for site.
+    DEFAULT_ROOT_PATH = Pathname.new(".").freeze
+
+    attr_reader :root_path, :resources_pipeline
+
+    # Cache resources for production runs of Sitepress. Development
+    # modes don't cache to optimize for files reloading.
+    attr_accessor :cache_resources
+    alias :cache_resources? :cache_resources
+
+    # TODO: Get rid of these so that folks have ot call site.resources.get ...
+    extend Forwardable
+    def_delegators :resources, :get, :glob
+
+    def initialize(root_path: DEFAULT_ROOT_PATH, cache_resources: false)
+      self.root_path = root_path
+      self.cache_resources = cache_resources
+    end
+
+    # A tree representation of the resourecs wthin the site.
+    def root
+      ResourcesNode.new.tap do |node|
+        DirectoryCollection.new(assets: assets, path: root_path).mount(node)
+        resources_pipeline.process node
+      end
+    end
+
+    # Returns a list of all the resources within #root.
+    def resources
+      @resources = nil unless cache_resources
+      @resources ||= ResourceCollection.new(node: root, root_path: root_path)
+    end
+
+    def root_path=(path)
+      @root_path = Pathname.new(path)
+    end
+
+    # Quick and dirty way to manipulate resources in the site without
+    # creating classes that implement the #process_resources method
+    def manipulate(&block)
+      resources_pipeline << Extensions::ProcManipulator.new(block)
+    end
+
+    def resources_pipeline
+      @resources_pipeline ||= ResourcesPipeline.new
+    end
+
+    private
+    # Lazy stream of files that will be rendered by resources.
+    def assets(glob = DEFAULT_GLOB)
+      Dir.glob(root_path.join(glob)).select(&File.method(:file?)).lazy.map do |path|
+        Asset.new(path: path)
+      end
+    end
+  end
+end

data/lib/sitepress/version.rb

@@ -0,0 +1,3 @@
+module Sitepress
+  VERSION = "0.1.16"
+end

data/lib/sitepress.rb

@@ -0,0 +1,19 @@
+require "sitepress/version"
+
+module Sitepress
+  # Raised by Resources if a path is added that's not a valid path.
+  InvalidRequestPathError = Class.new(RuntimeError)
+
+  # Raised by Resources if a path is already in its index
+  ExistingRequestPathError = Class.new(InvalidRequestPathError)
+
+  autoload :Asset,                "sitepress/asset"
+  autoload :DirectoryCollection,  "sitepress/directory_collection"
+  autoload :Formats,              "sitepress/formats"
+  autoload :Frontmatter,          "sitepress/frontmatter"
+  autoload :Resource,             "sitepress/resource"
+  autoload :ResourceCollection,   "sitepress/resource_collection"
+  autoload :ResourcesPipeline,    "sitepress/resources_pipeline"
+  autoload :ResourcesNode,        "sitepress/resources_node"
+  autoload :Site,                 "sitepress/site"
+end

data/sitepress.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sitepress/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sitepress"
+  spec.version       = Sitepress::VERSION
+  spec.authors       = ["Brad Gessler"]
+  spec.email         = ["bradgessler@gmail.com"]
+
+  spec.summary       = %q{An embeddable file-backed content management system.}
+  spec.homepage      = "https://github.com/bradgessler/sitepress"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_runtime_dependency "mime-types", ">= 2.99"
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: sitepress
+version: !ruby/object:Gem::Version
+  version: 0.1.16
+platform: ruby
+authors:
+- Brad Gessler
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.99'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.99'
+description: 
+email:
+- bradgessler@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sitepress.rb
+- lib/sitepress/asset.rb
+- lib/sitepress/directory_collection.rb
+- lib/sitepress/extensions/layouts.rb
+- lib/sitepress/extensions/proc_manipulator.rb
+- lib/sitepress/formats.rb
+- lib/sitepress/frontmatter.rb
+- lib/sitepress/resource.rb
+- lib/sitepress/resource_collection.rb
+- lib/sitepress/resources_node.rb
+- lib/sitepress/resources_pipeline.rb
+- lib/sitepress/site.rb
+- lib/sitepress/version.rb
+- sitepress.gemspec
+homepage: https://github.com/bradgessler/sitepress
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: An embeddable file-backed content management system.
+test_files: []
+has_rdoc: