guard-mthaml 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bebf45e1efab70a01cc599778fbe9ba24b0de22e
+  data.tar.gz: 6e99eaac82f0d5f3b05edb178a9fc0c8e30bcce0
+SHA512:
+  metadata.gz: 333cb564784aa5ad1240b86042ce0a6c4b11873e7775eb35a6bd3cb248af5da2a9b536f1320cc20adad1d7ea8c3e2029a23be91041cc617de360e0df36d0b970
+  data.tar.gz: 04d110e33c81739fb7bcb626ab0b7bf5dac26a9ebc3acea718cda594376d5965761c3352d1786938f9103f60f91a24e39295d6790bbcdfe5f9dd5fe494d5d324

data/README.md

@@ -0,0 +1,34 @@
+# Guard::MtHaml
+This is a Guard wrapper to compile Haml to PHP, Twig or static HTML.
+
+Add to your `Gemfile`:
+```ruby
+gem 'guard-mthaml'
+```
+
+Require in your `Guardfile`:
+```ruby
+require "guard/mthaml"
+```
+
+Or, add the default Guard::MtHaml template to your `Guardfile` by running:
+```bash
+$ guard init mthaml
+```
+
+## Usage
+
+```ruby
+###
+# Sample Guardfile block for Guard::MtHaml
+#
+# :input           ("views/src") set output directory for compiled files
+# :output          ("views")     set input directory with haml files
+# :environment     ("php")       haml environment
+# :notifications   (true)        toggle guard notifications
+# :compress_output (false)       compress compiled haml files
+# :static_files    (false)       compile haml to static html
+# :run_at_start    (true)        compile files when guard starts
+###
+guard :haml, :input => "views/src", :output => "views"
+```

data/lib/guard/mthaml.rb

@@ -0,0 +1,140 @@
+require "guard"
+require "guard/plugin"
+require "guard/watcher"
+
+module Guard
+    class MtHaml < Plugin
+
+        ###
+        # Initializer
+        ###
+        def initialize(options = {})
+            options = {
+                :input => "views/src",
+                :output => "views",
+                :environment => "php",
+                :notifications => true,
+                :compress_output => false,
+                :run_at_start => true,
+                :static_files => false
+            }.merge(options)
+
+            super(options)
+
+            if options[:input]
+                watchers << ::Guard::Watcher.new(%r{^#{options[:input]}/(.+\.haml)$})
+            end
+        end
+
+        ###
+        # Run at start
+        ###
+        def start
+            run_all if options[:run_at_start]
+        end
+
+        def stop
+            true
+        end
+
+        def reload
+            run_all
+        end
+
+        ###
+        # Run all
+        ###
+        def run_all
+            run_on_changes Watcher.match_files(self, Dir.glob(File.join("**", "*.*")).reject { |f| f[%r{(\.php)$}] })
+        end
+
+        ###
+        # Run on changes to watched files
+        #
+        # @param {Array} paths
+        #   Paths of changed files
+        ###
+        def run_on_changes(paths)
+            paths.each do |file|
+
+                file = Pathname.new(file)
+                file_dir = file.dirname.realpath
+                input_dir = Pathname.new(options[:input]).realpath
+                input_file = file.realpath
+
+                unless input_dir == file_dir
+                    output_dir = Pathname.new(options[:output]).realpath + file_dir.basename
+                    make_directory(output_dir)
+                else
+                    output_dir = Pathname.new(options[:output]).realpath
+                end
+
+                compile_haml(input_file, output_dir)
+            end
+        end
+
+        private
+
+        ###
+        # Wrapper to run through PHP Haml compiler, which creates new files itself
+        #
+        # @param {String} input
+        #   Input file to pass to compiler
+        # @param {String} output
+        #   Output directory to pass to compiler
+        ###
+        def compile_haml(input, output)
+
+            ext = if options[:static_files]
+                ".html"
+            else
+                ".#{options[:environment]}"
+            end
+
+            command = [
+                "php #{File.dirname(__FILE__)}/mthaml/compiler/MtHaml.php",
+                "--input #{input}",
+                "--output #{output}",
+                "--environment #{options[:environment]}",
+                "--static_files #{options[:static_files]}",
+                "--compress_output #{options[:compress_output]}"
+            ].join " "
+
+            begin
+                throw :task_has_failed unless system command
+                ::Guard::UI.info(color("write #{File.basename(input, ".*") + ext}", ";32")) if options[:notifications]
+            rescue StandardError => error
+                ::Guard::UI.error(color("error #{File.basename(input, ".*") + ext} : #{error}", ";31")) if options[:notifications]
+            end
+        end
+
+        ###
+        # Create dir if it doesn't already exist, used to make sure the
+        #   output file structure matches the input structure
+        #
+        # @param {String} dir
+        #   Directory to create
+        ###
+        def make_directory(dir)
+            unless File.directory? dir
+                FileUtils.mkdir_p(dir)
+            end
+        end
+
+        ###
+        # Set message color
+        #
+        # @param {String} message
+        #   Text to color
+        # @param {String} color
+        #   Color code
+        ###
+        def color(message, color)
+            if ::Guard::UI.send(:color_enabled?)
+                "\e[0#{color}m#{message}\e[0m"
+            else
+                message
+            end
+        end
+    end
+end

data/lib/guard/mthaml/compiler/MtHaml.php

@@ -0,0 +1,255 @@
+<?php
+
+namespace EGabrielse;
+
+// Go up to root of plugin
+require_once dirname(dirname(dirname(dirname(__DIR__)))) . "/vendor/autoload.php";
+
+use MtHaml;
+use Michelf\Markdown as Markdown;
+use CoffeeScript\Compiler as CoffeeScript;
+
+/**
+ * Compile Haml files locally. Used during development stages.
+ *   Can minify compiled assets for production, as well as
+ *   compile inline Markdown and CoffeeScript.
+ *
+ * @since 0.1.0
+ */
+class MtHamlCompiler {
+
+    /**
+     * @var {String}
+     *   Input filename that was passed into compiler
+     *
+     * @since 0.1.0
+     */
+    private $input_file;
+
+    /**
+     * @var {String}
+     *   Output directory to write compiled output to
+     *
+     * @since 0.1.0
+     */
+    private $output_dir;
+
+    /**
+     * @var {String}
+     *   Type of MtHaml environment, either Twig or PHP
+     *
+     * @since 0.1.0
+     */
+    private $environment;
+
+    /**
+     * @var {Array}
+     *   Array of options to be passed to MtHaml
+     *
+     * @since 0.1.0
+     */
+    private $options;
+
+    /**
+     * @var {Array}
+     *   Array containing Haml filters and their instances
+     *
+     * @since 0.1.0
+     */
+    private $filters;
+
+    /**
+     * @var {Object}
+     *   Instance of \MtHaml\Environment
+     *
+     * @since 0.1.0
+     */
+    private $compiler;
+
+    /**
+     * @var {String}
+     *   Compiled output of Haml file
+     *
+     * @since 0.1.0
+     */
+    private $output;
+
+    /**
+     * Constructor
+     *
+     * @param {Array} $opts
+     *   Array that contains input file and output directory
+     *
+     * @since 0.1.0
+     */
+    public function __construct( $opts = array() ) {
+
+        // Set filters
+        $this->filters["markdown"] = new \MtHaml\Filter\Markdown\MichelfMarkdown( new Markdown );
+        $this->filters["coffeescript"] = new \MtHaml\Filter\CoffeeScript( new CoffeeScript(), array( "header" => false ) );
+
+        /**
+         * Get the input file
+         */
+        if( isset( $opts['input'] ) ) {
+            $this->input_file = $opts['input'];
+        } else {
+            throw new \Exception( "No input file was passed into \$opts." );
+        }
+
+        /**
+         * Get the output dir
+         */
+        if( isset( $opts['output'] ) ) {
+            $this->output_dir = $opts["output"];
+        } else {
+            throw new \Exception( "No output directory was passed into \$opts." );
+        }
+
+        /**
+         * Make sure an options map was passed
+         */
+        if( isset( $opts['options'] ) ) {
+            $this->options = $opts['options'];
+        } else {
+            throw new \Exception( "No options were passed into \$opts." );
+        }
+
+        /**
+         * Get the environment
+         */
+        if( isset( $this->options['environment'] ) ) {
+            $this->environment = $this->options['environment'];
+        } else {
+            throw new \Exception( "No environment was passed into \$opts." );
+        }
+
+        // Set the MtHaml environment
+        self::set_environment();
+    }
+
+    /**
+     * Runs compiler and writes contents to output file
+     *
+     * @since 0.1.0
+     */
+    public function run() {
+        // Compile output
+        $this->output = $this->compile();
+        // Compress output if set
+        if( $this->options["compress_output"] ) {
+            $this->output = $this->compress();
+        }
+        // Write output to file
+        $this->write();
+    }
+
+    /**
+     * Create HtHaml environment
+     *
+     * @since 0.1.0
+     */
+    private function set_environment() {
+        $this->compiler = new \MtHaml\Environment( $this->environment, array(
+            'enable_dynamic_attrs' => false,
+            "enable_escaper" => false,
+            "cdata" => false
+        ), array(
+            "markdown" => $this->filters["markdown"],
+            "coffeescript" => $this->filters["coffeescript"],
+        ));
+    }
+
+    /**
+     * Instantiate MtHaml and compile passed file
+     *
+     * @since 0.1.0
+     */
+    private function compile() {
+        if ( $this->options["static_files"] ) {
+            // Instantiate executor based on environment
+            if ( $this->environment == "php" ) {
+                $this->executor = new \MtHaml\Support\Php\Executor( $this->compiler, array(
+                    "cache" => $this->output_dir . '/cache',
+                ));
+            } else {
+                throw new \Exception("To compile static files, please set your environment to PHP. It is currently set to `$this->environment`.");
+            }
+            // Compile assets
+            return $this->executor->render( $this->input_file, array() );
+        } else {
+            // Get contents from input file and compile
+            return $this->compiler->compileString( file_get_contents( $this->input_file ), basename( $this->input_file ) );
+        }
+    }
+
+    /**
+     * Removes all white space and newlines from output
+     *
+     * @TODO Find a Composer plugin that will do this, as this isn't very clean
+     *
+     * @since 0.1.0
+     */
+    private function compress() {
+        return preg_replace( "/^\s+|\n|\r|\s+$/m", "", $this->output );
+    }
+
+    /**
+     * Make sure that the path is writable
+     *
+     * @param {String} $dir
+     *   Directory path
+     *
+     * @since 0.1.0
+     */
+    private function ensure_path_writable( $dir ) {
+        // Attempt to change permissions if not writable
+        if ( ! is_writable( $dir ) ) {
+            chmod( $dir, 0760 );
+        }
+        // If dir is still not writable, throw err
+        if ( ! is_writable( $dir ) ) {
+            throw new \Exception("It looks like the directory `$dir` isn't writable.");
+        }
+    }
+
+    /**
+     * Writes compiled assets to output file
+     *
+     * @since 0.1.0
+     */
+    private function write() {
+        if ( $this->output ) {
+            $extension = $this->options["static_files"] ? "html" : $this->environment;
+            // Make sure our path is writable
+            self::ensure_path_writable( $this->output_dir );
+            // Render output
+            return file_put_contents( "$this->output_dir/" . basename( $this->input_file, ".haml" ) . ".$extension", $this->output );
+        } else {
+            throw new \Exception( "It looks like `" . basename( $this->input_file ) . "` compiled without any output." );
+        }
+    }
+}
+
+/**
+ * Get passed arguments from Guard
+ */
+$opts = getopt( "", array( "input:", "output:", "environment:", "static_files:", "compress_output:" ) );
+
+/**
+ * Instantiate compiler and parse file with input from Guard
+ */
+try {
+    $compiler = new MtHamlCompiler( array(
+        "input" => $opts["input"],
+        "output" => $opts["output"],
+        "options" => array(
+            "environment" => $opts["environment"],
+            "static_files" => $opts["static_files"] === "true" ? true : false,
+            "compress_output" => $opts["compress_output"] === "true" ? true : false
+        )
+    ));
+    $compiler->run();
+} catch ( \Exception $err ) {
+    exit ( $err->getMessage() . "\n" );
+}

data/lib/guard/mthaml/templates/Guardfile

@@ -0,0 +1,12 @@
+###
+# Sample Guardfile block for Guard::MtHaml
+#
+# :input           ("views/src") set output directory for compiled files
+# :output          ("views")     set input directory with haml files
+# :environment     ("php")       haml environment
+# :notifications   (true)        toggle guard notifications
+# :compress_output (false)       compress compiled haml files
+# :static_files    (false)       compile haml to static html
+# :run_at_start    (true)        compile files when guard starts
+###
+guard :mthaml, :input => "views/src", :output => "views"