stasis 0.1.0

data/config/gemsets.yml

@@ -0,0 +1,9 @@
+stasis:
+  directory_watcher: '~>1.4.0'
+  rake: '>=0.8.7'
+  redis: '~>2.2.1'
+  rocco: '~>0.8'
+  rspec: '~>1.0'
+  slop: '~>2.1.0'
+  tilt: '~>1.3'
+  yajl-ruby: '~>0.8.2'

data/config/gemspec.yml

@@ -0,0 +1,17 @@
+name: stasis
+version: 0.1.0
+authors:
+  - Winton Welsh
+email: mail@wintoni.us
+homepage: http://wintoni.us
+summary: Markup-agnostic static site generator
+description: A markup-agnostic static site generator.
+dependencies:
+  - directory_watcher
+  - redis
+  - slop
+  - tilt
+  - yajl-ruby
+development_dependencies:
+  - rake
+  - rspec

data/lib/stasis.rb

@@ -0,0 +1,291 @@
+# **Stasis** is a dynamic framework for static sites.
+
+### Prerequisites
+
+require 'fileutils'
+
+# `Stasis::Gems` handles loading of rubygems and gems listed in [config/gemsets.yml][ge].
+#
+# [ge]: https://github.com/winton/stasis/blob/master/config/gemsets.yml
+
+require File.dirname(__FILE__) + '/stasis/gems'
+
+# [Slim][sl] ships with its own [Tilt][ti] integration. If the user has [Slim][sl]
+# installed, require it, otherwise don't worry about it.
+#
+# [sl]: http://slim-lang.com/
+# [ti]: https://github.com/rtomayko/tilt
+
+begin
+  require 'slim'
+rescue Exception => e
+end
+
+# Activate the [Tilt][ti] gem.
+
+Stasis::Gems.activate %w(tilt)
+
+# Add the project directory to the load paths.
+
+$:.unshift File.dirname(__FILE__)
+
+# Require all Stasis library files.
+
+require 'stasis/dev_mode'
+require 'stasis/plugin'
+require 'stasis/server'
+
+require 'stasis/scope'
+require 'stasis/scope/action'
+require 'stasis/scope/controller'
+
+require 'stasis/plugins/before'
+require 'stasis/plugins/helpers'
+require 'stasis/plugins/ignore'
+require 'stasis/plugins/instead'
+require 'stasis/plugins/layout'
+require 'stasis/plugins/priority'
+require 'stasis/plugins/render'
+
+### Public Interface
+
+class Stasis
+  
+  # `Action` -- changes with each iteration of the main loop within `Stasis#render`.
+  attr_accessor :action
+
+  # `Controller` -- set to the same instance for the lifetime of the `Stasis` instance.
+  attr_accessor :controller
+
+  # `String` -- the destination path passed to `Stasis.new`.
+  attr_accessor :destination
+
+  # `String` -- changes with each iteration of the main loop within `Stasis#render`.
+  attr_accessor :path
+
+  # `Array` -- all paths in the project that Stasis will act upon.
+  attr_accessor :paths
+
+  # `Options` -- options passed to `Stasis.new`.
+  attr_accessor :options
+
+  # `Array` -- `Plugin` instances.
+  attr_accessor :plugins
+
+  # `String` -- the root path passed to `Stasis.new`.
+  attr_accessor :root
+  
+  def initialize(root, *args)
+    @options = {}
+    @options = args.pop if args.last.is_a?(::Hash)
+    
+    @root = File.expand_path(root)
+    @destination = args[0] || @root + '/public'
+    @destination = File.expand_path(@destination, @root)
+
+    # Create an `Array` of paths that Stasis will act upon.
+    @paths = Dir["#{@root}/**/*"]
+    
+    # Reject paths that are directories or within the destination directory.
+    @paths.reject! do |path|
+      !File.file?(path) || path[0..@destination.length-1] == @destination
+    end
+
+    # Create plugin instances.
+    @plugins = find_plugins.collect { |klass| klass.new(self) }
+
+    # Create a controller instance.
+    @controller = Controller.new(self)
+  end
+
+  def render(*only)
+    collect = {}
+    render_options = {}
+
+    if only.last.is_a?(::Hash)
+      render_options = only.pop
+    end
+
+    # Resolve paths given via the `only` parameter.
+    only = only.inject([]) do |array, path|
+      # If `path` is a regular expression...
+      if path.is_a?(::Regexp)
+        array << path
+      # If `root + path` exists...
+      elsif (path = File.expand_path(path, root)) && File.exists?(path)
+        array << path
+      # If `path` exists...
+      elsif File.exists?(path)
+        array << path
+      end
+      array
+    end
+
+    if only.empty?
+      # Remove old generated files.
+      FileUtils.rm_rf(destination)
+    end
+
+    # Reject paths that are controllers.
+    @paths.reject! do |path|
+      if File.basename(path) == 'controller.rb'
+        # Add controller to `Controller` instance.
+        @controller._add(path)
+        true
+      else
+        false
+      end
+    end
+    
+    # Trigger all plugin `before_all` events.
+    trigger(:before_all)
+
+    @paths.uniq.each do |path|
+      @path = path
+
+      # If `only` parameters given...
+      unless only.empty?
+        # Skip iteration unless there is a match.
+        next unless only.any? do |only|
+          # Regular expression match.
+          (only.is_a?(::Regexp) && @path =~ only) ||
+          (
+            only.is_a?(::String) && (
+              # File match.
+              @path == only ||
+              # Directory match.
+              @path[0..only.length-1] == only
+            )
+          )
+        end
+      end
+
+      # Create an `Action` instance, the scope for rendering the view.
+      @action = Action.new(self)
+
+      # Set the extension if the `@path` extension is supported by [Tilt][ti].
+      ext =
+        Tilt.mappings.keys.detect do |ext|
+          File.extname(@path)[1..-1] == ext
+        end
+      
+      # Trigger all plugin `before_render` events.
+      trigger(:before_render)
+
+      # Skip if `@path` set to `nil`.
+      next unless @path
+
+      # Render the view.
+      view =
+        # If the path has an extension supported by [Tilt][ti]...
+        if ext
+          # If the controller calls `render` within the `before` block for this
+          # path, receive output from `@action._render`.
+          #
+          # Otherwise, render the file located at `@path`.
+          output = @action._render || @action.render(@path, :callback => false)
+
+          # If a layout was specified via the `layout` method...
+          if @action._layout
+            # Render the layout with a block for the layout to `yield` to.
+            @action.render(@action._layout) { output }
+          # If a layout was not specified...
+          else
+            output
+          end
+        # If the path does not have an extension supported by [Tilt][ti] and `render` was
+        # called within the `before` block for this path...
+        elsif @action._render
+          @action._render
+        end
+      
+      # Trigger all plugin `after_render` events.
+      trigger(:after_render)
+
+      # Cut the `root` out of the `path` to get the relative destination.
+      relative = @path[root.length..-1]
+
+      # Add `destination` (as specified from `Stasis.new`) to front of relative
+      # destination.
+      dest = "#{destination}#{relative}"
+
+      # Cut off the extension if the extension is supported by [Tilt][ti].
+      dest =
+        if ext && File.extname(dest) == ".#{ext}"
+          dest[0..-1*ext.length-2]
+        else
+          dest
+        end
+
+      # Create the directories leading up to the destination.
+      FileUtils.mkdir_p(File.dirname(dest))
+
+      # If markup was rendered...
+      if view
+        # Write the rendered markup to the destination.
+        if render_options[:write] != false
+          File.open(dest, 'w') do |f|
+            f.write(view)
+          end
+        end
+        # Collect render output.
+        if render_options[:collect]
+          collect[relative[1..-1]] = view
+        end
+      # If markup was not rendered and the path exists...
+      elsif File.exists?(@path)
+        # Copy the file located at the path to the destination path.
+        if render_options[:write] != false
+          FileUtils.cp(@path, dest)
+        end
+      end
+    end
+
+    # Trigger all plugin `after_all` events, passing the `Stasis` instance.
+    trigger(:after_all)
+
+    # Unset class-level instance variables.
+    @action, @path = nil, nil
+
+    # Respond with collected render output if `collect` option given.
+    collect if render_options[:collect]
+  end
+
+  # Add a plugin to all existing controller instances. This method should be called by
+  # all external plugins.
+  def self.register(plugin)
+    ObjectSpace.each_object(::Stasis) do |stasis|
+      plugin = plugin.new(stasis)
+      stasis.plugins << plugin
+      stasis.controller._bind_plugin(plugin, :controller_method)
+    end
+  end
+
+  # Trigger an event on every plugin in the controller.
+  def trigger(type)
+    each_priority do |priority|
+      @controller._send_to_plugin(priority, type)
+    end
+  end
+
+  private
+
+  # Iterate through plugin priority integers (sorted) and yield each to a block.
+  def each_priority(&block)
+    priorities = @plugins.collect do |plugin|
+      plugin.class._priority
+    end
+    priorities.uniq.sort.each(&block)
+  end
+
+  # Returns an `Array` of `Stasis::Plugin` classes.
+  def find_plugins
+    plugins = []
+    ObjectSpace.each_object(Class) do |klass|
+      if klass < ::Stasis::Plugin
+        plugins << klass
+      end
+    end
+    plugins
+  end
+end

data/lib/stasis/dev_mode.rb

@@ -0,0 +1,55 @@
+Stasis::Gems.activate %w(directory_watcher)
+require 'directory_watcher'
+
+class Stasis
+  class DevMode
+
+    def initialize(dir, options={})
+      trap("INT") { exit }
+
+      puts "\nDevelopment mode enabled: #{dir}"
+
+      @dir = dir
+      @options = options
+
+      render
+
+      dw = DirectoryWatcher.new(@stasis.root)
+      dw.interval = 1
+
+      Dir.chdir(@stasis.root) do
+        within_public = @stasis.destination[0..@stasis.root.length-1] == @stasis.root
+        rel_public = @stasis.destination[@stasis.root.length+1..-1] rescue nil
+        dw.glob = Dir["*"].inject(["*"]) do |array, path|
+          if File.directory?(path) && (!within_public || path != rel_public)
+            array << "#{path}/**/*"
+          end
+          array
+        end
+      end
+
+      dw.add_observer do |*events|
+        modified = events.detect { |e| e[:type] == :modified }
+        render if modified
+      end
+
+      dw.start
+      loop { sleep 1000 }
+    end
+
+    private
+
+    def render
+      puts "\n[#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}] Regenerating #{@options[:only] ? @options[:only].join(', ') : 'project'}..."
+      begin
+        @stasis = Stasis.new(*[ @dir, @options[:public], @options ].compact)
+        @stasis.render(*@options[:only])
+      rescue Exception => e
+        puts "\n[#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}] Error: #{e.message}`"
+        puts "\t#{e.backtrace.join("\n\t")}"
+      else
+        puts "\n[#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}] Complete"
+      end
+    end
+  end
+end

data/lib/stasis/gems.rb

@@ -0,0 +1,154 @@
+unless defined?(Stasis::Gems)
+  
+  require 'yaml'
+  
+  class Stasis
+    module Gems
+      class <<self
+        
+        attr_accessor :config
+        attr_reader :gemset, :gemsets, :versions
+        
+        class SimpleStruct
+          attr_reader :hash
+          
+          def initialize(hash)
+            @hash = hash
+            @hash.each do |key, value|
+              self.class.send(:define_method, key) { @hash[key] }
+              self.class.send(:define_method, "#{key}=") { |v| @hash[key] = v }
+            end
+          end
+        end
+        
+        Gems.config = SimpleStruct.new(
+          :gemsets => [ "#{File.expand_path('../../../', __FILE__)}/config/gemsets.yml" ],
+          :gemspec => "#{File.expand_path('../../../', __FILE__)}/config/gemspec.yml",
+          :warn => true
+        )
+        
+        def activate(*gems)
+          begin
+            require 'rubygems' unless defined?(::Gem)
+          rescue LoadError
+            puts "rubygems library could not be required" if @config.warn
+          end
+          
+          self.gemset ||= gemset_from_loaded_specs
+          
+          gems.flatten.collect { |g| g.to_sym }.each do |name|
+            version = @versions[name]
+            vendor = File.expand_path("../../../vendor/#{name}/lib", __FILE__)
+            if File.exists?(vendor)
+              $:.unshift vendor
+            elsif defined?(gem)
+              gem name.to_s, version
+            else
+              puts "#{name} #{"(#{version})" if version} failed to activate" if @config.warn
+            end
+          end
+        end
+        
+        def dependencies
+          dependency_filter(@gemspec.dependencies, @gemset)
+        end
+        
+        def development_dependencies
+          dependency_filter(@gemspec.development_dependencies, @gemset)
+        end
+        
+        def gemset=(gemset)
+          if gemset
+            @gemset = gemset.to_sym
+        
+            @gemsets = @config.gemsets.reverse.collect { |config|
+              if config.is_a?(::String)
+                YAML::load(File.read(config)) rescue {}
+              elsif config.is_a?(::Hash)
+                config
+              end
+            }.inject({}) do |hash, config|
+              deep_merge(hash, symbolize_keys(config))
+            end
+            
+            @versions = (@gemsets[gemspec.name.to_sym] || {}).inject({}) do |hash, (key, value)|
+              if !value.is_a?(::Hash) && value
+                hash[key] = value
+              elsif key == @gemset
+                (value || {}).each { |k, v| hash[k] = v }
+              end
+              hash
+            end
+          else
+            @gemset = nil
+            @gemsets = nil
+            @versions = nil
+          end
+        end
+        
+        def gemset_names
+          (
+            [ :default ] +
+            @gemsets[gemspec.name.to_sym].inject([]) { |array, (key, value)|
+              array.push(key) if value.is_a?(::Hash) || value.nil?
+              array
+            }
+          ).uniq
+        end
+        
+        def gemspec(reload=false)
+          if @gemspec && !reload
+            @gemspec
+          else
+            data = YAML::load(File.read(@config.gemspec)) rescue {}
+            @gemspec = SimpleStruct.new(data)
+          end
+        end
+      
+        private
+      
+        def deep_merge(first, second)
+          merger = lambda do |key, v1, v2|
+            Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
+          end
+          first.merge(second, &merger)
+        end
+        
+        def dependency_filter(dependencies, match)
+          (dependencies || []).inject([]) { |array, value|
+            if value.is_a?(::Hash)
+              array += value[match.to_s] if value[match.to_s]
+            else
+              array << value
+            end
+            array
+          }.uniq.collect(&:to_sym)
+        end
+        
+        def gemset_from_loaded_specs
+          if defined?(Gem)
+            Gem.loaded_specs.each do |name, spec|
+              if name == gemspec.name
+                return :default
+              elsif name[0..gemspec.name.length] == "#{gemspec.name}-"
+                return name[gemspec.name.length+1..-1].to_sym
+              end
+            end
+            :default
+          else
+            :none
+          end
+        end
+      
+        def symbolize_keys(hash)
+          return {} unless hash.is_a?(::Hash)
+          hash.inject({}) do |options, (key, value)|
+            value = symbolize_keys(value) if value.is_a?(::Hash)
+            options[(key.to_sym rescue key) || key] = value
+            options
+          end
+        end
+      end
+    end
+  end
+end