mint 0.1.3 → 0.1.4

data/README.md

@@ -75,8 +75,8 @@ You can pass any of the following to a new document:
 
   1. If you specify a template name here, Mint will search its paths in order (see **The Mint Path** for more details) for a template with that name. A template file looks like the following:
 
-        ${MINT_PATH}/templates/template_name/style.css
-        ${MINT_PATH}/templates/template_name/layout.haml
+            ${MINT_PATH}/templates/template_name/style.css
+            ${MINT_PATH}/templates/template_name/layout.haml
 
   2. If you specify a template name that is also the name of an existing file in your working directory, Mint will use the file and not look for a template. (It is unlikely you'll have an extension-less file named 'normal' or 'default' in your working directory, so don't worry about this edge case.) If you do specify an existing file, the path/file will be resolved from the directory where you're calling Mint (the 'working directory'). To use Mint this way (and I don't see this as more than a temporary solution) you'll probably want to call Mint from within your source's directory. Alternatively, you can use [`Dir.chdir`][Dir::chdir method] for the same effect.
 
@@ -84,7 +84,7 @@ You can pass any of the following to a new document:
 
   Defaults:
 
-        :destination => ''
+        :destination => nil
         :style_destination => nil
 
   Notes:
@@ -95,7 +95,7 @@ You can pass any of the following to a new document:
 
 ### Examples ###
 
-At this point, a couple of example may be useful.
+At this point, a couple of examples may be useful.
 
 The following are possible:
 
@@ -227,14 +227,14 @@ When you name a layout or style with a string or symbol, Mint will first search
 The default Mint path (in order) is:
 
 - the current working directory
-- ${HOME}/.mint
-- /usr/share/mint (or whatever your system uses for system-wide configuration - Mint will make a smart guess)
+- `${HOME}/.mint`
+- `/usr/share/mint` (or whatever your system uses for system-wide configuration - Mint will make a smart guess)
 - the Mint gem directory (which holds the Mint-approved templates)
 
 Templates should be in a directory named templates. Inside this directory, there should be a subdirectory for each template:
 
-- ${MINT\_PATH}/templates/normal/style.css
-- ${MINT\_PATH}/templates/normal/layout.haml
+- `${MINT_PATH}/templates/normal/style.sass`
+- `${MINT_PATH}/templates/normal/layout.haml`
 
 Normally a style will go best with its layout complement. However, layouts and styles can be mixed and matched at your discretion. This is especially true where you are primarily customizing DOM elements with your stylesheet instead of targeting specific IDs or classes you're expecting to find. (In other words, this works best when your stylesheet focuses on modifying typography and not page layout.)
 
@@ -269,7 +269,6 @@ The following correspond to the parameters you can pass to `Mint::Document.new`,
 - `--style, -s`
 - `--destination, -d`
 - `--style-destination, -n`
-- `--copy-style`
 
 There are also scoping options, both for the `set` and `edit` commands:
 
@@ -300,16 +299,15 @@ Currently, the `mint` vocabulary consists of `set`, `edit`, and `config`.
 
 To set a local (directory-specific) configuration option, call `mint set`:
 
-    mint set [local] --template serif-professional --destination final
+    mint set [--local] template=serif-professional
 
 This will create (or update) a config file: ./.mint/config.yml
 
 It will contain:
 
     template: serif-professional
-    destination: final
 
-From now on, calling `mint` in this directory will automatically draw on these two options. (Commandline options will override these file options.)
+From now on, calling `mint` in this directory will automatically draw on this option. (Commandline options will override any file-based options.)
 
 You can also set user-wide options:
 
@@ -328,8 +326,7 @@ Finally, you can set global options for all users:
 This configuration affects all users and will be put somewhere appropriate:
 
 - In Linux and on other FHS-compliant systems, this will be in /usr/share/mint
-- On Mac OS X, this is going to land somewhere unknown, possibly inside 
-  of /Library/Application Support/Mint or /usr/share/mint -- I haven't decided
+- On Mac OS X, this is going to land somewhere yet to be determined, possibly inside of /Library/Application Support/Mint or /usr/share/mint -- I haven't decided
 - On Windows, this will end up *(somewhere dumber than before)*
 
 These options give you the power to unify a directory or user or all users under a certain default layout and style. These options are all overridden via commandline options and only provide defaults so that you can save typing common commands. `mint` selects the most specific option possible, starting with the commandline, then checking local the config file, and finally moving to the user-wide and global config files.
@@ -363,24 +360,10 @@ This section documents features that do not yet exist, but that I would like to
 
 ### Composed styles ###
 
-Not everyone wants to code an entire stylesheet every time he wants a new look. In fact, the most common use case for stylesheets is probably tweaking typography. For this reason (and to make this tool as accessible as possible), I want to implement a feature where you can select one stylesheet as a base and implement tweaks on top of that file. Of course Css makes this easy enough, but I want to implement this feature in such a way that it is easy and intuitive for everyone.
+Not everyone wants to code an entire stylesheet every time he wants a new look. In fact, the most common use case for stylesheets is probably tweaking typography. For this reason (and to make this tool as accessible as possible), I want to implement a feature where you can select one stylesheet as a base and implement tweaks on top of that file, using a Yaml-based DSL. Of course Css makes this easy enough, but I want to implement this feature in such a way that it is easy and intuitive for everyone.
 
 ### Packages ###
 
-Sometimes, it may be useful to "finalize" the design of a document, for example, with publications. The best way I can think of to do this is to package the document's output file along with its style in a zipped package, which can be read by the following:
+Sometimes, it may be useful to "finalize" the design of a document, for example, with publications. The best way I can think of to do this is to package the document's output file with its style inline. To do so, simply add the package option:
 
-    mint open --package Minimalism --in firefox
-
-To package a document with its stylesheet, as a sort of a printing:
-
-    mint package document.md --name Document
-
-Eventually, this could include multiple output formats, like Html4, Html5, Pdf and ePub. The format opened by the `mint open` command could be determined by the application you choose to open it with. (This would take some serious OS hacking, I think.)
-
-When that does happen, you'll also be able to set the default version of the document that will open using:
-
-    mint set [local] --package-default html5
-    
-### More ###
-
-More ideas are coming soon...
+    mint package document.md

data/bin/mint

@@ -2,37 +2,36 @@
 # A script for harnessing Mint at the commandline
 
 require 'pathname'
-
-$:.unshift Pathname.new(__FILE__).realpath.dirname + '..' + 'lib'
-
 require 'optparse'
 require 'yaml'
 require 'mint'
 
 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.'],
-
-      # 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
-
   module CommandLine
+    # 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, or nil to link in place'],
+
+        # 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
+
     def self.config_options
       config_filename = Pathname.new(Mint.files[:config])      
 
@@ -43,18 +42,18 @@ module Mint
         select(&:exist?).
         map {|p| YAML.load_file p }.
         reverse.
-        reduce({}) {|r,p| r.merge p }
+        reduce(Hash.new) {|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.install(file, scope=:local)
+    #   directory = path_for_scope(scope)
+    #   FileUtils.copy file, directory
+    # end
+
     def self.edit(name, layout_or_style=:layout)
       file = Mint.lookup_template name, layout_or_style
       
@@ -62,6 +61,12 @@ module Mint
       system "#{editor} #{file}"
     end
 
+    def self.write_config(opts, scope=:local)
+      config_directory = Mint.path_for_scope scope
+      Helpers.ensure_directory config_directory
+      Helpers.update_yaml(opts, config_directory + Mint.files[:config])
+    end
+ 
     def self.set(key, value, scope=:local)
       write_config({ key => value }, scope)
     end
@@ -77,7 +82,6 @@ module Mint
     # 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
       
@@ -98,7 +102,7 @@ commandline_options = {}
 optparse = OptionParser.new do |opts|
   opts.banner = 'Usage: mint [command] files [options]'
 
-  Mint.options.each do |k,v|
+  Mint::Commandline.options.each do |k,v|
     has_param = v[2]
 
     v[0] = "-#{v[0]}"
@@ -120,6 +124,19 @@ optparse.parse!
 
 case ARGV.first.downcase.to_sym
 
+when :help
+  puts optparse.help
+
+# ... if we get the install command, install the listed file to the
+# scope listed, using local as the default scope
+when :install
+  commandline_options[:local] = true
+  scope = [:global, :user, :local].
+    select {|e| commandline_options[e] }.
+    first
+
+  Mint::CommandLine.install ARGV.shift, scope
+
 # 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 ...
@@ -159,6 +176,5 @@ else
   commandline_options.delete :verbose
   commandline_options.delete :simulation
 
-  puts "ARGV = #{ARGV}"
   Mint::CommandLine.mint ARGV, commandline_options
 end

data/lib/mint/mint.rb

@@ -4,8 +4,6 @@ require 'tilt'
 require 'helpers'
 
 module Mint
-  VERSION = '0.1.3'
-  MINT_DIR = Pathname.new(__FILE__).realpath.dirname + '..'
 
   # Assume that someone using an Html template has formatted it
   # in Erb and that a Css stylesheet will pass untouched through
@@ -13,18 +11,24 @@ module Mint
   Tilt.register 'html', Tilt::ERBTemplate
   Tilt.register 'css', Tilt::LessTemplate
 
+  def root
+    Pathname.new(__FILE__).realpath.dirname + '../..'
+  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.
+  # Either way, earlier/higher paths take precedence. And is considered to
+  # be the directory for "local" config options, templates, etc.
   def self.path
     mint_path = ENV['MINT_PATH'] || "#{Dir.getwd}/.mint:~/.mint:#{MINT_DIR}"
-    path = mint_path.split(':').map {|p| Pathname.new(p).expand_path }
+    mint_path.split(':').map {|p| Pathname.new(p).expand_path }
   end
 
   # I want to refactor this so that Mint.path is always a Hash...
   # should take care of this in the Mint.path=() method.
   # Right now, this is a hack. It assumes a sane MINT_PATH, where the
-  # first entry is most local and the last entry is most global.
+  # first entry is most local, the second is user-level,
+  # and the last entry is most global.
   def self.path_for_scope(scope=:local)
     case Mint.path
     when Array

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - David Jacobs