mint 0.5.1 → 0.7.1

data/lib/mint.rb

@@ -1,11 +1,11 @@
-require 'mint/helpers'
-require 'mint/mint'
-require 'mint/resource'
-require 'mint/layout'
-require 'mint/style'
-require 'mint/document'
-require 'mint/version'
-require 'mint/css'
-require 'mint/commandline'
-require 'mint/exceptions'
-require 'mint/plugin'
+require "mint/helpers"
+require "mint/mint"
+require "mint/resource"
+require "mint/layout"
+require "mint/style"
+require "mint/document"
+require "mint/version"
+require "mint/css"
+require "mint/command_line"
+require "mint/exceptions"
+require "mint/plugin"

data/lib/mint/{commandline.rb → command_line.rb}

@@ -1,6 +1,9 @@
-require 'pathname'
-require 'yaml'
-require 'optparse'
+require "pathname"
+require "yaml"
+require "optparse"
+require "fileutils"
+
+require "active_support/core_ext/object/blank"
 
 module Mint
   module CommandLine
@@ -14,22 +17,24 @@ module Mint
     # @return [Hash] a structured set of options that the commandline
     #   executable accepts
     def self.options
-      options_file = "../../../#{Mint.files[:syntax]}"
+      options_file = "../../../config/#{Mint.files[:syntax]}"
       YAML.load_file File.expand_path(options_file, __FILE__)
     end
 
-    # Yields each commandline option specified by options_metadata as
-    # a key/value pair to a block. If the option does not take a param, the value
-    # will be specified as true.
+    # Parses ARGV according to the specified or default commandline syntax
     #
-    # @param [Hash, #[]] options_metadata a structured set of options that the executable 
-    #   can use to parse commandline configuration options
-    # @return [OptionParser] an object that will parse ARGV when called
-    def self.parser(options_metadata=Mint::CommandLine.options)
-      optparse = OptionParser.new do |opts|
-        opts.banner = 'Usage: mint [command] files [options]'
-
-        Helpers.symbolize_keys(options_metadata).each do |k,v|
+    # @param [Array] argv a list of arguments to parse
+    # @param [Hash] opts default parsing options (to specify syntax file)
+    # @return [Hash] an object that contains parsed options, remaining arguments,
+    #   and a help message
+    def self.parse(argv, opts={})
+      opts = { syntax: options }.merge(opts)
+      parsed_options = {}
+
+      parser = OptionParser.new do |cli|
+        cli.banner = "Usage: mint [command] files [options]"
+
+        Helpers.symbolize_keys(opts[:syntax]).each do |k,v|
           has_param = v[:parameter]
 
           v[:short] = "-#{v[:short]}"
@@ -37,49 +42,20 @@ module Mint
 
           if has_param
             v[:long] << " PARAM"
-            opts.on v[:short], v[:long], v[:description] do |p|
-              yield k.to_sym, p
+            cli.on v[:short], v[:long], v[:description] do |p|
+              parsed_options[k.to_sym] = p
             end
           else
-            opts.on v[:short], v[:long], v[:description] do
-              yield k, true
+            cli.on v[:short], v[:long], v[:description] do
+              parsed_options[k.to_sym] = true
             end
           end
         end
       end
-    end
-
-    # Returns a hash of all active options specified by file (for all scopes).
-    # That is, if you specify file as 'config.yaml', this will return the aggregate
-    # of all config.yaml-specified options in the Mint path, where more local
-    # members of the path take precedence over more global ones.
-    #
-    # @param [String] file a filename pointing to a Mint configuration file
-    # @return [Hash] a structured set of configuration options
-    def self.configuration(file=Mint.files[:config])
-      return nil unless file
-      config_file = Pathname.new file
-
-      # Merge config options from all config files on the Mint path,
-      # where more local options take precedence over more global
-      # options
-      configuration = Mint.path(true).map {|p| p + config_file }.
-        select(&:exist?).
-        map {|p| YAML.load_file p }.
-        reverse.
-        reduce(Mint.default_options) {|r,p| r.merge p }
-
-      Helpers.symbolize_keys configuration
-    end
 
-    # Returns all configuration options (as specified by the aggregate
-    # of all config files), along with opts, where opts take precedence.
-    #
-    # @param [Hash] additional options to add to the current configuration
-    # @return [Hash] a structured set of configuration options with opts
-    #   overriding any options from config files
-    def self.configuration_with(opts)
-      configuration.merge opts
+      transient_argv = argv.dup 
+      parser.parse! transient_argv
+      { argv: transient_argv, options: parsed_options, help: parser.help }
     end
 
     # Mint built-in commands
@@ -92,19 +68,64 @@ module Mint
       puts message
     end
 
+    # Install the named file as a template
+    #
     # @param [File] file the file to install to the appropriate Mint directory
     # @param [Hash] commandline_options a structured set of options, including 
     #   a scope label that the method will use to choose the appropriate 
     #   installation directory
     # @return [void]
     def self.install(file, commandline_options={})
-      commandline_options[:local] = true
-      scope = [:global, :user, :local].
+      opts = { scope: :local }.merge(commandline_options)
+      scope = [:global, :user].
         select {|e| commandline_options[e] }.
-        first
+        first || :local
+
+      filename, ext = file.split "."
+
+      name = commandline_options[:template] || filename
+      type = Mint.css_formats.include?(ext) ? :style : :layout
+      destination = Mint.template_path(name, type, :scope => opts[:scope], :ext => ext) 
+      FileUtils.mkdir_p File.expand_path("#{destination}/..")
 
-      directory = Mint.path_for_scope(scope)
-      FileUtils.copy file, directory
+      puts "reading file"
+      puts File.read file
+
+      if File.exist? file
+        FileUtils.cp file, destination
+      else
+        raise "[error] no such file"
+      end
+    end
+
+    # Uninstall the named template
+    #
+    # @param [String] name the name of the template to be uninstalled
+    # @param [Hash] commandline_options a structured set of options, including 
+    #   a scope label that the method will use to choose the appropriate 
+    #   installation directory
+    # @return [void]
+    def self.uninstall(name, commandline_options={})
+      opts = { scope: :local }.merge(commandline_options)
+      FileUtils.rm_r Mint.template_path(name, :all, :scope => opts[:scope])
+    end
+
+    # List the installed templates
+    #
+    # @return [void]
+    def self.templates(filter=nil, commandline_options={})
+      scopes = Mint::SCOPE_NAMES.select do |s|
+        commandline_options[s] 
+      end.presence || Mint::SCOPE_NAMES
+
+      Mint.templates(:scopes => scopes).
+        grep(Regexp.new(filter || "")).
+        sort.
+        each do |template|
+          print File.basename template
+          print " [#{template}]" if commandline_options[:verbose]
+          puts
+        end
     end
 
     # Retrieve named template file (probably a built-in or installed 
@@ -115,21 +136,25 @@ module Mint
     #   a layout or style flag that the method will use to choose the appropriate 
     #   file to edit
     # @return [void]
-    def self.edit(name, commandline_options)
+    def self.edit(name, commandline_options={})
       layout = commandline_options[:layout]
       style = commandline_options[:style]
 
-      if layout and not style
-        layout_or_style = :layout
-      elsif style
-        layout_or_style = :style
+      # Allow for convenient editing (edit "default" works just as well
+      # as edit :style => "default")
+      if style
+        name, layout_or_style = style, :style
+      elsif layout
+        name, layout_or_style = layout, :layout
       else
-        puts optparse.help
+        layout_or_style = :style
       end
 
+      abort "[error] no template specified" if name.nil? || name.empty?
+
       file = Mint.lookup_template name, layout_or_style
       
-      editor = ENV['EDITOR'] || 'vi'
+      editor = ENV["EDITOR"] || "vi"
       system "#{editor} #{file}"
     end
 
@@ -142,9 +167,8 @@ module Mint
     # @return [void]
     def self.configure(opts, scope=:local)
       config_directory = Mint.path_for_scope(scope, true)
-      config_file = config_directory + Mint.files[:config]
-      Helpers.ensure_directory config_directory
-      Helpers.update_yaml! opts, config_file
+      FileUtils.mkdir_p config_directory
+      Helpers.update_yaml! "#{config_directory}/#{Mint.files[:defaults]}", opts
     end
 
     # Tries to set a config option (at the specified scope) per 
@@ -156,7 +180,7 @@ module Mint
     #   a scope label that the method will use to choose the appropriate 
     #   scope
     # @return [void]
-    def self.set(key, value, commandline_options)
+    def self.set(key, value, commandline_options={})
       commandline_options[:local] = true
       scope = [:global, :user, :local].
         select {|e| commandline_options[e] }.
@@ -170,7 +194,7 @@ module Mint
     #
     # @return [void]
     def self.config
-      puts YAML.dump(configuration)
+      puts YAML.dump(Mint.configuration)
     end
     
     # Renders and writes to file all resources described by a document.
@@ -184,18 +208,10 @@ module Mint
     # @param [Hash, #[]] commandline_options a structured set of configuration options
     #   that will guide Mint.publish!
     # @return [void]
-    def self.publish!(files, commandline_options)
-      documents = []
-      options = configuration_with commandline_options
-      
-      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).publish! :render_style => render_style
-        render_style = false
+    def self.publish!(files, commandline_options={})
+      options = { root: Dir.getwd }.merge(Mint.configuration_with commandline_options)
+      files.each_with_index do |file, idx|
+        Document.new(file, options).publish!(:render_style => (idx == 0))
       end
     end
   end

data/lib/mint/css.rb

@@ -1,61 +1,70 @@
+require "sass"
+
 module Mint
   module CSS
-    def container
-      'container'
+    def self.container
+      "container"
     end
 
-    # Maps a "DSL" onto actual CSS. This is not yet implemented, but 
-    # the plan is to translate this ...
+    # Maps a "DSL" onto actual CSS. Translates this ...
     #
     # ---
     # Font: Helvetica
-    # Margin: 1 in
-    # Line spacing: 1.25
+    # Margin: 1in
+    # Orientation: Landscape
     #
     # ... into something like:
     #
     # #container {
-    #   font: (value specified and cleaned up)
-    #   padding-left: (value specified and cleaned up)
-    #   ...
-    #   p { line-height: (value specified and cleaned up) }
+    #   font-family: Helvetica;
+    #   padding-left: 1in;
+    #   @page { size: landscape };
     # }
-    def mappings
+    def self.mappings
       { 
-        font: 'font',
-        color: 'color',
-        top_margin: 'padding-top',
-        bottom_margin: 'padding-bottom',
-        left_margin: 'padding-left',
-        right_margin: 'padding-right',
-        top: 'padding-top',
-        bottom: 'padding-bottom',
-        left: 'padding-left',
-        right: 'padding-right',
-        height: 'height',
-        width: 'width',
-        line_spacing: 'p { line-height: %s }',
-        bullet: 'bullet-shape',
-        indentation: 'text-indent',
-        after_paragraph: 'margin-bottom',
-        before_paragraph: 'margin-top',
-        smart_typography: 'optimizeLegibility'
+        font: "font-family",
+        font_size: "font-size",
+        font_color: "color",
+        color: "color",
+        top_margin: "padding-top",
+        top: "padding-top",
+        bottom_margin: "padding-bottom",
+        bottom: "padding-bottom",
+        left_margin: "padding-left",
+        left: "padding-left",
+        right_margin: "padding-right",
+        right: "padding-right",
+        height: "height",
+        width: "width",
+        columns: "column-count",
+        column_gap: "column-gap",
+        orientation: "@page { size: %s }",
+        indentation: "p+p { text-indent: %s }",
+        indent: "p+p { text-indent: %s }",
+        bullet: "li { list-style-type: %s }",
+        bullet_image: "li { list-style-image: url(%s) }",
+        after_paragraph: "margin-bottom",
+        before_paragraph: "margin-top"
       }
     end
 
-    def format(key, value)
+    def self.stylify(key, value)
       selector = mappings[Helpers.symbolize key]
 
-      if selector.include? '%'
+      if selector.nil?
+        ""
+      elsif selector.include? "%"
         selector % value
       else
         "#{selector || key}: #{value}"
       end
     end
 
-    def parse(style)
-      css = style.map {|k,v| format(k, v) }.join("\n  ")
-      "##{container} {\n  #{css.strip}\n}"
+    def self.parse(style)
+      css = style.map {|k,v| stylify(k, v) }.join("\n  ")
+      container_scope = "##{container}\n  #{css.strip}\n"
+      engine = Sass::Engine.new(container_scope)
+      engine.silence_sass_warnings { engine.render }
     end
   end
 end

data/lib/mint/document.rb

@@ -1,15 +1,69 @@
-require 'mint/resource'
-require 'mint/layout'
-require 'mint/style'
+require "mint/resource"
+require "mint/layout"
+require "mint/style"
 
 module Mint
   class Document < Resource
     METADATA_DELIM = "\n\n"
 
+    # Creates a new Mint Document object. Can be block initialized.
+    # Accepts source and options. Block initialization occurs after
+    # all defaults are set, so not all options must be specified.
+    def initialize(source, opts={})
+      options = Mint.default_options.merge opts
+
+      # Loads source and destination, which will be used for
+      # all source_* and destination_* virtual attributes.
+      super(source, options)
+      self.type     = :document
+
+      # Each of these should invoke explicitly defined method
+      self.content  = source
+      self.layout   = options[:layout]
+      self.style    = options[:style]
+      self.style_destination = options[:style_destination]
+
+      # The template option will override layout and style choices
+      self.template = options[:template]
+
+      # Yield self to block after all other parameters are loaded,
+      # so we only have to tweak. (We don't have to give up our
+      # defaults or re-test blocks beyond them being tweaked.)
+      yield self if block_given?
+    end
+
+    # Renders content in the context of layout and returns as a String.
+    def render(args={})
+      intermediate_content = layout.render self, args
+      Mint.after_render(intermediate_content)
+    end
+
+    # Writes all rendered content where a) possible, b) required,
+    # and c) specified. Outputs to specified file.
+    def publish!(opts={})      
+      options = { :render_style => true }.merge(opts)
+      FileUtils.mkdir_p self.destination_directory
+      File.open(self.destination_file, "w+") do |f|
+        f << self.render
+      end
+
+      # Only renders style if a) it's specified by the options path and
+      # b) it actually needs rendering (i.e., it's in template form and
+      # not raw, browser-parseable CSS) or it if it doesn't need
+      # rendering but there is an explicit style_destination.
+      if options[:render_style]
+        FileUtils.mkdir_p style_destination_directory
+        File.open(self.style_destination_file, "w+") do |f|
+          f << self.style.render
+        end
+      end
+
+      Mint.after_publish(self, opts)
+    end
+
     # Implicit readers are paired with explicit accessors. This
     # allows for processing variables before storing them.
-    attr_reader :content, :layout, :style
-    attr_accessor :metadata
+    attr_reader :content, :metadata, :layout, :style
 
     # Passes content through a renderer before assigning it to be
     # the Document's content
@@ -21,11 +75,12 @@ module Mint
       tempfile = Helpers.generate_temp_file! content
       original_content = File.read content
 
-      metadata, text = Document.parse_metadata_from original_content
-      self.metadata = metadata
+      @metadata, text = Document.parse_metadata_from original_content
       intermediate_content = Mint.before_render text
 
-      File.open(tempfile, 'w') {|file| file << intermediate_content }
+      File.open(tempfile, "w") do |file|
+        file << intermediate_content
+      end
 
       @renderer = Mint.renderer tempfile
       @content = @renderer.render
@@ -65,6 +120,17 @@ module Mint
       abort "Template '#{style}' does not exist."
     end
 
+    # Overrides layout and style settings with named template.
+    #
+    # @param [String] template the name of the template to set as
+    #   layout and string
+    def template=(template)
+      if template
+        self.layout = template
+        self.style = template
+      end
+    end
+
     # Explanation of style_destination:
     #
     # I'm going to maintain a document's official style_destination
@@ -126,72 +192,6 @@ module Mint
       style_destination_directory_path.to_s
     end
 
-    # Overrides layout and style settings with named template.
-    #
-    # @param [String] template the name of the template to set as
-    #   layout and string
-    def template=(template)
-      if template
-        self.layout = template
-        self.style = template
-      end
-    end
-    
-    # Creates a new Mint Document object. Can be block initialized.
-    # Accepts source and options. Block initialization occurs after
-    # all defaults are set, so not all options must be specified.
-    def initialize(source, opts={})
-      options = Mint.default_options.merge opts
-
-      # Loads source and destination, which will be used for
-      # all source_* and destination_* virtual attributes.
-      super(source, options)
-      self.type     = :document
-
-      # Each of these should invoke explicitly defined method
-      self.content  = source
-      self.layout   = options[:layout]
-      self.style    = options[:style]
-      self.style_destination = options[:style_destination]
-
-      # The template option will override layout and style choices
-      self.template = options[:template]
-
-      # Yield self to block after all other parameters are loaded,
-      # so we only have to tweak. (We don't have to give up our
-      # defaults or re-test blocks beyond them being tweaked.)
-      yield self if block_given?
-    end
-
-    # Renders content in the context of layout and returns as a String.
-    def render(args={})
-      intermediate_content = layout.render self, args
-      Mint.after_render(intermediate_content)
-    end
-
-    # Writes all rendered content where a) possible, b) required,
-    # and c) specified. Outputs to specified file.
-    def publish!(opts={})      
-      options = { :render_style => true }.merge(opts)
-      FileUtils.mkdir_p self.destination_directory
-      File.open(self.destination_file, 'w+') do |f|
-        f << self.render
-      end
-
-      # Only renders style if a) it's specified by the options path and
-      # b) it actually needs rendering (i.e., it's in template form and
-      # not raw, browser-parseable CSS) or it if it doesn't need
-      # rendering but there is an explicit style_destination.
-      if options[:render_style]
-        FileUtils.mkdir_p style_destination_directory
-        File.open(self.style_destination_file, 'w+') do |f|
-          f << self.style.render
-        end
-      end
-
-      Mint.after_publish(self, opts)
-    end
-
     # Convenience methods for views
 
     # Returns a relative path from the document to its stylesheet. Can
@@ -201,29 +201,35 @@ module Mint
                              self.destination_directory).to_s
     end
 
-    protected
-
-    def self.metadata_chunk(text)
-      text.split(METADATA_DELIM).first
+    def inline_styles
+      CSS.parse(metadata)
     end
 
-    def self.metadata_from(text)
-      raw_metadata = YAML.load metadata_chunk(text)
-      raw_metadata.is_a?(String) ? {} : raw_metadata
-    rescue
-      {}
-    end
+    # Functions
 
-    def self.parse_metadata_from(text)
-      metadata = metadata_from text
-      new_text =
-        if !metadata.empty?
-          text.sub metadata_chunk(text) + METADATA_DELIM, ''
-        else
-          text
-        end
+    class << self
+      def metadata_chunk(text)
+        text.split(METADATA_DELIM).first
+      end
 
-      [metadata, new_text]
+      def metadata_from(text)
+        raw_metadata = YAML.load metadata_chunk(text)
+        raw_metadata.is_a?(String) ? {} : raw_metadata
+      rescue
+        {}
+      end
+
+      def parse_metadata_from(text)
+        metadata = metadata_from text
+        new_text =
+          if !metadata.empty?
+            text.sub metadata_chunk(text) + METADATA_DELIM, ""
+          else
+            text
+          end
+
+        [metadata, new_text]
+      end
     end
   end
 end