massimo 0.4.6 → 0.5.0

data/VERSION

@@ -1 +1 @@
-0.4.6
+0.5.0

data/bin/massimo

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 
-require File.expand_path("../../lib/massimo", __FILE__)
-require File.expand_path("../../lib/massimo/command", __FILE__)
+$:.unshift File.expand_path('../../lib', __FILE__)
 
-exit Massimo::Command.new(ARGV).run!
+require 'massimo'
+require 'massimo/cli'
+
+Massimo::CLI.start

data/lib/massimo/cli.rb

@@ -0,0 +1,101 @@
+require 'optparse'
+require 'ostruct'
+require 'thor'
+
+module Massimo
+  class CLI < Thor
+    include Thor::Actions
+    
+    default_task :build
+    class_option 'config',      :desc => 'Path to the config file', :aliases => '-c'
+    class_option 'source_path', :desc => 'Path to the source dir',  :aliases => '-s'
+    class_option 'output_path', :desc => 'Path to the output dir',  :aliases => '-o'
+    
+    desc 'build', 'Builds the site'
+    def build
+      site.process
+      say 'massimo has built your site'
+    end
+    map 'b' => :build
+    
+    desc 'watch', 'Watches your files for changes and rebuilds'
+    def watch
+      begin
+        say 'massimo is watching your files for changes'
+        Massimo::Watcher.start(site)
+      rescue Interrupt
+        exit
+      end
+    end
+    map 'w' => :watch
+    
+    desc 'server [PORT]', 'Runs a local web server and processes the site on save'
+    def server(port = 3000)
+      say "massimo is serving your site at http://localhost:#{port}"
+      Massimo::Server.start(site, port.to_i)
+    end
+    map 's' => :server
+    
+    desc 'generate SITE_OR_RESOURCE [FILE]', 'Generates a new site. Optionally generates a resource file.'
+    method_option 'page_ext',
+      :desc    => 'The extension used for generated Pages and Views',
+      :default => 'haml',
+      :aliases => '--page'
+    method_option 'javascript_ext',
+      :desc    => 'The extension used for generated Javascripts',
+      :default => 'js',
+      :aliases => '--js'
+    method_option 'stylesheet_ext',
+      :desc    => 'The extension used for generated Stylesheets',
+      :default => 'sass',
+      :aliases => '--css'
+    def generate(site_or_resource, file = nil)
+      require 'active_support/inflector'
+      
+      if file
+        create_file File.join(site.config.path_for(resource.pluralize), file)
+      else
+        empty_directory site_or_resource
+        inside site_or_resource do
+          site.resources.each do |resource|
+            empty_directory(resource.path)
+          end
+          create_file     File.join(Massimo::Page.path,       "index.#{options[:page_ext]}")
+          create_file     File.join(Massimo::Javascript.path, "main.#{options[:javascript_ext]}")
+          create_file     File.join(Massimo::Stylesheet.path, "main.#{options[:stylesheet_ext]}")
+          create_file     File.join(Massimo::View.path,       "layouts/main.#{options[:page_ext]}")
+          empty_directory site.config.output_path
+        end
+      end
+    end
+    map 'g' => :generate
+    
+    desc 'version', 'Displays current version'
+    def version
+      say Massimo::VERSION
+    end
+    map %w( -v --version ) => :version
+    
+    protected
+    
+      def site
+        @site ||= begin
+          site = Massimo::Site.new config_file(:yml)
+          if config_rb = config_file(:rb)
+            site.instance_eval File.read(config_rb)
+          end
+          site.config.source_path = options[:source_path] if options[:source_path]
+          site.config.output_path = options[:output_path] if options[:output_path]
+          site
+        end
+      end
+      
+      def config_file(ext)
+        if options[:config] && File.extname(options[:config]) == ".#{ext}"
+          options[:config]
+        elsif File.exist?("config.#{ext}")
+          "config.#{ext}"
+        end
+      end
+  end
+end

data/lib/massimo/config.rb

@@ -0,0 +1,56 @@
+require 'active_support/core_ext/hash/keys'
+require 'ostruct'
+require 'yaml'
+
+module Massimo
+  class Config < OpenStruct
+    DEFAULT_OPTIONS = {
+      :source_path     => '.',
+      :output_path     => 'public',
+      :resources_path  => '.',
+      :resources_url   => '/',
+      :javascripts_url => '/javascripts',
+      :stylesheets_url => '/stylesheets',
+      :resources_url   => '/'
+    }.freeze
+    
+    def initialize(options = nil)
+      hash = DEFAULT_OPTIONS.dup
+      
+      options = YAML.load_file(options) if options.is_a?(String)
+      hash.merge!(options.symbolize_keys) if options.is_a?(Hash)
+      
+      super hash
+    end
+    
+    def source_path
+      File.expand_path(super)
+    end
+    
+    def output_path
+      File.expand_path(super)
+    end
+    
+    def path_for(resource_name)
+      path_method = "#{resource_name}_path"
+      if resource_path = (respond_to?(path_method) and send(path_method))
+        File.expand_path(resource_path)
+      else
+        File.join(source_path, resource_name.to_s)
+      end
+    end
+    
+    def url_for(resource_name)
+      url_method = "#{resource_name}_url"
+      if resource_url = (respond_to?(url_method) and send(url_method))
+        resource_url
+      else
+        resources_url
+      end
+    end
+    
+    def files_in(resource_name, extension = '*')
+      Dir.glob(File.join(path_for(resource_name), "**/*.#{extension}"))
+    end
+  end
+end

data/lib/massimo/helpers.rb

@@ -1,28 +1,21 @@
-begin require "sinatra_more"; rescue LoadError; end
+require 'rack/utils' # needed for sinatra_more...
+require 'sinatra_more/markup_plugin'
 
 module Massimo
-  class Helpers
-    if defined? SinatraMore
-      include SinatraMore::OutputHelpers
-      include SinatraMore::TagHelpers
-      include SinatraMore::AssetTagHelpers
-      include SinatraMore::FormHelpers
-      include SinatraMore::FormatHelpers
-    end
-    
-    #
-    def initialize(modules = nil)
-      extend(*modules) unless modules.nil? || modules.empty?
-    end
+  module Helpers
+    include SinatraMore::OutputHelpers
+    include SinatraMore::TagHelpers
+    include SinatraMore::AssetTagHelpers
+    include SinatraMore::FormHelpers
+    include SinatraMore::FormatHelpers
     
-    # Gets the site instance
     def site
-      Massimo::Site()
+      Massimo.site
     end
     
-    #
-    def render(name, locals = {}, &block)
-      site.render_view(name, locals, &block)
+    def render(view_name, locals = {})
+      view = Massimo::View.find(view_name)
+      view && view.render(locals)
     end
   end
 end

data/lib/massimo/javascript.rb

@@ -1,24 +1,23 @@
-require "jsmin"
-require "sprockets"
-require "massimo/resource/base"
-
 module Massimo
-  class Javascript < Massimo::Resource::Base
-    processable!
-    
-    # Concat the Javascript using Sprockets, then minify using JSmin
+  class Javascript < Massimo::Resource
     def render
-      secretary = Sprockets::Secretary.new(
-        :assert_root  => site.output_dir,
-        :source_files => [ @source_path.to_s ]
-      )
-      # install assets if necessary
-      secretary.install_assets
-      
-      # Concatenate the scripts and minify if necessary
-      output = secretary.concatenation.to_s
-      output = JSMin.minify(output) if site.production? or site.options[:minify]
-      output
+      case source_path.extname.to_s
+      when '.coffee'
+        require 'coffee-script' unless defined?(CoffeeScript)
+        CoffeeScript.compile(content)
+      else
+        require 'sprockets' unless defined?(Sprockets)
+        secretary = Sprockets::Secretary.new(
+          :assert_root  => Massimo.config.output_path,
+          :source_files => [ source_path.to_s ]
+        )
+        secretary.install_assets
+        secretary.concatenation.to_s
+      end
+    end
+    
+    def extension
+      @extension ||= '.js'
     end
   end
 end

data/lib/massimo/page.rb

@@ -1,97 +1,90 @@
-require "active_support/inflector"
-require "pathname"
-require "yaml"
-require "massimo/view"
+require 'active_support/core_ext/hash/keys'
+require 'active_support/inflector'
+require 'tilt'
+require 'yaml'
+
+Tilt.register 'html', Tilt::StringTemplate
 
 module Massimo
-  class Page < Massimo::View
-    META_SEP = %r/\A---\s*(?:\r\n|\n)?\z/ # :nodoc:
+  class Page < Resource
+    def render
+      template  = Tilt.new(source_path.basename.to_s, @line || 1) { content }
+      meta_data = @meta_data.merge(self.class.resource_name.singularize.to_sym => self)
+      output    = template.render(Massimo.site.template_scope, meta_data)
+      if found_layout = Massimo::View.find("layouts/#{layout}")
+        output = found_layout.render(:page => self) { output }
+      end
+      output
+    end
     
-    processable!
+    def title
+      @meta_data[:title] ||= source_path.basename.to_s.chomp(source_path.extname.to_s).titleize
+    end
     
-    # Creates a new page associated with the given file path.
-    def initialize(source_path)
-      super(source_path, {
-        :title     => File.basename(source_path).gsub(File.extname(source_path), "").titleize, 
-        :extension => ".html",
-        :url       => source_path.gsub(self.class.dir, "").gsub(File.extname(source_path), "").dasherize,
-        :layout    => "application"
-      })
+    def extension
+      @meta_data[:extension] ||= '.html'
     end
     
-    # Override render to wrap the result in the layout
-    def render(use_layout = true)
-      output = super()
-      if use_layout and found_layout = find_layout
-        output = found_layout.render(:page => self) { output }
+    def url
+      @meta_data[:url] ||= begin
+        url = super
+        url.chomp!('index.html')
+        url.sub!(/\.html$/, '/')
+        url
       end
-      output
     end
     
-    # Override to_s so that the layout can include the page with `<%= page %>`
-    def to_s
-      render(false)
+    def layout
+      @meta_data[:layout] = 'main' if @meta_data[:layout].nil?
+      @meta_data[:layout]
+    end
+    
+    def output_path
+      @output_path ||= begin
+        output_path = super.to_s
+        output_path << "index.html" if output_path =~ /\/$/
+        Pathname.new output_path
+      end
     end
     
     protected
     
-      # Reads the source page file, and populates the `@meta_data` and
-      # `@body` attributes.
-      def read_source!
-        # read the source file and setup some values for the loop
-        source       = super()
+      def read_source
         @line        = nil
+        @content     = ''
         front_matter = false
-        meta_data    = ""
-        body         = ""
+        meta_data    = ''
         
-        # Loop through source to get meta data
-        # and the correct line number for the body
-        source.each_with_index do |line, line_num|
-          if line =~ META_SEP
-            front_matter = !front_matter
-          else
-            if front_matter
-              meta_data << line
+        source_path.open do |file|
+          file.each do |line|
+            if line =~ /\A---\s*\Z/
+              front_matter = !front_matter
             else
-              @line ||= line_num
-              body   << line
+              if front_matter
+                meta_data << line
+              else
+                @line ||= file.lineno
+                @content << line
+              end
             end
           end
         end
         
-        # finally get the meta_data as a hash and set the body
-        meta_data = YAML.load(meta_data)
-        @meta_data.merge!(meta_data.symbolize_keys) if meta_data
-        @body = body
+        @meta_data = (YAML.load(meta_data) || {}).symbolize_keys
       end
       
-      # Determine the output file path
-      def output_path
-        @output_path ||= begin
-          path  = site.output_dir(url)
-          path << if index? or not html?
-              extension unless path.match(/#{extension}$/)
-            else
-              "/index.html" unless path.match(/\/index\.html$/)
-            end
-          Pathname.new(path)
+      def method_missing(method, *args, &block)
+        if args.length == 0
+          read_source
+          method_name = method.to_s
+          if method_name.chomp! '?'
+            !!@meta_data[method_name.to_sym]
+          else
+            @meta_data[method_name.to_sym]
+          end
+        else
+          super
         end
       end
-      
-      # Determines if this is an index page
-      def index?
-        @source_path.basename.to_s =~ /^index/
-      end
-      
-      # Determines if this an HTML page.
-      def html?
-        extension =~ /(html|php)$/
-      end
-      
-      # Finds the Layout View if it exists
-      def find_layout
-        site.find_view("layouts/#{layout}") unless layout == false
-      end
   end
 end

data/lib/massimo/resource.rb

@@ -0,0 +1,92 @@
+require 'active_support/inflector'
+require 'fileutils'
+require 'pathname'
+
+module Massimo
+  class Resource
+    class << self
+      def resource_name
+        self.name.underscore.sub(/.*\//, '').pluralize
+      end
+      
+      def path
+        Massimo.config.path_for resource_name
+      end
+      
+      def url
+        Massimo.config.url_for resource_name
+      end
+      
+      def find(name)
+        resource_path = Dir.glob(File.join(path, "#{name}.*")).first
+        resource_path && self.new(resource_path)
+      end
+      
+      def all
+        files = Massimo.config.files_in resource_name
+        files.reject! { |file| File.basename(file) =~ /^_/ }
+        files.map { |file| self.new(file) }
+      end
+      
+      def processable?
+        true
+      end
+      
+      protected
+        
+        def unprocessable
+          def self.processable?; false; end
+          define_method(:process) { false }
+        end
+    end
+    
+    attr_reader :source_path, :content
+    
+    def initialize(source)
+      @source_path = source.is_a?(Pathname) ? source.expand_path : Pathname.new(source).expand_path
+      read_source
+    end
+    
+    def filename
+      @filename ||= source_path.basename.to_s
+    end
+    
+    def extension
+      @extension ||= source_path.extname
+    end
+    
+    def url
+      @url ||= begin
+        url = source_path.to_s.sub(/^#{Regexp.escape(self.class.path)}/, '')
+        url = url.sub(/\.[^\.]+$/, extension)
+        url = File.join(self.class.url, url) unless url.include? self.class.url
+        url = url.dasherize
+        url
+      end
+    end
+    
+    # The path to the output file.
+    def output_path
+      @output_path ||= Pathname.new File.join(Massimo.config.output_path, url)
+    end
+    
+    # Runs the content through any necessary filters, templates, etc.
+    def render
+      content
+    end
+    
+    # Writes the rendered content to the output file.
+    def process
+      FileUtils.mkdir_p(output_path.dirname)
+      output_path.open('w') do |f|
+        f.write render
+      end
+    end
+    
+    protected
+    
+      def read_source
+        @content = source_path.read
+      end
+  end
+end

data/lib/massimo/server.rb

@@ -0,0 +1,27 @@
+require 'rack'
+
+module Massimo
+  class Server
+    class << self
+      def start(site, port = 3000)
+        app = Rack::Builder.new do
+          use Rack::ShowExceptions
+          run Massimo::Server.new(site)
+        end
+        Rack::Handler::WEBrick.run(app, :Port => port)
+      end
+    end
+    
+    def initialize(site)
+      @site        = site
+      @file_server = Rack::File.new(site.config.output_path)
+      @watcher     = Massimo::Watcher.new(site)
+    end
+    
+    def call(env)
+      @watcher.process
+      env['PATH_INFO'] << 'index.html' if env['PATH_INFO'] =~ /\/$/
+      @file_server.call(env)
+    end
+  end
+end