mint 0.2.2 → 0.2.5

data/lib/mint/mint.rb

@@ -8,22 +8,23 @@ require 'mint/exceptions'
 module Mint
   # Assume that someone using an Html template has formatted it
   # in Erb and that a Css stylesheet will pass untouched through
-  # a Less parser.
-  Tilt.register 'html', Tilt::ERBTemplate
-  Tilt.register 'css', Tilt::LessTemplate
+  # a Scss parser.
+  Tilt.register Tilt::ERBTemplate, :html
+  Tilt.register Tilt::ScssTemplate, :css
 
   def self.root
-    Pathname.new(__FILE__).realpath.dirname + '../..'
+    (Pathname.new(__FILE__).realpath.dirname + '../..').to_s
   end
 
   # Return the an array with the Mint template path. Will first look
   # for MINT_PATH environment variable. Otherwise will use smart defaults.
   # Either way, earlier/higher paths take precedence. And is considered to
   # be the directory for "local" config options, templates, etc.
-  def self.path
+  def self.path(as_path=false)
     mint_path = ENV['MINT_PATH'] || 
       "#{Dir.getwd}/.mint:~/.mint:#{Mint.root}"
-    mint_path.split(':').map {|p| Pathname.new(p).expand_path }
+    paths = mint_path.split(':')
+    as_path ? paths.map {|p| Pathname.new(p).expand_path } : paths
   end
 
   # I want to refactor this so that Mint.path is always a Hash...
@@ -31,13 +32,13 @@ module Mint
   # Right now, this is a hack. It assumes a sane MINT_PATH, where the
   # first entry is most local, the second is user-level,
   # and the last entry is most global.
-  def self.path_for_scope(scope=:local)
+  def self.path_for_scope(scope=:local, as_path=false)
     case Mint.path
     when Array
       index = { local: 0, user: 1, global: 2 }[scope]
-      Mint.path[index]
+      Mint.path(as_path)[index]
     when Hash
-      Mint.path[scope]
+      Mint.path(as_path)[scope]
     else
       nil
     end
@@ -45,12 +46,18 @@ module Mint
 
   # Returns a hash with key Mint directories
   def self.directories
-    { templates: 'templates' }
+    { 
+      templates: 'templates',
+      config: 'config'
+    }
   end
 
   # Returns a hash with key Mint files
   def self.files
-    { config: 'config.yaml' }
+    { 
+      syntax: directories[:config] + '/syntax.yaml',
+      config: directories[:config] + '/config.yaml'
+    }
   end
 
   def self.default_options
@@ -75,6 +82,18 @@ module Mint
     css_formats = ['css', 'sass', 'scss', 'less']
   end
 
+  # Lists the full path for each known template in the
+  # Mint path
+  def self.templates
+    templates_dir = Mint.directories[:templates]
+
+    Mint.path(true).
+      map {|p| p + directories[:templates] }.
+      select(&:exist?).
+      map {|p| p.children.select(&:directory?).map(&:to_s) }.
+      flatten
+  end
+
   # Decides whether the template specified by `name_or_file` is a real
   # file or the name of a template. If it is a real file, Mint will
   # return a that file. Otherwise, Mint will look for a file with that
@@ -87,7 +106,7 @@ module Mint
   # ~/.mint/templates/normal/style.css.
   def self.lookup_template(name_or_file, type=:layout)
     name = name_or_file.to_s
-    File.exist?(name) ? Pathname.new(name) : find_template(name, type)
+    File.exist?(name) ? name : find_template(name, type)
   end
 
   # Finds a template named `name` in the Mint path. If `type` is :layout,
@@ -105,17 +124,26 @@ module Mint
     find_files = lambda {|x| Pathname.glob "#{x.to_s}.*" }
     acceptable = lambda {|x| x.to_s =~ /#{Mint.formats.join '|'}/ }
 
-    template = Mint.path.map(&file_name).map(&find_files).flatten.
-      select(&acceptable).select(&:exist?).first
+    template = Mint.path(true).map(&file_name).map(&find_files).flatten.
+      select(&acceptable).select(&:exist?).first.to_s
     raise TemplateNotFoundException unless template
 
     template
   end
 
+  # A non-rigourous check to see if the file is somewhere on the
+  # MINT_PATH
+  def self.template?(file)
+    paths = Mint.path.map {|f| File.expand_path f }
+    file_path = Pathname.new(file)
+    file_path.exist? and 
+      file_path.dirname.expand_path.to_s =~ /#{paths.join('|')}/
+  end
+
   # Guesses an appropriate name for the resource output file based on
   # its source file's base name
   def self.guess_name_from(name)
-    name = name.basename if name.respond_to? :basename
+    name = Pathname(name).basename if name
     css = Mint.css_formats.join '|'
     name.to_s.
       gsub(/\.(#{css})$/, '.css').
@@ -127,4 +155,8 @@ module Mint
   def self.renderer(path)
     Tilt.new path.to_s, :smart => true, :ugly => true
   end
+
+  def self.publish!(document)
+    document.publish!
+  end
 end

data/lib/mint/resource.rb

@@ -4,44 +4,82 @@ module Mint
   class Resource
     attr_accessor :type
 
-    attr_reader :source
-    def source=(source)
-      @source = Pathname.new(source) if source
-    end
-    
-    # I haven't tested this - moved empty string from
-    # default options into this method, so that default options
-    # can be uniform - i.e., style_destination and destination
-    # can each be nil to indicate that any rendering will be
-    # done in the same folder the file is already in. I need
-    # to make sure that adding the empty string here actually
-    # keeps us in the current working directory
-    attr_reader :destination
-    def destination=(destination)
-      @destination = Pathname.new(destination) if destination 
-    end
-    
     attr_reader :name
     def name=(name)
       @name = name
     end
 
+    attr_reader :root
+    def root=(root)
+      @root = root
+    end
+
+    def root_directory_path
+      Pathname.new(root || Dir.getwd).expand_path
+    end
+
+    def root_directory
+      root_directory_path.to_s
+    end
+
+    attr_accessor :source
+
+    def source_file_path
+      path = Pathname.new(source)
+      path.absolute? ? 
+        path.expand_path : root_directory_path + path
+    end
+
+    def source_file
+      source_file_path.to_s
+    end
+
+    def source_directory_path
+      source_file_path.dirname
+    end
+
+    def source_directory
+      source_directory_path.to_s
+    end
+
+    attr_accessor :destination
+
+    def destination_file_path
+      root_directory_path + (destination || '') + name
+    end
+
+    def destination_file
+      destination_file_path.to_s
+    end
+
+    def destination_directory_path
+      destination_file_path.dirname
+    end
+
+    def destination_directory
+      destination_directory_path.to_s
+    end
+    
     def renderer=(renderer)
       @renderer = renderer
     end
 
-    def initialize(source, type=:resource, options={})
+    def initialize(source, options={})
       return nil unless source
 
+      self.type = :resource
       self.source = source
-      self.type = type
+      self.root = options[:root] || source_directory
       self.destination = options[:destination]
+
+      yield self if block_given?
+
       self.name = Mint.guess_name_from source
       self.renderer = Mint.renderer source
     end
 
     def equal?(other)
-      self.destination + self.name == other.destination + other.name
+      self.destination_file_path == other.destination_file_path
     end
     alias_method :==, :equal?
 

data/lib/mint/style.rb

@@ -6,12 +6,31 @@ module Mint
   # file to use when a template name is specified.
   class Style < Resource
     def initialize(source, opts=Mint.default_options)
-      super(source, :style, opts)
-      self.destination ||= source.dirname.expand_path + 'css'
+      super(source, opts)
+      self.type = :style
+
+      # We want to render final stylesheet to the /css subdirectory if
+      # an output directory is not specified and we are dealing with
+      # a named template (not a local file). If we don't do this, the rendered
+      # Css file might be picked up next time we look for a named template
+      # in this directory, and the (correct) Sass file won't be picked up.
+      # However, if a destination directory is already specified, we
+      # leave it alone.
+      if Mint.template?(self.source_directory) and rendered?
+        self.destination ||= 'css' 
+      end
+    end
+
+    def render
+      if rendered?
+        super
+      else
+        File.read source
+      end
     end
 
-    def need_rendering?
-      source.extname !~ /\.css$/
+    def rendered?
+      source_file_path.extname !~ /\.css$/
     end
   end
 end

data/lib/mint/version.rb

@@ -1,3 +1,3 @@
 module Mint
-  VERSION = '0.2.2'
+  VERSION = '0.2.5'
 end

data/spec/document_spec.rb

@@ -2,225 +2,187 @@ require 'spec_helper'
 
 module Mint
   describe Document do
-    before(:all) do
-      @old_dir = Dir.getwd
-      Dir.chdir 'tmp'
-    end
-
-    before do 
-      @content_file = 'content.md'
-      @layout_file = 'local.haml'
-      @style_file = 'local.css'
+    before { @tmp_dir = Dir.getwd }
 
-      @content = <<-HERE
-Header
-------
+    # We're not going to re-test derivative methods like source_file_path
+    # or root_directory. resource_spec.rb tells us that if the master
+    # values hold true, then their derivatives will be what we expect, as well.
+    # We do have to test #style_destination derivatives. Those aren't
+    # covered by resource_spec.rb.
+    shared_examples_for "all documents" do
+      # Convenience methods
+      
+      it "#stylesheet" do
+        relative_path = document.destination_file_path.
+            relative_path_from(document.style_destination_file_path)
 
-This is just a test.
-      HERE
+        document.stylesheet.should == relative_path.to_s
+      end
 
-      @layout = <<-HERE
-!!!
-%html
-  %head
-  %body= content
-      HERE
+      # style_spec.rb ensures that our style generation goes as planned
+      # However, we need to test layout generation because it should now
+      # include our content
+      its(:content) { should =~ /<p>This is just a test.<\/p>/ }
 
-      @style = 'body { font-size: 16px }'
+      # Render output
 
-      File.open @content_file, 'w' do |f|
-        f << @content
+      it "renders its layout, injecting content inside" do
+        document.render.should =~ 
+          /.*<html>.*#{document.content}.*<\/html>.*/m
       end
 
-      File.open @layout_file, 'w' do |f|
-        f << @layout
+      it "links to its stylesheet" do 
+        document.render.should =~ /#{document.stylesheet}/
       end
 
-      File.open @style_file, 'w' do |f|
-        f << @style
+      # Mint output
+
+      it "writes its rendered style to #style_destination_file" do
+        document.publish!
+        document.style_destination_file_path.should exist
       end
-    end
 
-    after do
-      File.delete @content_file
-      File.delete @layout_file
-      File.delete @style_file
+      it "writes its rendered layout and content to #destination_file" do
+        document.publish!
+        document.destination_file_path.should exist
+        content = File.read document.destination_file
+        content.should == document.render
+      end
     end
 
-    after(:all) do
-      Dir.chdir @old_dir
-    end
+    context "when it's created with default options" do
+      let(:document) { Document.new @content_file }
 
-    shared_examples_for "all documents" do
-      it "loads content as its source" do
-        document.source.to_s.should == 'content.md'
-      end
+      subject { document }
+      its(:root) { should == @tmp_dir }
+      its(:destination) { should be_nil }
+      its(:source) { should == 'content.md' }
+      its(:style_destination) { should be_nil }
 
-      it "guesses its name from the source" do
-        document.name.to_s.should =~ /content/
+      its(:style_destination_file) do
+        should == Mint.root + '/templates/default/css/style.css'
       end
 
-      it "renders its content" do
-        document.content.should =~ /<p>This is just a test.<\/p>/
+      its(:style_destination_directory) do 
+        should == Mint.root + '/templates/default/css'
       end
 
-      it "renders its layout, injecting content inside" do
-        document.render.should =~ 
-          /.*<html>.*<p>This is just a test.<\/p>.*<\/html>.*/m
+      its(:style_destination_file_path) do
+        should == Pathname.new(document.style_destination_file)
       end
 
-      # This test makes me think I want to add document.destination_file and
-      # change document.destination to document.destination_directory.
-      it "creates a named output file in its specified destination directory" do
-        pending
-        document.mint
-        document.destination_file.should exist
-        # file = Pathname.getwd + (document.destination || '') + document.name
-        # file.should exist
+      its(:style_destination_directory_path) do
+        should == Pathname.new(document.style_destination_directory)
       end
 
-      it "writes its rendered layout and content to that output file" do
-        pending
-        document.mint
-        content = File.read document.destination_file
-        content.should =~ /.*<html>.*<p>This is just a test.<\/p>.*<\/html>.*/m
-      end
-    end
+      its(:layout) { should be_in_directory('default') }
+      its(:style) { should be_in_directory('default') }
 
-    shared_examples_for "documents with a static stylesheet" do
-      it "knows not to render its style" do
-        document.style.need_rendering?.should == false
-      end
-      
-      it "does not render or write its style"
+      it_should_behave_like "all documents"
     end
 
-    shared_examples_for "documents with a dynamic stylesheet" do
-      it "knows to render its style" do
-        document.style.need_rendering?.should == true
-      end
+    context "when it's created with explicit destination directories" do
+      let(:document) { Document.new @content_file,
+                       :destination => 'destination',
+                       :style_destination => 'styles' }
 
-      it "writes its rendered style into its style_destination"
-    end
+      subject { document }
+      its(:root) { should == @tmp_dir }
+      its(:destination) { should == 'destination' }
+      its(:source) { should == 'content.md' }
+      its(:style_destination) { should == 'styles' }
 
-    shared_examples_for "documents with the default template" do
-      it "chooses the default layout" do
-        document.layout.should be_in_directory('default')
+      its(:style_destination_file) do
+        should == "#{@tmp_dir}/destination/styles/style.css"
       end
 
-      it "chooses the default style" do
-        document.style.should be_in_directory('default')
+      its(:style_destination_directory) do
+        should == "#{@tmp_dir}/destination/styles"
       end
-    end
 
-    shared_examples_for "documents with the pro template" do
-      it "chooses the pro layout" do
-        document.layout.should be_in_directory('pro')
+      its(:style_destination_file_path) do
+        should == Pathname.new(document.style_destination_file)
       end
 
-      it "chooses the pro style" do
-        document.style.should be_in_directory('pro')
+      its(:style_destination_directory_path) do
+        should == Pathname.new(document.style_destination_directory)
       end
-    end
 
-    shared_examples_for "documents with the local template" do
-      it "chooses the local layout" do
-        document.layout.name.to_s.should =~ /local/
-        document.layout.source.to_s.should == 'local.haml'
-      end
+      its(:layout) { should be_in_directory('default') }
+      its(:style) { should be_in_directory('default') }
 
-      it "chooses the local style" do
-        document.style.name.to_s.should =~ /local/
-        document.style.source.to_s.should == 'local.css'
-      end
+      it_should_behave_like "all documents"
     end
 
-    shared_examples_for "documents without explicit directories" do
-      it "does not have a nested destination directory" do
-        document.destination.should be_nil
-      end
+    context "when it's created with an explicit root" do 
+      let(:document) { Document.new @content_file,
+                       :root => "#{@tmp_dir}/alternative-root" }
 
-      it "sets the style's current directory as its style destination" do
-        document.style_destination.should be_nil
-      end
-    end
+      subject { document }
+      its(:root) { should == "#{@tmp_dir}/alternative-root" }
+      its(:destination) { should be_nil }
+      its(:source) { should == 'content.md' }
+      its(:style_destination) { should be_nil }
 
-    shared_examples_for "documents with explicit directories" do
-      it "has a nested destination directory" do
-        document.destination.to_s.should == 'destination'
+      its(:style_destination_file) do
+        should == Mint.root + '/templates/default/css/style.css'
       end
 
-      it "sets the destination directory as its style destination" do
-        document.style_destination.to_s.should == 'styles'
+      its(:style_destination_directory) do
+        should == Mint.root + '/templates/default/css'
       end
-    end
 
-    context "when it's created without explicit options" do
-      let(:document) { Document.new @content_file }
+      its(:style_destination_file_path) do
+        should == Pathname.new(document.style_destination_file)
+      end
 
-      it_behaves_like "all documents"
-      it_behaves_like "documents with the default template"
-      it_behaves_like "documents without explicit directories"
-      it_behaves_like "documents with a dynamic stylesheet"
-    end
+      its(:style_destination_directory_path) do
+        should == Pathname.new(document.style_destination_directory)
+      end
 
-    context "when it's created inline with named layouts and styles" do
-      let(:document) { Document.new @content_file, 
-                       :layout => 'pro', :style => 'pro' }
+      its(:layout) { should be_in_directory('default') }
+      its(:style) { should be_in_directory('default') }
 
-      it_behaves_like "all documents"
-      it_behaves_like "documents with the pro template"
-      it_behaves_like "documents without explicit directories"
-      it_behaves_like "documents with a dynamic stylesheet"
+      it_should_behave_like "all documents"
     end
 
-    context "when it's created inline with local layouts and styles" do
-      let(:document) { Document.new @content_file, 
-                       :layout => 'local.haml', :style => 'local.css' }
-
-      it_behaves_like "all documents"
-      it_behaves_like "documents with the local template"
-      it_behaves_like "documents without explicit directories"
-      it_behaves_like "documents with a static stylesheet"
-    end
+    context "when it is created with a block" do
+      let(:document) do
+        Document.new @content_file do |doc|
+          doc.root              = "#{@tmp_dir}/alternative-root"
+          doc.destination       = 'destination'
+          doc.style_destination = 'styles'
+          doc.layout            = 'pro'
+          doc.style             = 'pro'
+        end
+      end
 
-    context "when it's created with a template" do
-      let(:document) { Document.new @content_file, :template => 'pro' }
+      subject { document }
+      its(:root) { should == "#{@tmp_dir}/alternative-root" }
+      its(:destination) { should == 'destination' }
+      its(:source) { should == 'content.md' }
+      its(:style_destination) { should == 'styles' }
 
-      it_behaves_like "all documents"
-      it_behaves_like "documents with the pro template"
-      it_behaves_like "documents without explicit directories"
-      it_behaves_like "documents with a dynamic stylesheet"
-    end
+      its(:style_destination_file) do
+        should == "#{@tmp_dir}/alternative-root/destination/styles/style.css"
+      end
 
-    context "when it's created with a non-default destinations" do
-      let(:document) { Document.new @content_file, 
-                       :root => 'root', :destination => 'destination',
-                       :style_destination => 'styles' }
+      its(:style_destination_directory) do
+        should == "#{@tmp_dir}/alternative-root/destination/styles"
+      end
 
-      it_behaves_like "all documents"
-      it_behaves_like "documents with the default template"
-      it_behaves_like "documents with explicit directories"
-      it_behaves_like "documents with a dynamic stylesheet"
-    end
+      its(:style_destination_file_path) do
+        should == Pathname.new(document.style_destination_file)
+      end
 
-    context "when it's created with a block" do
-      let(:document) do
-        Document.new @content_file do |document|
-          document.destination = 'destination'
-          document.style_destination = 'styles'
-          document.layout = 'pro'
-          document.style = 'pro'
-        end
+      its(:style_destination_directory_path) do
+        should == Pathname.new(document.style_destination_directory)
       end
 
-      it_behaves_like "all documents"
-      it_behaves_like "documents with the pro template"
-      it_behaves_like "documents with explicit directories"
-      it_behaves_like "documents with a dynamic stylesheet"
-    end
+      its(:layout) { should be_in_directory('pro') }
+      its(:style) { should be_in_directory('pro') }
 
-    context "when it's created with an existing layout"
-    context "when it's created with an existnig style"
+      it_should_behave_like "all documents"
+    end
   end
 end