spontaneous 0.1.0.alpha1

data/lib/spontaneous/collections/entry_set.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Collections
+  class EntrySet < Array
+    alias_method :array_insert, :insert
+    alias_method :array_push,   :push
+    alias_method :array_delete, :delete
+
+    attr_reader :owner
+
+    def initialize(owner, piece_store)
+      @owner = owner
+      (piece_store || []).each do |data|
+        id = data[0]
+        entry = \
+          if data.length == 2
+            page = @owner._pieces.detect { |piece| piece.id == id }
+            Spontaneous::PagePiece.new(@owner, page, data[1])
+          else
+            @owner._pieces.detect { |piece| piece.id == id }
+          end
+        # if the piece/page has been deleted or is invisible
+        # then we just want to silently skip it
+        array_push(entry) if entry
+      end
+    end
+
+    def for_box(box)
+      sid = box.schema_id
+      self.select { |e| e.box_sid == sid }
+    end
+
+    def insert(index, piece)
+      # piece.piece_store = self
+      array_insert(index, piece)
+      owner.entry_modified!(piece)
+    end
+
+
+    def destroy!
+      self.destroy
+      owner.entry_modified!(nil)
+    end
+
+    def destroy
+      self.dup.each { |e| e.destroy(false) }
+    end
+
+    def remove(piece)
+      delete(piece)
+    end
+
+
+    def delete(piece)
+      e = array_delete(piece)
+      owner.entry_modified!(nil)
+    end
+
+    def serialize_db
+      self.map { |e| e.serialize_db }
+    end
+
+
+    def set_position(content, position)
+      piece = self.detect {|e| e.id == content.id }
+      self.array_delete(piece)
+      self.insert(position, piece)
+      owner.entry_modified!(piece)
+    end
+
+    def export
+      map do | piece |
+        piece.export
+      end
+    end
+
+    def visible!
+      self.dup.reject { |e| e.nil? or e.hidden? }.freeze
+    end
+
+  end
+end

data/lib/spontaneous/collections/field_set.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module Spontaneous::Collections
+  class FieldSet < PrototypeSet
+
+    attr_reader :owner
+
+    def initialize(owner, initial_values)
+      super()
+      @owner = owner
+      initialize_from_prototypes(initial_values)
+    end
+
+    def initialize_from_prototypes(initial_values)
+      values = (initial_values || []).map do |value|
+        value = S::FieldTypes.deserialize_field(value)
+        [Spontaneous::Schema::UID[value[:id]], value]
+      end
+      values = Hash[values]
+      owner.field_prototypes.each do |field_prototype|
+        field = field_prototype.to_field(values[field_prototype.schema_id])
+        add_field(field)
+      end
+    end
+
+    def serialize_db
+      self.map { |field| field.serialize_db }
+    end
+
+    def export
+      owner.class.field_names.map do |name|
+        self[name].export
+      end
+    end
+
+    def saved
+      self.each { |field| field.mark_unmodified }
+    end
+
+    protected
+
+    def add_field(field)
+      field.owner = owner
+      getter_name = field.name
+      setter_name = "#{field.name}="
+      self[field.name.to_sym] = field
+      singleton_class.class_eval do
+        define_method(getter_name) { |*args| field.tap { |f| f.template_params = args } }
+        define_method(setter_name) { |value| field.value = value }
+      end
+    end
+  end
+end

data/lib/spontaneous/collections/prototype_set.rb

@@ -0,0 +1,131 @@
+# encoding: UTF-8
+
+module Spontaneous::Collections
+  class PrototypeSet
+    include Enumerable
+
+    attr_reader :store
+
+    def initialize(superobject = nil, superset_name = nil)
+      @superobject, @superset_name = superobject, superset_name
+      @has_superset = !!(@superobject && @superobject.respond_to?(@superset_name))
+      @store = {}
+      @order = []
+    end
+
+    def []=(name, value)
+      key = name.to_sym
+      @store[key] = value
+      @order << key unless order.include?(key)
+    end
+
+    def [](key)
+      case key
+      when Fixnum
+        indexed(key)
+      else
+        named(key)
+      end
+    end
+
+    def key?(key)
+      keys.include?(key.to_sym)
+    end
+
+    alias_method :has_key?, :key?
+
+    def empty?
+      order.empty?
+    end
+
+    def length
+      order.length
+    end
+
+    alias_method :count, :length
+
+    def last
+      named(order.last)
+    end
+
+    def sid(schema_id)
+      values.detect { |e| e.schema_id == schema_id }
+    end
+
+    def each
+      order.each do |name|
+        yield(named(name)) if block_given?
+      end
+    end
+
+    def keys
+      order.map { |name| name }
+    end
+
+    def values
+      map { | value | value }
+    end
+
+    # overwrites the existing ordering with a custom one
+    # any current keys not explicitly included in the new ordering
+    # will be tacked on the end in their current arrangement
+    #
+    # e.g.
+    # set.order #=> [:a, :b, :c, :d]
+    # set.order = [:b, :d]
+    # set.order #=> [:b, :d, :a, :c]
+    #
+    def order=(new_order)
+      # clear any previous custom order
+      @custom_order = nil
+      old_order = order.dup
+      order = []
+      new_order.each do |name|
+        key = name.to_sym
+        if old_order.include?(key)
+          old_order.delete(key)
+          order << key
+        end
+      end
+      order += old_order
+      @custom_order = order
+    end
+
+
+    def order
+      return @custom_order if @custom_order
+      superset? ? (superset.order + @order) : @order
+    end
+
+    alias_method :names, :order
+
+
+    def indexed(index)
+      named(order[index])
+    end
+
+    def named(name)
+      @store[name.to_sym] || (superset? ? superset.named(name) : nil)
+    end
+
+    def superset?
+      @has_superset
+    end
+
+    # returns the superset for this set, if it exists
+    # initialised lazily to avoid potential loops
+    def superset
+      @superset ||= @superobject.send(@superset_name) if superset?
+    end
+
+    protected
+
+    def method_missing(method, *args)
+      if key?(method)
+        named(method)
+      else
+        super
+      end
+    end
+  end # PrototypeSet
+end # Spontaneous

data/lib/spontaneous/collections/style_set.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Spontaneous::Collections
+  class StyleSet < PrototypeSet
+
+    attr_reader :owner
+
+    def initialize(owner)
+      super(owner.supertype, :style_prototypes)
+      @owner = owner
+    end
+  end # StyleSet
+end # Spontaneous::Collections

data/lib/spontaneous/config.rb

@@ -0,0 +1,156 @@
+require 'forwardable'
+
+module Spontaneous
+  class Config
+
+    class Loader
+
+      def self.read(settings, file, mode)
+        self.new(settings, file, mode).load
+      end
+
+      def initialize(settings, file, mode)
+        @settings, @file, @mode = settings, file, mode
+      end
+
+      def load
+        instance_eval(File.read(@file))
+        @settings
+      end
+
+
+      def back(&block)
+        __mode__(:back, &block)
+      end
+
+      def front(&block)
+        __mode__(:front, &block)
+      end
+
+      def __mode__(mode, &block)
+        if @mode == mode
+          yield if block_given?
+        end
+      end
+
+      def method_missing(parameter, *args)
+        if args.length == 1
+          args = args[0]
+        end
+        @settings[parameter] = args
+      end
+    end
+
+    class Configuration
+      extend ::Forwardable
+
+      def initialize(settings = nil)
+        @settings = {}
+        merge!(settings) if settings
+      end
+
+      def merge!(hash)
+        hash.each do |key, value|
+          add_setting(key, value)
+        end
+      end
+
+      def []=(key, value)
+        add_setting(key, value)
+      end
+
+      def add_setting(key, value)
+        @settings[key] = value
+        singleton_class.send(:define_method, key) do
+          value
+        end
+      end
+
+      def get_setting(key)
+        v = @settings[key]
+        if v.is_a?(Proc)
+          v.call
+        else
+          v
+        end
+      end
+
+      def [](key)
+        get_setting(key)
+      end
+
+      def method_missing(key, *args)
+        if key.to_s =~ /=$/
+          key = key.to_s.gsub(/=$/, '').to_sym
+          @settings[key] = args[0]
+        else
+          if @settings.key?(key)
+            get_setting(key)
+          else
+            # Config.base[key]
+            nil
+          end
+        end
+      end
+
+      def_delegators :@settings, :key?
+    end
+
+    @@defaults = {
+      #TODO: add in sensible default configuration (or do it in the generators)
+    }
+
+    attr_reader :environment, :mode, :env, :base, :local, :defaults
+
+    def initialize(environment=:development, mode=:back)
+      @environment = environment.to_sym
+      @mode = mode
+      @local = Configuration.new
+      @env = Configuration.new
+      @base = Configuration.new
+      @defaults = Configuration.new(@@defaults)
+    end
+
+    def load(config_root)
+      default = File.join(config_root, 'environment.rb')
+      merge_file(default, @base)
+      file =  File.join(config_root, "environments/#{environment}.rb")
+      merge_file(file, @env)
+    end
+
+    def merge_file(path, configuration)
+      store = Hash.new
+      Loader.read(store, path, mode) if File.exist?(path)
+      configuration.merge!(store)
+    end
+
+    def [](key)
+      if local.key?(key)
+        local[key]
+      elsif env.key?(key)
+        env[key]
+      elsif base.key?(key)
+        base[key]
+      elsif defaults.key?(key)
+        defaults[key]
+      else
+        # acting like a hash and returning nil for an unknown setting
+        nil
+      end
+    end
+
+    def []=(key, val)
+      local[key] = val
+    end
+
+    def method_missing(key, *args)
+      if key.to_s =~ /=$/
+        key = key.to_s.gsub(/=$/, '').to_sym
+        self[key] = args[0]
+      else
+        self[key]
+      end
+    end
+  end
+end
+

data/lib/spontaneous/constants.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Constants
+    EMPTY = "".freeze
+    SLASH = "/".freeze
+    DASH = "-".freeze
+    AMP = "&".freeze
+    DOT = ".".freeze
+    QUESTION = "?".freeze
+    LF = "\n".freeze
+    PATH_INFO = "PATH_INFO".freeze
+
+    SPOT_REVISION_NUMBER = "SPOT_REVISION".freeze
+    SPOT_ROOT = "SPOT_ROOT".freeze
+    SPOT_MODE = "SPOT_MODE".freeze
+    SPOT_ENV = "SPOT_ENV".freeze
+
+    RE_QUOTES = /['"]/.freeze
+    RE_FLATTEN = /[^\.a-z0-9-]+/.freeze
+    RE_FLATTEN_REPEAT = /\-+/.freeze
+    RE_FLATTEN_TRAILING = /(^\-|\-$)/.freeze
+  end
+end

data/lib/spontaneous/content.rb

@@ -0,0 +1,113 @@
+# encoding: UTF-8
+
+
+require File.expand_path("../../sequel/plugins/yajl_serialization", __FILE__)
+require File.expand_path("../../sequel/plugins/content_table_inheritance", __FILE__)
+
+module Spontaneous
+  class Content < Sequel::Model(:content)
+    class << self
+      alias_method :sequel_plugin, :plugin unless method_defined?(:sequel_plugin)
+    end
+
+    alias_method :each_attribute, :each
+
+    # need to load this first because it's used by the ContentTableInheritance plugin
+    plugin Plugins::SchemaId
+
+    sequel_plugin :content_table_inheritance, :type_sid
+    sequel_plugin :yajl_serialization, :field_store, :entry_store, :box_store
+    sequel_plugin :instance_hooks
+    sequel_plugin :skip_create_refresh
+    sequel_plugin :timestamps, :create=>:created_at, :update=>:modified_at
+    sequel_plugin :identity_map
+    sequel_plugin :association_dependencies
+    sequel_plugin :defaults_setter
+
+    # overwrite the sequel version defined in IdentityMap to support
+    # revisions
+    def self.identity_map_key(pk)
+      "#{super}:#{revision}"
+    end
+
+    # must resolve my is_*? schizophrenia
+    def self.page?
+      false
+    end
+
+    def self.is_page?
+      page?
+    end
+
+    many_to_one :container, :key => :container_id, :class => self, :reciprocal => :_pieces
+    one_to_many :_pieces,    :key => :container_id, :class => self, :reciprocal => :container
+    many_to_one :page, :class => Content, :key => :page_id, :reciprocal => :content
+
+    extend Plugins
+    include Enumerable
+
+    plugin Plugins::Entry
+    plugin Plugins::Boxes
+    plugin Plugins::Fields
+    plugin Plugins::Entries
+    plugin Plugins::Styles
+    plugin Plugins::SchemaTitle
+    plugin Plugins::Render
+    plugin Plugins::SchemaHierarchy
+    plugin Plugins::InstanceCode
+    plugin Plugins::Serialisation
+    plugin Plugins::Media
+    plugin Plugins::Publishing
+    plugin Plugins::Aliases
+    plugin Plugins::Visibility
+    plugin Plugins::Prototypes
+    plugin Plugins::Permissions
+
+    # marker method enabling a simple test for "cms content" vs "everything else"
+    def spontaneous_content?
+      true
+    end
+
+    def alias?
+      false
+    end
+
+    def page?
+      false
+    end
+    alias_method :is_page?, :page?
+
+
+    # terminate the supertype chain here
+    def self.supertype
+      nil
+    end
+
+    def self.supertype?
+      !supertype.nil?
+    end
+
+    def start_inline_edit_marker
+      "spontaneous:previewedit:start:content id:#{id}"
+    end
+
+    def end_inline_edit_marker
+      "spontaneous:previewedit:end:content id:#{id}"
+    end
+
+    def to_s
+      %(#<#{self.class.name} id=#{id}>)
+    end
+
+    def each
+      iterable.each do |i|
+        yield i if block_given?
+      end
+    end
+
+    def formats
+      return page.formats if page
+      [:html]
+    end
+  end
+end

data/lib/spontaneous/content_query.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Spontaneous
+  class ContentQuery
+    ALL = "*".freeze
+
+    def initialize(selector)
+      @selector = selector
+    end
+
+    def matches(content)
+      return true if @selector == ALL
+    end
+    alias_method :matches?, :matches
+  end
+end
+

data/lib/spontaneous/errors.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+require 'forwardable'
+module Spontaneous
+  class Error < StandardError; end
+
+  # raised when trying to show something that is not showable due to
+  # ancestor being hidden
+  class NotShowable < Error
+    def initialize(content, hidden_ancestor_id)
+      @content, @hidden_ancestor_id = content, hidden_ancestor_id
+    end
+  end
+
+  class UnknownLayoutError < Error
+    def initialize(parent_class, layout_name)
+      @parent_class, @layout_name = parent_class, layout_name
+    end
+  end
+
+
+  class UnknownFormatException < Error
+    def initialize(unsupported_format)
+      super("Format '#{unsupported_format}' has no matching mime type")
+    end
+  end
+  class UnsupportedFormatException < Error
+    def initialize(style, unsupported_format)
+      super("'#{unsupported_format}' format not supported by style '#{style.name}'.\nTemplate path: #{style.directory}\n")
+    end
+  end
+
+  class SchemaModificationError < Error
+    extend Forwardable
+
+    attr_reader :modification
+
+    def initialize(modification)
+      @modification = modification
+    end
+
+    def_delegators :@modification, :added_classes, :removed_classes
+    def_delegators :@modification, :added_fields, :removed_fields
+    def_delegators :@modification, :added_boxes, :removed_boxes
+    def_delegators :@modification, :added_styles, :removed_styles
+    def_delegators :@modification, :added_layouts, :removed_layouts
+  end
+end

data/lib/spontaneous/extensions/array.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Extensions
+    module Array
+      def render(format = :html)
+        self.map { |e| e.respond_to?(:render) ? e.render(format) : nil }.join
+      end
+    end
+  end
+end
+
+
+class Array
+  include Spontaneous::Extensions::Array
+end
+
+

data/lib/spontaneous/extensions/class.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Extensions
+    module Class
+      def ui_class
+        name.gsub(/::/, ".")
+      end
+    end
+  end
+end
+
+
+class Class
+  include Spontaneous::Extensions::Class
+end
+

data/lib/spontaneous/extensions/hash.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  module Extensions
+    module Hash
+      # def to_json
+      #   Yajl::Encoder.new.encode(self)
+      # end
+    end
+  end
+end
+
+
+# class Hash
+#   include Spontaneous::Extensions::Hash
+# end
+