massimo 0.3.9 → 0.4.0

data/lib/massimo/resource/processing.rb

@@ -0,0 +1,64 @@
+module Massimo
+  module Resource
+    module Processing
+      def self.included(base) # :nodoc:
+        base.extend ClassMethods
+      end
+      
+      module ClassMethods
+        # Determine if this Resource type is processable. By default this is `false`.
+        def processable?
+          false
+        end
+    
+        # This will override `processable?` to return `true`.
+        def processable!
+          def self.processable?
+            true
+          end
+        end
+        
+        # Process all the Resources in this Resource type's directory.
+        def process!
+          all(true).each(&:process!)
+        end
+      end
+      
+      # Writes the rendered body to the output file.
+      def process!
+        if self.class.processable?
+          # Make the full path to the directory of the output file
+          FileUtils.mkdir_p(output_path.dirname)
+          # write the filtered data to the output file
+          output_path.open("w") do |file|
+            file.write render
+          end
+        else
+          false
+        end
+      end
+      
+      protected
+    
+        # Reads the source page file, and populates the `@meta_data` and
+        # `@body` attributes.
+        def read_source!
+          raise Massimo::MissingResource unless @source_path.exist?
+          # try to read it now
+          begin
+            @line = 1
+            @body = @source_path.read
+          rescue
+            raise Massimo::InvalidResource
+          end
+        end
+      
+        # Determine the output file path
+        def output_path
+          @output_path ||= Pathname.new(
+            @source_path.to_s.sub(site.source_dir, site.output_dir)
+          )
+        end
+    end
+  end
+end

data/lib/massimo/site.rb

@@ -5,60 +5,42 @@ module Massimo
     # Default options. Overriden by values given when creating a Site.
     DEFAULT_OPTIONS = {
       :source      => ".",
-      :output      => ::File.join(".", "public"),
+      :output      => File.join(".", "public"),
       :server_port => "1984"
     }.freeze
     
-    SOURCE_DIRS = [ :pages, :views, :stylesheets, :javascripts, :helpers, :lib ].freeze # :nodoc:
-    
     attr_accessor :options, :helpers
     
     # Setup the Site with the given options. These options may be overridden by the config file.
     def setup(options = {})
       @options = DEFAULT_OPTIONS.dup.merge(options.symbolize_keys)
+      reload
       self
     end
     
-    # Processes all the Pages, Stylesheets, and Javascripts and outputs
-    # them to the output dir.
-    def process!
+    # Reload helpers and libs.
+    def reload
       reload_helpers
       reload_libs
-      pages(true).each(&:process!)
-      stylesheets(true).each(&:process!)
-      javascripts(true).each(&:process!)
-    end
-    
-    # Get all the Pages in the pages dir.
-    def pages(reload = false)
-      return @pages if defined?(@pages) && !reload
-      page_paths = self.find_files_in(:pages)
-      @pages = page_paths.collect { |path| ::Massimo::Page.new(path) }
-    end
-    
-    # Get all the Stylesheets in the stylesheets dir.
-    def stylesheets(reload = false)
-      return @stylesheets if defined?(@stylesheets) && !reload
-      stylesheet_paths = self.find_files_in(:stylesheets, [ :css, :sass, :less ])
-      @stylesheets = stylesheet_paths.collect { |path| ::Massimo::Stylesheet.new(path) }
+      reload_resources
     end
     
-    # Get all the Javascripts in the javascripts dir.
-    def javascripts(reload = false)
-      return @javascripts if defined?(@javascripts) && !reload
-      javascript_paths = self.find_files_in(:javascripts, [ :js ])
-      @javascripts = javascript_paths.collect { |path| ::Massimo::Javascript.new(path) }
+    # Processes all the Pages, Stylesheets, and Javascripts and outputs
+    # them to the output dir.
+    def process!
+      reload
+      Massimo.processable_resources.each(&:process!)
     end
     
     # Finds a view by the given name
     def find_view(name, meta_data = {})
-      view_path = Dir.glob(self.views_dir("#{name}.*")).first
-      view_path && ::Massimo::View.new(view_path, meta_data)
+      view_path = Dir.glob(dir_for(:views, "#{name}.*")).first
+      view_path && Massimo::View.new(view_path, meta_data)
     end
     
     # Finds a view then renders it with the given locals
     def render_view(name, locals = {}, &block)
-      view = self.find_view(name)
+      view = find_view(name)
       view && view.render(locals, &block)
     end
     
@@ -78,107 +60,65 @@ module Massimo
     
     # The path to the source dir
     def source_dir(*path)
-      ::File.join(@options[:source], *path)
+      File.join(@options[:source], *path)
     end
     
-    # Get all the source directories as an array.
-    def all_source_dirs
-      SOURCE_DIRS.collect { |d| dir_for(d) }
+    # Get the directory to the given resource type (pages, views, etc.).
+    # If the path has been manually set in the options, you will get that
+    # path. Otherwise you will get the path relative to the source directory.
+    def dir_for(type, *path)
+      if type_path = @options["#{type}_path".to_sym]
+        File.join(type_path, *path)
+      else
+        source_dir(type.to_s, *path)
+      end
     end
     
-    SOURCE_DIRS.each do |d|
-      define_method("#{d}_dir") do |*path|
-        dir_for(d, *path)
-      end
+    # Get all the source directories as an array.
+    def all_source_dirs
+      Massimo.resources.collect(&:dir) + [ dir_for(:helpers), dir_for(:lib) ]
     end
     
     # The path to the output dir
     def output_dir(*path)
-      ::File.join(@options[:output], *path)
+      File.join(@options[:output], *path)
     end
     
     protected
-    
-      # Get the directory to the given resource type (pages, views, etc.).
-      # If the path has been manually set in the options, you will get that
-      # path. Otherwise you will get the path relative to the source directory.
-      def dir_for(type, *path)
-        if type_path = @options["#{type}_path".to_sym]
-          ::File.join(type_path, *path)
-        else
-          self.source_dir(type.to_s, *path)
-        end
-      end
-    
-      # Find all the files in the given resouce type's directory, optionally
-      # selecting only those with the given extensions. This will return
-      # an array with the full path to the files.
-      def find_files_in(type, extensions = nil)
-        # the directory where these files will be found
-        type_dir = self.dir_for(type)
-        
-        # By default get the file list from the options
-        files = @options[type] && @options[type].dup
-        
-        unless files && files.is_a?(::Array)
-          # If files aren't listed in the options, get them
-          # from the given block
-          glob  = (extensions.nil? || extensions.empty?) ? "*" : "*.{#{extensions.join(",")}}"
-          files = ::Dir.glob(::File.join(type_dir, "**", glob))
-          
-          # normalize the files by removing the directory from the path
-          files.collect! { |file| file.gsub("#{type_dir}/", "") }
-          
-          # reject the files in the skip_files option, which can
-          # either be an array or a Proc.
-          if skip_files = @options["skip_#{type}".to_sym]
-            files.reject! do |file|
-              case skip_files
-              when ::Array
-                skip_files.include?(file)
-              else ::Proc
-                skip_files.call(file)
-              end
-            end
-          end
-        end
-        
-        # Reject all files that begin with _ (like partials) and directories
-        files.reject! { |file| ::File.basename(file) =~ /^_/ }
-        
-        # now add the directory back to the path
-        files.collect! { |file| ::File.join(type_dir, file) }
-        
-        # And make sure we don't find directories
-        files.reject! { |file| ::File.directory?(file) }
-        files
-      end
       
       # Reload the Helpers instance with the helper modules
       def reload_helpers
-        @helpers = ::Massimo::Helpers.new(self.helper_modules.compact)
+        @helpers = Helpers.new(helper_modules.compact)
       end
       
       # Reload all the files in the source lib dir.
       def reload_libs
-        reload_files ::Dir.glob(lib_dir("**", "*.rb"))
+        reload_files Dir.glob(dir_for(:lib, "**", "*.rb"))
+      end
+    
+      # Load methods for listing all available files for each Resource type.
+      def reload_resources
+        class_eval do
+          # Define methods for getting all of the files for each Resource Type
+          Massimo.processable_resources.each do |type|
+            define_method(type.name.to_s.pluralize) do |*args|
+              type.all(*args)
+            end
+          end
+        end
       end
       
       # Find all the helper modules
       def helper_modules
-        reload_files ::Dir.glob(helpers_dir("*.rb"))
+        reload_files Dir.glob(dir_for(:helpers, "*.rb"))
       end
       
       # Relod the given file by removing their constants and loading the file again.
       # Return an Array of the reloaded Constants.
       def reload_files(files)
         files.collect do |file|
-          class_name = ::File.basename(file).gsub(::File.extname(file), "").classify
-          # Unload the constant if it already exists
-          ::Object.class_eval { remove_const(class_name) if const_defined?(class_name) }
-          # Load the constant
           load(file)
-          # return the constant
+          class_name = File.basename(file).gsub(File.extname(file), "").classify
           class_name.constantize rescue nil
         end
       end

data/lib/massimo/stylesheet.rb

@@ -1,26 +1,18 @@
 module Massimo
-  class Stylesheet < Resource
+  class Stylesheet < Massimo::Resource::Base
+    processable!
+    
     # Render the css based on the type of resource
     def render
       case resource_type.to_sym
-      when :css
-        @body.to_s
       when :sass
-        require "sass" unless defined? ::Sass
-        ::Sass::Files.tree_for(@source_path, sass_options).render
+        require "sass" unless defined?(Sass)
+        Sass::Files.tree_for(@source_path, sass_options).render
       when :less
-        require "less" unless defined? ::Less
-        ::Less.parse(@body)
-      end
-    end
-    
-    # Writes the rendered css to the output file.
-    def process!
-      # Make the full path to the directory of the output file
-      ::FileUtils.mkdir_p(self.output_path.dirname)
-      # write the filtered data to the output file
-      self.output_path.open("w") do |file|
-        file.write self.render
+        require "less" unless defined?(Less)
+        Less.parse(@body)
+      else
+        @body.to_s
       end
     end
     
@@ -28,9 +20,10 @@ module Massimo
       
       # Determine the output file path
       def output_path
-        @output_path ||= ::Pathname.new(@source_path.to_s.
-          sub(self.site.source_dir, self.site.output_dir). # move to output dir
-          sub(/#{@source_path.extname}$/, ".css")) # replace extension with .css
+        @output_path ||= Pathname.new(@source_path.to_s.
+          sub(site.source_dir, site.output_dir). # move to output dir
+          sub(/#{@source_path.extname}$/, ".css") # replace extension with .css
+        )
       end
       
       # Gets the Sass options, with Site options merged in.
@@ -38,8 +31,8 @@ module Massimo
         options = {
           :style => site.production? ? :compressed : :nested
         }
-        options.merge!(self.site.options[:sass]) if self.site.options[:sass].is_a?(Hash)
-        options.merge(:css_filename => self.output_path)
+        options.merge!(site.options[:sass]) if site.options[:sass].is_a?(Hash)
+        options.merge(:css_filename => output_path)
       end
     
   end

data/lib/massimo/templates.rb

@@ -1,18 +1,18 @@
 module Tilt
-  register :html, ::Tilt::ERBTemplate
-  register :php,  ::Tilt::ERBTemplate
+  register :html, Tilt::ERBTemplate
+  register :php,  Tilt::ERBTemplate
   
   # My Markdown implementation.
   class MarkdownTemplate < Template
     def compile!
-      @erb_engine = ::Tilt::ERBTemplate.new { data }
+      @erb_engine = Tilt::ERBTemplate.new { data }
     end
 
     def evaluate(scope, locals, &block)
       # First evaluate the code using ERB
       erb_output = @erb_engine.render(scope, locals, &block)
       # Then evaluate the code using the RDiscountTemplate
-      ::Tilt::RDiscountTemplate.new { erb_output }.render
+      Tilt::RDiscountTemplate.new { erb_output }.render
     end
   end
   register :markdown, MarkdownTemplate

data/lib/massimo/view.rb

@@ -1,5 +1,5 @@
 module Massimo
-  class View < Resource
+  class View < Massimo::Resource::Base
     attr_reader :meta_data
     
     # Creates a new page associated with the given file path.
@@ -8,15 +8,15 @@ module Massimo
       super(source_path)
     end
     
-    # Renders the page using the registered filters.
+    # Renders the page using the appropriate Tilt Template
     def render(locals = {}, &block)
-      template = ::Tilt.new(self.file_name, @line || 1, self.options_for_resource_type) { @body }
-      template.render(self.site.helpers, @meta_data.merge(locals), &block)
+      template = Tilt.new(file_name, @line || 1, options_for_resource_type) { @body }
+      template.render(site.helpers, @meta_data.merge(locals), &block)
     end
     
     protected
       
-      # All undefined methods are sent to the meta_data hash.
+      # All undefined methods are sent to the `@meta_data` hash.
       def method_missing(method, *args, &block)
         if method.to_s.match(/(.*)\=$/) && args.length == 1
           @meta_data[$1.to_sym] = args.first

data/lib/massimo.rb

@@ -1,6 +1,3 @@
-libdir = ::File.dirname(__FILE__)
-$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
-
 # Rubygems
 require "rubygems"
 
@@ -15,24 +12,38 @@ require "jsmin"
 require "tilt"
 
 # Internal
-require "massimo/helpers"
-require "massimo/templates"
-require "massimo/site"
-require "massimo/resource"
-require "massimo/view"
-require "massimo/page"
-require "massimo/stylesheet"
-require "massimo/javascript"
+lib_dir = File.dirname(__FILE__)
+require File.join(lib_dir, "massimo", "helpers")
+require File.join(lib_dir, "massimo", "templates")
+require File.join(lib_dir, "massimo", "site")
 
 module Massimo
-  VERSION = ::File.read(::File.join(::File.dirname(__FILE__), *%w{.. VERSION})) # :nodoc:
+  VERSION = File.read(File.join(File.dirname(__FILE__), "..", "VERSION")) # :nodoc:
   
-  MissingResource = ::Class.new(StandardError) # :nodoc:
-  InvalidResource = ::Class.new(StandardError) # :nodoc:
+  MissingResource = Class.new(StandardError) # :nodoc:
+  InvalidResource = Class.new(StandardError) # :nodoc:
   
-  #
+  # This will create an instance of Massimo::Site the first time it is called.
+  # Everytime it's called afterwords, without options, it returns the same
+  # instance.
   def self.Site(options = {})
     return @site if defined?(@site) && options.empty?
-    @site = ::Massimo::Site.instance.setup(options)
+    @site = Massimo::Site.instance.setup(options)
+  end
+  
+  # All the avaiable Resource types
+  def self.resources
+    @resources ||= []
+  end
+  
+  # All the Resource types that are processable.
+  def self.processable_resources
+    resources.select { |resource| resource.processable? }
   end
 end
+
+require File.join(lib_dir, "massimo", "resource", "base")
+require File.join(lib_dir, "massimo", "view")
+require File.join(lib_dir, "massimo", "page")
+require File.join(lib_dir, "massimo", "stylesheet")
+require File.join(lib_dir, "massimo", "javascript")

data/massimo.gemspec

@@ -5,14 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{massimo}
-  s.version = "0.3.9"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Peter Browne"]
-  s.date = %q{2009-12-24}
+  s.date = %q{2010-01-09}
   s.default_executable = %q{massimo}
   s.description = %q{Massimo builds HTML, Javascript, and CSS Files from your source.}
-  s.email = %q{peter@peterbrowne.net}
+  s.email = %q{me@petebrowne.com}
   s.executables = ["massimo"]
   s.extra_rdoc_files = [
     "LICENSE",
@@ -31,7 +31,9 @@ Gem::Specification.new do |s|
      "lib/massimo/helpers.rb",
      "lib/massimo/javascript.rb",
      "lib/massimo/page.rb",
-     "lib/massimo/resource.rb",
+     "lib/massimo/resource/base.rb",
+     "lib/massimo/resource/collection.rb",
+     "lib/massimo/resource/processing.rb",
      "lib/massimo/site.rb",
      "lib/massimo/stylesheet.rb",
      "lib/massimo/templates.rb",
@@ -71,6 +73,7 @@ Gem::Specification.new do |s|
      "test/source/views/with_helper.haml",
      "test/source/views/with_locals.haml",
      "test/source/views/without_locals.haml",
+     "test/test_helpers.rb",
      "test/test_javascript.rb",
      "test/test_page.rb",
      "test/test_resource.rb",
@@ -88,6 +91,7 @@ Gem::Specification.new do |s|
      "test/helper.rb",
      "test/source/helpers/test_helper.rb",
      "test/source/lib/site.rb",
+     "test/test_helpers.rb",
      "test/test_javascript.rb",
      "test/test_page.rb",
      "test/test_resource.rb",
@@ -104,7 +108,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<shoulda>, [">= 2.10.2"])
       s.add_development_dependency(%q<yard>, [">= 0.5.2"])
       s.add_runtime_dependency(%q<activesupport>, [">= 2.3.5"])
-      s.add_runtime_dependency(%q<sinatra_more>, [">= 0.3.26"])
+      s.add_runtime_dependency(%q<sinatra_more>, [">= 0.3.29"])
       s.add_runtime_dependency(%q<directory_watcher>, [">= 1.3.1"])
       s.add_runtime_dependency(%q<sprockets>, [">= 1.0.2"])
       s.add_runtime_dependency(%q<jsmin>, [">= 1.0.1"])
@@ -112,7 +116,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<shoulda>, [">= 2.10.2"])
       s.add_dependency(%q<yard>, [">= 0.5.2"])
       s.add_dependency(%q<activesupport>, [">= 2.3.5"])
-      s.add_dependency(%q<sinatra_more>, [">= 0.3.26"])
+      s.add_dependency(%q<sinatra_more>, [">= 0.3.29"])
       s.add_dependency(%q<directory_watcher>, [">= 1.3.1"])
       s.add_dependency(%q<sprockets>, [">= 1.0.2"])
       s.add_dependency(%q<jsmin>, [">= 1.0.1"])
@@ -121,7 +125,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<shoulda>, [">= 2.10.2"])
     s.add_dependency(%q<yard>, [">= 0.5.2"])
     s.add_dependency(%q<activesupport>, [">= 2.3.5"])
-    s.add_dependency(%q<sinatra_more>, [">= 0.3.26"])
+    s.add_dependency(%q<sinatra_more>, [">= 0.3.29"])
     s.add_dependency(%q<directory_watcher>, [">= 1.3.1"])
     s.add_dependency(%q<sprockets>, [">= 1.0.2"])
     s.add_dependency(%q<jsmin>, [">= 1.0.1"])

data/test/helper.rb

@@ -9,8 +9,7 @@ require "assertions"
 require "rr"
 
 # Load Massimo
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require "massimo"
+require File.join(File.dirname(__FILE__), "..", "lib", "massimo")
 
 class Test::Unit::TestCase
   include Assertions
@@ -33,7 +32,7 @@ class Test::Unit::TestCase
   
   #
   def site(options = {})
-    @site = Massimo::Site({
+    @site = ::Massimo::Site({
       :source => source_dir,
       :output => output_dir,
       :sass   => { :cache => false }
@@ -42,13 +41,20 @@ class Test::Unit::TestCase
   
   #
   def page(*path)
-    @page ||= Massimo::Page.new(source_dir("pages", *path))
+    @page ||= ::Massimo::Page.new(source_dir("pages", *path))
   end
   
   #
   def view(*path)
     return @view if defined?(@view)
     meta_data = path.extract_options!
-    @view = Massimo::View.new(source_dir("views", *path), meta_data)
+    @view = ::Massimo::View.new(source_dir("views", *path), meta_data)
+  end
+  
+  #
+  def source_page_paths
+    @source_page_paths ||= Pathname.glob(source_dir("pages", "**", "*")).
+      reject  { |p| p.basename.to_s =~ /^_/ || File.directory?(p) }.
+      collect { |p| p.basename }
   end
 end

data/test/test_helpers.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "helper")
+
+class TestHelpers < Test::Unit::TestCase
+  context "A Site's Helpers" do
+    setup do
+      @helpers = site().helpers
+    end
+    
+    should "include sinatra_more's helper methods" do
+      assert @helpers.class.include?(SinatraMore::OutputHelpers)
+      assert @helpers.class.include?(SinatraMore::TagHelpers)
+      assert @helpers.class.include?(SinatraMore::AssetTagHelpers)
+      assert @helpers.class.include?(SinatraMore::FormHelpers)
+      assert @helpers.class.include?(SinatraMore::FormatHelpers)
+    end
+    
+    should "have a method for accessing the Site" do
+      assert_equal @site, @helpers.site
+    end
+    
+    should "have a method for rendering views like partials" do
+      assert_equal "<h1>Testing</h1>\n", @helpers.render("with_locals", :title => "Testing")
+    end
+  end
+end

data/test/test_page.rb

@@ -104,11 +104,17 @@ class TestPage < Test::Unit::TestCase
         end
       
       end
+      
       context "with layouts" do
       
         should "filter the content from the page file correctly" do
           assert_equal "<title>ERB With Layout</title>\n<body><h1>ERB With Layout</h1></body>\n", page("erb_with_layout.erb").render
         end
+        
+        should "render the page without a layout when calling #to_s" do
+          page("erb_with_layout.erb")
+          assert_equal @page.render(false), @page.to_s
+        end
       end
     end
     

data/test/test_resource.rb

@@ -6,22 +6,65 @@ class TestResource < Test::Unit::TestCase
     
     should "raise an error when reading a non-existent resource" do
       assert_raise Massimo::MissingResource do
-        Massimo::Resource.new("some/non-existent/file")
+        Massimo::Resource::Base.new("some/non-existent/file")
       end
     end
   
     should "raise an error when reading an invalid resource" do
       assert_raise Massimo::InvalidResource do
-        Massimo::Resource.new(source_dir("views", "layouts"))
+        Massimo::Resource::Base.new(source_dir("views", "layouts"))
       end
     end
   
     should "have a method to get the resource's type (extension)" do
-      assert_equal Massimo::Resource.new(source_dir("pages", "about_us.erb")).resource_type, "erb"
+      assert_equal Massimo::Resource::Base.new(source_dir("pages", "about_us.erb")).resource_type, "erb"
     end
   
     should "render the resource files data" do
-      assert_equal Massimo::Resource.new(source_dir("pages", "without_meta_data.haml")).render, "%h1 A Page without meta_data"
+      assert_equal Massimo::Resource::Base.new(source_dir("pages", "without_meta_data.haml")).render, "%h1 A Page without meta_data"
+    end
+    
+    context "with unprocessable Resources" do
+      should "not process resources when process! is called" do
+        assert Massimo::View.processable? == false
+        assert view("with_locals.haml").process! == false
+      end
+    end
+    
+    context "with Resource collections" do
+      should "find only the pages set in the :pages option" do
+        only_pages = %w{about_us.erb feed.haml index.erb}
+        site(:pages => only_pages)
+        page_paths = Massimo::Page.all(true).collect { |page| page.source_path.basename }
+        assert_equal_arrays only_pages, page_paths
+      end
+  
+      should "skip pages set in the :skip_pages option (as an Array)" do
+        site(:skip_pages => %w{about_us.erb erb.erb erb_with_layout.erb feed.haml posts/first-post.haml haml.haml html.html index.erb markdown.markdown})
+        page_paths = Massimo::Page.all(true).collect { |page| page.source_path.basename }
+        assert_equal_arrays [
+          "with_extension.haml",
+          "with_meta_data.haml",
+          "with_title.haml",
+          "with_url.haml",
+          "without_extension.haml",
+          "without_meta_data.haml",
+          "without_title.haml",
+          "without_url.haml"
+        ], page_paths
+      end
+  
+      should "skip pages set in the :skip_pages option (as a Proc)" do
+        site(:skip_pages => lambda { |file| file.include?("with") })
+        page_paths = Massimo::Page.all(true).collect { |page| page.source_path.basename }
+        assert_equal_arrays %w{about_us.erb erb.erb feed.haml first-post.haml haml.haml html.html index.erb markdown.markdown}, page_paths
+      end
+      
+      should "not skip any pages when :skip_pages is set incorrectly" do
+        site(:skip_pages => 15)
+        page_paths = Massimo::Page.all(true).collect { |page| page.source_path.basename }
+        assert_equal_arrays source_page_paths, page_paths
+      end
     end
   end
 end