spontaneous 0.1.0.alpha1

data/lib/spontaneous/logger.rb

@@ -0,0 +1,369 @@
+## Adapted from Padrino::Logger
+#
+# Defines our SPOT_LOG_LEVEL
+SPOT_LOG_LEVEL = ENV['SPOT_LOG_LEVEL'] unless defined?(SPOT_LOG_LEVEL)
+
+module Spontaneous
+
+  ##
+  # Returns the spontaneous logger
+  #
+  # ==== Examples
+  #
+  #   logger.debug "foo"
+  #   logger.warn "bar"
+  #
+  def self.logger
+    Thread.current[:spontaneous_logger] ||= Spontaneous::Logger.setup!
+  end
+
+  def self.logger=(logger)
+    Thread.current[:spontaneous_logger] = logger
+  end
+
+  ##
+  # Extensions to the built in Ruby logger.
+  #
+  # ==== Examples
+  #
+  #   logger.debug "foo"
+  #   logger.warn  "bar"
+  #
+  class Logger
+
+    attr_accessor :level
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+
+    ##
+    # Ruby (standard) logger levels:
+    #
+    # :fatal:: An unhandleable error that results in a program crash
+    # :error:: A handleable error condition
+    # :warn:: A warning
+    # :info:: generic (useful) information about system operation
+    # :debug:: low-level information for developers
+    #
+    Levels = {
+      :fatal => 7,
+      :error => 6,
+      :warn  => 4,
+      :info  => 3,
+      :debug => 1,
+      :trace => 0
+    } unless const_defined?(:Levels)
+
+    @@mutex = {}
+
+    ##
+    # Configuration for a given environment, possible options are:
+    #
+    # :log_level:: Once of [:fatal, :error, :warn, :info, :debug]
+    # :stream:: Once of [:to_file, :null, :stdout, :stderr] our your custom stream
+    # :log_level::
+    #   The log level from, e.g. :fatal or :info. Defaults to :debug in the
+    #   production environment and :debug otherwise.
+    # :auto_flush::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to true.
+    # :format_datetime:: Format of datetime. Defaults to: "%d/%b/%Y %H:%M:%S"
+    # :format_message:: Format of message. Defaults to: ""%s - - [%s] \"%s\"""
+    #
+    # ==== Examples
+    #
+    #   Spontaneous::Logger::Config[:development] = { :log_level => :debug, :to_file }
+    #   # or you can edit our defaults
+    #   Spontaneous::Logger::Config[:development][:log_level] = :error
+    #   # or you can use your stream
+    #   Spontaneous::Logger::Config[:development][:stream] = StringIO.new
+    #
+    # Defaults are:
+    #
+    #   :production  => { :log_level => :warn, :stream => :to_file }
+    #   :development => { :log_level => :debug, :stream => :stdout }
+    #   :test        => { :log_level => :fatal, :stream => :null }
+    #
+    Config = {
+      :production  => { :log_level => :warn,  :stream => :to_file },
+      :development => { :log_level => :debug, :stream => :stdout },
+      :test        => { :log_level => :debug, :stream => :null },
+      :gem         => { :log_level => :trace, :stream => :stdout }
+    }
+
+    # Embed in a String to clear all previous ANSI sequences.
+    CLEAR      = "\e[0m"
+    # The start of an ANSI bold sequence.
+    BOLD       = "\e[1m"
+    # Set the terminal's foreground ANSI color to black.
+    BLACK      = "\e[30m"
+    # Set the terminal's foreground ANSI color to red.
+    RED        = "\e[31m"
+    # Set the terminal's foreground ANSI color to green.
+    GREEN      = "\e[32m"
+    # Set the terminal's foreground ANSI color to yellow.
+    YELLOW     = "\e[33m"
+    # Set the terminal's foreground ANSI color to blue.
+    BLUE       = "\e[34m"
+    # Set the terminal's foreground ANSI color to magenta.
+    MAGENTA    = "\e[35m"
+    # Set the terminal's foreground ANSI color to cyan.
+    CYAN       = "\e[36m"
+    # Set the terminal's foreground ANSI color to white.
+    WHITE      = "\e[37m"
+
+    # Colors for levels
+    ColoredLevels = {
+      :fatal => [BOLD, RED],
+      :error => [RED],
+      :warn  => [YELLOW],
+      :info  => [GREEN],
+      :debug => [CYAN],
+      :trace => []
+    } unless defined?(ColoredLevels)
+
+    ##
+    # Setup a new logger
+    #
+    def self.setup!
+      setup
+    end
+
+    ##
+    # Setup a new logger with options
+    #
+    def self.setup(options = {})
+      config_level = (SPOT_LOG_LEVEL || Spontaneous.env || :test).to_sym # need this for SPOT_LOG_LEVEL
+      config = Config[config_level]
+      stream = \
+        if logfile = options[:logfile]
+          FileUtils.mkdir_p(File.dirname(logfile)) unless File.directory?(File.dirname(logfile))
+          File.new(logfile, "a+")
+        else
+          case config[:stream]
+          when :to_file
+            FileUtils.mkdir_p(Spontaneous.root("log")) unless File.exists?(Spontaneous.root("log"))
+            File.new(Spontaneous.root("log", "#{Spontaneous.env}.log"), "a+")
+          when :null   then StringIO.new
+          when :stdout then $stdout
+          when :stderr then $stderr
+          else config[:stream] # return itself, probabilly is a custom stream.
+          end
+        end
+      config[:log_level] = options[:log_level] if options[:log_level]
+      Spontaneous.logger = Spontaneous::Logger.new(config.merge(:stream => stream))
+    end
+
+    ##
+    # To initialize the logger you create a new object, proxies to set_log.
+    #
+    # ==== Options
+    #
+    # :stream:: Either an IO object or a name of a logfile. Defaults to $stdout
+    # :log_level::
+    #   The log level from, e.g. :fatal or :info. Defaults to :debug in the
+    #   production environment and :debug otherwise.
+    # :auto_flush::
+    #   Whether the log should automatically flush after new messages are
+    #   added. Defaults to true.
+    # :format_datetime:: Format of datetime. Defaults to: "%d/%b/%Y %H:%M:%S"
+    # :format_message:: Format of message. Defaults to: ""%s - - [%s] \"%s\"""
+    #
+    def initialize(options={})
+      @buffer            = []
+      @auto_flush        = options.has_key?(:auto_flush) ? options[:auto_flush] : true
+      @level             = options[:log_level] ? Levels[options[:log_level]] : Levels[:debug]
+      @log               = options[:stream]  || $stdout
+      @log.sync          = true
+      @mutex             = @@mutex[@log] ||= Mutex.new
+      @format_datetime   = options[:format_datetime] || "%d/%b/%Y %H:%M:%S"
+      @format_message    = options[:format_message]  || "%s - [%s] \"%s\""
+    end
+
+    ##
+    # Colorize our level
+    #
+    def colored_level(level)
+      style = ColoredLevels[level.to_s.downcase.to_sym].join("")
+      "#{style}#{level.to_s.upcase.rjust(7)}#{CLEAR}"
+    end
+
+    ##
+    # Set a color for our string. Color can be a symbol/string
+    #
+    def set_color(string, color, bold=false)
+      color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
+      bold  = bold ? BOLD : ""
+      "#{bold}#{color}#{string}#{CLEAR}"
+    end
+
+    ##
+    # Flush the entire buffer to the log object.
+    #
+    def flush
+      return unless @buffer.size > 0
+      @mutex.synchronize do
+        @log.write(@buffer.slice!(0..-1).join(''))
+      end
+    end
+
+    ##
+    # Close and remove the current log object.
+    #
+    def close
+      flush
+      @log.close if @log.respond_to?(:close) && !@log.tty?
+      @log = nil
+    end
+
+    ##
+    # Appends a message to the log. The methods yield to an optional block and
+    # the output of this block will be appended to the message.
+    #
+    def push(message = nil, level = nil)
+      unless @silent
+      self << @format_message % [colored_level(level), set_color(Time.now.strftime(@format_datetime), :yellow), message.to_s.strip]
+      end
+    end
+
+    ##
+    # Directly append message to the log.
+    #
+    def <<(message = nil)
+      message << "\n" unless message[-1] == ?\n
+      @buffer << message
+      flush if @auto_flush
+      message
+    end
+
+    ##
+    # Generate the logging methods for Spontaneous.logger for each log level.
+    #
+    Levels.each_pair do |name, number|
+      class_eval <<-LEVELMETHODS, __FILE__, __LINE__
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger.
+      #
+      # ==== Parameters
+      # message:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}(message = nil)
+        if #{number} >= level
+          message = block_given? ? yield : message
+          self.push(message, :#{name})
+        end
+        self
+      end
+
+      # Appends a message to the log if the log level is at least as high as
+      # the log level of the logger. The bang! version of the method also auto
+      # flushes the log buffer to disk.
+      #
+      # ==== Parameters
+      # message:: The message to be logged. Defaults to nil.
+      #
+      # ==== Returns
+      # self:: The logger object for chaining.
+      def #{name}!(message = nil)
+        if #{number} >= level
+          message = block_given? ? yield : message
+          self.push(message, :#{name})
+          flush
+        end
+        self
+      end
+
+      # ==== Returns
+      # Boolean:: True if this level will be logged by this logger.
+      def #{name}?
+        #{number} >= level
+      end
+      LEVELMETHODS
+    end
+
+    def silent!
+      @silent = true
+      if block_given?
+        begin
+          yield
+        ensure
+          @silent = false
+        end
+      end
+    end
+
+    alias_method :pause!, :silent!
+
+    def silent?
+      @silent
+    end
+
+    def resume!
+      @silent = false
+    end
+    ##
+    # Spontaneous::Loggger::Rack forwards every request to an +app+ given, and
+    # logs a line in the Apache common log format to the +logger+, or
+    # rack.errors by default.
+    #
+    class Rack
+      ##
+      # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+      # "lilith.local - - GET / HTTP/1.1 500 -"
+      #  %{%s - %s %s %s%s %s - %d %s %0.4f}
+      #
+      FORMAT = %{%s - %s %s %s%s %s - %d %s %0.4f}
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        began_at = Time.now
+        status, header, body = @app.call(env)
+        log(env, status, header, began_at)
+        [status, header, body]
+      end
+
+      private
+        def log(env, status, header, began_at)
+          now = Time.now
+          length = extract_content_length(header)
+
+          logger.debug FORMAT % [
+            env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+            env["REMOTE_USER"] || "-",
+            env["REQUEST_METHOD"],
+            env["PATH_INFO"],
+            env["QUERY_STRING"].empty? ? "" : "?" + env["QUERY_STRING"],
+            env["HTTP_VERSION"],
+            status.to_s[0..3],
+            length,
+            now - began_at ]
+        end
+
+        def extract_content_length(headers)
+          headers.each do |key, value|
+            if key.downcase == 'content-length'
+              return value.to_s == '0' ? '-' : value
+            end
+          end
+          '-'
+        end
+    end # Rack
+  end # Logger
+end # Spontaneous
+
+module Kernel #:nodoc:
+  ##
+  # Define a logger available every where in our app
+  #
+  def logger
+    Spontaneous.logger
+  end
+end # Kernel
+

data/lib/spontaneous/media.rb

@@ -0,0 +1,84 @@
+require 'digest/sha1'
+
+module Spontaneous
+  class Media
+    class << self
+
+      include Spontaneous::Constants
+
+      def media_path(*args)
+        File.join(Spontaneous.media_dir, *args)
+      end
+
+      @@upload_uid_lock  = Mutex.new
+      @@upload_uid_index = 0
+
+      def upload_index
+        @@upload_uid_lock.synchronize do
+          @@upload_uid_index = (@@upload_uid_index + 1) % 0xFFFFFF
+        end
+      end
+
+      def upload_path(filename)
+        time = Time.now.to_i
+        dir = "#{time}.#{upload_index}"
+        Spontaneous.media_path("tmp", dir, filename)
+      end
+
+      def to_urlpath(filepath)
+        filepath.gsub(%r{^#{Spontaneous.media_dir}}, "/media")
+      end
+
+      def to_filepath(urlpath)
+        parts = urlpath.split("/")
+        parts[1] = Spontaneous.media_dir
+        ::File.join(*parts)
+      end
+
+      def to_filename(input)
+        parts = input.strip.split(/\./)
+        ext = parts.last
+        name = parts[0..-2].join(DOT)
+        name.gsub!(RE_QUOTES, EMPTY)
+        name.gsub!(/[^\.A-Za-z0-9_-]+/, DASH)
+        name.gsub!(RE_FLATTEN_REPEAT, DASH)
+        name.gsub!(RE_FLATTEN_TRAILING, EMPTY)
+        [name, ext].join(DOT)
+      end
+
+
+      def sha1(filepath)
+        Digest::SHA1.file(filepath).hexdigest
+      end
+
+      alias_method :digest, :sha1
+
+      def combine_shards(hashes, &block)
+        hashes = hashes.split(',') unless hashes.is_a?(Array)
+        shards = hashes.map { |hash| Spontaneous.shard_path(hash) }
+        combined = Tempfile.new('shard')
+        combined.binmode
+
+        shards.each do |shard|
+          File.open(shard, 'rb') do |part|
+            while data = part.read(131072)
+              combined.write(data)
+            end
+          end
+        end
+        combined.close
+
+        if block_given?
+          begin
+            yield(combined)
+          ensure
+            combined.close!
+          end
+        else
+          # caller's responsibility to close & delete tempfile
+          combined
+        end
+      end
+    end
+  end
+end

data/lib/spontaneous/page.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  class Page < Content
+
+    plugin Plugins::Supertype
+    plugin Plugins::Page::Formats
+    plugin Plugins::Layouts
+    plugin Plugins::Paths
+    plugin Plugins::PageTree
+    plugin Plugins::SiteMap
+    plugin Plugins::PageSearch
+    plugin Plugins::Controllers
+    plugin Plugins::Page::Request
+
+    many_to_one :parent,   :class => Content, :reciprocal => :children
+    one_to_many :children, :class => Content, :key => :parent_id, :reciprocal => :parent
+    one_to_many :content,   :class => Content, :key => :page_id, :reciprocal => :page
+
+    # field :title, :string, :default => "New Page"
+
+    set_inheritance_root
+
+    def self.page?
+      true
+    end
+
+    def self.export
+      super.merge(:title_field => self.title_field.to_s)
+    end
+
+    def self.title_field
+      :title
+    end
+
+    def page?
+      true
+    end
+
+    alias_method :is_page?, :page?
+
+    def before_save
+      if parent
+        self.depth = parent.depth+1
+      end
+      super
+    end
+
+    def page
+      self
+    end
+
+    def entry
+      @entry ||= resolve_entry
+    end
+
+    def resolve_entry
+      container.all_pieces.find { |e| e.id == self.id }
+    end
+
+    def page=(page)
+    end
+
+    def content_depth
+      0
+    end
+
+    def page_title
+      if field = self.fields[title_field]
+        field.value
+      end
+    end
+
+    def title_field
+      self.class.title_field
+    end
+
+    def shallow_export
+      hash = super.merge({
+        :path => path,
+        :title => page_title,
+        :slug => slug,
+        :uid => uid
+      })
+      hash.delete(:label)
+      hash.delete(:name)
+      hash
+    end
+
+  end
+end

data/lib/spontaneous/page_controller.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+require 'sinatra/base'
+
+module Spontaneous
+  class PageController < Sinatra::Base
+    attr_reader :content, :format
+
+    def initialize(content, format)
+      @content, @format = content, (format || :html).to_sym
+      super(nil)
+    end
+
+    def page
+      content.page
+    end
+  end
+end

data/lib/spontaneous/page_piece.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  class PagePiece < ProxyObject
+    extend Plugins
+    plugin Plugins::Render
+
+    attr_accessor :container
+    attr_reader :target, :style_id
+
+    def initialize(container, target, style_id)
+      @container, @target, @style_id = container, target, style_id
+    end
+
+    def id
+      target.id
+    end
+
+    def depth
+      container.content_depth + 1
+    end
+
+    def style(format = :html)
+      target.class.resolve_style(style_name, format)
+    end
+
+    def entry
+      self
+    end
+
+    def export
+      target.shallow_export.merge(export_styles).merge({
+        :depth => self.depth
+      })
+    end
+
+    def export_styles
+      {
+        :style => style_id.to_s,
+        :styles => container.available_styles(target).map { |s| s.schema_id.to_s },
+      }
+    end
+
+    def serialize_db
+      [target.id, @style_id]
+    end
+
+    def style=(style)
+      @style_id = style_to_schema_id(style)
+      # because it's not obvious that a change to an entry
+      # will affect the fields of the container piece
+      # make sure that the container is saved using an instance hook
+      target.after_save_hook do
+        container.save
+      end
+      container.entry_modified!(self)
+    end
+
+    def style
+      target.resolve_style(style_id)
+    end
+
+    def template(format = :html)
+      style.template(format)
+    end
+
+    def method_missing(method, *args)
+      if block_given?
+        self.target.__send__(method, *args, &Proc.new)
+      else
+        self.target.__send__(method, *args)
+      end
+    end
+  end
+end
+

data/lib/spontaneous/paths.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+require 'pathname'
+
+module Spontaneous
+  class Paths < ::Hash
+    def initialize(root)
+      @root = File.expand_path(root)
+      super()
+    end
+
+    def add(category, *paths)
+      self[category] = paths
+    end
+
+    def expanded(category)
+      self[category].map do |path, glob|
+        path = Pathname.new(@root) + path
+        if path.exist?
+          path = path.cleanpath
+          path += glob if glob
+          path.to_s
+        else
+          nil
+        end
+      end.compact
+    end
+
+  end # Paths
+end # Spontaneous