guard-markdown 0.1.1

data/.gitignore

@@ -0,0 +1,11 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/* 
+.rvmrc
+
+## MAC OS
+.DS_Store
+.Trashes
+.com.apple.timemachine.supported
+.fseventsd

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in guard-krammer.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,18 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+
+  # # Rails example
+  # watch('spec/spec_helper.rb')                       { "spec" }
+  # watch('config/routes.rb')                          { "spec/routing" }
+  # watch('app/controllers/application_controller.rb') { "spec/controllers" }
+  # watch(%r{^spec/.+_spec\.rb})
+  # watch(%r{^app/(.+)\.rb})                           { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^lib/(.+)\.rb})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
+  # watch(%r{^app/controllers/(.+)_(controller)\.rb})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] } 
+
+end

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/guard-markdown.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "guard/markdown/version"
+
+Gem::Specification.new do |s|
+  s.name        = "guard-markdown"
+  s.version     = Guard::MarkdownVersion::VERSION
+  s.authors     = ["Darren Wallace"]
+  s.email       = ["wallace@midweekcrisis.com"]
+  s.homepage    = ""
+	s.summary     = %q{Markdown folder > html folder conversion}
+  s.description = %q{Watches a source folder and converts markdown docs to html docs in a target folder}
+
+  s.rubyforge_project = "guard-markdown"
+
+  s.files         = `git ls-files`.split("\n") 
+	# s.files					= Dir.glob('{lib}/**/*')
+  #s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  #s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]  
+
+	s.add_dependency 'guard', '>= 0.2.2'
+	s.add_dependency 'kramdown', '~> 0.13.3'
+
+  s.add_development_dependency 'bundler', '~> 1.0'
+  s.add_development_dependency 'rspec',   '~> 2.6'
+	s.add_development_dependency 'guard-rspec' 
+	s.add_development_dependency 'growl' 
+end

data/lib/guard/markdown.rb

@@ -0,0 +1,53 @@
+require 'guard'
+require 'guard/guard'
+require 'guard/watcher'
+require 'Kramdown'
+
+module Guard  
+  class Markdown < Guard
+    # Your code goes here...
+    def initialize(watchers=[], options={})
+      super              
+      @options = {
+        :convert_on_start => true,
+        :dry_run          => false
+      }.update(options)
+    end         
+    
+    def start
+      UI.info("Guard::Markdown has started watching your files")
+      run_all if @options[:convert_on_start]
+    end
+    
+    def run_all
+      files = Dir.glob("**/*.*")
+      targets = Watcher.match_files(self, files)  
+      run_on_change targets
+    end
+    
+    # Called on file(s) modifications
+    # TODO  - this method does far too much. Must refactor to allow
+    #       - for better testing
+    def run_on_change(paths)
+      paths.each do |path|
+        input, output = path.split("|") 
+        UI.info "#{input} >> #{output}" 
+        unless @options[:dry_run]
+          source = File.open(input,"rb").read 
+                                            
+          # make sure directory path exists
+          reg = /(.+\/).+\.\w+/i
+          target_path = output.gsub(reg,"\\1")
+          FileUtils.mkpath target_path unless target_path.empty?
+        
+          doc = Kramdown::Document.new(source, :input => "markdown").to_html
+        
+          File.open(output, "w") do |f|
+            f.write(doc)
+          end
+        end
+      end
+      true
+    end
+  end
+end

data/lib/guard/markdown/templates/Guardfile

@@ -0,0 +1,5 @@
+guard 'markdown', :convert_on_start => true, :dry_run => true do  
+	# See README for info on the watch statement below
+	# Will not convert while :dry_run is true. Once you're happy with your watch statements remove it
+	watch (/source_dir\/(.+\/)*(.+\.)(md|markdown)/i) { |m| "source_dir/#{m[1]}#{m[2]}#{m[3]}|output_dir/#{m[1]}#{m[2]}html"}
+end

data/lib/guard/markdown/templates/README.md

@@ -0,0 +1,64 @@
+# Guard::Markdown #
+Markdown guard will watch your markdown documents for changes and convert them to lovely, semantic html. Yay!
+
+## Install ##
+
+You're going to need [Guard](https://github.com/guard/guard) too.
+
+Install with
+	
+	$ gem install guard-markdown
+	
+Or add it to your Gemfile
+
+	gem 'guard-markdown'    
+	
+## Usage ##
+
+Go see the [Guard usage doc](https://github.com/guard/guard#readme) for general instructions
+
+## The Guardfile - where the magic happens
+	
+The Guardfile is where you define your desired input and output paths.
+Create it with:
+
+	$ guard init markdown
+	
+Then tweak the watch statements to your hearts content. It'll look a lot like this:
+
+	guard 'markdown', :convert_on_start => true, :dry_run => true do  
+		watch (/source_dir\/(.+\/)*(.+\.)(md|markdown)/i) { |m| "source_dir/#{m[1]}#{m[2]}#{m[3]}|output_dir/#{m[1]}#{m[2]}html"}
+	end
+
+The guard statement defines which guard your configuring and sets any optional parameters.
+
+*	:convert_on_start - if true will run all conversions when you start the guard. Defaults to true
+*	:dry_run - if true won't actually run the conversion process, but it will output the files being watched and the file it would write to. Use it to tweak your watch statements and when you're happy set it to false.
+
+The watch statement - ok, it may look a little intimidating. You'll need to know your regular expressions. But this is what it's doing.
+
+	watch (/source_dir\/(.+\/)*(.+\.)(md|markdown)/i) { |m| "source_dir/#{m[1]}#{m[2]}#{m[3]}|output_dir/#{m[1]}#{m[2]}html"}
+			 
+			^ ------ input file pattern -----------  ^        ^ ---- input file path -------- ^|^ ----- output file path ---^
+	
+The "input file pattern" is a regular expression that is used to determine which files are watched by the guard. It'll be applied recursively to all files and folders starting in the current working directory. 
+
+Any matches are passed into the block and used to construct the conversion command. The conversion command is a string containing the path to the source file and the desired path to the output file separated by a "|" 
+
+I hope that makes sense :)
+
+
+
+## Have Fun ##
+
+Go see the other [great guards available](https://github.com/guard/guard/wiki/List-of-available-Guards)
+
+Oh yeah, I'm using [Kramdown](http://kramdown.rubyforge.org/) for the conversion engine. So if you want to know what markdown syntax it supports, [go here](http://kramdown.rubyforge.org/syntax.html)
+
+# TODO #
+
+*	Simplify the required watch statement
+	* Seems a little wasteful to have to recreate the input path in the regexp. Must find a way around it.
+*	Allow the passing of Kramdown options into the guard
+*  Allow the conversion of more doc types using Kramdown
+

data/lib/guard/markdown/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  module MarkdownVersion
+    VERSION = "0.1.1"
+  end
+end

data/spec/lib/guard/markdown_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'Kramdown'
+require "guard/watcher"
+require "guard/ui" 
+
+describe "Guard-Markdown" do      
+                             
+	before(:each) do   
+		@subject = Guard::Markdown.new
+	  @input_paths 	= ["input1.md","input2.markdown","dir1/dir2/input3.md"]
+		@output_paths = ["output1.html", "output2.html", "dir1/dir2/output3.html"]
+		@changed_paths = []
+		@input_paths.each_index do |i|
+			@changed_paths << "#{@input_paths[i]}|#{@output_paths[i]}"
+		end
+	end 
+	
+	describe "initialize" do
+	  it "should start with default options" do
+	      @subject.options[:convert_on_start].should be true
+	      @subject.options[:dry_run].should be false
+	  end 
+		
+		it "should be possible to overwrite the default options" do
+			@subject = Guard::Markdown.new([],{ 
+				:convert_on_start => false,
+				:dry_run					=> true	})
+				@subject.options[:convert_on_start].should be false
+	      @subject.options[:dry_run].should be true
+		end
+	end 
+	
+	describe "start" do
+	  it "should show a welcome message" do
+			Guard::UI.should_receive(:info).with("Guard::Markdown has started watching your files")
+			@subject.start
+	  end
+		    
+		describe "convert_on_start" do
+		  it "should run all conversions if convert_on_start is true" do
+		    @subject.should_receive(:run_all)
+				@subject.start
+		  end
+			it "should not convert on start if convert_on_start is false" do
+			  @subject = Guard::Markdown.new([],{ :convert_on_start => false })
+				@subject.should_not_receive(:run_all)
+				@subject.start
+			end
+		end
+		
+	end
+
+	describe "run_on_change" do		
+		it "should read the changed files markdown and convert it to html " do
+		  @input_paths.each_index do |i| 
+			  #mock file read
+				file_double = double() 
+				file_double.should_receive(:read).and_return("#Title")
+				File.should_receive(:open).with(@input_paths[i],"rb").and_return(file_double) 
+				
+				mock_kramdown("#Title").should_receive(:to_html).and_return("<h1>Title</h1>") 			
+				         
+				#test info messages
+				Guard::UI.should_receive(:info).with("#{@input_paths[i]} >> #{@output_paths[i]}")
+				
+				#mock file write                                       
+				file_out = double()   
+				target_path = @output_paths[i].gsub(/(.+\/).+\.\w+/i,"\\1")
+				FileUtils.should_receive(:mkpath).with(target_path)                                                      
+				File.should_receive(:open).with(@output_paths[i], "w").and_return(file_out)
+				
+				#TODO Not sure how to test actually writing to the file
+						
+			end
+			@subject.run_on_change(@changed_paths)
+		end
+		
+		describe "dry run" do
+		  it "should not permorm a conversion on a dry run" do
+		  	@subject = Guard::Markdown.new([],{ :dry_run=> true	})
+				FileUtils.should_not_receive(:mkpath)
+				File.should_not_receive(:open)
+				Kramdown::Document.should_not_receive(:new)
+				Guard::UI.should_receive(:info).exactly(3).times
+				@subject.run_on_change(@changed_paths)
+		  end
+		end            
+	end 
+	
+	describe "run_all" do
+	  it "should call run_on_change for all matching paths" do
+			#mock Guard.watcher
+			mock_watch = double()
+	
+			#mock Dir
+			Dir.should_receive(:glob).with("**/*.*").and_return(@input_paths)
+		 	
+			subject = Guard::Markdown.new(mock_watch)
+			
+			#Guard::Watcher should handle the matching and path manipulation
+			## TODO the following line throws an uninitilizd const error Guard::Guard::Watcher -> don't know why. It'll have to go untested for now
+			Guard::Watcher.should_receive(:match_files).with(subject, @input_paths).and_return(@changed_paths)
+						
+			subject.should_receive(:run_on_change).with(@changed_paths)
+			
+			subject.run_all
+	  end
+	end 
+end  
+
+private
+
+def mock_kramdown text
+ 	kram_doc = double()
+	Kramdown::Document.should_receive(:new).with(text, :input => "markdown").and_return(kram_doc)
+	kram_doc
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'guard/markdown'
+ENV["GUARD_ENV"] = 'test'

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification 
+name: guard-markdown
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Darren Wallace
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: guard
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: kramdown
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.13.3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.6"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: growl
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Watches a source folder and converts markdown docs to html docs in a target folder
+email: 
+- wallace@midweekcrisis.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- guard-markdown.gemspec
+- lib/guard/markdown.rb
+- lib/guard/markdown/templates/Guardfile
+- lib/guard/markdown/templates/README.md
+- lib/guard/markdown/version.rb
+- spec/lib/guard/markdown_spec.rb
+- spec/spec_helper.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: guard-markdown
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Markdown folder > html folder conversion
+test_files: []
+