processit 1.0.1

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gem "jeweler"
+gem "tilt"
+
+group :development do
+
+end

data/README

@@ -0,0 +1,16 @@
+<h1>ProcessMe</h1>
+
+<h2>Resources</h2>
+
+* [ProcessMe Homepage](http://process-me.org/)
+* [Installing ProcessMe](http://process-me.org/install/)
+* [ProcessMe Reference](http://process-me.org/install/reference/)
+
+<h2>Author</h2>
+ProcessMe is written by [Adam Scherer][adam@annconia.com].<br>
+Adam is a Software Architect who likes everything simple.
+
+<h2>License</h2>
+Copyright (c) 2012 Adam Scherer<br>
+All Rights Reserved.<br>
+Released under a [slightly modified MIT License][license].

data/README.markdown

@@ -0,0 +1,16 @@
+# ProcessIt
+
+## Resources
+
+* [ProcessMe Homepage](http://process-it.org/)
+* [Installing ProcessMe](http://process-it.org/install/)
+* [ProcessMe Reference](http://process-it.org/install/reference/)
+
+## Author
+ProcessMe is written by [Adam Scherer][adam@annconia.com].<br>
+Adam is a Software Architect who likes everything simple.
+
+## License
+Copyright (c) 2012 Adam Scherer<br>
+All Rights Reserved.<br>
+Released under a [slightly modified MIT License][license].

data/bin/processit

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require 'processit'
+require 'optparse'
+require 'shellwords'
+
+builder =  ProcessIt::Builder.new
+
+OptionParser.new do |opts|
+  opts.summary_width = 28
+  opts.banner = "Usage: processit [options]"
+
+  def opts.show_usage
+    puts self
+    exit 1
+  end
+
+  opts.on("-c", "--compile", "Compile the entire source structure") do |name|
+	builder.build
+  end
+
+  opts.on("-w", "--watch", "Perform an initial compile and then monitor for changes to compile automatically") do |directory|
+	builder.watch
+  end
+
+  opts.on("-n PROJECT_NAME", "--create PROJECT_NAME", "Copy the project template into PROJECT_NAME") do |name|
+
+  end
+
+  opts.on_tail("-h", "--help", "Shows this help message") do
+    opts.show_usage
+  end
+
+  opts.on_tail("-v", "--version", "Shows version") do
+    puts ProcessIt::VERSION
+    exit
+  end
+
+  opts.show_usage if ARGV.empty?
+
+  begin
+    opts.order(ARGV) do |filename|
+      filenames << File.expand_path(filename)
+    end
+  rescue OptionParser::ParseError => e
+    opts.warn e.message
+    opts.show_usage
+  end
+end

data/lib/processit.rb

@@ -0,0 +1,27 @@
+require 'processit/version'
+
+
+module ProcessIt
+
+	autoload :EjsTemplate,             "processit/processor/ejs_template"
+	autoload :JstProcessor,            "processit/processor/jst_processor"
+	autoload :JsMinTemplate,           "processit/processor/jsmin_template"
+	autoload :CharsetNormalizer,	   "processit/processor/charset_normalizer"
+	autoload :SafetyColons,		       "processit/processor/safety_colons"
+	autoload :Utils,                   "processit/utils"
+
+	require 'processit/processors'
+	require 'processit/builder'
+	require 'tilt'
+	require 'haml'
+	require 'yaml'
+
+	Processors.instance.register_processor '.js', 'js', [Tilt::ERBTemplate, SafetyColons, JsMinTemplate]
+	Processors.instance.register_processor '.jst', 'js', [Tilt::ERBTemplate, EjsTemplate]
+	Processors.instance.register_processor '.haml', 'html', [Tilt::ERBTemplate, Tilt::HamlTemplate]
+	Processors.instance.register_processor '.html', 'html', [Tilt::ERBTemplate]
+	Processors.instance.register_processor '.scss', 'css', [Tilt::ERBTemplate, Tilt::ScssTemplate]
+	Processors.instance.register_processor '.sass', 'css', [Tilt::ERBTemplate, Tilt::SassTemplate]
+	Processors.instance.register_processor '.css', 'css', [Tilt::ERBTemplate, CharsetNormalizer]
+	
+end

data/lib/processit/base.rb

@@ -0,0 +1,105 @@
+module ProcessIt  
+  class Base
+    
+    include StaticMatic::RenderMixin
+    include StaticMatic::BuildMixin
+    include StaticMatic::SetupMixin
+    include StaticMatic::HelpersMixin    
+    include StaticMatic::ServerMixin    
+    include StaticMatic::RescueMixin    
+  
+    attr_accessor :configuration
+    attr_reader :current_page, :src_dir, :site_dir
+
+    def current_file
+      @current_file_stack[0] || ""
+    end
+    
+    def initialize(base_dir, configuration = Configuration.new)
+      @configuration = configuration
+      @current_page = nil
+      @current_file_stack = []
+      @base_dir = base_dir
+      @src_dir = File.join(@base_dir, "src")
+      @site_dir = File.join(@base_dir, "site")
+      
+      if File.exists?(File.join(@src_dir, "layouts", "application.haml"))
+        puts "DEPRECATION: layouts/application.haml will be renamed to layouts/default.haml in 0.12.0"
+        @default_layout = "application"
+      else
+        @default_layout = "default"
+      end
+      
+      @scope = Object.new
+      @scope.instance_variable_set("@staticmatic", self)
+      
+      load_configuration      
+      configure_compass
+
+      load_helpers
+    end
+    
+    def load_configuration
+      configuration = StaticMatic::Configuration.new
+      config_file = File.join(@base_dir, "config", "site.rb")
+
+      if !File.exists?(config_file)
+        config_file = File.join(@base_dir, "src", "configuration.rb")
+
+        if File.exists?(config_file)
+          puts "DEPRECATION: #{@base_dir}/src/configuration.rb will be moved to #{@base_dir}/config/site.rb in 0.12.0"
+        end
+      end
+      
+      if File.exists?(config_file)
+        config = File.read(config_file)
+        eval(config)
+      end
+
+      @configuration = configuration
+    end
+    
+    def base_dir
+      @base_dir
+    end
+  
+    def run(command)
+      puts "Site root is: #{@base_dir}"
+      
+      if %w(build setup preview).include?(command)
+        send(command)
+      else
+        puts "#{command} is not a valid StaticMatic command"
+      end
+    end
+      
+    # TODO: DRY this _exists? section up
+    def template_exists?(name, dir = '')
+      File.exists?(File.join(@src_dir, 'pages', dir, "#{name}.haml")) || File.exists?(File.join(@src_dir, 'stylesheets', "#{name}.sass")) || File.exists?(File.join(@src_dir, 'stylesheets', "#{name}.scss"))
+    end
+    
+    def layout_exists?(name)
+      File.exists? full_layout_path(name)
+    end
+    
+    def template_directory?(path)
+      File.directory?(File.join(@src_dir, 'pages', path))
+    end
+    
+    def full_layout_path(name)
+      File.join(@src_dir, "layouts", "#{name}.haml")
+    end
+    
+    def configure_compass
+      Compass.configuration.project_path = @base_dir 
+
+      compass_config_path = File.join(@base_dir, "config", "compass.rb")
+      
+      if File.exists?(compass_config_path)
+        Compass.add_configuration(compass_config_path)         
+      end
+
+      configuration.sass_options.merge!(Compass.configuration.to_sass_engine_options)
+    end
+  end
+end

data/lib/processit/builder.rb

@@ -0,0 +1,105 @@
+require 'processit/utils'
+require 'processit/processors'
+require 'fileutils'
+
+module ProcessIt
+	class Builder
+
+		def initialize(root = ".")
+			@base_dir = Dir.pwd
+			@src_dir = File.join(@base_dir, "src")
+			@site_dir = File.join(@base_dir, "site")
+			@html_src_dir = File.join(@src_dir, "pages")
+			
+			@config = YAML.load_file("#{@src_dir}/data/data.yml")
+		end
+
+		def watch
+			puts ">>> ProcessMe is watching for changes. Press Ctrl-C to Stop."
+
+			require 'fssm'
+			begin
+				FSSM.monitor do |monitor|
+					monitor.path @src_dir do |path|
+						path.create do |base, relative|
+							build
+						end
+						
+						path.update do |base, relative|
+							build
+						end
+
+						path.delete do |base, relative|
+							build
+						end
+					end
+				end
+			end
+		end
+		
+		def build
+			puts ">>> ProcessIt is building your site." 
+			Dir["#{@src_dir}/**/*"].each do |path|
+				next if File.basename(path) =~ /^\_/  or File.directory?(path) # skip partials and directories
+
+				save_page(path, evaluate(path))
+			end
+		end
+
+		def evaluate(path, options = {})
+			ext = File.extname(path)
+			path = File.absolute_path(path, @src_dir)
+			result = ProcessIt::Utils.read_unicode(path)
+			Processors.instance.processor(ext)["klasses"].each do |processor|
+				begin
+				  template = processor.new(path) { result }
+				  result = template.render(self, @config)
+				rescue Exception => e
+				  puts e
+				  raise
+				end
+			end
+
+			result
+		end
+		
+		def cms() 
+		
+		end
+
+		def copy_file(from, to)
+			FileUtils.cp(from, to)
+		end
+
+		def save_page(path, content)
+			ext = File.extname(path)
+			file_dir, file_name = File.split(path)
+			relative_name = path.sub(/^#{@src_dir}/, '')
+			relative_name.chomp!(ext)
+			output_ext = Processors.instance.processor(ext)["output_ext"]
+			if (output_ext)
+				generate_site_file(relative_name, output_ext, content)
+			end
+		end
+
+		def generate_site_file(relative_name, extension, content)
+			
+			path = File.join(@site_dir, "#{relative_name}.#{extension}")
+			FileUtils.mkdir_p(File.dirname(path))
+			File.open(path, 'w+') do |f|
+			  f << content
+			end
+
+			puts "created #{path}"
+		end
+
+		# Returns a raw template name from a source file path:
+		# source_template_from_path("/path/to/site/src/stylesheets/application.sass")  ->  "application"
+		def source_template_from_path(path)
+			file_dir, file_name = File.split(path)
+			file_name.chomp!(File.extname(file_name))
+			[ file_dir, file_name, File.extname(path) ]
+		end
+
+	end
+end

data/lib/processit/context.rb

@@ -0,0 +1,236 @@
+require 'base64'
+require 'rack/utils'
+require 'sprockets/errors'
+require 'sprockets/utils'
+require 'pathname'
+require 'set'
+
+module ProcessIt
+  # `Context` provides helper methods to all `Tilt` processors. They
+  # are typically accessed by ERB templates. You can mix in custom
+  # helpers by injecting them into `Environment#context_class`. Do not
+  # mix them into `Context` directly.
+  #
+  #     environment.context_class.class_eval do
+  #       include MyHelper
+  #       def asset_url; end
+  #     end
+  #
+  #     <%= asset_url "foo.png" %>
+  #
+  # The `Context` also collects dependencies declared by
+  # assets. See `DirectiveProcessor` for an example of this.
+  class Context
+    attr_reader :environment, :pathname
+    attr_reader :_required_paths, :_stubbed_assets
+    attr_reader :_dependency_paths, :_dependency_assets
+    attr_writer :__LINE__
+
+    def initialize(environment, logical_path, pathname)
+      @environment  = environment
+      @logical_path = logical_path
+      @pathname     = pathname
+      @__LINE__     = nil
+
+      @_required_paths    = []
+      @_stubbed_assets    = Set.new
+      @_dependency_paths  = Set.new
+      @_dependency_assets = Set.new([pathname.to_s])
+    end
+
+    # Returns the environment path that contains the file.
+    #
+    # If `app/javascripts` and `app/stylesheets` are in your path, and
+    # current file is `app/javascripts/foo/bar.js`, `root_path` would
+    # return `app/javascripts`.
+    def root_path
+      environment.paths.detect { |path| pathname.to_s[path] }
+    end
+
+    # Returns logical path without any file extensions.
+    #
+    #     'app/javascripts/application.js'
+    #     # => 'application'
+    #
+    def logical_path
+      @logical_path.chomp(File.extname(@logical_path))
+    end
+
+    # Returns content type of file
+    #
+    #     'application/javascript'
+    #     'text/css'
+    #
+    def content_type
+      environment.content_type_of(pathname)
+    end
+
+    # Given a logical path, `resolve` will find and return the fully
+    # expanded path. Relative paths will also be resolved. An optional
+    # `:content_type` restriction can be supplied to restrict the
+    # search.
+    #
+    #     resolve("foo.js")
+    #     # => "/path/to/app/javascripts/foo.js"
+    #
+    #     resolve("./bar.js")
+    #     # => "/path/to/app/javascripts/bar.js"
+    #
+    def resolve(path, options = {}, &block)
+      pathname   = Pathname.new(path)
+      attributes = environment.attributes_for(pathname)
+
+      if pathname.absolute?
+        pathname
+
+      elsif content_type = options[:content_type]
+        content_type = self.content_type if content_type == :self
+
+        if attributes.format_extension
+          if content_type != attributes.content_type
+            raise ContentTypeMismatch, "#{path} is " +
+              "'#{attributes.content_type}', not '#{content_type}'"
+          end
+        end
+
+        resolve(path) do |candidate|
+          if self.content_type == environment.content_type_of(candidate)
+            return candidate
+          end
+        end
+
+        raise FileNotFound, "couldn't find file '#{path}'"
+      else
+        environment.resolve(path, {:base_path => self.pathname.dirname}.merge(options), &block)
+      end
+    end
+
+    # `depend_on` allows you to state a dependency on a file without
+    # including it.
+    #
+    # This is used for caching purposes. Any changes made to
+    # the dependency file with invalidate the cache of the
+    # source file.
+    def depend_on(path)
+      @_dependency_paths << resolve(path).to_s
+      nil
+    end
+
+    # `depend_on_asset` allows you to state an asset dependency
+    # without including it.
+    #
+    # This is used for caching purposes. Any changes that would
+    # invalidate the dependency asset will invalidate the source
+    # file. Unlike `depend_on`, this will include recursively include
+    # the target asset's dependencies.
+    def depend_on_asset(path)
+      filename = resolve(path).to_s
+      @_dependency_assets << filename
+      nil
+    end
+
+    # `require_asset` declares `path` as a dependency of the file. The
+    # dependency will be inserted before the file and will only be
+    # included once.
+    #
+    # If ERB processing is enabled, you can use it to dynamically
+    # require assets.
+    #
+    #     <%= require_asset "#{framework}.js" %>
+    #
+    def require_asset(path)
+      pathname = resolve(path, :content_type => :self)
+      depend_on_asset(pathname)
+      @_required_paths << pathname.to_s
+      nil
+    end
+
+    # `stub_asset` blacklists `path` from being included in the bundle.
+    # `path` must be an asset which may or may not already be included
+    # in the bundle.
+    def stub_asset(path)
+      @_stubbed_assets << resolve(path, :content_type => :self).to_s
+      nil
+    end
+
+    # Tests if target path is able to be safely required into the
+    # current concatenation.
+    def asset_requirable?(path)
+      pathname = resolve(path)
+      content_type = environment.content_type_of(pathname)
+      stat = environment.stat(path)
+      return false unless stat && stat.file?
+      self.content_type.nil? || self.content_type == content_type
+    end
+
+    # Reads `path` and runs processors on the file.
+    #
+    # This allows you to capture the result of an asset and include it
+    # directly in another.
+    #
+    #     <%= evaluate "bar.js" %>
+    #
+    def evaluate(path, options = {})
+      pathname   = resolve(path)
+      attributes = environment.attributes_for(pathname)
+      processors = options[:processors] || attributes.processors
+
+      if options[:data]
+        result = options[:data]
+      else
+        if environment.respond_to?(:default_external_encoding)
+          mime_type = environment.mime_types(pathname.extname)
+          encoding  = environment.encoding_for_mime_type(mime_type)
+          result    = Sprockets::Utils.read_unicode(pathname, encoding)
+        else
+          result = Sprockets::Utils.read_unicode(pathname)
+        end
+      end
+
+      processors.each do |processor|
+
+        begin
+          template = processor.new(pathname.to_s) { result }
+          result = template.render(self, {})
+        rescue Exception => e
+          annotate_exception! e
+          raise
+        end
+      end
+
+      result
+    end
+
+    # Returns a Base64-encoded `data:` URI with the contents of the
+    # asset at the specified path, and marks that path as a dependency
+    # of the current file.
+    #
+    # Use `asset_data_uri` from ERB with CSS or JavaScript assets:
+    #
+    #     #logo { background: url(<%= asset_data_uri 'logo.png' %>) }
+    #
+    #     $('<img>').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')
+    #
+    def asset_data_uri(path)
+      depend_on_asset(path)
+      asset  = environment.find_asset(path)
+      base64 = Base64.encode64(asset.to_s).gsub(/\s+/, "")
+      "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
+    end
+
+    private
+      # Annotates exception backtrace with the original template that
+      # the exception was raised in.
+      def annotate_exception!(exception)
+        location = pathname.to_s
+        location << ":#{@__LINE__}" if @__LINE__
+
+        exception.extend(Sprockets::EngineError)
+        exception.sprockets_annotation = "  (in #{location})"
+      end
+
+      def logger
+        environment.logger
+      end
+  end
+end