spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/render/render_cache.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Render
+  module RenderCache
+    def _render_cache_value(key)
+      Spontaneous::Render.render_cache_value(key)
+    end
+
+    def _render_cache_set_value(key, value)
+      Spontaneous::Render.render_cache_set_value(key, value)
+    end
+
+    def _render_cache_key?(key)
+      Spontaneous::Render.render_cache_key?(key)
+    end
+
+    def _with_render_cache(key, &value_block)
+      if _render_cache_key?(key)
+        self._render_cache_value(key)
+      else
+        self._render_cache_set_value(key, yield)
+      end
+    end
+  end # RenderCache
+end # Spontaneous::Render

data/lib/spontaneous/render/renderer.rb

@@ -15,6 +15,10 @@ module Spontaneous
         # overwrite in subclasses
       end
 
+      def render_string(template_string, content, format=:html, params = {})
+        # overwrite in subclasses
+      end
+
       def template_file(filename, format)
         Render.template_file(template_root, filename, format)
       end
@@ -23,7 +27,7 @@ module Spontaneous
         Spontaneous.template_engine.extension
       end
 
-      protected
+      # protected
 
       def preview_renderer
         Spontaneous.template_engine.preview_renderer.new(template_root, cache?)

data/lib/spontaneous/render/request_context.rb

@@ -0,0 +1,8 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Render
+  module RequestContext
+    include Spontaneous::Render::ContextBase
+  end # RequestContext
+end # Spontaneous::Render

data/lib/spontaneous/schema.rb

@@ -5,13 +5,14 @@
 module Spontaneous
   module Schema
     autoload :UID, 'spontaneous/schema/uid'
+    autoload :UIDMap, 'spontaneous/schema/uid_map'
     autoload :SchemaModification, 'spontaneous/schema/schema_modification'
     # schema class <=> uid map backed by a file
     class PersistentMap
-      attr_reader :map, :inverse_map
+      attr_reader :map, :inverse_map, :uids
 
-      def initialize(path)
-        @path = path
+      def initialize(uids, path)
+        @uids, @path = uids, path
         load_map
       end
 
@@ -20,11 +21,11 @@ module Spontaneous
       end
 
       def reference_to_id(reference)
-        UID.get_id(reference)
+        uids.get_id(reference)
       end
 
       def [](id)
-        if uid = UID[id]
+        if uid = uids[id]
           uid.target
         else
           nil
@@ -35,7 +36,7 @@ module Spontaneous
         if exists?
           map = YAML.load_file(@path)
           map.each do | uid, reference |
-            UID.load(uid, reference)
+            uids.load(uid, reference)
           end
         end
       end
@@ -53,7 +54,7 @@ module Spontaneous
       # end
 
       def orphaned_ids
-        UID.select { |uid| uid.orphaned? }
+        uids.select { |uid| uid.orphaned? }
       end
 
       def reload!
@@ -66,14 +67,15 @@ module Spontaneous
     # used for tests
     class TransientMap < PersistentMap
 
-      def initialize(path)
+      def initialize(uids, path)
+        @uids = uids
       end
 
       def schema_id(obj)
         if id = super
           id
         else
-          UID.create(obj.schema_name)
+          uids.create(obj.schema_name)
         end
       end
 
@@ -86,13 +88,17 @@ module Spontaneous
       end
     end
 
-    class << self
-      def schema_loader_class
-        @schema_loader_class ||= PersistentMap
+    class Schema
+      attr_reader :schema_loader_class, :uids
+
+      def initialize(root, schema_loader_class = Spontaneous::Schema::PersistentMap)
+        @root = root
+        @schema_loader_class = schema_loader_class
+        initialize_uid_map
       end
 
       def schema_loader_class=(klass)
-        UID.clear!
+        initialize_uid_map
         @map = nil
         @schema_loader_class = klass
       end
@@ -112,11 +118,13 @@ module Spontaneous
           else
             if changes.resolvable?
               logger.warn("Schema changed...")
+              attempts = 0
               while changes and changes.resolvable? do
                 logger.warn("Fixing automatically")
                 changes.resolve!
                 map.reload!
                 changes = perform_validation
+                raise "Infinite loop in schema resolution" if (attempts += 1) >= 5
               end
               write_schema
               reload!
@@ -133,16 +141,17 @@ module Spontaneous
       end
 
       def apply_fix(action, source, dest=nil)
-        uid = S::Schema::UID[source]
+        uid = uids[source]
         case action
         when :delete
-          uid.destroy
+          uids.destroy(uid)
         when :rename
           uid.rewrite!(dest)
         end
         write_schema
         reload!
         validate!
+        logger.info("✓ Schema updated successfully")
       end
 
       def generate_new_schema
@@ -157,12 +166,12 @@ module Spontaneous
 
       def write_schema
         File.atomic_write(schema_map_file) do |file|
-          file.write(UID.export.to_yaml)
+          file.write(uids.export.to_yaml)
         end
       end
 
       def generate_schema_for(obj)
-        UID.create_for(obj)
+        uids.create_for(obj)
         [:boxes, :fields, :styles, :layouts].each do |category|
           if obj.respond_to?(category)
             objects = obj.send(category)
@@ -220,12 +229,12 @@ module Spontaneous
 
       def export
         self.content_classes.inject({}) do |hash, klass|
-          hash[klass.name] = klass.export
+          hash[klass.ui_class] = klass.export
           hash
         end
       end
 
-      def serialise_http
+      def serialise_http(user = nil)
         Spontaneous.serialise_http(export)
       end
 
@@ -234,13 +243,31 @@ module Spontaneous
         @classes ||= []
       end
 
+      def add_class(supertype, type)
+        inheritance_map[supertype.to_s] << type
+        classes << type unless classes.include?(type)
+      end
+
+      def inheritance_map
+        @inheritance_map ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+
+      def subclasses_of(type)
+        inheritance_map[type.to_s].map { |subclass| subclass }
+      end
+
+      def descendents_of(type)
+        subclasses_of(type).map{ |x| [x] + descendents_of(x) }.flatten
+      end
+
       # just subclasses of Content (excluding boxes)
       # only need this for the serialisation (which doesn't include boxes)
       def content_classes
         classes = []
-        Content.subclasses.each do |klass|
+        self.classes.reject { |k| k.is_box? }.each do |klass|
           classes << klass unless [Spontaneous::Page, Spontaneous::Piece].include?(klass)
-          recurse_classes(klass, classes)
+          # recurse_classes(klass, classes)
         end
         classes.uniq
       end
@@ -256,12 +283,17 @@ module Spontaneous
       def reset!
         Content.schema_reset!
         @classes = []
+        @inheritance_map = nil
         reload!
       end
 
       def reload!
         @map = nil
-        UID.clear!
+        initialize_uid_map
+      end
+
+      def initialize_uid_map
+        @uids = Spontaneous::Schema::UIDMap.new
       end
 
       def delete(klass)
@@ -269,7 +301,7 @@ module Spontaneous
       end
 
       def schema_map_file
-        @schema_map_file ||= Spontaneous.root / "config" / "schema.yml"
+        @schema_map_file ||= @root / "config" / "schema.yml"
       end
 
       def schema_map_file=(path)
@@ -279,7 +311,7 @@ module Spontaneous
       end
 
       def map
-        @map ||= self.schema_loader_class.new(schema_map_file)
+        @map ||= self.schema_loader_class.new(@uids, schema_map_file)
       end
 
       def schema_id(obj)

data/lib/spontaneous/schema/schema_modification.rb

@@ -140,7 +140,7 @@ module Spontaneous
         if only_added_items?
           added_items.each do |obj|
             logger.warn("Adding #{obj} to Schema")
-            Spontaneous::Schema.generate_schema_for(obj)
+            Spontaneous.schema.generate_schema_for(obj)
           end
         end
 
@@ -252,7 +252,7 @@ module Spontaneous
         actions.map { |action| action.export }
       end
 
-      def serialise_http
+      def serialise_http(user)
         Spontaneous.serialise_http(export)
       end
     end

data/lib/spontaneous/schema/uid.rb

@@ -6,109 +6,15 @@ require 'base58'
 module Spontaneous
   module Schema
     class UID
-      @@instance_lock  = Mutex.new
-      @@uid_lock  = Mutex.new
-      @@uid_index = 0
-      @@instances = {}
-
-      extend Enumerable
-      include Comparable
-
-      def self.load(id, reference)
-        @@instance_lock.synchronize do
-          unless instance = @@instances[id]
-            instance = self.new(id, reference)
-            # check to make sure that the uid is valid first
-            # this ensures that UIDs are not created before their owners
-            # have uids
-            if instance.valid?
-              @@instances[id] = instance
-            else
-              instance = nil
-            end
-          end
-          instance
-        end
-      end
-
-      def self.create(reference)
-        unless instance = @@instances.values.detect { |i| i.reference == reference }
-          instance = self.load(generate(reference), reference)
-        end
-        instance
-      end
-
-      def existing_references
-        @@instances.values.map { |i| i.reference }
-      end
-
-      def self.create_for(obj)
-        create(obj.schema_name)
-      end
-
-      def self.destroy(uid)
-        @@instance_lock.synchronize do
-          @@instances.delete(uid.to_s)
-          uid.after_destroy
-        end
-      end
-
-      def self.clear!
-        @@instances = {}
-      end
-
-      def self.[](id)
-        return id if self === id
-        return nil if id.blank?
-        @@instances[id]
-      end
-
-      def self.get_id(reference)
-        self.find { |uid| uid.reference == reference }
-      end
-
-      def self.each
-        uids = @@instances.map { |id, instance| instance }
-        if block_given?
-          uids.each { |instance| yield(instance) }
-        else
-          uids.each
-        end
-      end
-
-      def self.get_inc
-        @@uid_lock.synchronize do
-          @@uid_index = (@@uid_index + 1) % 0xFFFF
-        end
-      end
-
-      def self.generate(ref = nil)
-        generate58(ref)
-      end
-
-      def self.generate58(ref)
-        # reverse the time so that sequential ids are more obviously different
-        oid =  Base58.encode((Time.now.to_f * 1000).to_i).reverse
-        oid << Base58.encode(get_inc).rjust(3, '0')
-      end
-
-      def self.generate16(ref)
-        oid = ''
-        # 4 bytes current time
-        oid = (Time.now.to_f * 1000).to_i.to_s(16)
-        # 2 bytes inc
-        oid << get_inc.to_s(16).rjust(4, '0')
-      end
-
-      def self.export
-        Hash[ @@instances.map { |id, ref| [id, ref.reference] } ]
-      end
 
       REFERENCE_SEP = "/".freeze
 
-      attr_reader :reference, :name, :category
+      include Comparable
+
+      attr_reader :reference, :name, :category, :map
 
-      def initialize(id, reference)
+      def initialize(map, id, reference)
+        @map = map
         @id = id.freeze
         read_reference(reference)
       end
@@ -119,12 +25,8 @@ module Spontaneous
         @category = @category.to_sym
       end
 
-      class << self
-        protected :new
-      end
-
       def destroy
-        self.class.destroy(self)
+        map.destroy(self)
       end
 
       def after_destroy
@@ -193,11 +95,25 @@ module Spontaneous
       alias_method :schema_owner, :owner
 
       def owner_sid
-        self.class[@owner_sid]
+        map[@owner_sid]
+      end
+
+      def source_file
+        if owner
+          owner.__source_file
+        elsif target
+          target.__source_file
+        else
+          nil
+        end
       end
 
       def ==(obj)
-        super or obj == @id
+        super or (obj == @id)
+      end
+
+      def eql?(obj)
+        super or (obj.is_a?(Spontaneous::Schema::UID) and obj.to_s == @id)
       end
 
       def hash