mascot 0.1.11 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d49c4a14896b46d0fdcd7aedd1250a104e9b5048
-  data.tar.gz: 101a6a075f65556c4dc0a86ca69e7a5c39459a4d
+  metadata.gz: 1d705fe26af1339418f2018ebeed0af942e6b49e
+  data.tar.gz: d0fbb9055d2b7214078eb1de963065e8f1949c9b
 SHA512:
-  metadata.gz: 65db308403d25699fd58e498e09a7c390b885894709ebb60be396eeca3f1faed0d65c574dfc75164325272462bd7672e230f505694c6e1b15a7e2f5ba1b6addc
-  data.tar.gz: eec51f4ec3bd95bf28831e097a646acd3faeba341529f75eb3bb93a844ffdff87c44d3aa9d9d78d29d703897bde3fb7b1960d0bda74abf8f96d73e3dfe127f61
+  metadata.gz: 95f73264703dccec615c082cf1f071237160b94e967903842c7f889da8dae7617c3a5931539ea0be5fbb2fbd070959cfc17bfc800c67eca0c758976249e88f01
+  data.tar.gz: ab29c4b7f17646864334e14007b1bf27feab5960c9e5fa88a805785dab23421b62727b8b12d813519105a50555c5f116c6a74a82d34e35bbc46786747b9ba457

data/lib/mascot/asset.rb

@@ -30,15 +30,25 @@ module Mascot
       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)

data/lib/mascot/resource.rb

@@ -6,51 +6,84 @@ module Mascot
   # resources that point to the same asset. Resources are immutable
   # and may be altered by the resource proxy.
   class Resource
-    include Observable
-
     extend Forwardable
     def_delegators :asset, :mime_type
 
-    attr_accessor :request_path, :asset
     attr_writer :body, :data
+    attr_reader :node, :asset, :ext
+
+    # Default scope for querying parent/child/sibling resources.
+    DEFAULT_FILTER_SCOPE = :same
 
-    def initialize(asset: , request_path: nil)
-      self.request_path = request_path || asset.to_request_path
+    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
 
-    # When #dup or #clone is copied, the Resource
-    # collection observer must be removed so there's
-    # not duplicate resources.
-    def initialize_copy(instance)
-      instance.delete_observers
-      super instance
+    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 request_path=(request_path)
-      old_request_path = @request_path
-      # We freeze the value to ensure users can't modify
-      # the request_path string in place (e.g. Resource#request_path.capitalize!)
-      # and throw the resource out of sync with the Resources collection.
-      @request_path = request_path.to_s.freeze
-      changed
-      notify_observers self, old_request_path
+    def data
+      @data ||= asset.data
+    end
+
+    def body
+      @body ||= asset.body
     end
 
     def inspect
-      "#<#{self.class}:0x#{(object_id << 1).to_s(16)} @request_path=#{@request_path.inspect} @asset=#{@asset.inspect}>"
+      "<#{self.class}:#{object_id} request_path=#{request_path.inspect} asset_path=#{@asset.path.to_s.inspect}>"
     end
 
-    def data
-      @data ||= asset.data
+    def parents(**args)
+      filter_resources(**args){ node.parents }
     end
 
-    def body
-      @body ||= asset.body
+    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
 
-    def ==(asset)
-      request_path == asset.request_path
+    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
+      resources = block.call.map(&:resources)
+
+      case type
+      when :all
+        resources
+      when :same
+        resources.flatten.select { |r| r.ext == ext }
+      when String
+        resources.flatten.select { |r| r.ext == type }
+      when MIME::Type
+        resources.flatten.select { |r| r.mime_type == type }
+      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/mascot/resources_node.rb

@@ -0,0 +1,148 @@
+module Mascot
+  # 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
+    # TODO: Should it be called "formats" or "extensions"? Probably the latter, but that could conflict with Resource Manipulators.
+    attr_reader :parent, :name, :formats
+    include Enumerable
+
+    DELIMITER = "/".freeze
+
+    def initialize(parent: nil, delimiter: ResourcesNode::DELIMITER, name: nil)
+      @parent = parent
+      @name = name.freeze
+      @delimiter = delimiter.freeze
+      @children = Hash.new { |hash, key| hash[key] = ResourcesNode.new(parent: self, delimiter: delimiter, name: key) }
+      @resources = Hash.new
+    end
+
+    # Returns the immediate children nodes.
+    def children
+      @children.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
+
+    # Iterates through resources in the current node and all child resources.
+    # TODO: Should this include all children? Perhaps I should move this method
+    # into an eumerator that more clearly states it returns an entire sub-tree.
+    def each(&block)
+      @resources.values.each { |resource| block.call(resource) }
+      children.each{ |c| c.each(&block) }
+    end
+
+    def root?
+      parent.nil?
+    end
+
+    def leaf?
+      @children.empty?
+    end
+
+    def resources
+      @resources.values
+    end
+
+    def remove_resource(resource)
+      @resources.delete resource.ext #if @resources[resource.ext] == resource
+    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
+        @resources.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")
+        add_format(asset: asset, ext: head)
+      else
+        @children[head].add(path: path, asset: asset)
+      end
+    end
+    alias :[]= :add
+
+    def get_resource(path)
+      *path, ext = tokenize(path)
+      if node = dig(*path)
+        node.get_format(ext: ext)
+      end
+    end
+
+    def inspect
+      "<#{self.class}: resources=#{resources.map(&:request_path)} children=#{children.map(&:name).inspect}>"
+    end
+
+    def get(path)
+      *path, ext = tokenize(path)
+      dig(*path)
+    end
+    alias :[] :get
+
+    protected
+    def get_format(ext: "")
+      @resources[ext]
+    end
+
+    def remove_child(path)
+      *_, segment, _ = tokenize(path)
+      @children.delete(segment)
+    end
+
+    def add_format(asset: , ext: )
+      resource = Resource.new(asset: asset, node: self, ext: ext)
+      if @resources.has_key? ext
+        raise Mascot::ExistingRequestPathError, "Resource at #{resource.request_path} already set"
+      else
+        @resources[ext] = resource
+      end
+    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 @children.has_key?(head)
+        @children[head].dig(*tail)
+      else
+        nil
+      end
+    end
+
+    private
+    # 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/mascot/site.rb

@@ -22,11 +22,16 @@ module Mascot
       end
     end
 
+    def glob(glob)
+      paths = safe_root.glob(root.join(glob))
+      resources.select{ |r| paths.include? r.asset.path.to_s }
+    end
+
     # Returns a list of resources.
     def resources
-      Resources.new(root_file_path: root).tap do |resources|
-        assets.each { |a| resources.add_asset a }
-        resources_pipeline.process resources
+      ResourcesNode.new.tap do |root_node|
+        assets.each { |a| root_node.add path: asset_path_to_request_path(a), asset: a }
+        resources_pipeline.process root_node
       end
     end
 
@@ -38,7 +43,7 @@ module Mascot
 
     # Find the page with a path.
     def get(request_path)
-      resources.get(request_path)
+      resources.get_resource(request_path)
     end
 
     def root=(path)
@@ -50,6 +55,13 @@ module Mascot
     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(root).to_s
+    end
+
     def safe_root
       SafeRoot.new(path: root)
     end

data/lib/mascot/version.rb

@@ -1,3 +1,3 @@
 module Mascot
-  VERSION = "0.1.11"
+  VERSION = "0.1.12"
 end

data/lib/mascot.rb

@@ -13,8 +13,8 @@ module Mascot
   autoload :Asset,        "mascot/asset"
   autoload :Frontmatter,  "mascot/frontmatter"
   autoload :ResourcesPipeline,     "mascot/resources_pipeline"
-  autoload :Resources,    "mascot/resources"
   autoload :Resource,     "mascot/resource"
+  autoload :ResourcesNode, "mascot/resources_node"
   autoload :SafeRoot,     "mascot/safe_root"
-  autoload :Site,      "mascot/site"
+  autoload :Site,         "mascot/site"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mascot
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.12
 platform: ruby
 authors:
 - Brad Gessler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-10 00:00:00.000000000 Z
+date: 2016-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -79,7 +79,7 @@ files:
 - lib/mascot/extensions/proc_manipulator.rb
 - lib/mascot/frontmatter.rb
 - lib/mascot/resource.rb
-- lib/mascot/resources.rb
+- lib/mascot/resources_node.rb
 - lib/mascot/resources_pipeline.rb
 - lib/mascot/safe_root.rb
 - lib/mascot/site.rb

data/lib/mascot/resources.rb

@@ -1,103 +0,0 @@
-require "forwardable"
-require "pathname"
-
-module Mascot
-  class Resources
-    include Enumerable
-
-    extend Forwardable
-    def_delegators :@routes, :size, :empty?, :any?, :clear
-
-    def initialize(root_file_path: )
-      @routes = Hash.new
-      @root_file_path = Pathname.new(root_file_path)
-    end
-
-    def each(&block)
-      @routes.values.each(&block)
-    end
-
-    def last
-      @routes.values.last
-    end
-
-    def request_paths
-      @routes.keys
-    end
-
-    def glob(pattern = "**/**")
-      paths = safe_root.glob @root_file_path.join(pattern)
-      select { |r| paths.include? r.asset.path.to_s}
-    end
-
-    def get(request_path)
-      return if request_path.nil?
-      @routes[key(request_path)]
-    end
-
-    def add(resource)
-      validate_request_path resource
-      validate_uniqueness resource
-
-      resource.add_observer self
-      @routes[key(resource)] = resource
-    end
-
-    def update(resource, old_request_path)
-      validate_request_path old_request_path
-      validate_request_path resource
-      validate_uniqueness resource
-
-      @routes.delete key(old_request_path)
-      @routes[key(resource)] = resource
-    end
-
-    def remove(resource)
-      validate_request_path resource
-      resource.delete_observer self
-      @routes.delete key(resource)
-      resource
-    end
-
-    def add_asset(asset, request_path: nil)
-      add Resource.new asset: asset, request_path: asset_path_to_request_path(request_path || asset.to_request_path)
-    end
-
-    private
-    def key(path)
-      # TODO: Conslidate this into SafeRoot.
-      File.join "/", validate_request_path(coerce_request_path(path))
-    end
-
-    def coerce_request_path(resource)
-      resource.respond_to?(:request_path) ? resource.request_path : resource
-    end
-
-    def validate_request_path(path)
-      path = coerce_request_path(path)
-      raise InvalidRequestPathError, "path can't be nil" if path.nil?
-      path
-    end
-
-    # Raise an exception if the user tries to add a Resource with an existing request path.
-    def validate_uniqueness(resource)
-      path = coerce_request_path(resource)
-      if existing_resource = get(path)
-        raise ExistingRequestPathError, "Resource #{existing_resource} already exists at #{path}"
-      else
-        resource
-      end
-    end
-
-    # 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(path)
-      # Relative path of resource to the file_path of this project.
-      relative_path = Pathname.new(path).relative_path_from(@root_file_path)
-    end
-
-    def safe_root
-      @safe_root ||= SafeRoot.new(path: @root_file_path)
-    end
-  end
-end