spontaneous 0.2.0.beta4 → 0.2.0.beta5

data/lib/spontaneous/collections/box_set.rb

@@ -40,12 +40,12 @@ module Spontaneous::Collections
     # A call to ${ content } within a layout template will call
     # this #render method. The obvious result of this should be
     # to just render each of the contained boxes.
-    def render(format = :html, params = {}, *args)
-      map { |box| box.render(format, params, *args) }.join("\n")
+    def render(format = :html, locals = {}, parent_context = nil)
+      map { |box| box.render(format, locals, parent_context) }.join("\n")
     end
 
-    def render_using(renderer, format = :html, params = {}, *args)
-      map { |box| box.render_using(renderer, format, params, *args) }.join("\n")
+    def render_using(renderer, format = :html, locals = {}, parent_context = nil)
+      map { |box| box.render_using(renderer, format, locals, parent_context) }.join("\n")
     end
 
     protected

data/lib/spontaneous/collections/field_set.rb

@@ -36,12 +36,12 @@ module Spontaneous::Collections
     # this #render method.
     # This should only be used during development
     #
-    def render(format = :html, params = {}, *args)
-      map { |field| wrap_field_value(field, field.render(format, params, *args), format) }.join("\n")
+    def render(format = :html, locals = {}, parent_context = nil)
+      map { |field| wrap_field_value(field, field.render(format, locals), format) }.join("\n")
     end
 
-    def render_using(renderer, format = :html, params = {}, *args)
-      map { |field| wrap_field_value(field, field.render_using(renderer, format, params, *args), format) }.join("\n")
+    def render_using(renderer, format = :html, locals = {}, parent_context = nil)
+      map { |field| wrap_field_value(field, field.render_using(renderer, format, locals), format) }.join("\n")
     end
 
     protected

data/lib/spontaneous/collections/prototype_set.rb

@@ -6,10 +6,11 @@ module Spontaneous::Collections
 
     attr_reader :store, :local_order
 
-    def initialize(superobject = nil, superset_name = nil)
+    def initialize(superobject = nil, superset_name = nil, &default_proc)
       @superobject, @superset_name = superobject, superset_name
       @has_superset = !!(@superobject && @superobject.respond_to?(@superset_name))
-      @store = {}
+      @store = Hash.new
+      @default_proc = default_proc
       @local_order = []
     end
 
@@ -128,13 +129,20 @@ module Spontaneous::Collections
 
     alias_method :names, :order
 
-
     def indexed(index)
       named(order[index])
     end
 
     def named(name)
-      @store[name.to_sym] || (superset? ? superset.named(name) : nil)
+      key = name.to_sym
+      return @store[key] if @store.key?(key)
+      value = (superset? ? superset.named(name) : nil)
+      return value unless value.nil?
+      if @default_proc
+        @default_proc.call(self, key)
+      else
+        nil
+      end
     end
 
     def index(entry)

data/lib/spontaneous/data_mapper.rb

@@ -27,16 +27,19 @@ module Spontaneous
         @keys = {
           :visible  => :"#{name}_mapper_visibility",
           :revision => :"#{name}_mapper_revision",
-          :dataset => :"#{name}_mapper_dataset"
+          :active_scope => :"#{name}_mapper_dataset"
         }
       end
 
-      def_delegators :dataset,
+      def_delegators :active_scope,
+        :dataset,
         :filter, :where,
         :filter!, :where!,
+        :untyped,
         :count, :count!,
         :order, :limit,
         :all, :get, :[], :first,
+        :primary_key_lookup,
         :all!, :first!,
         :reload,
         :instance,
@@ -47,6 +50,7 @@ module Spontaneous
         :columns, :table_name,
         :qualify_column, :quote_identifier,
         :with_cache,
+        :sql, :to_sql,
         :logger=, :logger
 
       def_delegators :@schema,
@@ -88,7 +92,7 @@ module Spontaneous
           if block_given?
             yield
           else
-            dataset
+            active_scope
           end
         else
           scope!(revision, visible, &block)
@@ -97,7 +101,7 @@ module Spontaneous
 
       def scope!(revision, visible, &block)
         if block_given?
-          r, v, d  = @keys.values_at(:revision, :visible, :dataset)
+          r, v, d  = @keys.values_at(:revision, :visible, :active_scope)
           thread   = Thread.current
           state    = [thread[r], thread[v], thread[d]]
           begin
@@ -113,12 +117,12 @@ module Spontaneous
         end
       end
 
-      def dataset
-        Thread.current[@keys[:dataset]] || current_scope
+      def active_scope
+        Thread.current[@keys[:active_scope]] || current_scope
       end
 
       def cached_dataset?
-        !Thread.current[@keys[:dataset]].nil?
+        !Thread.current[@keys[:active_scope]].nil?
       end
 
       def use_current_scope?(revision, visible)

data/lib/spontaneous/data_mapper/content_model.rb

@@ -87,10 +87,18 @@ module Spontaneous
 
       alias_method :[], :get
 
+      def primary_key_lookup(id)
+        mapper.primary_key_lookup(id)
+      end
+
       def count
         mapper.count(types)
       end
 
+      def dataset
+        mapper.dataset(types)
+      end
+
       def all
         mapper.all(*types)
       end

data/lib/spontaneous/data_mapper/content_model/associations.rb

@@ -207,7 +207,7 @@ module Spontaneous
           end
 
           def load_one_to_many_association(assoc)
-            members = self.send(assoc[:dataset_method]).all
+            members = self.send(assoc[:dataset_method]).all.compact
             if (reciprocal = assoc[:reciprocal])
               members.each do |member|
                 member.send :set_association_cache, reciprocal, self

data/lib/spontaneous/data_mapper/dataset.rb

@@ -16,7 +16,7 @@ module Spontaneous
         if (instance = @identity_map[id])
           instance
         else
-          first(id: id)
+          primary_key_lookup(id)
         end
       end
 
@@ -38,6 +38,10 @@ module Spontaneous
         }
       end
 
+      def primary_key_lookup(pk)
+        first(id: pk)
+      end
+
       def first(*args, &block)
         load_instance @dataset.first(*args, &block)
       end
@@ -134,6 +138,11 @@ module Spontaneous
         self
       end
 
+      def invert
+        @dataset.invert!
+        self
+      end
+
       def qualify_to_first_source
         @dataset = @dataset.qualify_to_first_source
         self
@@ -144,9 +153,11 @@ module Spontaneous
       end
 
       def to_sql
-        @dataset.inspect
+        @dataset.sql
       end
 
+      alias_method :sql, :to_sql
+
       private
 
       def get_raw(id)
@@ -185,6 +196,7 @@ module Spontaneous
           instance
         else
           model = @schema.to_class(attributes[:type_sid])
+          return nil if model.nil?
           instance = model.new(attributes, true)
           @identity_map[instance.id] = instance
         end

data/lib/spontaneous/data_mapper/scope.rb

@@ -6,6 +6,7 @@ module Spontaneous
         @revision, @visible  = revision, visible
         @table, @schema      = table, schema
         @identity_map        = {}
+        @schema_types        = @schema.types
       end
 
       def count(types = nil)
@@ -17,6 +18,10 @@ module Spontaneous
         count(nil)
       end
 
+      def untyped
+        untyped_dataset
+      end
+
       def filter(types, *cond, &block)
         dataset(types).filter(*cond, &block)
       end
@@ -61,6 +66,10 @@ module Spontaneous
         dataset.get(id)
       end
 
+      def primary_key_lookup(id)
+        dataset.primary_key_lookup(id)
+      end
+
       alias_method :[], :get
 
       def insert(*values, &block)
@@ -84,8 +93,8 @@ module Spontaneous
         dataset.for_update
       end
 
-      def delete(types)
-        dataset(types).delete
+      def delete(types = nil)
+        dataset(types, {}).delete
       end
 
       def delete_instance(instance)
@@ -93,7 +102,7 @@ module Spontaneous
       end
 
       def reload(instance)
-        dataset.reload(instance)
+        untyped_dataset.reload(instance)
       end
 
       def create(instance)
@@ -101,7 +110,7 @@ module Spontaneous
       end
 
       def save(instance)
-        dataset.save(instance)
+        untyped_dataset.save(instance)
       end
 
       def order(types, *columns, &block)
@@ -164,30 +173,41 @@ module Spontaneous
         @visible || false
       end
 
-      def dataset(types = nil)
-        Dataset.new(table_dataset(types), @schema, @identity_map)
+      def dataset(types = nil, fallback_type_condition = all_types_condition)
+        Dataset.new(table_dataset(types, fallback_type_condition), @schema, @identity_map)
+      end
+
+      def untyped_dataset
+        Dataset.new(naked_dataset, @schema, @identity_map)
       end
 
       private
 
-      def table_dataset(types)
-        naked_dataset.filter(conditions(types))
+      def table_dataset(types, fallback_type_condition)
+        naked_dataset.filter(conditions(types, fallback_type_condition))
       end
 
       def naked_dataset
         @table.dataset(@revision)
       end
 
-      def conditions(types)
-        cond = type_conditions(types)
+      def conditions(types, fallback_type_condition)
+        cond = type_conditions(types, fallback_type_condition)
         cond[:hidden] = false if @visible
         cond
       end
 
-      def type_conditions(types)
-        return {} if types.nil?
+      def type_conditions(types, fallback_type_condition)
         types = Array(types)
-        return {} if types.empty?
+        return fallback_type_condition if types.empty?
+        { :type_sid => types.flatten.map { |model| @schema.to_id(model) } }
+      end
+
+      def all_types_condition
+        type_condition(@schema_types)
+      end
+
+      def type_condition(types)
         { :type_sid => types.flatten.map { |model| @schema.to_id(model) } }
       end
     end

data/lib/spontaneous/facet.rb

@@ -34,6 +34,10 @@ module Spontaneous
     end
 
     def paths
+      _paths
+    end
+
+    def _paths
       @paths ||= Spontaneous::Paths.new(@root)
     end
 

data/lib/spontaneous/field.rb

@@ -40,33 +40,33 @@ module Spontaneous
       (time.to_f * 10000000).to_i
     end
 
-    def self.update(content, params, user, asynchronous = false)
+    def self.update(site, content, params, user, asynchronous = false)
       fields = Hash[params.map { |sid, value| [content.fields.sid(sid), value] }]
-      Update.perform(fields, user, asynchronous)
+      Update.perform(site, fields, user, asynchronous)
     end
 
-    def self.update_asynchronously(content, params, user)
-      update(content, params, user, true)
+    def self.update_asynchronously(site, content, params, user)
+      update(site, content, params, user, true)
     end
 
-    def self.set(field, value, user, asynchronous = false)
-      Update.perform({field => value}, user, asynchronous)
+    def self.set(site, field, value, user, asynchronous = false)
+      Update.perform(site, {field => value}, user, asynchronous)
     end
 
-    def self.set_asynchronously(field, value, user)
-      set(field, value, user, true)
+    def self.set_asynchronously(site, field, value, user)
+      set(site, field, value, user, true)
     end
 
-    def self.find(*ids)
-      fields = ids.map { |id| resolve_id(id) }.compact
+    def self.find(content_model, *ids)
+      fields = ids.map { |id| resolve_id(content_model, id) }.compact
       return fields.first if ids.length == 1
       fields
     end
 
-    def self.resolve_id(id)
+    def self.resolve_id(content_model, id)
       content_id, box_sid, field_sid = id.split("/")
       field_sid, box_sid = box_sid, field_sid if field_sid.nil?
-      content = target = Spontaneous::Content.get(content_id)
+      content = target = content_model.get(content_id)
       return nil if target.nil?
       target  = content.boxes.sid(box_sid) if box_sid
       return nil if target.nil?

data/lib/spontaneous/field/base.rb

@@ -121,6 +121,10 @@ module Spontaneous
       end
 
       def pending_value=(value)
+        set_pending_value(value, Spontaneous::Site.instance)
+      end
+
+      def set_pending_value(value, site)
         values[:__pending__] = {
           :value => value,
           :version => version + 1,
@@ -148,18 +152,18 @@ module Spontaneous
         values.delete(:__pending__)
       end
 
-      def process_pending_value
-        if (pending = process_pending_value!)
+      def process_pending_value(site = Spontaneous::Site.instance)
+        if (pending = process_pending_value!(site))
           cleanup_pending_value!(pending)
         end
         save
       end
 
-      def process_pending_value!
+      def process_pending_value!(site)
         if has_pending_value?
           pending = pending_value
           @previous_values = values.dup
-          set_value!(pending_value[:value])
+          set_value!(pending_value[:value], true, site)
           pending
         end
       end
@@ -206,8 +210,8 @@ module Spontaneous
       end
 
       def reload
-        Spontaneous::Content.scope! do
-          Spontaneous::Field.find(self.id)
+        owner.model.scope! do
+          Spontaneous::Field.find(owner.model, id)
         end
       end
 
@@ -224,20 +228,20 @@ module Spontaneous
         [:html, :plain]
       end
 
-      def process_value(value)
+      def process_value(value, site)
         @modified = (@initial_value != value)
         increment_version if @modified
-        self.processed_values = generate_outputs(@unprocessed_value)
+        self.processed_values = generate_outputs(@unprocessed_value, site)
       end
 
       def set_value(v, process = true)
-        set_value!(v, process)
+        set_value!(v, process, Spontaneous::Site.instance)
         save
       end
 
-      def set_value!(v, process = true)
+      def set_value!(v, process = true, site = nil)
         set_unprocessed_value(v)
-        process_value(v) if process
+        process_value(v, site) if process
       end
 
       def modified!
@@ -266,16 +270,16 @@ module Spontaneous
         unprocessed_value
       end
 
-      def generate_outputs(value)
+      def generate_outputs(value, site)
         values = {}
-        value = preprocess(value)
+        value = preprocess(value, site)
         outputs.each do |output|
           process_method = "generate_#{output}"
           values[output] = \
             if respond_to?(process_method)
-              send(process_method, value)
+              send(process_method, value, site)
             else
-              generate(output, value)
+              generate(output, value, site)
             end
         end
         values
@@ -283,7 +287,7 @@ module Spontaneous
 
       # should be overwritten in subclasses that actually do something
       # with the field value
-      def preprocess(value)
+      def preprocess(value, site)
         value
       end
 
@@ -295,7 +299,7 @@ module Spontaneous
         value.to_s.gsub(%r{[#{HTML_ESCAPE_TABLE.keys.join}]}) { |s| HTML_ESCAPE_TABLE[s] }
       end
 
-      def generate(output, value)
+      def generate(output, value, site)
         value
       end
 
@@ -323,16 +327,16 @@ module Spontaneous
         value(format).to_s
       end
 
-      def render(format=:html, *args)
+      def render(format = :html, locals = {}, *args)
         value(format)
       end
 
-      def render_using(renderer, format=:html, *args)
-        render(format)
+      def render_using(renderer, format = :html, locals = {}, *args)
+        render(format, locals)
       end
 
-      def to_html(*args)
-        render(:html, *args)
+      def to_html(locals = {})
+        value(:html)
       end
 
       def to_pdf(*args)
@@ -460,6 +464,7 @@ module Spontaneous
         data = params.dup
         unprocessed_value = data.delete(:unprocessed_value) || ""
         processed_values  = data.delete(:processed_values)  || {}
+        set_unprocessed_value(unprocessed_value)
         @processed_values = processed_values
         set_value(unprocessed_value, default_values)
         data.each do |property, value|