massimo 0.4.6 → 0.5.0

data/lib/massimo/site.rb

@@ -1,132 +1,95 @@
-require "active_support/inflector"
-require "active_support/core_ext/hash/keys"
-require "singleton"
-# require "massimo/helpers"
-# require "massimo/view"
+require 'active_support/inflector'
+require 'tilt'
 
 module Massimo
   class Site
-    include Singleton
+    attr_accessor :config
     
-    # Default options. Overriden by values given when creating a Site.
-    DEFAULT_OPTIONS = {
-      :source      => ".",
-      :output      => File.join(".", "public"),
-      :server_port => "1984"
-    }.freeze
-    
-    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
-    
-    # Reload helpers and libs.
-    def reload
-      reload_helpers
-      reload_libs
-      reload_resources
-    end
-    
-    # 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(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 = find_view(name)
-      view && view.render(locals, &block)
-    end
-    
-    # Determines if the Site is in development mode.
-    def development?
-      @options[:environment].nil? || @options[:environment].to_sym == :development || @options[:development]
+    def initialize(options = nil, &block)
+      @config                    = Config.new(options)
+      @template_scope_blocks     = []
+      @template_scope_extensions = []
+      Massimo.site               = self
+      
+      instance_eval(&block) if block_given?
     end
     
-    # Determines if the Site is in production mode.
-    def production?
-      (@options[:environment] && @options[:environment].to_sym == :production) || @options[:production]
+    def resources
+      @resources ||= [ Massimo::Page, Massimo::Javascript, Massimo::Stylesheet, Massimo::View ]
     end
     
-    #------------------------------------
-    #  Directory Path Methods
-    #------------------------------------
-    
-    # The path to the source dir
-    def source_dir(*path)
-      File.join(@options[:source], *path)
+    def resource(name_or_class, &block)
+      resource = case name_or_class
+        when Class
+          name_or_class
+        else
+          Object.const_set name_or_class.to_s.classify, Class.new(Massimo::Page, &block)
+        end
+      resources << resource
     end
     
-    # 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)
+    def template_scope
+      @template_scope ||= begin
+        scope = Object.new.extend(Massimo::Helpers, Tilt::CompileSite)
+        add_template_scope_blocks(scope)
+        add_template_scope_extensions(scope)
+        add_template_scope_helpers(scope)
+        scope
       end
     end
     
-    # Get all the source directories as an array.
-    def all_source_dirs
-      Massimo.resources.collect(&:dir) + [ dir_for(:helpers), dir_for(:lib) ]
+    def helpers(*extensions, &block)
+      @template_scope_blocks     << block if block_given?
+      @template_scope_extensions += extensions
     end
     
-    # The path to the output dir
-    def output_dir(*path)
-      File.join(@options[:output], *path)
+    def process
+      @template_scope = nil
+      reload_libs
+      resources.select(&:processable?).each do |resource|
+        resource.all.each(&:process)
+      end
     end
     
     protected
+    
+      def add_template_scope_blocks(scope)
+        @template_scope_blocks.each do |block|
+          scope.instance_eval(&block)
+        end
+      end
       
-      # Reload the Helpers instance with the helper modules
-      def reload_helpers
-        @helpers = Helpers.new(helper_modules.compact)
+      def add_template_scope_extensions(scope)
+        @template_scope_extensions.each do |extension|
+          scope.extend(extension)
+        end
       end
       
-      # Reload all the files in the source lib dir.
-      def reload_libs
-        reload_files Dir.glob(dir_for(:lib, "**/*.rb"))
+      def add_template_scope_helpers(scope)
+        config.files_in(:helpers, :rb).each do |file|
+          load(file)
+          if helper = (class_name_of_file(file).constantize rescue nil)
+            scope.extend(helper)
+          end
+        end
       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)
+      def reload_libs
+        if defined? @previous_libs
+          @previous_libs.each do |lib|
+            class_name = class_name_of_file(lib)
+            Object.class_eval do
+              remove_const(class_name) if const_defined?(class_name)
             end
           end
         end
-      end
-      
-      # Find all the helper modules
-      def helper_modules
-        reload_files Dir.glob(dir_for(:helpers, "*.rb"))
-      end
-      
-      # Reload the given files and an Array of the reloaded Constants.
-      def reload_files(files)
-        files.collect do |file|
-          class_name = File.basename(file).gsub(File.extname(file), "").classify
-          Object.class_eval { remove_const(class_name) if const_defined?(class_name) }
+        @previous_libs = config.files_in(:lib, :rb).each do |file|
           load(file)
-          class_name.constantize rescue nil
         end
       end
+      
+      def class_name_of_file(file)
+        File.basename(file).sub(/\.[^\.]+$/, '').classify
+      end
   end
 end

data/lib/massimo/stylesheet.rb

@@ -1,42 +1,20 @@
-require "pathname"
-require "massimo/resource/base"
-
 module Massimo
-  class Stylesheet < Massimo::Resource::Base
-    processable!
-    
-    # Render the css based on the type of resource
+  class Stylesheet < Massimo::Resource
     def render
-      case resource_type.to_sym
-      when :sass
-        require "sass" unless defined?(Sass)
-        Sass::Files.tree_for(@source_path, sass_options).render
-      when :less
-        require "less" unless defined?(Less)
-        Less.parse(@body)
+      case source_path.extname.to_s
+      when '.sass'
+        require 'sass' unless defined?(Sass)
+        Sass::Files.tree_for(source_path.to_s, :css_filename => output_path).render
+      when '.less'
+        require 'less' unless defined?(Less)
+        Less::Engine.new(content).to_css
       else
-        @body.to_s
+        super
       end
     end
     
-    protected
-      
-      # Determine the output file path
-      def output_path
-        @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.
-      def sass_options
-        options = {
-          :style => site.production? ? :compressed : :nested
-        }
-        options.merge!(site.options[:sass]) if site.options[:sass].is_a?(Hash)
-        options.merge(:css_filename => output_path)
-      end
-    
+    def extension
+      @extension ||= '.css'
+    end
   end
-end
+end

data/lib/massimo/view.rb

@@ -1,39 +1,12 @@
-require "tilt"
-require "massimo/resource/base"
+require 'tilt'
 
 module Massimo
-  class View < Massimo::Resource::Base
-    attr_reader :meta_data
+  class View < Resource
+    unprocessable
     
-    # Creates a new page associated with the given file path.
-    def initialize(source_path, meta_data = {})
-      @meta_data = meta_data
-      super(source_path)
-    end
-    
-    # Renders the page using the appropriate Tilt Template
     def render(locals = {}, &block)
-      template = Tilt.new(file_name, @line || 1, options_for_resource_type) { @body }
-      template.render(site.helpers, @meta_data.merge(locals), &block)
+      template = Tilt.new(source_path.basename.to_s) { content }
+      template.render(Massimo.site.template_scope, locals, &block)
     end
-    
-    protected
-      
-      # All undefined methods are sent to the `@meta_data` hash.
-      def method_missing(method, *args, &block)
-        case args.length
-        when 1
-          method_name = method.to_s
-          if method_name.chomp!('=')
-            @meta_data[method_name.to_sym] = args.first
-          else
-            super
-          end
-        when 0
-          @meta_data[method]
-        else
-          super
-        end
-      end
   end
 end

data/lib/massimo/watcher.rb

@@ -0,0 +1,52 @@
+module Massimo
+  class Watcher
+    class << self
+      def start(site)
+        self.new(site).run
+      end
+    end
+    
+    def initialize(site)
+      @site  = site
+      @files = []
+    end
+    
+    def run
+      loop do
+        process
+        sleep 0.5
+      end
+    end
+    
+    def process
+      if changed?
+        begin
+          puts 'massimo has noticed a change'
+          @site.process
+          puts 'massimo has built your site'
+        rescue Exception => e
+          puts e.message
+          puts e.backtrace
+        end
+      end
+    end
+    
+    def changed?
+      @files != files
+    end
+    
+    protected
+    
+      def files
+        @files = Dir[*glob].map { |file| File.mtime(file) }
+      end
+      
+      def glob
+        glob  = @site.resources.map(&:path)
+        glob << @site.config.path_for(:lib)
+        glob << @site.config.path_for(:helpers)
+        glob.map! { |path| File.join(path, '**/*.*') }
+        glob
+      end
+  end
+end

data/lib/massimo.rb

@@ -1,37 +1,28 @@
-libdir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
-
-require "massimo/helpers"
-require "massimo/templates"
-require "massimo/site"
-
 module Massimo
-  VERSION = File.read(File.expand_path("../../VERSION", __FILE__)) # :nodoc:
+  autoload :Config,     'massimo/config'
+  autoload :Helpers,    'massimo/helpers'
+  autoload :Javascript, 'massimo/javascript'
+  autoload :Page,       'massimo/page'
+  autoload :Resource,   'massimo/resource'
+  autoload :Server,     'massimo/server'
+  autoload :Site,       'massimo/site'
+  autoload :Stylesheet, 'massimo/stylesheet'
+  autoload :View,       'massimo/view'
+  autoload :Watcher,    'massimo/watcher'
   
-  MissingResource = Class.new(StandardError) # :nodoc:
-  InvalidResource = Class.new(StandardError) # :nodoc:
+  VERSION = File.read File.expand_path('../../VERSION', __FILE__)
   
-  # 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 = Site.instance.setup(options)
-  end
-  
-  # All the avaiable Resource types
-  def self.resources
-    @resources ||= []
-  end
+  class << self
+    def site
+      @site ||= Site.new
+    end
   
-  # All the Resource types that are processable.
-  def self.processable_resources
-    resources.select { |resource| resource.processable? }
+    def site=(site)
+      @site = site
+    end
+    
+    def config
+      site.config
+    end
   end
 end
-
-require "massimo/resource/base"
-require "massimo/view"
-require "massimo/page"
-require "massimo/stylesheet"
-require "massimo/javascript"