spontaneous 0.1.0.alpha1

data/lib/sequel/plugins/content_table_inheritance.rb

@@ -0,0 +1,196 @@
+# encoding: UTF-8
+
+module Sequel
+  module Plugins
+    # The single_table_inheritance plugin allows storing all objects
+    # in the same class hierarchy in the same table.  It makes it so
+    # subclasses of this model only load rows related to the subclass,
+    # and when you retrieve rows from the main class, you get instances
+    # of the subclasses (if the rows should use the subclasses's class).
+    #
+    # By default, the plugin assumes that the +sti_key+ column (the first
+    # argument to the plugin) holds the class name as a string.  However,
+    # you can override this by using the <tt>:model_map</tt> option and/or
+    # the <tt>:key_map</tt> option.
+    #
+    # You should only load this plugin in the parent class, not in the subclasses.
+    #
+    # You shouldn't call set_dataset in the model after applying this
+    # plugin, otherwise subclasses might use the wrong dataset. You should
+    # make sure this plugin is loaded before the subclasses. Note that since you
+    # need to load the plugin before the subclasses are created, you can't use
+    # direct class references in the plugin class.  You should specify subclasses
+    # in the plugin call using class name strings or symbols, see usage below.
+    #
+    # Usage:
+    #
+    #   # Use the default of storing the class name in the sti_key
+    #   # column (:kind in this case)
+    #   Employee.plugin :single_table_inheritance, :kind
+    #
+    #   # Using integers to store the class type, with a :model_map hash
+    #   # and an sti_key of :type
+    #   Employee.plugin :single_table_inheritance, :type,
+    #     :model_map=>{1=>:Staff, 2=>:Manager}
+    #
+    #   # Using non-class name strings
+    #   Employee.plugin :single_table_inheritance, :type,
+    #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager}
+    #
+    #   # Using custom procs, with :model_map taking column values
+    #   # and yielding either a class, string, symbol, or nil,
+    #   # and :key_map taking a class object and returning the column
+    #   # value to use
+    #   Employee.plugin :single_table_inheritance, :type,
+    #     :model_map=>proc{|v| v.reverse},
+    #     :key_map=>proc{|klass| klass.name.reverse}
+    #
+    # One minor issue to note is that if you specify the <tt>:key_map</tt>
+    # option as a hash, instead of having it inferred from the <tt>:model_map</tt>,
+    # you should only use class name strings as keys, you should not use symbols
+    # as keys.
+    module ContentTableInheritance
+      # Setup the necessary STI variables, see the module RDoc for SingleTableInheritance
+      def self.configure(model, key, opts={})
+        model.instance_eval do
+          # @sti_model_map =  lambda{|v| v if v && v != ''}
+          # @sti_key_map = lambda{|klass| klass.name.to_s}
+          @sti_model_map = lambda { |id| Spontaneous::Schema[id] }
+          @sti_key_map = lambda { |klass| klass.schema_id.to_s }
+          @sti_key_array = nil
+          @sti_subclasses_array = [sti_key_map[model]]
+          @sti_key = key
+          @sti_dataset = dataset
+          @is_content_inheritance_root = false
+          @is_site_inheritance_root = false
+          dataset.row_proc = lambda{|r| model.sti_load(r)}
+        end
+      end
+
+      module ClassMethods
+        # The base dataset for STI, to which filters are added to get
+        # only the models for the specific STI subclass.
+        attr_reader :sti_dataset
+
+        # The column name holding the STI key for this model
+        attr_reader :sti_key
+
+        # Array holding keys for all subclasses of this class, used for the
+        # dataset filter in subclasses. Nil in the main class.
+        attr_reader :sti_key_array
+
+        # A hash/proc with class keys and column value values, mapping
+        # the the class to a particular value given to the sti_key column.
+        # Used to set the column value when creating objects, and for the
+        # filter when retrieving objects in subclasses.
+        attr_reader :sti_key_map
+
+        # A hash/proc with column value keys and class values, mapping
+        # the value of the sti_key column to the appropriate class to use.
+        attr_reader :sti_model_map
+
+        attr_reader :sti_subclasses_array
+
+        attr_reader :is_site_inheritance_root
+
+        # Copy the necessary attributes to the subclasses, and filter the
+        # subclass's dataset based on the sti_kep_map entry for the class.
+        def inherited(subclass)
+          super
+          sk = sti_key
+          sd = sti_dataset
+          skm = sti_key_map
+          smm = sti_model_map
+          key = skm[subclass]
+          ska = [key]
+          sti_subclass_added(key, subclass)
+          unless subclass.is_site_inheritance_root
+            subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>ska), :inherited=>true)
+          end
+          subclass.instance_eval do
+            @sti_key = sk
+            @sti_key_array = ska
+            @sti_subclasses_array = [skm[subclass]]
+            @sti_dataset = sd
+            @sti_key_map = skm
+            @sti_model_map = smm
+            @simple_table = nil
+          end
+        end
+
+        # used by Page and Piece classes to control the subclasses used in searches
+        # see 'test_content_inheritance.rb'
+        def set_inheritance_root
+          @is_content_inheritance_root = true
+          dataset.row_proc = Spontaneous::Content.dataset.row_proc
+        end
+
+        def set_site_inheritance_root
+          @is_site_inheritance_root = true
+          dataset.row_proc = Spontaneous::Content.dataset.row_proc
+        end
+
+        def unset_site_inheritance_root
+          @is_site_inheritance_root = false
+        end
+
+        # Return an instance of the class specified by sti_key,
+        # used by the row_proc.
+        def sti_load(r)
+          sti_class(sti_model_map[r[sti_key]]).load(r)
+        end
+
+        # Make sure that all subclasses of the parent class correctly include
+        # keys for all of their descendant classes.
+        # Subclasses of Spontaneous::[Page, Piece] as well as ::Page & ::Piece are treated specially
+        # they only return instances of that one class as this is the intuitively correct result
+        # The top level Page & Piece classes return all sub-classes
+        def sti_subclass_added(key, subclass = nil)
+          if sti_key_array
+            if subclass && subclass.name
+              # alright, so this is a bit of a hack
+              # we want the site defined ::Page, ::Piece classes to work like Spot::[Page,Piece]
+              # but we don't want generic subclasses of Spot::[Page, Piece] to do so
+              if subclass.name.demodulize == self.name.demodulize && @is_content_inheritance_root
+                subclass.set_site_inheritance_root
+              end
+            end
+            if @is_site_inheritance_root or @is_content_inheritance_root
+              sti_key_array << key unless sti_key_array.include?(key)
+            end
+            sti_subclasses_array << key
+            superclass.sti_subclass_added(key)
+          end
+        end
+
+        private
+
+        # Return a class object.  If a class is given, return it directly.
+        # Treat strings and symbols as class names.  If nil is given or
+        # an invalid class name string or symbol is used, return self.
+        # Raise an error for other types.
+        def sti_class(v)
+          case v
+          when String, Symbol
+            constantize(v) rescue self
+          when nil
+            self
+          when Class
+            v
+          else
+            raise(Error, "Invalid class type used: #{v.inspect}")
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Set the sti_key column based on the sti_key_map.
+        def before_create
+          send("#{model.sti_key}=", model.sti_key_map[model]) unless self[model.sti_key]
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/yajl_serialization.rb

@@ -0,0 +1,154 @@
+# encoding: UTF-8
+
+module Sequel
+  module Plugins
+    # Sequel's built in Serialization plugin allows you to keep serialized
+    # ruby objects in the database, while giving you deserialized objects
+    # when you call an accessor.
+    #
+    # This plugin works by keeping the serialized value in the values, and
+    # adding a @deserialized_values hash.  The reader method for serialized columns
+    # will check the @deserialized_values for the value, return it if present,
+    # or deserialized the entry in @values and return it.  The writer method will
+    # set the @deserialized_values entry.  This plugin adds a before_save hook
+    # that serializes all @deserialized_values to @values.
+    #
+    # You can use either marshal, yaml, or json as the serialization format.
+    # If you use yaml or json, you should require them by yourself.
+    #
+    # Because of how this plugin works, it must be used inside each model class
+    # that needs serialization, after any set_dataset method calls in that class.
+    # Otherwise, it is possible that the default column accessors will take
+    # precedence.
+    #
+    # == Example
+    #
+    #   require 'sequel'
+    #   require 'yajl'
+    #   class User < Sequel::Model
+    #     plugin :yajl_serialization, :permissions
+    #     # or
+    #     plugin :yajl_serialization
+    #     yajl_serialize_attributes :permissions, :attributes
+    #   end
+    #   user = User.create
+    #   user.permissions = { :global => 'read-only' }
+    #   user.save
+    module YajlSerialization
+
+      def self.parse(json)
+        parser.parse(json)
+      end
+
+      def self.parser
+        Yajl::Parser.new(:symbolize_keys => true)
+      end
+
+      def self.encode(obj)
+        encoder.encode(obj)
+      end
+
+      def self.encoder
+        Yajl::Encoder.new
+      end
+
+      # Set up the column readers to do deserialization and the column writers
+      # to save the value in deserialized_values.
+      def self.apply(model, *args)
+        model.instance_eval{@serialization_map = {}}
+      end
+
+      def self.configure(model, *columns)
+        model.yajl_serialize_attributes(*columns) unless columns.empty?
+      end
+
+      module ClassMethods
+        # A map of the serialized columns for this model.  Keys are column
+        # symbols, values are serialization formats (:marshal, :yaml, or :json).
+        attr_reader :serialization_map
+
+        # Module to store the serialized column accessor methods, so they can
+        # call be overridden and call super to get the serialization behavior
+        attr_accessor :serialization_module
+
+        # Copy the serialization format and columns to serialize into the subclass.
+        def inherited(subclass)
+          super
+          sm = serialization_map.dup
+          subclass.instance_eval{@serialization_map = sm}
+        end
+
+        # Create instance level reader that deserializes column values on request,
+        # and instance level writer that stores new deserialized value in deserialized
+        # columns
+        def yajl_serialize_attributes(*columns)
+          raise(Error, "No columns given.  The serialization plugin requires you specify which columns to serialize") if columns.empty?
+          define_serialized_attribute_accessor(*columns)
+        end
+
+
+        private
+
+        # Add serializated attribute acessor methods to the serialization_module
+        def define_serialized_attribute_accessor(*columns)
+          m = self
+          include(self.serialization_module ||= Module.new) unless serialization_module
+          serialization_module.class_eval do
+            columns.each do |column|
+              m.serialization_map[column] = :json
+              define_method(column) do
+                if deserialized_values.has_key?(column)
+                  deserialized_values[column]
+                else
+                  deserialized_values[column] = deserialize_value(column, super())
+                end
+              end
+              define_method("#{column}=") do |v|
+                changed_columns << column unless changed_columns.include?(column)
+                deserialized_values[column] = v
+              end
+            end
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Hash of deserialized values, used as a cache.
+        attr_reader :deserialized_values
+
+        # Set @deserialized_values to the empty hash
+        def initialize(*args)
+          @deserialized_values = {}
+          super
+        end
+
+        # Serialize all deserialized values
+        def before_save
+          deserialized_values.each{|k,v| @values[k] = serialize_value(k, v)}
+          super
+        end
+
+        # Empty the deserialized values when refreshing.
+        def refresh
+          @deserialized_values = {}
+          super
+        end
+
+        private
+
+        # Deserialize the column from JSON format
+        def deserialize_value(column, v)
+          return v if v.nil?
+          YajlSerialization.parse(v)
+        end
+
+        # Serialize the column to JSON format
+        def serialize_value(column, v)
+          return v if v.nil?
+          YajlSerialization.encode(v)
+        end
+      end
+    end
+  end
+end
+

data/lib/spontaneous/application/feature.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Application
+    class Feature < Spontaneous::Facet
+    end # Feature
+  end # Application
+end # Spontaneous
+

data/lib/spontaneous/application/plugin.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Application
+    class Plugin < Spontaneous::Facet
+      def init!
+        init_file = @root / "init.rb"
+        require(init_file) if File.exist?(init_file)
+        super
+      end
+    end # Plugin
+  end # Application
+end # Spontaneous

data/lib/spontaneous/application.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Application
+    autoload :Plugin, "spontaneous/application/plugin"
+    autoload :Feature, "spontaneous/application/feature"
+  end # Application
+end # Spontaneous

data/lib/spontaneous/box.rb

@@ -0,0 +1,232 @@
+# encoding: UTF-8
+
+module Spontaneous
+  class Box
+    extend Plugins
+    include Enumerable
+
+    plugin Plugins::SchemaHierarchy
+    plugin Plugins::Fields
+    plugin Plugins::Styles
+    plugin Plugins::Serialisation
+    plugin Plugins::Render
+    plugin Plugins::AllowedTypes
+    plugin Plugins::Permissions
+    plugin Plugins::Media
+
+    # use underscores to protect against field name conflicts
+    attr_reader :_name, :_prototype, :_owner
+
+
+    def initialize(name, prototype, owner)
+      @_name, @_prototype, @_owner = name.to_sym, prototype, owner
+      @field_initialization = false
+    end
+
+
+    def self.schema_id
+      Spontaneous::Schema.schema_id(self)
+    end
+
+    def self.schema_name
+      "type//#{self.name}"
+    end
+
+
+    def self.supertype
+      if self == Spontaneous::Box
+        nil
+      else
+        superclass
+      end
+    end
+
+    def self.supertype?
+      !supertype.nil? #&& supertype.respond_to?(:field_prototypes)
+    end
+
+    def schema_id
+      # Spontaneous::Schema.schema_id(_owner.class, :box, _name.to_s)
+      # _prototype.schema_id
+      self.class.schema_id
+    end
+
+    def schema_name
+      _name.to_s
+    end
+
+    def owner_sid
+      nil
+    end
+
+    def schema_owner
+      nil
+    end
+
+    def formats
+      _owner.formats
+    end
+
+    def media_id
+      "#{_owner.padded_id}/#{schema_id}"
+    end
+
+    def box_name
+      _name
+    end
+
+    def label
+      _name.to_s
+    end
+
+    # needed by Render::Context
+    def box?(box_name)
+      false
+    end
+
+    def field_store
+      _owner.box_field_store(self) || initialize_fields
+    end
+
+    # don't like this
+    def initialize_fields
+      field_store = nil
+      if default_values = _prototype.field_defaults
+        field_store = []
+        default_values.each do |field_name, value|
+          if self.field?(field_name)
+            field = self.class.field_prototypes[field_name].to_field
+            field.unprocessed_value = value
+            field_store << field.serialize_db
+          end
+        end
+      end
+      field_store
+    end
+
+    def field_modified!(modified_field)
+      @modified = true
+      _owner.box_modified!(self)
+    end
+
+    def serialize_db
+      {
+        :box_id => schema_id.to_s,
+        :fields => fields.serialize_db
+      }
+    end
+
+    def self.resolve_style(box)
+      Spontaneous::BoxStyle.new(box)
+    end
+
+    def self.style_class
+      Spontaneous::BoxStyle
+    end
+
+    def style
+      resolve_style(self)
+    end
+
+    def container
+      _owner
+    end
+
+    def page
+      container.page
+    end
+
+    def depth
+      container.content_depth
+    end
+
+    def push(content)
+      insert(-1, content)
+    end
+
+    alias_method :<<, :push
+
+    def insert(index, content)
+      @modified = true
+      _owner.insert(index, content, self)
+    end
+
+    def set_position(entry, new_position)
+      @modified = true
+      piece = pieces[new_position]
+      new_position = container.pieces.index(piece)
+      container.pieces.set_position(entry, new_position)
+    end
+
+    def modified?
+      @modified
+    end
+
+    def pieces
+      @pieces ||= _owner.pieces.for_box(self)
+    end
+
+
+    def each
+      pieces.each do |piece|
+        yield piece if block_given?
+      end
+    end
+
+    def last
+      pieces.last
+    end
+
+    def iterable
+      pieces
+    end
+
+    def export
+      shallow_export.merge({
+        :entries => pieces.map { |p| p.export }
+      })
+    end
+
+    def shallow_export
+      {
+        :name => _prototype.name.to_s,
+        :id => _prototype.schema_id.to_s,
+        :fields => self.class.readable_fields.map { |name| fields[name].export }
+      }
+    end
+
+    # only called directly after saving a boxes fields so
+    # we don't need to return the entries
+    def serialise_http
+      Spontaneous.serialise_http(shallow_export)
+    end
+
+    def writable?(content_type = nil)
+      return true if Spontaneous::Permissions.has_level?(Spontaneous::Permissions.root)
+      box_writable = self._owner.box_writable?(_name)
+      if content_type
+        allowed = self.allowed_type(content_type)
+        box_writable && allowed && allowed.addable?
+      else
+        box_writable
+      end
+    end
+
+    def readable?
+      self._owner.box_readable?(_name)
+    end
+
+    def start_inline_edit_marker
+      "spontaneous:previewedit:start:box id:#{schema_id}"
+    end
+
+    def end_inline_edit_marker
+      "spontaneous:previewedit:end:box id:#{schema_id}"
+    end
+
+    def save
+      _owner.save
+    end
+  end
+
+end

data/lib/spontaneous/box_style.rb

@@ -0,0 +1,64 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  class BoxStyle < Style
+    attr_reader :box
+
+    def self.to_directory_name(klass)
+      return nil if klass == Spontaneous::Box
+      super
+    end
+
+    def initialize(box)
+      @box = box
+      @owner = box._owner.class
+    end
+
+    def inline_template(format)
+      nil
+    end
+
+    def supertype_template(format)
+      supertype = box.class.supertype
+      if supertype && supertype != Spontaneous::Box
+        self.class.new(supertype).template(format)
+      else
+        nil
+      end
+    end
+
+    def name
+      box._name.to_s
+    end
+
+    def try_paths
+      prototype = box._prototype
+      box_directory_name = self.class.to_directory_name(prototype.box_base_class)
+      paths = [ [owner_directory_name, box._name.to_s] ]
+
+      if box.styles.empty?
+        paths.push(box_directory_name)
+      else
+        if style_name = prototype.default_style
+          name = style_name.to_s
+          paths.push([owner_directory_name, name])
+          paths.push([box_directory_name, name])
+        else
+          box.styles.each do |style|
+            name = style.name.to_s
+            paths.push([owner_directory_name, name])
+            paths.push([box_directory_name, name])
+          end
+        end
+      end
+
+      paths
+    end
+
+    def anonymous_template
+      Proc.new { "{{ render_content }}" }
+    end
+  end
+end
+