spontaneous 0.2.0.beta5 → 0.2.0.beta6

data/lib/spontaneous/cli/init/db.rb

@@ -0,0 +1,94 @@
+# encoding: UTF-8
+
+module Spontaneous::Cli
+  class Init
+    class Db
+
+      attr_reader :site_connection_params, :admin_connection_params, :database, :config
+
+      def initialize(connection, cli)
+        @cli = cli
+        @connection = connection
+        # setup_connection_params(connection_settings, @cli.options)
+        # @admin_connection_params[:database] = "postgres"
+      end
+
+      def run
+        databases.each do |site_connection_params, admin_connection_params|
+          # config = site_connection_params.merge(:database => db)
+          create(admin_connection_params, site_connection_params)
+          migrate(site_connection_params)
+        end
+      end
+
+      def create(admin_config, site_config)
+        Sequel.connect(admin_config) do |connection|
+          begin
+            @cli.say "  >> Creating database `#{site_config[:database]}`", :green
+            create_database(connection, site_config)
+          rescue => e
+            @cli.say " >>> Unable to create #{admin_config[:adapter]} database `#{site_config[:database]}`:\n   > #{e}", :red
+          end
+        end
+      end
+
+      def migrate(site_config)
+        Sequel.connect(site_config) do |connection|
+          begin
+            connection.logger = nil
+            @cli.say "  >> Running migrations..."
+            Sequel::Migrator.apply(connection, ::Spontaneous.gem_dir('db/migrations'))
+            @cli.say "  >> Done"
+          rescue => e
+            @cli.say " >>> Error running migrations on database `#{site_config[:database]}`:\n   > #{e}", :red
+            raise e
+          end
+        end
+      end
+
+      def create_database(connection, config)
+        commands = create_database_commands(config)
+        commands.each do |command, raise_error|
+          begin
+            connection.run(command)
+          rescue => e
+            raise e if raise_error
+          end
+        end
+      end
+
+      def create_database_commands(config)
+        [["", false]]
+      end
+
+      def setup_connection_params(connection_settings, options)
+        @options = options
+        @site_connection_params = connection_settings
+        @admin_connection_params = @site_connection_params.dup
+        @admin_connection_params[:user] = @options.user unless @options.user.blank?
+        @admin_connection_params[:password] = @options.password unless @options.password.blank?
+
+        # @database = @admin_connection_params.delete(:database)
+      end
+
+      def databases
+        environments.map { |env|
+          config_for_environment(env)
+        }
+      end
+
+      def config_for_environment(env)
+        site_config = @connection[env].dup
+        admin_config = site_config.dup
+        admin_config.delete(:database)
+        admin_config[:user] = @cli.options.user unless @cli.options.user.blank?
+        admin_config[:password] = @cli.options.password unless @cli.options.password.blank?
+        [site_config, admin_config]
+      end
+
+      def environments
+        [:development, :test]
+      end
+    end
+  end
+end

data/lib/spontaneous/cli/init/mysql.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module Spontaneous::Cli
+  class Init
+    class MySQL < Db
+
+      def create_database_commands(config)
+        host = config[:host].blank? ? "" : "@#{config[:host]}"
+        cmds = [ ["CREATE DATABASE `#{config[:database]}` CHARACTER SET UTF8", true] ]
+        unless config[:user] == "root"
+          cmds << ["GRANT ALL ON `#{config[:database]}`.* TO `#{config[:user]}`#{host} IDENTIFIED BY '#{config[:password]}'", false]
+        end
+        cmds
+      end
+    end
+  end
+end

data/lib/spontaneous/cli/init/postgresql.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+module Spontaneous::Cli
+  class Init
+    class Postgresql < Db
+
+      def config_for_environment(env)
+        site_config, admin_config = super
+        admin_config[:database] = "postgres"
+        [site_config, admin_config]
+      end
+
+      # On some machines the db creation fails due to incompabilities between the UTF8 encoding
+      # and the configured locale.
+      # You can force a locale for the db by adding LC_COLLATE & LC_CTYPE params
+      # to the CREATE command:
+      #
+      #   LC_COLLATE='C.UTF-8' LC_CTYPE='C.UTF-8'
+      #
+      # but I don't know a good/the best way to determine the most appropriate UTF-8 locale
+      # C.UTF-8 doesn't exist on OS X.
+      def create_database_commands(config)
+        create_cmd = %(CREATE DATABASE "#{config[:database]}" WITH TEMPLATE=template0 ENCODING='UTF8')
+        cmds = []
+        unless config[:user].blank?
+          create_cmd << %( OWNER="#{config[:user]}")
+          cmds << [%(CREATE ROLE "#{config[:user]}" LOGIN PASSWORD '#{config[:password]}'), false]
+        end
+        cmds << [create_cmd, true]
+      end
+    end
+  end
+end

data/lib/spontaneous/cli/init/sqlite.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+require 'fileutils'
+
+module Spontaneous::Cli
+  class Init
+    class Sqlite < Db
+
+      def create_database(connection, config)
+        FileUtils.mkdir_p(File.join(@cli.options.site, 'db'))
+      end
+    end
+  end
+end

data/lib/spontaneous/cli/site.rb

@@ -102,25 +102,58 @@ module Spontaneous
       end
 
       desc "dump", "Dumps the current site to an archive on the local machine"
-      def dump
-        prepare! :dump
-        Dump.start
+      def dump(*args)
+        dump_site_data
       end
 
       desc "load", "Uploads a dump of the current site to a remote server"
-      def load
-        prepare! :load
-        Load.start
+      def load(*args)
+        load_site_data
       end
 
       desc "publish", "Publishes the site"
       method_option :pages, :type => :array, :desc => "List of pages to publish"
       method_option :logfile, :type => :string, :desc => "Location of logfile"
-      def publish
+      def publish(*args)
+        publish_site
+      rescue => e
+        $stderr.puts(e.message)
+        send_error_notification(e)
+      end
+
+      desc "render", "Re-renders the current content"
+      def render(*args)
+        render_site
+      end
+
+      desc "revision", "Shows the site status"
+      def revision(*args)
+        show_site_revision
+      end
+
+      desc "browse", "Launches a browser pointing to the current development CMS"
+      def browse(*args)
+        browse_site
+      end
+
+      private
+
+      def dump_site_data
+        prepare! :dump
+        Dump.start
+      end
+
+
+      def load_site_data
+        prepare! :load
+        Load.start
+      end
+
+      def publish_site
         site = prepare! :publish
         site.background_mode = :immediate
         ::Spontaneous::Logger.setup(:logfile => options.logfile) if options.logfile
-        say "Creating revision #{site.revision}", :green, true
+        say "Creating revision #{site.working_revision}", :green, true
         if options.pages
           say ">  Publishing pages #{options.pages.inspect}", :green, true
           site.publish_pages(options.pages)
@@ -129,34 +162,26 @@ module Spontaneous
           site.publish_all
         end
         # Rescue all errors to feed back to the UI
-      rescue => e
-        $stderr.puts(e.message)
-        send_error_notification(e)
       end
 
-      desc "render", "Re-renders the current content"
-      def render
+      def render_site
         site = prepare! :render
         site.background_mode = :immediate
         site.rerender
       end
 
-      desc "revision", "Shows the site status"
-      def revision
+      def show_site_revision
         site = prepare! :revision
-        say "Site is at revision #{site.revision}", :green
+        say "Site is at revision #{site.working_revision}", :green
       end
 
-      desc "browse", "Launches a browser pointing to the current development CMS"
-      def browse
+      def browse_site
         site = prepare :browse
         require 'launchy'
         boot!
         ::Launchy.open("http://localhost:#{site.config.port}/@spontaneous")
       end
 
-      private
-
       def send_error_notification(error)
         simultaneous_event('publish_progress', {:state => "error", :progress => error}.to_json)
       end

data/lib/spontaneous/collections/box_set.rb

@@ -48,6 +48,9 @@ module Spontaneous::Collections
       map { |box| box.render_using(renderer, format, locals, parent_context) }.join("\n")
     end
 
+    alias_method :render_inline, :render
+    alias_method :render_inline_using, :render_using
+
     protected
 
     def get_single(index)

data/lib/spontaneous/collections/entry_set.rb

@@ -9,8 +9,19 @@ module Spontaneous::Collections
 
     def initialize(owner, piece_store = [])
       @owner = owner
-      @store = Hash.new { |hash, key| hash[key] = [] }
-      (piece_store || []).each do |data|
+      @loaded = false
+      @piece_store = piece_store || []
+    end
+
+    def store
+      @store ||= initialize_store
+    end
+
+    # Lazily load the entries as it's not unlikely that we'll be loading instances
+    # without ever wanting to access their contents
+    def initialize_store
+      store = Hash.new { |hash, key| hash[key] = [] }
+      @piece_store.each do |data|
         id = data[0]
         entry = if (content = @owner._pieces.detect { |piece| piece.id == id })
           content.page? ? Spontaneous::PagePiece.new(@owner, content, data[1]) : content
@@ -19,9 +30,35 @@ module Spontaneous::Collections
         # then we just want to silently skip it
         if entry
           box_id =  entry.box_sid.to_s
-          @store[box_id] << entry
+          store[box_id] << entry
         end
       end
+      @loaded = true
+      store
+    end
+
+    def wrap_page(page)
+      case @loaded
+      when true
+        find { |e| e.id == page.id }
+      else
+        quick_wrap_page(page)
+      end
+    end
+
+    # Wrap a page with an entry without loading the owning item's content
+    # association see Page#render_inline for a use case.
+    #
+    # We might be loading an individual page using its id and then trying to
+    # render it immediately, in which case having to load the entire '_pieces'
+    # association just to render a single page entry would be insane.
+    #
+    def quick_wrap_page(page)
+      data = @piece_store.detect { |data|
+        data[0] == page.id
+      }
+      return nil if data.nil?
+      Spontaneous::PagePiece.new(@owner, page, data[1])
     end
 
     def each(&block)
@@ -94,8 +131,10 @@ module Spontaneous::Collections
     end
 
     def freeze
-      super
+      # freeze the entries first in order to ensure that we've loaded our entries
+      # before freezing ourself
       store.values.each { |entries| entries.freeze }
+      super
       self
     end
 

data/lib/spontaneous/collections/field_set.rb

@@ -5,8 +5,8 @@ module Spontaneous::Collections
 
     attr_reader :owner
 
-    def initialize(owner, initial_values)
-      super()
+    def initialize(owner, initial_values, superobject = nil, superset_name = nil)
+      super(superobject, superset_name)
       @owner = owner
       @field_data = initial_values
       initialize_from_prototypes
@@ -27,6 +27,14 @@ module Spontaneous::Collections
       self.each { |field| field.mark_unmodified }
     end
 
+    def with_dynamic_default_values
+      select { |field| field.prototype.dynamic_default? }
+    end
+
+    def prototypes
+      map(&:prototype)
+    end
+
     # Lazily load fields by name
     def named(name)
       super || load_field(owner.field_prototypes[name.to_sym])
@@ -40,10 +48,14 @@ module Spontaneous::Collections
       map { |field| wrap_field_value(field, field.render(format, locals), format) }.join("\n")
     end
 
+    alias_method :render_inline, :render
+
     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
 
+    alias_method :render_inline_using, :render_using
+
     protected
 
     def wrap_field_value(field, value, format)

data/lib/spontaneous/data_mapper.rb

@@ -63,6 +63,14 @@ module Spontaneous
         :revision_history_dataset, :revision_archive_dataset,
         :quote_identifier
 
+      def prepare(type, name, *values, &block)
+        active_scope.prepare(type, prepared_statement_namespace(name), &block)
+      end
+
+      def prepared_statement_namespace(name)
+        "#{name}_#{current_revision || "editable"}_#{visible_only?}".to_sym
+      end
+
       def visible(visible_only = true, &block)
         scope(current_revision, visible_only, &block)
       end
@@ -87,6 +95,18 @@ module Spontaneous
         revision!(nil, &block)
       end
 
+      def editable?
+        current_revision.nil?
+      end
+
+      def with(dataset, &block)
+        with!(dataset, &block)
+      end
+
+      def with!(dataset, &block)
+        scope!(nil, false, dataset, &block)
+      end
+
       def scope(revision, visible, &block)
         if use_current_scope?(revision, visible)
           if block_given?
@@ -99,7 +119,7 @@ module Spontaneous
         end
       end
 
-      def scope!(revision, visible, &block)
+      def scope!(revision, visible, dataset = nil, &block)
         if block_given?
           r, v, d  = @keys.values_at(:revision, :visible, :active_scope)
           thread   = Thread.current
@@ -107,7 +127,7 @@ module Spontaneous
           begin
             thread[r] = to_revision(revision)
             thread[v] = visible
-            thread[d] = current_scope
+            thread[d] = configured_scope_or_dataset(dataset)
             yield
           ensure
             thread[r], thread[v], thread[d] = state
@@ -118,15 +138,15 @@ module Spontaneous
       end
 
       def active_scope
-        Thread.current[@keys[:active_scope]] || current_scope
+        Thread.current[@keys[:active_scope]] || configured_scope
       end
 
-      def cached_dataset?
+      def cached_scope?
         !Thread.current[@keys[:active_scope]].nil?
       end
 
       def use_current_scope?(revision, visible)
-        cached_dataset? &&
+        cached_scope? &&
           (current_revision == to_revision(revision)) &&
           ((visible || false) == visible_only?)
       end
@@ -153,12 +173,25 @@ module Spontaneous
 
       private
 
-      def current_scope
+      def configured_scope_or_dataset(dataset = nil)
+        return configured_scope if dataset.nil?
+        scope_with(dataset)
+      end
+
+      def configured_scope
         scope_for(current_revision, visible_only?)
       end
 
       def scope_for(revision, visibility)
-        Scope.new(revision, visibility, @table, @schema)
+        scope_with(ds(revision, visibility))
+      end
+
+      def scope_with(dataset)
+        Scope.new(dataset, @schema)
+      end
+
+      def ds(revision, visibility)
+        @table.dataset(revision, visibility)
       end
     end
   end