spontaneous 0.1.0.alpha1

data/db/migrations/20110201133550_visibility.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    alter_table(:content) do
+      add_column :hidden,  :boolean, :default => false
+      # keeps track of the id of the parent item that is giving us our invisible status
+      add_column :hidden_origin, :integer
+      # a 'materialized path' for the complete content path
+      add_column :content_path, String
+
+      add_index :hidden
+      add_index :content_path
+    end
+  end
+
+  down do
+    alter_table(:content) do
+      drop_index :hidden
+      drop_index :content_path
+      drop_column :hidden
+      drop_column :hidden_origin
+      drop_column :content_path
+    end
+  end
+end
+

data/db/migrations/20110209152710_users_and_groups.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    adapter_scheme =  self.adapter_scheme
+    create_table!(:spontaneous_users) do
+      primary_key :id
+      varchar     :name
+      varchar     :login, :size => 32, :index => true, :unique => true
+      varchar     :email
+      varchar     :salt
+      varchar     :crypted_password
+      boolean     :disabled, :default => false
+
+      datetime    :last_login_at
+      datetime    :created_at
+
+      index       [:login, :disabled], :name => "enabled_login_index"
+    end
+
+    create_table!(:spontaneous_groups) do
+      primary_key :id
+      foreign_key :user_id, :spontaneous_users, :on_delete => :cascade # test for being a single user group is user_id.nil?
+      index       :user_id
+      varchar     :name
+      varchar     :level_name, :default => 'none'
+      boolean     :disabled, :default => false
+      varchar     :access_selector, :default => "*"
+    end
+
+
+    create_table!(:spontaneous_groups_users) do
+      primary_key :id
+      foreign_key :user_id, :spontaneous_users
+      foreign_key :group_id, :spontaneous_groups
+    end
+
+    create_table!(:spontaneous_access_keys) do
+      primary_key :id
+      foreign_key :user_id, :spontaneous_users, :on_delete => :cascade
+      index       :user_id
+      char        :key_id, :size => 44, :index => true, :unique => true
+      datetime    :last_access_at
+      varchar     :last_access_ip
+      varchar     :source_ip
+      datetime    :created_at
+    end
+  end
+
+  down do
+    drop_table :spontaneous_users
+    drop_table :spontaneous_groups
+    drop_table :spontaneous_groups_users
+    drop_table :spontaneous_access_keys
+  end
+end
+
+

data/db/migrations/20110215133910_boxes.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    adapter_scheme =  self.adapter_scheme
+    alter_table(:content) do
+      # content stores
+      case adapter_scheme
+      when :mysql, :mysql2
+        add_column  :box_store, 'mediumtext'
+      else
+        add_column  :box_store, :text
+      end
+    end
+  end
+
+  down do
+    alter_table(:content) do
+      drop_column :box_store
+    end
+  end
+end
+
+
+

data/db/migrations/20110521114145_remove_slots_and_entries.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    adapter_scheme =  self.adapter_scheme
+    alter_table(:content) do
+      drop_column :slot_name
+      drop_column :slot_id
+      add_column  :box_id, :varchar
+    end
+  end
+
+  down do
+    alter_table(:content) do
+      add_column  :slot_name
+      add_column  :slot_id
+      drop_column :box_id
+    end
+  end
+end
+

data/db/migrations/20110604192145_rename_schema_id_columns.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    adapter_scheme =  self.adapter_scheme
+    alter_table(:content) do
+      rename_column :type_id, :type_sid
+      rename_column :style_id, :style_sid
+      rename_column :box_id, :box_sid
+    end
+  end
+
+  down do
+    alter_table(:content) do
+      rename_column :type_sid, :type_id
+      rename_column :style_sid, :style_id
+      rename_column :box_sid, :box_id
+    end
+  end
+end
+
+

data/db/migrations/20110805141925_rename_site_to_state.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    rename_table(:sites, :spontaneous_state)
+  end
+
+  down do
+    rename_table(:spontaneous_state, :sites)
+  end
+end

data/lib/cutaneous/context_helper.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+
+module Cutaneous
+  module ContextHelper
+    include Tenjin::ContextHelper
+    include Spontaneous::Render::Context
+    include Spontaneous
+
+
+    def extends(parent)
+      self._layout = parent
+    end
+
+    def block_super
+      block_name = @_block_level.last
+      @_block_super_calls[block_name].push(@_buf.length - @_block_positions[block_name])
+    end
+
+    def block(block_name)
+      @_block_super_calls ||= Hash.new { |h, k| h[k] = [] }
+      @_block_positions ||= {}
+      @_block_content ||= {}
+      @_block_level ||= []
+      block_name = block_name.to_sym
+      @_block_positions[block_name] = @_buf.length
+      @_block_level << block_name
+      if block_given?
+        yield
+        output = endblock
+      end
+    end
+
+    # the _block_name param is ignored though could throw warning if the two are different
+    def endblock(_block_name=nil)
+      block_name = @_block_level.pop
+      return unless block_name
+      start_position = @_block_positions[block_name]
+      output = @_buf[start_position..-1]
+      @_buf[start_position..-1] = ''
+      if @_block_content.key?(block_name)
+        super_calls = @_block_super_calls[block_name]
+        result = @_block_content[block_name]
+        if !super_calls.empty?
+          position = super_calls.pop
+          result = result[0...position] << output << (result[(position)..-1] || "")
+          if _layout
+            @_block_super_calls[block_name][-1] = @_block_super_calls[block_name].last + position
+            @_block_content[block_name] = result
+          end
+        end
+        @_buf << result
+      else
+        if _layout.nil?
+          @_buf << output
+        else
+          @_block_content[block_name] = output
+        end
+      end
+      output
+    end
+
+    def include(filename)
+      import(filename)
+    end
+
+    protected
+
+    def _decode_params(param, *args)
+      unless param.is_a?(String)
+        @_render_method ||= "to_#{format}".to_sym
+        if param.respond_to?(@_render_method)
+          param = param.send(@_render_method, *args)
+        end
+        if param.respond_to?(:render)
+          param = param.render(format, *args)
+        end
+      end
+      super(param)
+    end
+  end
+end

data/lib/cutaneous/first_pass_parser.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class FirstPassParser < Tenjin::Preprocessor
+    include ParserCore
+
+    ## {% ruby_code %}
+    STMT_PATTERN = /\{%( |\t|\r?\n)(.*?) *%\}([ \t]*\r?\n)?/m
+
+    ## {{ statement }} or {$ statement $}
+    EXPR_PATTERN = /\{([\{\$])(.*?)[\}\$]\}/m
+
+    def stmt_pattern
+      STMT_PATTERN
+    end
+
+    def expr_pattern
+      EXPR_PATTERN
+    end
+  end
+end
+
+

data/lib/cutaneous/first_pass_renderer.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class FirstPassRenderer < Renderer
+
+    def template_class
+      Cutaneous::FirstPassParser
+    end
+
+    def context_class
+      Cutaneous::PublishContext
+    end
+  end
+end
+
+
+
+

data/lib/cutaneous/parser_core.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Cutaneous
+  module ParserCore
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+    end
+
+    def initialize(filepath=nil, format=:html)
+      @format = format
+      super(filepath)
+    end
+  end
+end
+

data/lib/cutaneous/preview_context.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class PreviewContext
+    include ContextHelper
+
+    def include(filename)
+      _comment(filename)
+      import(filename)
+    end
+
+    def _decode_params(param, *args)
+      if param.respond_to?(:start_inline_edit_marker)
+        _comment(param.start_inline_edit_marker) << super << _comment(param.end_inline_edit_marker)
+      else
+        super
+      end
+    end
+
+    def _comment(text)
+      @_comment_method ||= "_comment_#{format}".to_sym
+      if (respond_to?(@_comment_method))
+        self.send(@_comment_method, text)
+      end
+    end
+
+    def _comment_html(text)
+      "<!-- #{escape(text.to_s.escape_html)} -->\n"
+    end
+  end
+end

data/lib/cutaneous/preview_renderer.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class PreviewRenderer < FirstPassRenderer
+
+    def context_class
+      Cutaneous::PreviewContext
+    end
+  end
+end
+
+
+
+
+

data/lib/cutaneous/publish_context.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class PublishContext
+    include ContextHelper
+  end
+end
+
+

data/lib/cutaneous/renderer.rb

@@ -0,0 +1,122 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class Renderer# < Spontaneous::Renderer
+    attr_reader :template_root, :cache_root
+
+    def initialize(template_root, cache = nil)
+      @template_root = template_root
+      @cache = cache
+    end
+
+    def use_cache?
+      @cache
+    end
+
+    def extension
+      Cutaneous.extension
+    end
+
+    def render_string(string, content, format = :html, params = {})
+      template = string_to_template(string)
+      render_template(template, content, format, params)
+    end
+
+    def render_file(file_path, content, format = :html, params = {})
+      template = get_template(file_path, format)
+      render_template(template, content, format, params)
+    end
+
+    def render(filename, context, _layout=true)
+      hook_context(context)
+      while true
+        template = get_template(filename, context.format)
+        _buf = context._buf
+        output = template.render(context)
+        context._buf = _buf
+        unless context._layout.nil?
+          layout = context._layout
+          context._layout = nil
+        end
+        break unless layout
+        filename = layout
+        layout = false
+      end
+      output
+    end
+
+    protected
+
+    def render_template(template, content, format, params = {})
+      context = context_class.new(content, format, params)
+      render(template, context)
+    end
+
+
+    def create_template(filepath, format)
+      template = template_class.new(nil, format)
+      case filepath
+      when String
+        template.timestamp = Time.now
+        template.filename = filepath
+        if use_cache?
+          cache_path = filepath[0...(-Cutaneous.extension.length)] + 'rb'
+          if test(?f, cache_path)
+            # puts "Using cached template #{cache_path}"
+            template.script = File.read(cache_path)
+          else
+            template.convert(File.read(filepath))
+            File.open(cache_path, 'w') do |f|
+              f.flock(File::LOCK_EX)
+              f.write(template.script)
+            end
+          end
+        else
+          template.convert(File.read(filepath))
+        end
+      when Proc
+        template = template_class.new(nil, format)
+        template.convert(filepath.call, filepath.to_s)
+      end
+      template
+    end
+
+    def get_template(template, format)
+      case template
+      when String
+        # if the path is absolute and points to an existing file, just render that
+        # used by the published renderer
+        filepath = make_path_absolute(template, format)
+        create_template(filepath, format)
+      when Proc
+        create_template(template, format)
+      else
+        template
+      end
+    end
+
+    def make_path_absolute(path, format)
+      if ::File.file?(path)
+        path
+      else
+        Spontaneous::Render.find_template(path, format)
+      end
+    end
+
+    def string_to_template(string)
+      template = template_class.new
+      template.convert(string)
+      template
+    end
+
+
+    def hook_context(context)
+      context._engine = self
+      context._layout = nil
+      context
+    end
+  end
+end
+
+
+

data/lib/cutaneous/request_context.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class RequestContext
+    include ContextHelper
+  end
+end
+

data/lib/cutaneous/second_pass_parser.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class SecondPassParser < Tenjin::Template
+    include ParserCore
+
+    ## %{ ruby_code }
+    STMT_PATTERN = /%\{( |\t|\r?\n)(.*?) *\}(?:[ \t]*\r?\n)?/m
+
+    ##  #{ statement } or ${ statement }
+    EXPR_PATTERN = /([\$#])\{(.*?)\}/m
+
+    def stmt_pattern
+      STMT_PATTERN
+    end
+
+    def expr_pattern
+      EXPR_PATTERN
+    end
+  end
+end
+
+

data/lib/cutaneous/second_pass_renderer.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Cutaneous
+  class SecondPassRenderer < Renderer
+
+    def template_class
+      Cutaneous::SecondPassParser
+    end
+
+    def context_class
+      Cutaneous::RequestContext
+    end
+
+  end
+end
+
+
+

data/lib/cutaneous.rb

@@ -0,0 +1,47 @@
+require "tenjin"
+
+module Cutaneous
+  def self.template_path(filename, format)
+    Spontaneous.template_path(template_name(filename, format))
+  end
+
+  def self.template_name(filename, format)
+    "#{filename}.#{format}.#{self.extension}"
+  end
+
+  # this is basicially the API that any templating engine has to provide
+  def self.extension
+    'cut'
+  end
+
+  def self.preview_renderer
+    PreviewRenderer
+  end
+
+  def self.publishing_renderer
+    FirstPassRenderer
+  end
+
+  def self.request_renderer
+    SecondPassRenderer
+  end
+
+  def self.is_dynamic?(render)
+    SecondPassParser::STMT_PATTERN === render || SecondPassParser::EXPR_PATTERN === render
+  end
+
+
+  autoload :ContextHelper, "cutaneous/context_helper"
+  autoload :PreviewContext, "cutaneous/preview_context"
+  autoload :PublishContext, "cutaneous/publish_context"
+  autoload :RequestContext, "cutaneous/request_context"
+
+  autoload :Renderer, "cutaneous/renderer"
+  autoload :ParserCore, "cutaneous/parser_core"
+  autoload :FirstPassParser, "cutaneous/first_pass_parser"
+  autoload :FirstPassRenderer, "cutaneous/first_pass_renderer"
+  autoload :SecondPassParser, "cutaneous/second_pass_parser"
+  autoload :SecondPassRenderer, "cutaneous/second_pass_renderer"
+  autoload :PreviewRenderer, "cutaneous/preview_renderer"
+end
+