ruhoh 1.1 → 2.1

data/lib/ruhoh/parsers/routes.rb

@@ -1,20 +0,0 @@
-class Ruhoh
-  module Parsers
-    module Routes
-
-      def self.generate
-        routes = {}
-        Ruhoh::DB.pages.each_value { |page|
-          routes[page['url']] = page['id'] 
-        }
-
-        Ruhoh::DB.posts['dictionary'].each_value { |page|
-          routes[page['url']] = page['id'] 
-        }
-        
-        routes
-      end
-    
-    end #Routes
-  end #Parsers
-end #Ruhoh

data/lib/ruhoh/parsers/scaffolds.rb

@@ -1,35 +0,0 @@
-class Ruhoh
-  module Parsers
-    module Scaffolds
-    
-      def self.generate
-        self.system_scaffolds.merge(
-          self.scaffolds
-        )
-      end
-      
-      def self.scaffolds
-        self.process(Ruhoh.paths.scaffolds)
-      end
-
-      def self.system_scaffolds
-        self.process(Ruhoh.paths.system_scaffolds)
-      end
-      
-      def self.process(path)
-        return {} unless File.exist?(path)
-      
-        scaffolds = {}
-        FileUtils.cd(path) {
-          Dir.glob("**/*").each { |filename|
-            next if FileTest.directory?(filename)
-            next if ['.'].include? filename[0]
-            File.open(filename, 'r:UTF-8') { |f| scaffolds[filename] = f.read }
-          }
-        }
-        scaffolds
-      end
-    
-    end #Scaffolds
-  end #Parsers
-end #Ruhoh

data/lib/ruhoh/parsers/site.rb

@@ -1,19 +0,0 @@
-class Ruhoh
-
-  module Parsers
-
-    # Sitewide data hash + configuration file.
-    module Site
-      
-      def self.generate
-        site = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.site_data) || {}
-        config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.config_data)
-        site['config'] = config
-        site
-      end
-    
-    end #Site
-  
-  end #Parsers
-  
-end #Ruhoh

data/lib/ruhoh/parsers/stylesheets.rb

@@ -1,63 +0,0 @@
-class Ruhoh
-  module Parsers
-    # Collect all registered stylesheets.
-    # Themes explicitly define which stylesheets to load via theme.yml.
-    # All styling is managed by the theme, including widget styles.
-    # If the theme provides widget stylesheets they will load automatically.
-    # theme.yml may also specify an explicit widget stylesheet to load.
-    module Stylesheets
-
-      # Generates mappings to all registered stylesheets.
-      # Returns Hash with layout names as keys and Array of asset Objects as values
-      def self.generate
-        assets = self.theme_stylesheets
-        assets[Ruhoh.names.widgets] = self.widget_stylesheets
-        assets
-      end
-      
-      # Create mappings for stylesheets registered to the theme layouts.
-      # Themes register stylesheets relative to their layouts.
-      # Returns Hash with layout names as keys and Array of asset Objects as values.
-      def self.theme_stylesheets
-        return {} unless Ruhoh::DB.theme_config[Ruhoh.names.stylesheets].is_a? Hash
-        assets = {}
-        Ruhoh::DB.theme_config[Ruhoh.names.stylesheets].each do |key, value|
-          next if key == Ruhoh.names.widgets # Widgets are handled separately.
-          assets[key] = Array(value).map { |v|
-            url = (v =~ /^(http:|https:)?\/\//i) ? v : "#{Ruhoh.urls.theme_stylesheets}/#{v}"
-            {
-              "url" => url,
-              "id" => File.join(Ruhoh.paths.theme_stylesheets, v)
-            }
-          }
-        end
-        
-        assets
-      end
-      
-      # Create mappings for stylesheets registered to a given widget.
-      # A theme may provide widget stylesheets which will load automatically,
-      # provided they adhere to the default naming rules.
-      # Themes may also specify an explicit widget stylesheet to load.
-      # 
-      # Returns Array of asset objects.
-      def self.widget_stylesheets
-        assets = []
-        Ruhoh::DB.widgets.each_key do |name|
-          default_name = "#{name}.css"
-          stylesheet = Ruhoh::DB.theme_config[Ruhoh.names.stylesheets][Ruhoh.names.widgets][name] rescue default_name
-          stylesheet ||=  default_name
-          file = File.join(Ruhoh.paths.theme_widgets, name, Ruhoh.names.stylesheets, stylesheet)
-          next unless File.exists?(file)
-          assets << {
-            "url" => [Ruhoh.urls.theme_widgets, name, Ruhoh.names.stylesheets, stylesheet].join('/'),
-            "id" => file
-          }
-        end
-
-        assets
-      end
-      
-    end #Stylesheets
-  end #Parsers
-end #Ruhoh

data/lib/ruhoh/parsers/theme_config.rb

@@ -1,30 +0,0 @@
-class Ruhoh
-  module Parsers
-    module ThemeConfig
-      
-      def self.generate
-        config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.theme_config_data)
-        if config.nil?
-          Ruhoh::Friend.say{ 
-            yellow "WARNING: theme.yml config file not found:"
-            yellow "  #{Ruhoh.paths.theme_config_data}"
-          }
-          return {}
-        end
-        return {} unless config.is_a? Hash
-        
-        config["exclude"] = Array(config['exclude']).compact.map do |node| 
-          is_last = node[0] == "*"
-          node = node.chomp("*").reverse.chomp("*").reverse
-          node = Regexp.escape("#{node}")
-          node = is_last ? "#{node}$" : "^#{node}"
-          
-          Regexp.new(node, true)
-        end
-        
-        config
-      end
-      
-    end #ThemeConfig
-  end #Parsers
-end #Ruhoh

data/lib/ruhoh/parsers/widgets.rb

@@ -1,104 +0,0 @@
-class Ruhoh
-  module Parsers
-    module Widgets
-      WidgetStructure = Struct.new(
-        :name,
-        :config,
-        :javascripts,
-        :layout
-      )
-
-      # Process available widgets into widget dictionary.
-      #
-      # Returns Dictionary of widget data.
-      def self.generate
-        widgets = {}
-        self.widgets.each do |name|
-          config = self.process_config(name)
-          widgets[name] = WidgetStructure.new(
-            name,
-            config,
-            self.process_javascripts(config, name),
-            self.process_layout(config, name)
-          )
-        end
-        Ruhoh::Utils.report('Widgets', widgets, [])
-
-        widgets
-      end
-
-      # Find the widgets.
-      #
-      # Returns Array of widget names.
-      def self.widgets
-        names = []
-        if FileTest.directory?(Ruhoh.paths.widgets)
-          FileUtils.cd(Ruhoh.paths.widgets) { names += Dir["*"] }
-        end
-        if FileTest.directory?(Ruhoh.paths.system_widgets)
-          FileUtils.cd(Ruhoh.paths.system_widgets) { names += Dir["*"] }
-        end
-        names.uniq!
-        names
-      end
-      
-      # Process the widget configuration params.
-      #
-      # Returns Hash of configuration params.
-      def self.process_config(widget_name)
-        system_config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.system_widgets, widget_name, Ruhoh.names.config_data) || {}
-        user_config = Ruhoh::Utils.parse_yaml_file(Ruhoh.paths.widgets, widget_name, Ruhoh.names.config_data) || {}
-        config = Ruhoh::Utils.deep_merge(system_config, user_config)
-        config['layout'] ||= widget_name
-        config['stylesheet'] ||= widget_name
-        config
-      end
-      
-      # Process widget script dependencies.
-      # Script dependencies may be set in the config.
-      # Look for default script at: scripts/{widget_name}.js if no config.
-      # If found, we include it, else no javascripts will load.
-      #
-      # Returns Array of script filenames to load.
-      def self.process_javascripts(config, widget_name)
-        scripts = config[Ruhoh.names.javascripts] ? Array(config[Ruhoh.names.javascripts]) : []
-        
-        # Try for the default script if no config.
-        if scripts.empty?
-          script_file = File.join(Ruhoh.paths.widgets, widget_name, Ruhoh.names.javascripts, "#{widget_name}.js")
-          if File.exist?(script_file)
-            scripts << "#{widget_name}.js"
-          else
-            script_file = File.join(Ruhoh.paths.system_widgets, widget_name, Ruhoh.names.javascripts, "#{widget_name}.js")
-            scripts << "#{widget_name}.js" if File.exist?(script_file)
-          end
-        end
-        
-        scripts
-      end
-      
-      # Determine and process the correct widget layout.
-      # The layout may be manually configured by the user,
-      # else system defaults will be used.
-      # Layouts cascade from: theme -> blog -> system
-      #
-      # Returns String of rendered layout content.
-      def self.process_layout(config, widget_name)
-        layout = nil
-        layout_path = File.join(widget_name, 'layouts', "#{config['layout']}.html")
-        [
-          File.join(Ruhoh.paths.theme_widgets, layout_path),
-          File.join(Ruhoh.paths.widgets, layout_path),
-          File.join(Ruhoh.paths.system_widgets, layout_path)
-        ].each do |path|
-          layout = path and break if File.exist?(path)
-        end
-
-        return '' unless layout
-        content = File.open(layout, 'r:UTF-8') { |f| f.read }
-        Mustache.render(content, {'config' => config})
-      end
-      
-    end #Widgets
-  end #Parsers
-end #Ruhoh

data/lib/ruhoh/paths.rb

@@ -1,83 +0,0 @@
-class Ruhoh
-  # Structured container for all paths to relevant directories and files in the system.
-  # Paths are based on the ruhohspec for the Universal Blog API.
-  # Additionally we store some system (gem) level paths for cascading to default functionality,
-  # such as default widgets, default dashboard view, etc.
-  module Paths
-    Paths = Struct.new(
-      :base,
-      :compiled,
-      :config_data,
-      :dashboard_file,
-      :media,
-      :pages,
-      :partials,
-      :plugins,
-      :posts,
-      :scaffolds,
-      :site_data,
-      :themes,
-      :widgets,
-      
-      :theme,
-      :theme_config_data,
-      :theme_dashboard_file,
-      :theme_layouts,
-      :theme_media,
-      :theme_partials,
-      :theme_javascripts,
-      :theme_stylesheets,
-      :theme_widgets,
-      
-      :system,
-      :system_dashboard_file,
-      :system_scaffolds,
-      :system_partials,
-      :system_widgets
-    )
-    
-    def self.generate
-      paths                     = Paths.new
-      paths.base                = Ruhoh.base
-      paths.config_data         = File.join(Ruhoh.base, Ruhoh.names.config_data)
-      paths.pages               = File.join(Ruhoh.base, Ruhoh.names.pages)
-      paths.posts               = File.join(Ruhoh.base, Ruhoh.names.posts)
-      paths.partials            = File.join(Ruhoh.base, Ruhoh.names.partials)
-      paths.media               = File.join(Ruhoh.base, Ruhoh.names.media)
-      paths.widgets             = File.join(Ruhoh.base, Ruhoh.names.widgets)
-      paths.compiled            = File.join(Ruhoh.base, Ruhoh.names.compiled)
-      paths.dashboard_file      = File.join(Ruhoh.base, Ruhoh.names.dashboard_file)
-      paths.site_data           = File.join(Ruhoh.base, Ruhoh.names.site_data)
-      paths.themes              = File.join(Ruhoh.base, Ruhoh.names.themes)
-      paths.plugins             = File.join(Ruhoh.base, Ruhoh.names.plugins)
-      paths.scaffolds           = File.join(Ruhoh.base, Ruhoh.names.scaffolds)
-      
-      paths.theme               = File.join(Ruhoh.base, Ruhoh.names.themes, Ruhoh.config.theme)
-      paths.theme_dashboard_file= File.join(paths.theme, Ruhoh.names.dashboard_file)
-      paths.theme_config_data   = File.join(paths.theme, Ruhoh.names.theme_config)
-      paths.theme_layouts       = File.join(paths.theme, Ruhoh.names.layouts)
-      paths.theme_stylesheets   = File.join(paths.theme, Ruhoh.names.stylesheets)
-      paths.theme_javascripts       = File.join(paths.theme, Ruhoh.names.javascripts)
-      paths.theme_media         = File.join(paths.theme, Ruhoh.names.media)
-      paths.theme_widgets       = File.join(paths.theme, Ruhoh.names.widgets)
-      paths.theme_partials      = File.join(paths.theme, Ruhoh.names.partials)
-      
-      return false unless self.theme_is_valid?(paths)
-      
-      paths.system                    = File.join(Ruhoh::Root, Ruhoh.names.system)
-      paths.system_dashboard_file     = File.join(paths.system, Ruhoh.names.dashboard_file)
-      paths.system_partials           = File.join(paths.system, Ruhoh.names.partials)
-      paths.system_scaffolds          = File.join(paths.system, Ruhoh.names.scaffolds)
-      paths.system_widgets            = File.join(paths.system, Ruhoh.names.widgets)
-
-      paths
-    end
-    
-    def self.theme_is_valid?(paths)
-      return true if FileTest.directory?(paths.theme)
-      Ruhoh.log.error("Theme directory does not exist: #{paths.theme}")
-      return false
-    end
-    
-  end #Paths
-end #Ruhoh

data/lib/ruhoh/previewer.rb

@@ -1,48 +0,0 @@
-class Ruhoh
-  # Public: Rack application used to render singular pages via their URL.
-  # 
-  # This class depends on a correctly loaded Ruhoh environment;
-  # it should only be used as part of a Ruhoh 'program' routine.
-  # See Ruhoh::Program for usage.
-  #
-  class Previewer
-    
-    def initialize(page)
-      Ruhoh.config.env ||= 'development'
-      @page = page
-    end
-
-    def call(env)
-      return favicon if env['PATH_INFO'] == '/favicon.ico'
-      # Always remove trailing slash if sent unless it's the root page.
-      env['PATH_INFO'].gsub!(/\/$/, '') unless env['PATH_INFO'] == "/"
-      return admin if env['PATH_INFO'] == Ruhoh.urls.dashboard
-      
-      id = Ruhoh::DB.routes[env['PATH_INFO']]
-      raise "Page id not found for url: #{env['PATH_INFO']}" unless id
-      @page.change(id)
-
-      [200, {'Content-Type' => 'text/html'}, [@page.render]]
-    end
-    
-    def favicon
-      [200, {'Content-Type' => 'image/x-icon'}, ['']]
-    end
-
-    def admin
-      template = nil
-      [
-        Ruhoh.paths.theme_dashboard_file,
-        Ruhoh.paths.dashboard_file,
-        Ruhoh.paths.system_dashboard_file
-      ].each do |path|
-        template = path and break if File.exist?(path)
-      end
-      template = File.open(template, 'r:UTF-8') {|f| f.read }
-      output = @page.templater.render(template, Ruhoh::DB.payload)
-      
-      [200, {'Content-Type' => 'text/html'}, [output]]
-    end
-        
-  end #Previewer
-end #Ruhoh

data/lib/ruhoh/program.rb

@@ -1,68 +0,0 @@
-class Ruhoh
-  module Program
-    
-    # Public: A program for running ruhoh as a rack application
-    # which renders singular pages via their URL.
-    # 
-    # Examples
-    #
-    #  In config.ru:
-    #
-    #   require 'ruhoh'
-    #   run Ruhoh::Program.preview
-    #
-    # Returns: A new Rack builder object which should work inside config.ru
-    def self.preview(opts={})
-      opts[:watch] ||= true
-      opts[:env] ||= 'development'
-      
-      Ruhoh.setup
-      Ruhoh.config.env = opts[:env]
-      Ruhoh.setup_paths
-      Ruhoh.setup_urls
-      Ruhoh.setup_plugins unless opts[:enable_plugins] == false
-      
-      Ruhoh::DB.update_all
-      
-      Ruhoh::Watch.start if opts[:watch]
-      Rack::Builder.new {
-        use Rack::Lint
-        use Rack::ShowExceptions
-
-        # Serve base media
-        map Ruhoh.urls.media do
-          run Rack::File.new(Ruhoh.paths.media)
-        end
-        
-        # Serve theme assets
-        map Ruhoh.urls.theme do
-          run Rack::File.new(Ruhoh.paths.theme)
-        end
-        
-        # Serve widget javascripts
-        map Ruhoh.urls.widgets do
-          run Rack::File.new(Ruhoh.paths.widgets)
-        end
-
-        map '/' do
-          run Ruhoh::Previewer.new(Ruhoh::Page.new)
-        end
-      }
-    end
-    
-    # Public: A program for compiling to a static website.
-    # The compile environment should always be 'production' in order
-    # to properly omit drafts and other development-only settings.
-    def self.compile(target)
-      Ruhoh.setup
-      Ruhoh.config.env = 'production'
-      Ruhoh.setup_paths
-      Ruhoh.setup_urls
-      Ruhoh.setup_plugins
-      
-      Ruhoh::DB.update_all
-      Ruhoh::Compiler.compile(target)
-    end
-    
-  end #Program
-end #Ruhoh