stasis 0.1.0

data/lib/stasis/plugin.rb

@@ -0,0 +1,76 @@
+class Stasis
+  class Plugin
+    class <<self
+
+      # `Hash` -- Keys are the "bind as" method names and values are the actual method
+      # names on the `Plugin` instance.
+      attr_accessor :_methods
+
+      # `Fixnum` -- The execution priority for this plugin (defaults to 0).
+      def _priority; @priority || 0; end
+
+      # The methods in this `Array` essentially all take the same kind of parameters.
+      # Either a `Hash` or an `Array` of method names. No matter what, the input is
+      # converted to a `Hash` (see `_methods`).
+      %w(
+        action_method
+        after_all
+        after_render
+        before_all
+        before_render
+        controller_method
+      ).each do |method|
+        method = method.to_sym
+        # Define method on the `Plugin` class.
+        define_method(method) do |*methods|
+          # Set defaults on the `_` class variable.
+          self._methods ||= {}
+          self._methods[method] ||= {}
+          # If passing a `Hash`...
+          if methods[0].is_a?(::Hash)
+            self._methods[method].merge!(methods[0])
+          # If passing an `Array`...
+          else
+            # Generate `Hash` from `Array`.
+            methods = methods.inject({}) do |hash, m|
+              hash[m] = m
+              hash
+            end
+            self._methods[method].merge!(methods)
+          end
+        end
+      end
+
+      # Class method to set priority on the `Plugin`.
+      def priority(number)
+        @priority = number
+      end
+    end
+
+    # Helper method provided for built-in Stasis plugins. Returns a boolean value denoting
+    # whether or not a path is within another path.
+    def _within?(within_path, path=@stasis.path)
+      if within_path && path
+        dir = File.dirname(within_path)
+        path[0..dir.length-1] == dir
+      else
+        true
+      end
+    end
+
+    # Helper method provided for built-in Stasis plugins. Returns an `Array` of values
+    # of a `Hash` whose keys are `nil`, a literal match, or a pattern match.
+    def _match_key?(hash, match_key)
+      hash.inject([]) do |array, (key, value)|
+        if key.nil?
+          array << value
+        elsif key.is_a?(::String) && key == match_key
+          array << value
+        elsif key.is_a?(::Regexp) && key =~ match_key
+          array << value
+        end
+        array
+      end
+    end
+  end
+end

data/lib/stasis/plugins/before.rb

@@ -0,0 +1,50 @@
+class Stasis
+  class Before < Plugin
+
+    before_all :before_all
+    before_render :before_render
+    controller_method :before
+    priority 1
+
+    def initialize(stasis)
+      @stasis = stasis
+      @blocks = {}
+    end
+
+    # This method is bound to all controllers. Stores a block in the `@blocks` `Hash`,
+    # where the key is a path and the value is an `Array` of blocks.
+    def before(*paths, &block)
+      paths = [ nil ] if paths.empty?
+      if block
+        paths.each do |path|
+          path = @stasis.controller._resolve(path, true)
+          @blocks[path] ||= []
+          @blocks[path] << [ @stasis.path, block ]
+        end
+      end
+    end
+
+    # This event triggers before all files render. When a `before` call receives a path
+    # that does not exist, we want to create that file dynamically. This method adds
+    # those dynamic paths to the `paths` `Array`.
+    def before_all
+      new_paths = (@blocks || {}).keys.select do |path|
+        path.is_a?(::String)
+      end
+      @stasis.paths = (@stasis.paths + new_paths).uniq
+    end
+
+    # This event triggers before each file renders through Stasis. It finds matching
+    # blocks for the `path` and evaluates those blocks using the `action` as a scope.
+    def before_render
+      matches = _match_key?(@blocks, @stasis.path)
+      matches.each do |group|
+        group.each do |(path, block)|
+          if _within?(path)
+            @stasis.action.instance_eval(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stasis/plugins/helpers.rb

@@ -0,0 +1,29 @@
+class Stasis
+  class Helpers < Plugin
+
+    controller_method :helpers
+    before_render :before_render
+
+    def initialize(stasis)
+      @stasis = stasis
+      @blocks = []
+    end
+
+    #  This event triggers before each file renders through Stasis. For each helper
+    # `block`, evaluate the `block` in the scope of the `action` class.
+    def before_render
+      @blocks.each do |(path, block)|
+        if _within?(path)
+          @stasis.action.class.class_eval(&block)
+        end
+      end
+    end
+
+    # This method is bound to all controllers. Stores a block in the `@blocks` `Array`.
+    def helpers(&block)
+      if block
+        @blocks << [ @stasis.path, block ]
+      end
+    end
+  end
+end

data/lib/stasis/plugins/ignore.rb

@@ -0,0 +1,35 @@
+class Stasis
+  class Ignore < Plugin
+
+    before_render :before_render
+    controller_method :ignore
+
+    def initialize(stasis)
+      @stasis = stasis
+      @ignore = {}
+    end
+
+    # This event triggers before each file renders. Rejects any `paths` that are included
+    # in the `@ignore` `Array`.
+    def before_render
+      matches = _match_key?(@ignore, @stasis.path)
+      matches.each do |group|
+        group.each do |path|
+          @stasis.path = nil if _within?(path)
+        end
+      end
+    end
+
+    # This method is bound to all controllers. Adds an `Array` of paths to the `@ignore`
+    # `Array`.
+    def ignore(*array)
+      array.each do |path|
+        path = @stasis.controller._resolve(path)
+        if path
+          @ignore[path] ||= []
+          @ignore[path] << @stasis.path
+        end
+      end
+    end
+  end
+end

data/lib/stasis/plugins/instead.rb

@@ -0,0 +1,15 @@
+class Stasis
+  class Instead < Plugin
+
+    action_method :instead
+
+    def initialize(stasis)
+      @stasis = stasis
+    end
+
+    # This method is bound to all actions.
+    def instead(string)
+      @stasis.action._render = string
+    end
+  end
+end

data/lib/stasis/plugins/layout.rb

@@ -0,0 +1,51 @@
+class Stasis
+  class Layout < Plugin
+
+    action_method :layout => :layout_action
+    before_render :before_render
+    controller_method :layout => :layout_controller
+
+    def initialize(stasis)
+      @stasis = stasis
+      @layouts = {}
+    end
+
+    # This event triggers before each file renders through Stasis. It sets the `action`
+    # layout from the matching layout for `path`.
+    def before_render
+      @stasis.action._layout = nil
+      matches = _match_key?(@layouts, @stasis.path)
+      matches.each do |(within, layout)|
+        @stasis.action._layout = layout if _within?(within)
+      end
+    end
+
+    # This method is bound to all actions. Set the `action` layout.
+    def layout_action(path)
+      if path = @stasis.controller._resolve(path)
+        @stasis.action._layout = path
+      end
+    end
+
+    # This method is bound to all controllers. If it receives a `String` as a parameter,
+    # use that layout for all paths. Otherwise, it receives a `Hash` with the key being
+    # the `path` and the value being the layout to use for that `path`.
+    def layout_controller(hash_or_string)
+      if hash_or_string.is_a?(::String)
+        hash = {}
+        hash[/.*/] = hash_or_string
+      else
+        hash = hash_or_string
+      end
+      @layouts.merge! hash.inject({}) { |hash, (path, layout)|
+        path = @stasis.controller._resolve(path)
+        layout = @stasis.controller._resolve(layout)
+        if layout
+          hash[path] = [ @stasis.path, layout ]
+          @stasis.controller.ignore(layout)
+        end
+        hash
+      }
+    end
+  end
+end

data/lib/stasis/plugins/priority.rb

@@ -0,0 +1,41 @@
+class Stasis
+  class Priority < Plugin
+
+    after_all :after_all
+    before_all :before_all
+    controller_method :priority
+    priority 2
+
+    def initialize(stasis)
+      @stasis = stasis
+      @priorities = {}
+    end
+
+    # This event triggers before all files render through Stasis. Collect matching
+    # `paths` and sort those `paths` by priority.
+    def before_all
+      @stasis.paths.collect! do |path|
+        priority = 0
+        matches = _match_key?(@priorities, path)
+        matches.each do |(within, value, force)|
+          priority = value if _within?(within, path) || force
+        end
+        [ path, priority ]
+      end
+      @stasis.paths.sort! { |a, b| b[1] <=> a[1] }
+      @stasis.paths.collect! { |(path, priority)| path }
+    end
+
+    # This method is bound to all controllers. Stores a priority integer in the
+    # `@@priorities` `Hash`, where the key is a path and the value is the priority.
+    def priority(hash)
+      hash = hash.inject({}) do |hash, (key, value)|
+        force = key[0..0] == '/'
+        key = @stasis.controller._resolve(key)
+        hash[key] = [ @stasis.path, value, force ] if key
+        hash
+      end
+      @priorities.merge!(hash)
+    end
+  end
+end

data/lib/stasis/plugins/render.rb

@@ -0,0 +1,71 @@
+require 'tilt'
+
+class Stasis
+  class Render < Plugin
+
+    action_method :render
+
+    def initialize(stasis)
+      @stasis = stasis
+    end
+
+    # This method is bound to all actions.
+    def render(path_or_options={}, options={}, &block)
+      if path_or_options.is_a?(::String)
+        options[:path] = path_or_options
+      else
+        options.merge!(path_or_options)
+      end
+
+      callback = options[:callback]
+      locals = options[:locals]
+      path = options[:path]
+      scope = options[:scope]
+      text = options[:text]
+
+      if @stasis.controller
+        path = @stasis.controller._resolve(path)
+      end
+      
+      output =
+        if text
+          text
+        elsif path && File.file?(path)
+          unless callback == false
+            # Trigger all plugin `before_render` events.
+            temporary_path(path) do
+              @stasis.trigger(:before_render)
+            end
+          end
+
+          output =
+            if Tilt.mappings.keys.include?(File.extname(path)[1..-1])
+              scope = options[:scope] ||= @stasis.action
+              Tilt.new(path).render(scope, locals, &block)
+            else
+              File.read(path)
+            end
+
+          unless callback == false
+            # Trigger all plugin `after_render` events.
+            temporary_path(path) do
+              @stasis.trigger(:after_render)
+            end
+          end
+
+          output
+        end
+      
+      output
+    end
+
+    private
+
+    # Temporarily set `Stasis#path`.
+    def temporary_path(path, &block)
+      @stasis.path, old_path = path, @stasis.path
+      yield
+      @stasis.path = old_path
+    end
+  end
+end

data/lib/stasis/scope.rb

@@ -0,0 +1,54 @@
+class Stasis
+  class Scope
+
+    # `Stasis`.
+    attr_accessor :_stasis
+
+    # Plugins use the `controller_method` and `action_method` class methods to bind
+    # plugin methods to a scope instance. This method does the binding.
+    def _bind_plugin(plugin, type)
+      _each_plugin_method(plugin, type) do |plugin, method, real_method|
+        self.instance_eval <<-EVAL
+          # Define a method on `self` (the `Scope` instance).
+          def #{method}(*args, &block)
+            # Find the plugin.
+            plugin = self._stasis.plugins.detect do |plugin|
+              plugin.to_s == "#{plugin.to_s}"
+            end
+            # Pass parameters to the method on the plugin.
+            plugin.send(:#{real_method}, *args, &block)
+          end
+        EVAL
+      end
+    end
+
+    def _each_plugin_method(plugin, type, &block)
+      # Retrieve plugin `methods`: a `Hash` whose keys are the method name to bind to
+      # `self`, and whose values are the method name on the `Plugin` class we are
+      # binding from.
+      methods = plugin.class._methods ? plugin.class._methods[type] : nil
+      methods ||= {}
+      methods.each do |method, real_method|
+        yield(plugin, method, real_method)
+      end
+    end
+
+    def _each_plugins_method(type, &block)
+      # For each plugin...
+      _stasis.plugins.each do |plugin|
+        _each_plugin_method(plugin, type, &block)
+      end
+    end
+
+    # Using all `Plugin` instances of a certain priority, call methods of a certain type.
+    def _send_to_plugin(priority, type)
+      _each_plugins_method(type) do |plugin, method, real_method|
+        # If priority matches and plugin responds to method...
+        if plugin.class._priority == priority && plugin.respond_to?(real_method)
+          # Call plugin method.
+          plugin.send(real_method)
+        end
+      end
+    end
+  end
+end

data/lib/stasis/scope/action.rb

@@ -0,0 +1,25 @@
+# `Action` provides a scope for markup rendered via [Tilt][ti] and `before` blocks within
+# a controller.
+#
+# [ti]: https://github.com/rtomayko/tilt
+
+class Stasis
+  class Action < Scope
+
+    # `String` -- Path to the layout for this action.
+    attr_accessor :_layout
+
+    # `String` -- If present, render this path instead of the default.
+    attr_accessor :_render
+
+    def initialize(stasis)
+      @_stasis = stasis
+
+      # Some plugins define methods to be made available to action scopes. This call
+      # binds those methods.
+      @_stasis.plugins.each do |plugin|
+        _bind_plugin(plugin, :action_method)
+      end
+    end
+  end
+end