scms 3.2.0 → 4.0.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTQyZDcwZTdiYzYyZmM4YzQyY2Q2NTNlMWRkNjQ0ZjQ1ZDFkNTVkNA==
+    NDRkYmE3ODg1NzQzMDQ3NjcwYjJlNTAxNTk4YWJiYzg4MzQ5MmI0MA==
   data.tar.gz: !binary |-
-    YWNhMDA4Y2QxOGRmODJkYTExZDE2N2UzMWNiYjI3M2M5ZWM5ZWMyYQ==
+    YjliNjY2YzNhNTFmYzg1NjI2Y2I1ZjE3NTg0NmExMDY4ODA2ZWJkZg==
 SHA512:
   metadata.gz: !binary |-
-    YTdkNTc3ZjNmMTgxNjNlNGVjZGRlZDdiMWEwMzIwMzY4YzBhMDQwZGIwYjQ1
-    ZjZmODY5NDliMzg3ZDA5YjRlMmVkZWM3ZTJhMjBjM2IxYzgyNmVmYzgwZjUw
-    MTI4MWFjYTA0YTU1OTM4ZmJhOGRjZjljOWY0NGQxN2UwZWMyZjQ=
+    ODdlZWEzZGM0MDQ2NTA5MzczOTQzZDMwYzY2Y2Q2NTA5Nzg0NzExYjE3NzA3
+    NGU5OGQzYjEyNmZhMWY4NTA1NWVkNmFhNDUwYjJjYzZiYjA3NTI5ZTM3N2Q2
+    MDA3NmRmYjE3NDViNTY4OWE3ZjdlNTkwODY4M2M1NTg3N2IxZWU=
   data.tar.gz: !binary |-
-    NGVmNjYzYmUzN2ZkNGRhMmIzNTRkM2M0MjY0NzBmYjgzZjYzYjYyNDliYmZk
-    NTJiNjkxZTZhZDEwYjI3NDFjY2U1YjYyOTY0YjY0ZjA1NDA5ZWFiMDVkNTQw
-    ZTM1ZTk1OTkzNTViZWQ2ZTU5NWY5NTkzYmM1NDg1OWFjMDZkZDM=
+    NTMyYTMwMGVlMzNiODZjZDg2MmUzOTk4MTMxZTRjMDFkMWZmZjRmMGUyOWIw
+    M2YyY2RiZmQzYWUyNjRiYzczOTI1YWQ4OTVmN2Q2ZmU2MzQ2Y2Y1NzM2MjMw
+    M2E4OTRjNGQyZWM2NGFlYTA3OWRmZjI2YmMxZjczZTAxYzhhY2Q=

data/bin/scms

@@ -118,18 +118,20 @@ if options[:create] != nil
     exit
 end
 
-monkeyhook = File.join(Folders[:website], "scripts", "air-monkey-hook.js")
+monkeyhookDir = File.join(Folders[:website], "scripts")
+monkeyhook = File.join(monkeyhookDir, "air-monkey-hook.js")
 if options[:mode] == "cms"
+  Dir.mkdir(monkeyhookDir, 755) unless File::directory?(monkeyhookDir)
   FileUtils.cp(File.join(Folders[:assets], "air-monkey-hook.js"), monkeyhook)
 else
   FileUtils.rm(monkeyhook) if File.exist?(monkeyhook) && options[:publish]
 end
 
-settings = Scms.getsettings(Folders[:config])
+settings = Scms.getSettings(Folders[:config])
 Scms.sassall(Folders[:website])
 Scms.bundle(settings, Folders[:website])
-Scms.build(Folders[:website], settings, options[:mode])
-Scms.copywebsite(Folders[:website], Folders[:destination]) if Folders[:destination] != ''
+Scms.build(Folders[:website], settings, options)
+Scms.copyWebsite(Folders[:website], Folders[:destination]) if Folders[:destination] != ''
 
 if options[:watch]
   ScmsWatcher.watch(settings, options, Folders[:config])

data/lib/scms.rb

@@ -1,11 +1,13 @@
-require "scms/version"
-
 module Scms
+    require "scms/version"
+    require 'scms/scms-pageoptions.rb'
     require 'scms/scms-helpers.rb'
     require 'scms/scms-utils.rb'
     require 'scms/scms-xmlhandler.rb'
     require 'scms/s3deploy.rb'
 
+    require 'fileutils'
+    require 'pathname'
     require 'erb'
     require 'ostruct' 
     require 'yaml'
@@ -15,7 +17,7 @@ module Scms
     
     include YAML
     
-    def Scms.getsettings(configdir)
+    def Scms.getSettings(configdir)
         yamlpath=File.join(configdir, "_config.yml")
         settings = ScmsUtils.readyaml(yamlpath)
         if settings           
@@ -25,9 +27,8 @@ module Scms
         end
     end
 
-    def Scms.build(website, settings, mode = "pub")
-        @mode = mode
-        #ScmsUtils.log("Mode: #{mode}")
+    def Scms.build(website, settings, options)
+
         
         ScmsUtils.boldlog("Compiling #{website}")
         
@@ -49,7 +50,7 @@ module Scms
                     ScmsUtils.writelog("type NUL > #{bootstrap}", website)
                 end
             end 
-            Scms.parsepages(settings, website)
+            Scms.parsePages(website, settings, options)
         else
             ScmsUtils.errLog("Config is empty")
         end
@@ -58,232 +59,179 @@ module Scms
         ScmsUtils.log(ScmsUtils.uriEncode("file:///#{website}"))
     end
 
-    def Scms.parsepages(settings, website)
-        # build views from templates
-        
-        if settings["pages"] != nil
+    def Scms.parsePages(website, settings, options)
+        # build pages defined in config file
+        Scms.parseSettingsPages(website, settings, options)
+        # build pages pased on _pages folder
+        Scms.parseFolderPages(website, settings, options)
+    end
 
-            # Build bundle model
-            bundlemodel = Scms.bundlemodel(settings)
-            # Build navigation model
-            navmodel = Scms.navmodel(settings)
-            #puts "navmodel: #{navmodel}"
+    def Scms.parseSettingsPages(website, settings, options)
+        if settings["pages"] != nil
 
             ScmsUtils.log("Compiling Pages:")
             settings["pages"].each do |pagedata|
                 #puts "pagedata: #{pagedata}"
                 if pagedata != nil
-                    pagedata.each do |pageoptions|
-                        pagename =  pageoptions[0]
-                        pageconfig = pageoptions[1]
-                        pageurl = pageconfig["generate"]
-                        title = pagename
-                        title = pageconfig["title"] unless pageconfig["title"] == nil
-                        description = ""
-                        description = pageconfig["description"] if pageconfig["description"] != nil
-                        keywords = ""
-                        keywords = pageconfig["keywords"] if pageconfig["keywords"] != nil
-                        skin = settings["template"]
-                        skin = pageconfig["template"] unless pageconfig["template"] == nil
-                        
-                        resource = Hash.new
-                        if pageconfig["resource"] != nil
-                            resourcepath = File.join(website, pageconfig["resource"])
-                            if File.exists?(resourcepath)
-                                #ScmsUtils.log( "_Resource found: #{pageconfig["resource"]}_" )
-                                begin
-                                    resource = YAML.load_file(resourcepath)
-                                rescue Exception=>e
-                                    ScmsUtils.errLog(e.message)
-                                    ScmsUtils.log(e.backtrace.inspect)
-                                end
-                            else
-                                ScmsUtils.errLog("Resource not found: #{pageconfig["resource"]}")
-                                ScmsUtils.writelog("::Resource not found #{pageconfig["resource"]}", website)
-                                ScmsUtils.writelog("type NUL > #{resourcepath}", website)
-                            end
-                        end
-                        
-                        hasHandler = false
-                        if pageconfig["handler"] != nil
-                            handlerpath = File.join(website, pageconfig["handler"])
-                            if File.exists?(handlerpath)
-                                ScmsUtils.log( "Handler found: #{pageconfig["handler"]}" )
-                                hasHandler = true
-                                begin
-                                     require handlerpath
-                                #     #hasHandler = ScmsHandler.instance_methods(false).include? :render
-                                #     hasHandler = ScmsHandler.method_defined?(:render)
-                                #     puts "has render method: #{hasHandler}"
-                                #     if !hasHandler
-                                #         ScmsUtils.errLog( "Handler doesnt have a render method" )
-                                #     end
-                                rescue Exception => e 
-                                    ScmsUtils.errLog( "Problem running: ScmsHandler: #{e.message}" )
-                                end
-                            else
-                                ScmsUtils.errLog("Handler not found: #{pageconfig["handler"]}")
-                                ScmsUtils.writelog("::Handler not found #{pageconfig["handler"]}", website)
-                                ScmsUtils.writelog("type NUL > #{handlerpath}", website)
-                            end
-                        end
-                        
-                        views = Hash.new
-                        if pageconfig["views"] != nil
-                            pageconfig["views"].each do |view| 
-                                views[view[0]] = ""
-                                viewparts = view[1].split("?") # This allows views to have a query string in the config
-                                viewname = viewparts[0]
-                                viewqs = viewparts[1]
-
-                                #puts "viewname: #{viewname}, viewqs: #{viewqs}"
-
-                                viewpath = File.join(website, viewname)
-                                
-
-                                if File.exists?(viewpath)
-                                    begin
-                                        htmlsnipet = File.read(viewpath)
-                                    rescue Exception=>e
-                                        ScmsUtils.errLog(e.message)
-                                        ScmsUtils.log(e.backtrace.inspect)
-                                    end
-                                    
-                                    if htmlsnipet.empty?
-                                        ScmsUtils.log("Empty view: #{view[1]}")
-                                    end
-
-                                    model = Hash.new
-                                    model = Hash[viewqs.split('&').map{ |q| q.split('=') }] if viewqs != nil
-
-                                    viewmodel = Hash.new
-                                    viewmodel = { 
-                                        :name => pagename,
-                                        :title => title,
-                                        :url => pageurl,
-                                        :data => pagedata,
-                                        :rootdir => website, 
-                                        :resource => resource,
-                                        :view => {
-                                            :name => viewname,
-                                            :model => model
-                                        }
-                                    }
-
-                                    if hasHandler
-                                        ScmsUtils.log("Rendering with handler")
-                                        begin
-                                            viewSnippet = ScmsHandler.render(viewpath)
-                                        rescue Exception=>e
-                                            ScmsUtils.errLog(e.message)
-                                            ScmsUtils.log(e.backtrace.inspect)
-                                        end
-                                        
-                                    else
-                                        #todo: why not use htmlsnipet
-                                        snnipetCode = File.read(viewpath)
-                                        
-                                        case File.extname(view[1])
-                                        when ".xml"
-                                            viewSnippet = ScmsXmlHandler.transform(snnipetCode)
-                                        when ".md"
-                                            begin  
-                                                snnipetCode = snnipetCode.encode('UTF-8', :invalid => :replace, :undef => :replace)
-                                                doc = Maruku.new(snnipetCode)
-                                                viewSnippet = doc.to_html
-                                            rescue Exception => e  
-                                                viewSnippet = snnipetCode
-                                                ScmsUtils.errLog(e.message)
-                                                ScmsUtils.log(e.backtrace.inspect)
-                                            end
-                                        else
-                                          viewSnippet = snnipetCode
-                                        end
-                                    end
-                                    
-                                    if @mode == "cms"
-                                        views[view[0]] = "<div class='cms' data-view='#{view[1]}' data-page='#{pageurl}'>#{Scms.parsetemplate(viewSnippet, viewmodel)}</div>"
-                                    else
-                                        views[view[0]] = Scms.parsetemplate(viewSnippet, viewmodel)
-                                    end
-                                else
-                                    ScmsUtils.errLog("View not found: #{view[0]} - #{view[1]} [#{viewpath}]")
-                                    ScmsUtils.writelog("::View not found: #{view[0]} - #{view[1]} [#{viewpath}]", website)
-                                    ScmsUtils.writelog("type NUL > #{viewpath}", website)
-                                end
-                                #ScmsUtils.log( "view = #{view[0]} - #{view[1]}" )
-                            end
-                        end
+                    pagedata.each do |pageOptions|
+                        pagename =  pageOptions[0]
+                        pageconfig = pageOptions[1]
 
-                        monkeyhook = "";
-                        monkeyhook = "<script src='scripts/air-monkey-hook.js'></script>" if @mode == "cms"
+                        pageOptions = PageOptions.new(pagename, website, pageconfig, settings)
+                        views = Scms.getSettingsViews(pageconfig["views"], website, pageOptions, options)
 
-                        livereload = ""
-                        if @mode != "deploy"
-                            livereload = "<script>document.write('<script src=\"http://' + (location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1\"></' + 'script>')</script>" if @mode != "cms"
-                        end
-                        
-                        pagemodel = Hash.new
-                        pagemodel = { 
-                            :name => pagename,
-                            :title => title,
-                            :description => description,
-                            :keywords => keywords,
-                            :url => pageurl,
-                            :views => views, 
-                            :resource => resource, 
-                            :config => pageconfig, 
-                            :bundles => bundlemodel,
-                            :navigation => navmodel,
-                            :data => pagedata,
-                            :rootdir => website, 
-                            :monkeyhook => monkeyhook,
-                            :livereload => livereload
-                        }
-
-                        break if pageconfig["generate"] == nil
-
-                        erb = File.join(website, skin)
-                        out = File.join(website, File.join(pageconfig["generate"].sub('~/',''))) 
-                        
-                        #ScmsUtils.log("Generating: #{pageurl} with #{skin}")
+                        # Dont save a page if no views have been defined (so the config han have pages for nav building)
+                        break if views.length < 1
+                        Scms.save(settings, website, pageOptions, views, options)
+                    end
+                end
+                #ScmsUtils.log( out )
+            end
+        end
+    end
 
-                        if File.exists?(erb)
-                            pubsubdir = File.dirname(out)
-                            Dir.mkdir(pubsubdir, 755) unless File::directory?(pubsubdir)
+    def Scms.getSettingsViews(settingsViews, website, pageOptions, options)
+        views = Hash.new
+        if settingsViews != nil
+            settingsViews.each do |view| 
+                viewname = view[0]
+                viewparts = view[1].split("?") # This allows views to have a query string in the config
+                viewpath = viewparts[0]
+                viewqs = viewparts[1]
+
+                viewModel = Hash.new
+                viewModel = Hash[viewqs.split('&').map{ |q| q.split('=') }] if viewqs != nil
+                views[viewname] = Scms.parseView(viewname, viewpath, website, pageOptions, options, viewModel)
+            end
+        end
+        return views
+    end
 
-                            erbtemplate = File.read(erb)
+    def Scms.parseFolderPages(website, settings, options)
+        pagesFolder = File.join(website, "_pages")
+        Dir.glob("#{pagesFolder}/**/*/").each do |pageFolder|
+            pagename = File.basename(pageFolder, ".*")
+            #puts "pagename: #{pagename}"
+
+            pageconfig = nil
+            pageconfig = Scms.getSettings(pageFolder) if File.exists?(File.join(pageFolder, "_config.yml"))
+            pageOptions = PageOptions.new(pagename, website, pageconfig, settings)
+            views = Hash.new
+            if pageconfig != nil
+                views = Scms.getSettingsViews(pageconfig["views"], website, pageOptions, options) if pageconfig["views"] != nil
+            end
+            
+            Dir.glob(File.join(pageFolder, "*")).reject { |f| f =~ /\.yml$/ || File.directory?(f) }.each do |view|
+                viewname = File.basename(view, ".*")
+                viewpath = Pathname.new(view).relative_path_from(Pathname.new(website)).to_s
+                views[viewname] = Scms.parseView(viewname, viewpath, website, pageOptions, options)
+            end
+            Scms.save(settings, website, pageOptions, views, options)
+        end
+    end
 
-                            #puts "pagemodel: #{pagemodel}"
-                            #html = ""
-                            html = Scms.parsetemplate(erbtemplate, pagemodel)
+    def Scms.parseView(viewname, viewpath, website, pageOptions, options, viewModel = nil)
+        #puts "parsing view: #{viewname}"
 
-                            html = html.gsub('~/', ScmsUtils.uriEncode("file:///#{website}/")) if @mode == "cms"
-                            websiteroot = '/'
-                            websiteroot = settings["url"] unless settings["rooturl"] == nil
+        viewhtml = ""
+        viewfullpath = File.join(website, viewpath)
 
-                            html = html.gsub('~/', websiteroot)
-                            begin
-                                File.open(out, 'w') {|f| f.write(html) }
-                            rescue Exception=>e
-                                ScmsUtils.errLog(e.message)
-                                ScmsUtils.log(e.backtrace.inspect)
-                            end
-                        else
-                            ScmsUtils.errLog("Template doesn't exist: #{skin}")
-                            ScmsUtils.writelog("::Template doesn't exist #{skin}", website)
-                            ScmsUtils.writelog("type NUL > #{erb}", website)
-                        end
+        if File.exists?(viewfullpath)
+            begin
+                htmlsnipet = File.read(viewfullpath)
+            rescue Exception=>e
+                ScmsUtils.errLog(e.message)
+                ScmsUtils.log(e.backtrace.inspect)
+            end
+            
+            if htmlsnipet.empty?
+                ScmsUtils.log("Empty view: #{viewpath}")
+            end
 
-                        ScmsUtils.successLog("Generated: #{pageurl}")
+            hasHandler = false
+            if pageOptions.handler != nil
+                handlerpath = File.join(website, pageOptions.handler)
+                if File.exists?(handlerpath)
+                    ScmsUtils.log( "Handler found: #{pageOptions.handler}" )
+                    hasHandler = true
+                    begin
+                         require handlerpath
+                    #     #hasHandler = ScmsHandler.instance_methods(false).include? :render
+                    #     hasHandler = ScmsHandler.method_defined?(:render)
+                    #     puts "has render method: #{hasHandler}"
+                    #     if !hasHandler
+                    #         ScmsUtils.errLog( "Handler doesnt have a render method" )
+                    #     end
+                    rescue Exception => e 
+                        ScmsUtils.errLog( "Problem running: ScmsHandler: #{e.message}" )
                     end
+                else
+                    ScmsUtils.errLog("Handler not found: #{pageOptions.handler}")
+                    ScmsUtils.writelog("::Handler not found #{pageOptions.handler}", website)
+                    ScmsUtils.writelog("type NUL > #{handlerpath}", website)
                 end
-                #ScmsUtils.log( out )
             end
+
+            if hasHandler
+                ScmsUtils.log("Rendering with handler")
+                begin
+                    viewSnippet = ScmsHandler.render(viewpath)
+                rescue Exception=>e
+                    ScmsUtils.errLog(e.message)
+                    ScmsUtils.log(e.backtrace.inspect)
+                end
+            else
+                case File.extname(viewpath)
+                when ".xml"
+                    viewSnippet = ScmsXmlHandler.transform(htmlsnipet)
+                when ".md"
+                    begin  
+                        htmlsnipet = htmlsnipet.encode('UTF-8', :invalid => :replace, :undef => :replace)
+                        doc = Maruku.new(htmlsnipet)
+                        viewSnippet = doc.to_html
+                    rescue Exception => e  
+                        viewSnippet = htmlsnipet
+                        ScmsUtils.errLog(e.message)
+                        ScmsUtils.log(e.backtrace.inspect)
+                    end
+                else
+                  viewSnippet = htmlsnipet
+                end
+            end
+
+            viewmodel = Hash.new
+            viewmodel = { 
+                :name => pageOptions.name,
+                :title => pageOptions.title,
+                :url => pageOptions.url,
+                :resource => pageOptions.resource,
+                :rootdir => website, 
+                :view => {
+                    :name => viewname,
+                    :path => viewfullpath,
+                    :model => viewModel
+                }
+            }
+            
+            if options[:mode] == "cms"
+                viewhtml = "<div class='cms' data-view='#{viewpath}' data-page='#{pageOptions.url}'>#{Scms.render(viewSnippet, viewmodel)}</div>"
+            else
+                viewhtml = Scms.render(viewSnippet, viewmodel)
+            end
+        else
+            ScmsUtils.errLog("View not found: #{viewname} [#{viewpath}]")
+            ScmsUtils.writelog("::View not found: #{viewname} [#{viewpath}]", website)
+            ScmsUtils.writelog("type NUL > #{viewpath}", website)
         end
+
+        return viewhtml
     end
 
     def Scms.parsetemplate(template, hash = Hash.new)
+        return Scms.render(template, hash)
+    end
+
+    def Scms.render(template, hash = Hash.new)
         result = ""
         if template != nil
             begin 
@@ -291,22 +239,29 @@ module Scms
                     page = hash 
                 else
                     page = OpenStruct.new(hash)
-                end  
+                end
 
                 erb = ERB.new(template)
                 result = erb.result(page.instance_eval { binding })
             rescue StandardError => e
+                puts "page: #{page}"
                 ScmsUtils.errLog("Critical Error: Could not parse template")
-                #ScmsUtils.errLog(e.message)
-                #puts e.inspect
+                ScmsUtils.errLog(e.message)
 
-                result = "Invalid Keys in Template\n\n"
+                result = "<code style='border: 1px solid #666; background-color: light-yellow;'><pre>"
+                result += e.message
+                result += "\n\n"
+                result += e.inspect
+                result += "\n\n"
+                result += "Invalid Keys in Template\n\n"
                 result += "Valid Keys are:\n"
                 hash.each do |key, value|
                     result += "- page.#{key}\n"
                     puts "nil value foy key: #{key}" if value == nil
                     singleton_class.send(:define_method, key) { value }
                 end
+                result = "</code></pre>"
+
                 
                 result += "\n\n"
                 result += template
@@ -320,41 +275,140 @@ module Scms
         return result
     end
 
-    def Scms.bundlemodel(settings)
-        puts "Bundeling Assets"
-        bundlemodel = Hash.new
+    def Scms.save(settings, website, pageOptions, views, options)
+
+        fileName = File.join(website, File.join(pageOptions.url.sub('~/',''))) 
+        erb = File.join(website, pageOptions.template)
+        #ScmsUtils.log("Generating: #{fileName} with #{pageOptions.template}")
+
+        if File.exists?(erb)
+
+            # Build bundle model
+            bundleModel = Scms.bundleModel(website, settings, options)
+            # Build navigation model
+            navModel = Scms.navModel(website, settings, options)
+            #puts "navModel: #{navModel}"
+
+            monkeyhook = "";
+            monkeyhook = "<script src='scripts/air-monkey-hook.js'></script>" if options[:mode] == "cms"
+
+            livereload = ""
+            if options[:watch]
+                livereload = "<script async='true' defer='true'>document.write('<script src=\"http://' + (location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1\"></' + 'script>')</script>" if options[:mode] != "cms"
+            end
+            
+            pagemodel = Hash.new
+            pagemodel = { 
+                :name => pageOptions.name,
+                :title => pageOptions.title,
+                :description => pageOptions.description,
+                :keywords => pageOptions.keywords,
+                :url => pageOptions.url,
+                :resource => pageOptions.resource, 
+                :bundles => bundleModel,
+                :navigation => navModel,
+                :views => views, 
+                :rootdir => website, 
+                :monkeyhook => monkeyhook,
+                :livereload => livereload
+            }
+
+            #puts "pagemodel:"
+            #puts pagemodel
+
+            pubsubdir = File.dirname(fileName)
+            Dir.mkdir(pubsubdir, 755) unless File::directory?(pubsubdir)
+
+            erbtemplate = File.read(erb)
+
+            #puts "pagemodel: #{pagemodel}"
+            #html = ""
+            html = Scms.render(erbtemplate, pagemodel)
+
+            
+            websiteroot = '/'
+            websiteroot = settings["rooturl"] if settings["rooturl"] != nil
+            #puts "On save mode: #{options[:mode]}"
+            websiteroot = ScmsUtils.uriEncode("file:///#{website}/") if options[:mode] == "cms"
+
+            html = html.gsub('~/', websiteroot)
+            begin
+                File.open(fileName, 'w') {|f| f.write(html) }
+                ScmsUtils.successLog("Generated: #{pageOptions.url}")
+            rescue Exception=>e
+                ScmsUtils.errLog(e.message)
+                ScmsUtils.log(e.backtrace.inspect)
+            end
+        else
+            ScmsUtils.errLog("Template doesn't exist: #{pageOptions.template}")
+            ScmsUtils.writelog("::Template doesn't exist #{pageOptions.template}", website)
+            ScmsUtils.writelog("type NUL > #{erb}", website)
+        end
+    end
+
+    def Scms.navModel(website, settings, options)
+        websiteroot = '/'
+        websiteroot = settings["rooturl"] unless settings["rooturl"] == nil
+        websiteroot = ScmsUtils.uriEncode("file:///#{website}/") if options[:mode] == "cms"
+
+        navModel = Array.new
+        if settings["pages"] != nil
+            settings["pages"].each do |pagedata|
+                if pagedata != nil
+                    pagedata.each do |pageoptions|
+                        pagename =  pageoptions[0]
+                        pageconfig = pageoptions[1]
+                        pageurl = "about:blank"
+                        pageurl = pageconfig["generate"]
+                        pageurl = pageconfig["url"] unless pageconfig["url"] == nil
+                        navtext = pageconfig["navigation"]
+                        navmeta = pageconfig["navigation_meta"]
+                        navModel.push({"text" => navtext, "url" => pageurl.gsub("~/", websiteroot), "pagename" => pagename, "meta" => navmeta}) unless navtext == nil
+                    end
+                end
+            end
+        end
+        if settings["nav"] != nil
+            settings["nav"].each do |pagedata|
+                if pagedata != nil
+                    pagedata.each do |pageoptions|
+                        pagename =  pageoptions[0]
+                        pageconfig = pageoptions[1]
+                        pageurl = "about:blank"
+                        pageurl = pageconfig["url"] unless pageconfig["url"] == nil
+                        navtext = pagename
+                        navtext = pageconfig["text"]
+                        navmeta = pageconfig["meta"]
+                        navModel.push({"text" => navtext, "url" => pageurl.gsub("~/", websiteroot), "pagename" => pagename, "meta" => navmeta})
+                    end
+                end
+            end
+        end
+        return navModel
+    end  
+
+    def Scms.bundleModel(website, settings, options)
+        bundleModel = Hash.new
         bundleConfig = settings["bundles"]
         if bundleConfig != nil
             bundleConfig.each do |bundle|
                 #ScmsUtils.log( "bundle (#{bundle.class}) = #{bundle}" )
+
+                websiteroot = '/'
+                websiteroot = settings["rooturl"] unless settings["rooturl"] == nil
+                websiteroot = ScmsUtils.uriEncode("file:///#{website}/") if options[:mode] == "cms"
+
                 bundle.each do |option|
                     name = option[0]
-                    bundleName = File.join(option[1]["generate"])
-                    bundlemodel[name] = bundleName
-                end
-            end
-        end
-        return bundlemodel
-    end
+                    config = option[1]
 
-    def Scms.navmodel(settings)
-        navmodel = Array.new
-        settings["pages"].each do |pagedata|
-            if pagedata != nil
-                pagedata.each do |pageoptions|
-                    pagename =  pageoptions[0]
-                    pageconfig = pageoptions[1]
-                    pageurl = "about:blank"
-                    pageurl = pageconfig["generate"]
-                    pageurl = pageconfig["url"] unless pageconfig["url"] == nil
-                    navtext = pageconfig["navigation"]
-                    navmeta = pageconfig["navigation_meta"]
-                    navmodel.push({"text" => navtext, "url" => pageurl, "pagename" => pagename, "meta" => navmeta}) unless navtext == nil
+                    bundleName = File.join(config["generate"])
+                    bundleModel[name] = bundleName.gsub("~/", websiteroot)
                 end
             end
         end
-        return navmodel
-    end  
+        return bundleModel
+    end
 
     def Scms.bundle(settings, website)
         bundleConfig = settings["bundles"]
@@ -364,12 +418,14 @@ module Scms
                 #ScmsUtils.log( "bundle (#{bundle.class}) = #{bundle}" )
                 bundle.each do |option|
                     name = option[0]
-                    bundleName = File.join(option[1]["generate"])
+                    config = option[1]
+
+                    bundleName = File.join(config["generate"].gsub("~/",""))
                     ScmsUtils.boldlog("Bundeling:")
 
                     content = ""
                     assetList = ""
-                    files = option[1]["files"]
+                    files = config["files"]
                     if files != nil
                         files.each do |asset|
                             assetList += " - #{asset}\n" 
@@ -462,7 +518,7 @@ module Scms
         end
     end
 
-    def Scms.copywebsite(website, pub)
+    def Scms.copyWebsite(website, pub)
         if pub.to_s.strip.length != 0
             FileUtils.mkdir pub unless Dir.exists? pub
             source = File.join(website)

data/lib/scms/scms-pageoptions.rb

@@ -0,0 +1,87 @@
+module Scms
+  require 'fileutils'
+  require 'scms/scms-utils.rb'
+
+  class PageOptions
+      attr_accessor :name, :template, :url, :title, :keywords, :description, :resource, :handler
+
+      def name= name  
+        @name = name  
+      end 
+
+      def template= template  
+        @template = template  
+      end 
+
+      def url= url  
+        @url = url  
+      end 
+
+      def title= title  
+        @title = title  
+      end 
+
+      def keywords= keywords  
+        @keywords = keywords  
+      end 
+
+      def description= description  
+        @description = description  
+      end 
+
+      def resource= resource
+          @resource = resource
+      end
+
+      def handler= handler
+          @handler = handler
+      end
+
+      def initialize (name, website, pageconfig, siteConfig)  
+        @name = name
+        @template = siteConfig["template"]
+        @url = "#{name}.html"
+        @title = name
+        @keywords = ""
+        @description = ""
+        @resource = Hash.new
+        @handler = nil
+
+        if pageconfig != nil
+          @template = pageconfig["template"] unless pageconfig["template"] == nil
+          
+          @url = "#{name}/index.html" if pageconfig["cleanurl"] == true
+          @url = pageconfig["generate"] if pageconfig["generate"] != nil #depreciated
+          @url = pageconfig["url"] if pageconfig["url"] != nil
+
+          @title = pageconfig["title"] unless pageconfig["title"] == nil
+          @keywords = pageconfig["keywords"] if pageconfig["keywords"] != nil
+          @description = pageconfig["description"] if pageconfig["description"] != nil
+          @handler = pageconfig["handler"]
+          @resource = getResource(website, pageconfig["resource"])
+        end
+      end  
+
+      
+      def getResource(website, resource)
+          ymlresource = Hash.new
+          if resource != nil
+              resourcepath = File.join(website, resource)
+              if File.exists?(resourcepath)
+                  #ScmsUtils.log( "_Resource found: #{pageOptions.resource}_" )
+                  begin
+                      ymlresource = YAML.load_file(resourcepath)
+                  rescue Exception=>e
+                      ScmsUtils.errLog(e.message)
+                      ScmsUtils.log(e.backtrace.inspect)
+                  end
+              else
+                  ScmsUtils.errLog("Resource not found: #{resource}")
+                  ScmsUtils.writelog("::Resource not found #{resource}", website)
+                  ScmsUtils.writelog("type NUL > #{resourcepath}", website)
+              end
+          end
+          return ymlresource
+      end
+  end
+end

data/lib/scms/scms-utils.rb

@@ -20,17 +20,7 @@ module ScmsUtils
     end
 
     def ScmsUtils.readyaml(yamlpath)
-        ScmsUtils.log("Loading yaml: #{ScmsUtils.uriEncode("file:///#{yamlpath}")}")
         config = nil
-
-        ##http://snk.tuxfamily.org/log/yaml-json-validation-kwalify-ruby19.html
-        #'kwalify'
-        #schema = Kwalify::Yaml.load_file('some_complex_schema.yaml')
-        #validator = Kwalify::Validator.new(schema)
-        #parser = Kwalify::Yaml::Parser.new(validator)
-        #yaml = some_complex_object.to_yaml # machine-generate
-        #data = parser.parse(yaml)          # parse & validate <== FAIL
-        
         if File.exist?(yamlpath)
             tree = File.read(yamlpath)
             begin
@@ -40,6 +30,7 @@ module ScmsUtils
                 #config = YAML.load_file(yamlpath)
             rescue Exception => e  
                 ScmsUtils.errLog("Error Loading _config.yml (check there are no tabs in the file)")
+                ScmsUtils.log("Yaml: #{ScmsUtils.uriEncode("file:///#{yamlpath}")}")
                 ScmsUtils.log( "Verify your config")
                 ScmsUtils.log( "http://yaml-online-parser.appspot.com/")
                 ScmsUtils.errLog( e.message )

data/lib/scms/scms-watcher.rb

@@ -14,13 +14,15 @@ module ScmsWatcher
 				puts "***********************************"
 				puts ""
 
-				settings = Scms.getsettings(configdir)
+				settings = Scms.getSettings(configdir)
 				Scms.bundle(settings, Folders[:website])
-				Scms.build(Folders[:website], settings, options[:mode])
+				Scms.build(Folders[:website], settings, options)
 			end
 	    }
 
+	    #  [todo] Create this by getting all directories that start with _
 	    psst = []
+	    psst.push("_pages") if File.directory? "_pages" # .html .htm .md .xml .erb, etc
 	    psst.push("_views") if File.directory? "_views" # .html .htm .md .xml .erb, etc
 	    psst.push("_layouts") if File.directory? "_layouts" # .html .htm .erb
 	    psst.push("_templates") if File.directory? "_templates" # .html .htm .erb
@@ -29,15 +31,46 @@ module ScmsWatcher
 	    
 	    puts "Listening to #{psst}"
 	    listener = Listen.to(psst, force_polling: true) do |modified, added, removed|
-			# puts "modified: #{modified}" if modified.length > 0
-			# puts "added: #{added}" if added.length > 0
-			# puts "removed: #{removed}" if removed.length > 0
 
-			if modified.length > 0
-				sassfile = false
-				bundlefile = false
-				buildfile = true
+			sassfile = false
+			bundlefile = false
+			buildfile = false
+
+			if removed.length > 0
+				removed.each{|filename|
+					removedfile = Pathname.new(filename).relative_path_from(Pathname.new(Folders[:website])).to_s
+					#ext = File.extname(removedfile)  
+
+					puts ""
+					puts "***********************************************"
+					puts "  Deleted: #{removedfile}"
+					puts "***********************************************"
+					puts ""
+
+					if removedfile.start_with?('_pages/')
+						buildfile = true
+					end
+				}
+			end
+
+			if added.length > 0
+				added.each{|filename|
+					addedfile = Pathname.new(filename).relative_path_from(Pathname.new(Folders[:website])).to_s
+					#ext = File.extname(addedfile)  
+
+					puts ""
+					puts "***********************************************"
+					puts "  Added: #{addedfile}"
+					puts "***********************************************"
+					puts ""
 
+					if addedfile.start_with?('_pages/')
+						buildfile = true
+					end
+				}
+			end
+
+			if modified.length > 0
 				modified.each{|filename|
 					modifiedfile = Pathname.new(filename).relative_path_from(Pathname.new(Folders[:website])).to_s
 					ext = File.extname(modifiedfile)  
@@ -48,6 +81,8 @@ module ScmsWatcher
 					puts "***********************************************"
 					puts ""
 
+					buildfile = true
+
 					if modifiedfile.start_with?('_source/')
 						bundlefile = true
 						buildfile = false
@@ -60,12 +95,13 @@ module ScmsWatcher
 						break
 					end
 				}
-
-				Scms.sassall(Folders[:website]) if sassfile
-				Scms.bundle(settings, Folders[:website]) if bundlefile
-				Scms.build(Folders[:website], settings, options[:mode]) if buildfile
 			end
+
+			Scms.sassall(Folders[:website]) if sassfile
+			Scms.bundle(settings, Folders[:website]) if bundlefile
+			Scms.build(Folders[:website], settings, options) if buildfile
 	    end
+
 	    listener.start # not blocking
 	    listener.ignore! /\.png/
 	    listener.ignore! /\.gif/

data/lib/scms/version.rb

@@ -1,3 +1,3 @@
 module Scms
-  VERSION = "3.2.0"
+  VERSION = "4.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scms
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Courtenay Probert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-18 00:00:00.000000000 Z
+date: 2013-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cprobert-s3sync
@@ -191,6 +191,7 @@ files:
 - lib/scms/s3deploy.rb
 - lib/scms/scms-helpers.rb
 - lib/scms/scms-httpserver.rb
+- lib/scms/scms-pageoptions.rb
 - lib/scms/scms-utils.rb
 - lib/scms/scms-watcher.rb
 - lib/scms/scms-xmlhandler.rb