mint 0.1.1 → 0.1.3

data/bin/mint

@@ -1,80 +1,164 @@
 #!/usr/bin/env ruby
 # A script for harnessing Mint at the commandline
 
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'pathname'
+
+$:.unshift Pathname.new(__FILE__).realpath.dirname + '..' + 'lib'
 
-require 'rubygems'
-require 'mint'
 require 'optparse'
+require 'yaml'
+require 'mint'
 
-def usage
-  puts "You're doing it wrong."
-end
+module Mint
+  # A map of all options that OptParse will accept from the commandline.
+  # All other arguments are taken to be filenames.
+  def self.options
+    {
+      # These options take parameters
+      template: ['t', 'template', true, 'Specify the template (layout + style).'],
+      layout: ['l', 'layout', true, 'Specify only the layout.'],
+      style: ['s', 'style', true, 'Specify only the style.'],
+      root: ['w', 'root', true, 'Specify a root outside the current directory.'],
+      destination: ['d', 'destination', true, 'Specify a destination directory, relative to the root.'],
+      style_destination: ['n', 'style-destination', true, 'Specify a destination directory for stylesheets, relative to the document destination directory. If not explicit, will be linked from original location.'],
 
-unless ARGV[0]
-  usage
-  return
-end
+      # These options do not take parameters
+      global: ['G', 'global', false, 'Specify config changes on a global level.'],
+      user: ['U', 'user', false, 'Specify config changes on a user-wide level.'],
+      local: ['L', 'local', false, 'Specify config changes on a project-specific level.'],
+      force: ['f', 'force', false, 'Force file overwrite without prompt.'],
+      verbose: ['v', 'verbose', false, 'Verbose output.'],
+      simulation: ['s', 'simulation', false, 'Simulate transformation without actually creating files.']
+    }
+  end
 
-include Mint
+  module CommandLine
+    def self.config_options
+      config_filename = Pathname.new(Mint.files[:config])      
 
-module CommandLine
-  module DocumentContext
-    def mint_document(doc)
-      document = Document.new doc, :template => 'normal',
-        :style_destination => 'styles'
-      document.mint
+      # Merge config options from all config files on the Mint path,
+      # where more local options take precedence over more global
+      # options
+      Mint.path.map {|p| p + config_filename }.
+        select(&:exist?).
+        map {|p| YAML.load_file p }.
+        reverse.
+        reduce({}) {|r,p| r.merge p }
+    end
+
+    def self.full_options_with(commandline_options)
+      config_options.merge commandline_options
+    end
+
+    def self.write_config(opts, scope=:local)
+      Helpers.ensure_directory Mint.path_for_scope(scope)
+      Helpers.update_yaml(opts, Mint.path_for_scope(scope) + Mint.files[:config])
+    end
+    
+    def self.edit(name, layout_or_style=:layout)
+      file = Mint.lookup_template name, layout_or_style
+      
+      editor = ENV['EDITOR'] || 'vim'
+      system "#{editor} #{file}"
+    end
+
+    def self.set(key, value, scope=:local)
+      write_config({ key => value }, scope)
+    end
+
+    def self.config
+      puts YAML.dump(config_options)
     end
-  end
     
-  module ProjectContext
-    def init(dir, opts={})
-      dir = Pathname.new dir
-      if config = (dir + 'config.yaml').exists?
-        proj = Project.new(dir, YAML.load_file(config))
-      else
-        proj = Project.new(dir)
+    # Renders and writes to file all resources described by a document.
+    # Specifically: it renders itself (inside of its own layout) and then
+    # renders its style. This method will overwrite any existing content
+    # in a document's destination files. The `render_style` option
+    # provides an easy way to stop Mint from rendering a style, even
+    # if the document's style is not nil.
+    def self.mint(files, commandline_options)
+      puts "minting #{files}"
+      documents = []
+      options = Mint::CommandLine.full_options_with commandline_options
+      
+      root = options[:root] || Dir.getwd
+
+      # Eventually render_style should be replaced with file change detection
+      render_style = true
+      files.each do |file|
+        Document.new(file, options).mint(root, render_style)
+        render_style = false
       end
     end
   end
 end
 
-# --layout, -L
-# --style, -S
-# --root, -R
-# --destination, -D
-# --name, -N
-# --style-destination
-# --style-name
-
-options_with_parameters = {
-  :template => ['T', 'template'],
-  :layout => ['L', 'layout'],
-  :style => ['S', 'style'],
-  :root => ['R', 'root'],
-  :destination => ['D', 'destination'],
-  :name => ['N', 'name'],
-  :style_destination => ['E', 'style-destination'],
-  :style_name => ['A', 'style-name']
-}
-
-options_without_parameters = [ :verbose, :simulation ]
-
-config = {}
-
+# Parse options from the commandline
+commandline_options = {}
 optparse = OptionParser.new do |opts|
-  opts.banner = 'Usage: mint source [destination] [options]'
-  
-  options_with_parameters.each do |k,v|
+  opts.banner = 'Usage: mint [command] files [options]'
+
+  Mint.options.each do |k,v|
+    has_param = v[2]
+
     v[0] = "-#{v[0]}"
-    v[1] = "--#{v[1]} PARAM"
-    
-    opts.on v[0], v[1], 'Description goes here' do |p|
-      config[k] = p
+    v[1] = "--#{v[1]}"
+
+    if has_param
+      v[1] << " PARAM"
+      opts.on v[0], v[1], v[3] do |p|
+        commandline_options[k] = p
+      end
+    else
+      opts.on v[0], v[1], v[3] do
+        commandline_options[k] = true
+      end
     end
   end
 end
+optparse.parse!
 
-puts optparse.parse!
+case ARGV.first.downcase.to_sym
 
-CommandLine::DocumentContext.mint_document ARGV[0], config
+# If we get the edit command, will retrieve appropriate file
+# (probably a Mint template) and shell out that file to
+# the user's favorite editor. Otherwise ...
+when :edit
+  layout = commandline_options[:layout]
+  style  = commandline_options[:style]
+
+  if layout and not style
+    Mint::CommandLine.edit layout, :layout
+  elsif style
+    Mint::CommandLine.edit style, :style
+  else
+    puts optparse.help
+  end
+
+# ... if we get the set command, we will try to set
+# a config option (at the specified scope) per the user's command. Else ...
+when :set
+  # Determine scope, using local as the default
+  commandline_options[:local] = true
+  scope = [:global, :user, :local].
+    select {|e| commandline_options[e] }.
+    first
+
+  Mint::CommandLine.set ARGV.shift, ARGV.shift, scope
+
+# ... if we get the config command, display all active configurations,
+# where local configurations override global ones
+when :config
+  Mint::CommandLine.config
+
+# ... we know we've been passed a set of documents, so parse the
+# commandline options, merge them with the config options, and
+# start minting the document list.
+else
+  # The Mint library can't parse these options
+  commandline_options.delete :verbose
+  commandline_options.delete :simulation
+
+  puts "ARGV = #{ARGV}"
+  Mint::CommandLine.mint ARGV, commandline_options
+end

data/lib/mint.rb

@@ -1,433 +1,2 @@
-require 'pathname'
-require 'fileutils'
-require 'tilt'
-require 'haml'
-require 'rdiscount'
-
-require 'helpers'
-
-module Mint
-  VERSION = '0.1'
-  
-  # Default paths where Mint looks for styles and layouts, in this order
-  $path = [
-    Pathname.new('.mint'),                    # 1. Project-defined
-    Pathname.new(ENV['HOME']) + '.mint',      # 2. User-defined
-    Pathname.new('/usr') + 'share' + 'mint',  # 3. System-defined
-    Pathname.new(__FILE__).dirname + '..'     # 4. Gemfile-defined
-  ].collect! {|p| p.expand_path }
-  
-  # Directories within the Mint path
-  $default_directories = {
-    :templates => 'templates'
-  }
-  
-  # Files within a Mint Project
-  $default_files = {
-    :config => 'config.yaml'
-  }
-  
-  # Registered HTML and CSS formats, for source -> destination
-  # name guessing/conversion
-  $html_formats = ['.haml', '.erb', '.md']
-  $css_formats = ['.sass', '.scss', '.less']
-  $source_formats = $html_formats + $css_formats
-
-  # Default options, where nil acts as described in the specification
-  # Namely, a nil root or destination or style/layout template will
-  # not be used, and a nil name will prompt Mint to guess an appropriate
-  # name based on your source files
-  $default_opts = { 
-    :template => 'default', # this is a new feature I need to test
-    # :layout => 'default',
-    # :style => 'default',
-    :root => nil,
-    :destination => nil,
-    :style_destination => nil,
-    :name => nil,
-    :style_name => nil
-  }
-
-  class Resource
-    attr_accessor :type, :source, :destination, :name
-    
-    def initialize(source, opts={}, &block)
-      # A nil stylesheet or layout should not be rendered, so
-      # we'll return nil here
-      return nil unless source
-
-      # If there is a source, we initialize it right away as a
-      # Pathname, so we can use methods like @source.basename
-      @source = Pathname.new source
-
-      # Load in opts and change nil values to the assumptions
-      # described in the Mint README.
-      @opts = opts
-      
-      # If there is no destination value, ignore it
-      @opts[:destination] ||= String.new
-      
-      # For a nil name, guess based on source
-      @opts[:name] ||= Resource.guess_from(@source.basename.to_s)
-      
-      # Initialize resource values based on normalized, robust
-      # opts. For raw resources (i.e., not for Documents), the destination
-      # and source are both resolved relative to the current working
-      # directory. This only really matters if you are initializing Layouts
-      # or Styles on your own instead of via a Document. If you're using
-      # a Document, all destination paths are resolved relative to the
-      # Document root, which defaults to the content's source directory.
-      @destination = Pathname.new @opts[:destination]
-      @name = @opts[:name]     
-      @template = Resource.template @source
-      
-      # You can use a block to instantiate a Resource. Any values you set
-      # in this block will override all other values.
-      if block_given?
-        yield self
-      end
-    end
-    
-    def equals?(other)
-      destination + name == other.destination + other.name
-    end
-    
-    alias_method :==, :equals?
-    
-    # A convenience method for supplying and selecting configuration
-    # options. If supplied with an array of possible values, will return
-    # the first non-nil value. If the first non-nil value responds to
-    # `call`, will call that function and return its value.
-    def config_with(config)
-      (c = config.compact[0]).respond_to?(:call) ? c.call : c
-    end
-    
-    # Renders the current resource to a string, returning that string
-    # and not outputting to any file. Can operate within the context of
-    # an Object, whose methods can be called from within the template.
-    # Other arguments can be passed along to the template compiler. (For
-    # example, to output HAML as HTML5, pass the option `:format =>
-    # :html5`. See the Tilt TEMPLATES.md file for more information.)
-    def render(context=Object.new, args={})
-      @template.render context, args
-    end
-    
-    # Guesses an appropriate name for the Resource output file based on
-    # its source file's base name. Will convert registered HTML template
-    # extensions to '.html' and CSS template extensions to '.css'.
-    def self.guess_from(name)
-      css, html = $css_formats.join('|'), $html_formats.join('|')
-      name.gsub(/#{css}/, '.css').gsub(/#{html}/, '.html')
-    end
-    
-    # Transforms a path into a template that will render the file specified
-    # at that path. Currently uses Tilt, so any valid Tilt source file
-    # is valid here.
-    def self.template(path)
-      Tilt.new path
-    end
-  end
-  
-  # Layout describes a resource whose type is `:layout`. Beyond its type,
-  # it is a simple resource. However, its type helps decide which template
-  # file to use when a template name is specified. A Layout is best managed
-  # by a Document.
-  class Layout < Resource
-    def initialize(source, args={})
-      @type = :layout
-      super
-    end
-  end
-  
-  # Style describes a resource whose type is `:style`. Beyond its type,
-  # it is a simple resource. However, its type helps decide which template
-  # file to use when a template name is specified. A Style is best managed
-  # by a Document.
-  class Style < Resource
-    def initialize(source, args={})
-      @type = :style
-      super
-    end  
-  end
-  
-  # Document is a workhorse of the Mint library. It extends Resource
-  # to include helpful variables like `root`, which will be the context
-  # for all the Resources it contains. A Document's source is its content
-  # file, from which it can derive a root directory, an output name, and
-  # destination directories. A Document has one Style and one Layout, which
-  # it initializes on creation. Default and optional Styles and Layouts are
-  # included with Mint. You can add more templates to the Mint path
-  # for even more choices.
-  class Document < Resource
-    attr_accessor :root, :layout, :style, :content
-    
-    def initialize(source, opts={}, &block)      
-      # Initialize opts to the default opts, replacing them with user-
-      # supplied opts where possible.
-      @opts = $default_opts.merge opts
-      
-      # Invoke the parent class initializer, which sets the source,
-      # destination, name, template (content), and basic options.
-      super(source, @opts)
-      
-      # Add in Doc-specific opts and change nil values to the
-      # assumptions described in the Mint README.
-      @opts[:root] ||= @source.dirname
-      
-      # If a template name is given, it overrides style and layout
-      # names or files, per the Mint README.
-      if templ = @opts[:template]
-        @opts[:layout], @opts[:style] = templ, templ
-      end
-      
-      @opts[:style_destination] ||= String.new
-
-      style_opts = {
-        :destination => @destination + @opts[:style_destination],
-        :name => @opts[:style_name]
-      }
-      
-      # Initialize resource values based on normalized, robust opts. For
-      # Documents, the destination is resolved relative to the document
-      # root. The root and source paths are both resolved relative to the 
-      # current working directory whenever this instantiation method
-      # is called.
-      @type = :document
-      @root = Pathname.new(@opts[:root]).expand_path
-      
-      @content = Resource.template(@source).render
-      @layout = choose_template(@opts[:layout], :layout)
-      @style = choose_template(@opts[:style], :style, style_opts)
-      
-      # Be careful not to modify this code such that you can change the
-      # current working directory before the source directory is normalized.
-      # expand_path is always called relative to the *current* working
-      # directory, not the initial one.
-      @source = normalize_path(@source) # becomes relative here
-      
-      # You can use a block to instantiate a Document. Any values you set
-      # in this block will override all other values.
-      if block_given?
-        yield self
-        mint
-      end
-    end
-    
-    # Returns the relative path to dir1 from dir2, which defaults to the
-    # Document root.
-    def normalize_path(dir1, dir2=root)
-      Document.normalize_path(dir1, dir2)
-    end
-    
-    # Returns the relative path to dir1 from dir2.
-    def self.normalize_path(dir1, dir2)
-      path = case dir1
-        when String
-          Pathname.new dir1
-        when Pathname
-          dir1
-        end
-
-      path.expand_path.relative_path_from dir2
-    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 template using that file. Otherwise, Mint will look for a
-    # template with that name in the Mint path. The `layout_or_style`
-    # argument indicates whether the template we are looking for is
-    # a layout or a style and will affect which type of template is returned
-    # for a given template name. For example, `choose_template('normal',
-    # :layout)` might return a Layout template referring to the file 
-    # ~/.mint/templates/normal/layout.haml. Changing the second argument
-    # to :style would return a Style template whose source file is
-    # ~/.mint/templates/normal/style.sass.
-    def choose_template(name_or_file, layout_or_style=:layout, opts={})
-      template = File.file?(name_or_file) ? Pathname.new(name_or_file) :
-        find_template(name_or_file, layout_or_style)
-        
-      Mint.const_get(layout_or_style.to_s.capitalize).new(template, opts)
-    end
-    
-    # Finds a template named `name` in the Mint path. If `layout_or_style`
-    # is :layout, will look for `MINT_PATH/templates/layout.*`. If it is
-    # :style, will look for `MINT_PATH/templates/TEMPLATE_NAME/style.*`.
-    # Will reject raw HTML and CSS, which are currently not compatible
-    # with Tilt, the rendering interface that Mint uses. (There are plans
-    # to support these files in the future.) Mint assumes that a named
-    # template will hold only one layout and one style template. It does 
-    # not know how to decide between style.sass and style.less, for 
-    # example. For predictable results, only include one template file
-    # called `layout.*` in the TEMPLATE_NAME directory. If you do want
-    # several style files in the same template directory, you will want 
-    # to refer to the style file by its path and not by its template name.
-    # Will return nil if the named template is not in the Mint path.
-    def find_template(name, layout_or_style)
-      file = nil
-      
-      $path.each do |directory|
-        templates_dir = directory + $default_directories[:templates]
-        query = templates_dir + name + layout_or_style.to_s
-        
-        if templates_dir.exist?
-          # Mint looks for any
-          results = Pathname.glob "#{query}.*" 
-        
-          # Will only allow files ending in extensions that Tilt can
-          # handle. They are working to add raw HTML and CSS support, but 
-          # it is not yet implemented.
-          results.reject {|r| r.to_s !~ /#{$source_formats.join('|')}/}
-        
-          if results.length > 0
-            # Will return the first match found. See the `find_template`
-            # description for a discussion of when you should and should
-            # not rely on this method.
-            file = results[0]
-            break
-          end
-        end
-      end
-      
-      file
-    end
-    
-    # A Document renders itself (its content) in the context of its layout.
-    # This differs from raw Resources, which render themselves in the
-    # context of `Object.new`
-    def render(args={})
-      layout.render self, args
-    end
-    
-    # Renders and writes to file all Resources described by a Document.
-    # Specifically: it renders itself (inside of its own Layout) and then
-    # renders its Style. This method will overwrite any existing content
-    # in a Document's destination files. The `render_style?` option
-    # provides an easy way to stop Mint from rendering a style, even
-    # if the Document's style is not nil. This makes it possible to
-    # associate a style with a Document (a style that can be called
-    # from layouts via `stylesheet`) without regenerating that
-    # stylesheet every time Mint runs.
-    def mint(render_style=true)
-      
-      resources = [self]
-      resources << style if render_style
-    
-      resources.compact.each do |r|
-        dest = @root + r.destination + r.name
-        
-        # Kernel.puts <<-HERE
-        #   Source: #{@root + r.source}
-        #   Destination: #{dest}
-        # HERE
-        
-        # Create any directories in the destination path that don't exist.
-        FileUtils.mkdir_p dest.dirname
-        
-        # Render the resource to its destination file, overwriting any
-        # existing content.
-        dest.open 'w+' do |file|
-          file << r.render
-        end
-      end
-    end
-    
-    # Convenience methods for views
-    
-    # Returns a relative path from the Document to its stylesheet. Can
-    # be called directly from inside a Layout template.
-    def stylesheet
-      normalize_path(@root + style.destination, 
-        @root + @destination) + 
-        style.name.to_s
-    end
-  end
-  
-  $project_default_opts = {}
-  
-  class ProjectDocument < Document
-    attr_accessor :changed
-  end
-  
-  class Project
-    attr_accessor :root, :documents, :layout, :style, :config
-    
-    def initialize(root, opts={})
-      @opts = opts
-      @opts = $project_default_opts.merge opts
-      
-      if templ = @opts[:template]
-        @opts[:layout], @opts[:style] = templ, templ
-      end
-      
-      @root = root
-      @documents = Array.new
-      @style = @opts[:style]
-      @layout = @opts[:layout]
-    end
-    
-    def mint
-      @documents.each_index do |i|
-        render_style = (i == 0)
-        @documents[i].mint(render_style)
-      end
-    end
-    
-    def change_status(document, new_status)
-    end
-    
-    def status
-    end
-    
-    def add(document)
-      doc = Document.new
-      doc.layout = @layout
-      doc.style = @style
-      doc.root = @root
-    
-      @documents << doc
-    end
-    
-    alias_method :<<, :add
-    
-    def remove(document)
-      @documents.delete document
-    end
-    
-    def list
-    end
-    
-    def edit(file_or_name, type=:layout)
-      
-      
-      if editor = ENV['EDITOR']      
-        `#{editor} `
-      end
-    end
-    
-    def watch
-      require 'fssm'
-      
-      FSSM.monitor do
-        path root do
-          glob '*'
-
-          update {|base, relative|}
-          delete {|base, relative|}
-          create {|base, relative|}
-        end
-      end
-
-      path 'templates/**/*' do
-        update { |base, relative| update(relative) }
-        delete { |base, relative| update(relative) }
-        create { |base, relative| update(relative) }
-      end
-    end
-    
-    def update(relative)
-      puts ">>> Change Detected to: #{relative} <<<"
-
-      puts '>>> Update Complete <<<'
-    end
-  end
-end
+require 'mint/mint'
+require 'mint/version'