sitepress 0.1.20 → 0.1.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57a26550fd2e4633c7ab382fad0b0877a77d7536
-  data.tar.gz: ff402977fa074f30352f85ecce144728cafd2347
+  metadata.gz: 344bb99aa58dcaaa2ce9610d93bfd37dfef3c4c5
+  data.tar.gz: b8813d806775de3ada67302cbc66d10e5f1ddb4f
 SHA512:
-  metadata.gz: 566f9550bd7d77e8023229f676a243043526515c0259e0977c6aa6e2da0bba01da6575c008e11e86cbbf30f5ae5c55c7e148c2b5ba15912c10a9348377bb5702
-  data.tar.gz: b0e4269455ae324c9022dcc75003b7cf36e0e234c587b49eaab52cfbf93fe8d5a40874f7cc34313ba9f31e1cee730f36a52ade4ff3a678cb9575c6b71d75ee9e
+  metadata.gz: 6befa582a4f32510f440adb1947eeed4bd6d0b5e57cc4a83b19013999a77a9555b88622f72169dc5c37f5b39f0ffce723870ce48ebf9017de417361acd55fe65
+  data.tar.gz: 31c9418efd9de1b09506c12bf858685b979b9e4e43df914cfebe7b524661b3bc796f1b53d7e2d916b0ac614f2834ddc96d11a0763ccec96121ea1f2536941502

data/exe/sitepress

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "sitepress-cli"
+
+Sitepress::CLI.start(ARGV)

data/lib/sitepress.rb

@@ -1,19 +1,4 @@
 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/lib/sitepress/version.rb

@@ -1,3 +1,3 @@
 module Sitepress
-  VERSION = "0.1.20"
+  VERSION = "0.1.21"
 end

data/sitepress.gemspec

@@ -17,9 +17,5 @@ Gem::Specification.new do |spec|
   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"
+  spec.add_runtime_dependency "sitepress-cli", spec.version
 end

metadata

@@ -1,90 +1,39 @@
 --- !ruby/object:Gem::Specification
 name: sitepress
 version: !ruby/object:Gem::Version
-  version: 0.1.20
+  version: 0.1.21
 platform: ruby
 authors:
 - Brad Gessler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2016-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: sitepress-cli
   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'
+        version: 0.1.21
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.99'
+        version: 0.1.21
 description: 
 email:
 - bradgessler@gmail.com
-executables: []
+executables:
+- sitepress
 extensions: []
 extra_rdoc_files: []
 files:
+- exe/sitepress
 - 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/sitepress/sitepress

data/lib/sitepress/asset.rb

@@ -1,91 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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 parent(**args)
-      parents(**args).first
-    end
-
-    def parents(**args)
-      filter_resources(**args){ node.parents }
-    end
-
-    def siblings(**args)
-      filter_resources(**args){ node.siblings }.compact
-    end
-
-    def children(**args)
-      filter_resources(**args){ node.children }.compact
-    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{ |node| node.formats }
-      when :same
-        nodes.map{ |n| n.formats.ext(ext) }.flatten
-      when String
-        nodes.map{ |n| n.formats.ext(type) }.flatten
-      when MIME::Type
-        nodes.map{ |n| n.formats.mime_type(type) }.flatten
-      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

@@ -1,33 +0,0 @@
-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, :index, :[], :last, :length, :fetch, :count, :at
-
-    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

@@ -1,135 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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: pages_assets, path: pages_path).mount(node)
-        resources_pipeline.process node
-      end
-    end
-
-    def pages_path
-      root_path.join("pages")
-    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 pages_assets(glob = DEFAULT_GLOB)
-      Dir.glob(pages_path.join(glob)).select(&File.method(:file?)).lazy.map do |path|
-        Asset.new(path: path)
-      end
-    end
-  end
-end