spontaneous 0.2.0.beta5 → 0.2.0.beta6

data/lib/spontaneous/data_mapper/content_model.rb

@@ -343,7 +343,7 @@ module Spontaneous
         end
 
         def hash
-          [model, id.nil? ? @values.sort_by{|k,v| k.to_s} : id].hash
+          [model, id.nil? ? (@values || {}).sort_by{|k,v| k.to_s} : id].hash
         end
       end
     end

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

@@ -58,15 +58,41 @@ module Spontaneous
           end
         end
 
+        # Using prepared statements for associations within sqlite causes
+        # problems with multiprocess access as preparing the ps within a
+        # transaction locks the content table and prevents the field update &
+        # publishing processes from updating it
+        def associations_use_prepared_statements?
+          mapper.db.database_type != :sqlite
+        end
+
         def has_many_content(name, opts = {})
           opts[:association]    = :one_to_many
           opts[:dataset_method] = "#{name}_dataset"
+          opts[:load_ps_method] = "load_#{name}_association_prepared_statement".to_sym
+          opts[:ps_method]      = "#{name}_prepared_statement".to_sym
+          opts[:ps_name]        = "#{name}_#{opts[:association]}_association".to_sym
           opts[:add_method]     = "add_#{name.to_s.singularize}"
+          opts[:load_method]    = "load_#{opts[:association]}_association".to_sym
+          opts[:dataset] = Proc.new do |var|
+            mapper.where!([[mapper.qualify_column(opts[:key]), var]])
+          end
           mod = opts[:module] ||= association_method_module
-
+          if associations_use_prepared_statements?
+            define_association_method(mod, opts[:load_ps_method]) {
+              ps = self.send(opts[:ps_method])
+              ps.call(id: id)
+            }
+          else
+            define_association_method(mod, opts[:load_ps_method]) {
+              opts[:dataset].call(id).all
+            }
+          end
+          define_association_method(mod, opts[:ps_method]) {
+            mapper.prepare(:select, opts[:ps_name]) { opts[:dataset].call(:$id) }
+          }
           define_association_method(mod, opts[:dataset_method]) {
-            m = mapper
-            m.where!([[m.qualify_column(opts[:key]), id]])
+            opts[:dataset].call(id)
           }
           define_association_method(mod, name) { |options = {}|
             load_cached_association(name, options)
@@ -83,11 +109,35 @@ module Spontaneous
           opts[:association]    = :many_to_one
           opts[:dataset_method] = "#{name}_dataset"
           opts[:add_method]     = "#{name}="
+          opts[:load_method]    = "load_#{opts[:association]}_association".to_sym
+          opts[:load_ps_method] = "load_#{name}_association_prepared_statement".to_sym
+          opts[:ps_method]      = "#{name}_prepared_statement".to_sym
+          opts[:ps_name]        = "load_#{name}_#{opts[:association]}_association".to_sym
+          opts[:dataset] = Proc.new do |var|
+            m = mapper
+            m.where!([[m.qualify_column(:id), var]])
+          end
           mod = opts[:module] ||= association_method_module
 
+          if associations_use_prepared_statements?
+            define_association_method(mod, opts[:load_ps_method]) {
+              id = send(opts[:key])
+              return nil if id.nil?
+              ps = self.send(opts[:ps_method])
+              ps.call(id: id)
+            }
+          else
+            define_association_method(mod, opts[:load_ps_method]) {
+              id = send(opts[:key])
+              return nil if id.nil?
+              opts[:dataset].call(id).first
+            }
+          end
+          define_association_method(mod, opts[:ps_method]) {
+            mapper.prepare(:first, opts[:ps_name]) { opts[:dataset].call(:$id) }
+          }
           define_association_method(mod, opts[:dataset_method]) {
-            m  = mapper
-            m.where!([[m.qualify_column(:id), send(opts[:key])]])
+            opts[:dataset].call(send(opts[:key]))
           }
           define_association_method(mod, name) { |options = {}|
             load_cached_association(name, options)
@@ -201,13 +251,11 @@ module Spontaneous
           end
 
           def load_many_to_one_association(assoc)
-            id = send(assoc[:key])
-            return nil if id.nil?
-            mapper[id]
+            self.send(assoc[:load_ps_method])
           end
 
           def load_one_to_many_association(assoc)
-            members = self.send(assoc[:dataset_method]).all.compact
+            members = self.send(assoc[:load_ps_method])#.all.compact
             if (reciprocal = assoc[:reciprocal])
               members.each do |member|
                 member.send :set_association_cache, reciprocal, self
@@ -221,8 +269,7 @@ module Spontaneous
             clear_association_cache(name) if options[:reload]
             ac = associations_cache
             unless ac.key?(name)
-              load_method = "load_#{assoc[:association]}_association"
-              ac[name] = send(load_method, assoc)
+              ac[name] = send(assoc[:load_method], assoc)
             end
             ac[name]
           end
@@ -239,8 +286,12 @@ module Spontaneous
             associations_cache.delete(name)
           end
 
-          def refresh
+          def clear_association_cache!
             associations_cache.clear
+          end
+
+          def refresh
+            clear_association_cache!
             @association_proxy_instance = nil
             super
           end

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

@@ -12,27 +12,22 @@ module Spontaneous
           super
         end
 
-        # I have disabled update timestamps because the logic is more complex
-        # than this. Modification timestamps are controlled by the modification
-        # logic, e.g. preventing parent pages from appearing as modified on the
-        # addition of a new child page.
-        #
-        # def before_update
-        #   # set_update_timestamp
-        #   super
-        # end
+        def before_update
+          set_update_timestamp
+          super
+        end
 
         def set_create_timestamp(time=nil)
           return unless self.respond_to?(:created_at)
           time ||= Spontaneous::DataMapper.timestamp
           self.send(:"created_at=", time) if send(:created_at).nil?
-          # set_update_timestamp(time)
+          set_update_timestamp(time)
         end
 
-        # def set_update_timestamp(time=nil)
-        #   return unless self.respond_to?(:modified_at)
-        #   self.send(:modified_at=, time || Spontaneous::DataMapper.timestamp)
-        # end
+        def set_update_timestamp(time=nil)
+          return unless self.respond_to?(:modified_at)
+          self.send(:modified_at=, time || Spontaneous::DataMapper.timestamp)
+        end
       end
     end
   end

data/lib/spontaneous/data_mapper/content_table.rb

@@ -45,8 +45,10 @@ module Spontaneous
         :id
       end
 
-      def dataset(revision = nil)
-        @database[revision_table(revision)]
+      def dataset(revision = nil, visible_only = false)
+        ds = @database[revision_table(revision)]
+        ds.filter!(hidden: false) if visible_only
+        ds
       end
 
       def logger

data/lib/spontaneous/data_mapper/dataset.rb

@@ -143,6 +143,33 @@ module Spontaneous
         self
       end
 
+      class PreparedStatement
+        def initialize(name, ds, ps)
+          @name = name
+          @ds = ds
+          @ps = ps
+        end
+
+        def call(vars = {})
+          results = @ps.call(vars)
+          case results
+          when Array
+            @ds.load_instances(results)
+          else
+            @ds.load_instance(results)
+          end
+        end
+      end
+
+      def prepare(type, name, *values)
+        ps = @dataset.prepare(type, name, *values)
+        PreparedStatement.new(name, self, ps)
+      end
+
+      def db
+        @dataset.db
+      end
+
       def qualify_to_first_source
         @dataset = @dataset.qualify_to_first_source
         self
@@ -156,9 +183,11 @@ module Spontaneous
         @dataset.sql
       end
 
-      alias_method :sql, :to_sql
+      def unfiltered
+        @dataset.unfiltered
+      end
 
-      private
+      alias_method :sql, :to_sql
 
       def get_raw(id)
         @dataset.first(id: id)

data/lib/spontaneous/data_mapper/scope.rb

@@ -2,11 +2,11 @@ module Spontaneous
   module DataMapper
     class Scope
 
-      def initialize(revision, visible, table, schema)
-        @revision, @visible  = revision, visible
-        @table, @schema      = table, schema
-        @identity_map        = {}
-        @schema_types        = @schema.types
+      def initialize(dataset, schema)
+        @dataset      = dataset
+        @schema       = schema
+        @identity_map = {}
+        @schema_types = @schema.types
       end
 
       def count(types = nil)
@@ -125,16 +125,27 @@ module Spontaneous
         dataset(types).select(*columns, &block)
       end
 
+      def prepare(type, name, *values, &block)
+        prepared_statements[name] ||= begin
+          ds = block.call
+          ds.prepare(type, name, *values)
+        end
+      end
+
+      def prepared_statements
+        @prepared_statements ||= {}
+      end
+
       def schema_uid(id_string)
         @schema.uids[id_string]
       end
 
       def columns
-        @table.columns
+        @dataset.columns
       end
 
       def qualify_column(col)
-        @table.qualify(@revision, col)
+        Sequel::SQL::QualifiedIdentifier.new(@dataset.first_source, col)
       end
 
       def each(&block)
@@ -150,29 +161,25 @@ module Spontaneous
       end
 
       def pk
-        @table.pk
+        @dataset.db.primary_key(@dataset.first_source).to_sym
       end
 
       def table_name
-        naked_dataset.first_source_alias
+        naked_dataset.first_source_table
       end
 
       def logger
-        @table.logger
+        @dataset.logger
       end
 
       def logger=(logger)
-        @table.logger = logger
+        @dataset.db.logger = logger
       end
 
       def revision
         self
       end
 
-      def visible_only?
-        @visible || false
-      end
-
       def dataset(types = nil, fallback_type_condition = all_types_condition)
         Dataset.new(table_dataset(types, fallback_type_condition), @schema, @identity_map)
       end
@@ -184,17 +191,27 @@ module Spontaneous
       private
 
       def table_dataset(types, fallback_type_condition)
-        naked_dataset.filter(conditions(types, fallback_type_condition))
+        conditions = conditions(types, fallback_type_condition)
+        return naked_dataset.filter(conditions)
+        ds = nil
+        unless (ds = cached_datasets[conditions])
+          p [:new_dataset, conditions]
+          cached_datasets[conditions] = ds = naked_dataset.filter(conditions)
+        end
+        p [:ds, ds]
+        ds
+      end
+
+      def cached_datasets
+        @cached_datasets ||= {}
       end
 
       def naked_dataset
-        @table.dataset(@revision)
+        @dataset.dup
       end
 
       def conditions(types, fallback_type_condition)
-        cond = type_conditions(types, fallback_type_condition)
-        cond[:hidden] = false if @visible
-        cond
+        type_conditions(types, fallback_type_condition)
       end
 
       def type_conditions(types, fallback_type_condition)

data/lib/spontaneous/errors.rb

@@ -52,6 +52,12 @@ module Spontaneous
     end
   end
 
+  class SingletonException < Error
+    def initialize(type)
+      super("Attempt to create a second instance of #{type}")
+    end
+  end
+
   class SchemaModificationError < Error
     extend Forwardable
 

data/lib/spontaneous/facet.rb

@@ -23,6 +23,16 @@ module Spontaneous
       File.join(@root, path)
     end
 
+    def path(*args)
+      Pathname.new(@root).join(*args)
+    end
+
+    def path!(*args)
+      self.path(*args).tap do |path|
+        path.mkpath
+      end
+    end
+
     def name
       File.basename(root)
     end
@@ -51,10 +61,12 @@ module Spontaneous
       end
     end
 
-    def load_indexes!
+    # use Rails' alphabetical load order for initializers
+    def run_initializers
       paths.expanded(:config).each do |config_path|
-        index_file = config_path / "indexes.rb"
-        Kernel.load(index_file) if File.exists?(index_file)
+        Dir["#{config_path / "initializers"}/*.rb"].sort.each do |initializer|
+          require initializer
+        end
       end
     end
 
@@ -81,13 +93,11 @@ module Spontaneous
 
     def loaders
       @loaders ||= \
-        begin
-          use_reloader = config.reload_classes
-          {
-            :schema => Spontaneous::SchemaLoader.new(schema_load_paths, use_reloader),
-            :lib => Spontaneous::Loader.new(load_paths, use_reloader)
-          }
-        end
+      begin
+        use_reloader = config.reload_classes
+        {:schema => Spontaneous::SchemaLoader.new(schema_load_paths, use_reloader),
+         :lib => Spontaneous::Loader.new(load_paths, use_reloader) }
+      end
     end
 
     def load_paths

data/lib/spontaneous/field/base.rb

@@ -56,12 +56,14 @@ module Spontaneous
       end
 
       extend ClassMethods
+      include Spontaneous::Model::Core::ContentHash::FieldMethods
 
       attr_accessor :owner, :name, :unprocessed_value, :template_params, :version
       attr_accessor :prototype
 
 
       def initialize(params={}, default_values=true)
+        @default_values = default_values
         @processed_values = {}
         deserialize(params, default_values)
         @values = nil
@@ -331,10 +333,14 @@ module Spontaneous
         value(format)
       end
 
+      alias_method :render_inline, :render
+
       def render_using(renderer, format = :html, locals = {}, *args)
         render(format, locals)
       end
 
+      alias_method :render_inline_using, :render_using
+
       def to_html(locals = {})
         value(:html)
       end
@@ -358,7 +364,7 @@ module Spontaneous
       end
 
       def modified?
-        @modified
+        @modified || false
       end
 
       def schema_id
@@ -437,6 +443,7 @@ module Spontaneous
           :version => version,
           :value => @initial_value,
           :user => owner.current_editor)
+        mark_unmodified
       end
 
       def <=>(o)