spontaneous 0.2.0.beta9 → 0.2.0.beta10

data/lib/spontaneous/capistrano/deploy.rb

@@ -12,6 +12,9 @@ Capistrano::Configuration.instance(:must_exist).load do
   set :revision_dir, lambda { "#{deploy_to}/revisions" }
   set :upload_dir, lambda { "#{deploy_to}/uploadcache" }
 
+  set :spot, lambda { "./bin/spot" }
+  set :rake, lambda { "./bin/rake" }
+
   namespace :spot do
     task :symlink_cache do
       cache_dir = File.join(latest_release, 'cache')
@@ -29,24 +32,24 @@ Capistrano::Configuration.instance(:must_exist).load do
     end
 
     task :bundle_assets do
-      run "cd #{release_path} && ./bin/spot assets compile --destination=#{release_path}"
+      run "cd #{release_path} && #{fetch(:spot)} assets compile --destination=#{release_path}"
     end
 
     task :migrate, :roles => :db do
       spot_env = fetch(:spot_env, "production")
-      run "cd #{release_path} && SPOT_ENV=#{spot_env} ./bin/spot migrate"
+      run "cd #{release_path} && SPOT_ENV=#{spot_env} #{fetch(:spot)} migrate"
     end
 
     task :content_clean, :roles => :db do
       spot_env = fetch(:spot_env, "production")
-      run "cd #{release_path} && SPOT_ENV=#{spot_env} ./bin/spot content clean"
+      run "cd #{release_path} && SPOT_ENV=#{spot_env} #{fetch(:spot)} content clean"
     end
   end
 
   namespace :deploy do
     task :migrate, :roles => :db do
       spot_env = fetch(:spot_env, "production")
-      run "cd #{latest_release} && SPOT_ENV=#{spot_env} ./bin/spot migrate"
+      run "cd #{latest_release} && SPOT_ENV=#{spot_env} #{fetch(:spot)} migrate"
     end
   end
 

data/lib/spontaneous/capistrano/sync.rb

@@ -39,7 +39,7 @@ Capistrano::Configuration.instance(:must_exist).load do
         puts "  * Syncing database DOWN"
         dumper = Spontaneous::Utils::Database.dumper_for_database
         dumpfilename = ENV['dumpfile'] || dumper.dumpfilename
-        run %(cd #{current_path} && ./bin/rake db:dump dumpfile=#{dumpfilename} )
+        run %(cd #{current_path} && #{fetch(:rake)} db:dump dumpfile=#{dumpfilename} )
         dump_file = File.join("tmp", dumpfilename)
         top.download(File.join(current_path, dump_file), dump_file)
         system "bundle exec rake db:load dumpfile=#{dump_file}"
@@ -54,7 +54,7 @@ Capistrano::Configuration.instance(:must_exist).load do
         dumper.dump(dump_file)
         remote_dump_file = File.join(deploy_to, dumpfilename)
         top.upload(dump_file, remote_dump_file)
-        run %(cd #{current_path} && #{fetch(:bundle_cmd, 'bundle')} exec rake db:load dumpfile=#{remote_dump_file} )
+        run %(cd #{current_path} && #{fetch(:bundle_cmd, 'bundle')} exec #{fetch(:rake)} db:load dumpfile=#{remote_dump_file} )
       end
     end
 

data/lib/spontaneous/cli/init.rb

@@ -19,18 +19,21 @@ module Spontaneous::Cli
     method_option :create_user, :type => :boolean, :default => true, :desc => "Enable creation of a root user"
 
     def init
-      initialize_size
+      initialize_site
     end
 
     protected
 
-    def initialize_size
+    def initialize_site
       prepare :init
 
       @site = ::Spontaneous::Site.instantiate(Dir.pwd, options.environment, :console)
       Sequel.extension :migration
 
-      database_initializer.run
+      site_initializer.run(@site.environment)
+
+      empty_directory "tmp" unless ::File.directory?("tmp")
+      empty_directory "log" unless ::File.directory?("log")
 
       boot!
 
@@ -38,6 +41,68 @@ module Spontaneous::Cli
       insert_root_user if (options.create_user && ::Spontaneous::Permissions::User.count == 0)
     end
 
+    class DatabaseInitializer
+      def initialize(cli, site)
+        @cli, @site = cli, site
+      end
+
+      def run(environment)
+        initialize_databases(environment)
+      end
+
+      def initialize_databases(environment)
+        database_initializers(environment).each do |initializer|
+          initializer.run
+        end
+      end
+
+      # Returns a list of initializers for the given env.
+      #
+      # This de-dupes the initializers according to the config so that only
+      # one call is made in the case where different envs return the same db
+      # config.
+      def database_initializers(environment)
+        dbs = database_environments(environment).map { |env|
+          database_instance(env)
+        }.uniq { |db| db.opts }
+        dbs.map { |db| initializer_for_db(db) }
+      end
+
+      def database_initializer(env)
+        initializer_for_db(database_instance(env))
+      end
+
+      def initializer_for_db(db)
+        initializer_class = case db.opts[:adapter]
+        when /mysql/
+          'MySQL'
+        when /postgres/
+          'Postgresql'
+        when /sqlite/
+          'Sqlite'
+        end
+        klass = Spontaneous::Cli::Init.const_get(initializer_class)
+        klass.new(@cli, db)
+      end
+
+      def database_instance(env)
+        @site.database_instance(database_config(env))
+      end
+
+      def database_config(env)
+        @site.db_connection_options(env)
+      end
+
+      def database_environments(environment)
+        case environment
+        when :development
+          [:development, :test]
+        else
+          [environment]
+        end
+      end
+    end
+
     def insert_root_user
       invoke "user:add", [],  options.account
       # Set up auto_login configuration with the name of the root user
@@ -51,22 +116,8 @@ module Spontaneous::Cli
       end
     end
 
-    def database_initializer
-      @database_initializer ||= get_database_initializer
-    end
-
-    def get_database_initializer
-      connection_params = @site.db_config
-      classname = case connection_params[:development][:adapter]
-      when /mysql/
-        'MySQL'
-      when /postgres/
-        'Postgresql'
-      when /sqlite/
-        'Sqlite'
-      end
-      klass = Spontaneous::Cli::Init.const_get(classname)
-      klass.new(connection_params, self)
+    def site_initializer
+      @site_initializer ||= DatabaseInitializer.new(self, @site)
     end
   end # Init
 end # Spontaneous::Cli

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

@@ -4,50 +4,43 @@ module Spontaneous::Cli
   class Init
     class Db
 
-      attr_reader :site_connection_params, :admin_connection_params, :database, :config
+      attr_reader :database, :config
 
-      def initialize(connection, cli)
+      def initialize(cli, database)
         @cli = cli
-        @connection = connection
-        # setup_connection_params(connection_settings, @cli.options)
-        # @admin_connection_params[:database] = "postgres"
+        @database = database
       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
+        create
+        migrate
       end
 
-      def create(admin_config, site_config)
-        Sequel.connect(admin_config) do |connection|
+      def create
+        Sequel.connect(admin_connection_params) do |connection|
           begin
-            @cli.say "  >> Creating database `#{site_config[:database]}`", :green
-            create_database(connection, site_config)
+            @cli.say "  >> Creating database `#{database.opts[:database]}`", :green
+            create_database(connection)
           rescue => e
-            @cli.say " >>> Unable to create #{admin_config[:adapter]} database `#{site_config[:database]}`:\n   > #{e}", :red
+            @cli.say " >>> Unable to create #{connection.opts[:adapter]} database `#{database.opts[: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
+      def migrate
+        begin
+          database.logger = nil
+          @cli.say "  >> Running migrations..."
+          Sequel::Migrator.apply(database, ::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
 
-      def create_database(connection, config)
-        commands = create_database_commands(config)
+      def create_database(connection)
+        commands = create_database_commands(database.opts)
         commands.each do |command, raise_error|
           begin
             connection.run(command)
@@ -57,37 +50,23 @@ module Spontaneous::Cli
         end
       end
 
-      def create_database_commands(config)
-        [["", false]]
+      # connect to the database as a super/root user in order to create
+      # the database
+      def admin_connection_params
+        config = @database.opts.dup
+        config.delete(:database)
+        config[:user] = options.user unless options.user.blank?
+        config[:password] = options.password unless options.password.blank?
+        config
       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]
+      # Override in db specific sub-classes
+      def create_database_commands(opts)
+        [["", false]]
       end
 
-      def environments
-        [:development, :test]
+      def options
+        @cli.options
       end
     end
   end

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

@@ -4,11 +4,11 @@ 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]
+      def create_database_commands(opts)
+        host = opts[:host].blank? ? "" : "@#{opts[:host]}"
+        cmds = [ ["CREATE DATABASE `#{opts[:database]}` CHARACTER SET UTF8", true] ]
+        unless opts[:user] == "root"
+          cmds << ["GRANT ALL ON `#{opts[:database]}`.* TO `#{opts[:user]}`#{host} IDENTIFIED BY '#{opts[:password]}'", false]
         end
         cmds
       end

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

@@ -4,10 +4,9 @@ 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]
+      def admin_connection_params
+        config = super
+        config.merge(database: 'postgres')
       end
 
       # On some machines the db creation fails due to incompabilities between the UTF8 encoding
@@ -19,12 +18,12 @@ module Spontaneous::Cli
       #
       # 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')
+      def create_database_commands(opts)
+        create_cmd = %(CREATE DATABASE "#{opts[: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]
+        unless opts[:user].blank?
+          create_cmd << %( OWNER="#{opts[:user]}")
+          cmds << [%(CREATE ROLE "#{opts[:user]}" LOGIN PASSWORD '#{opts[:password]}'), false]
         end
         cmds << [create_cmd, true]
       end

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

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

data/lib/spontaneous/cli/migrate.rb

@@ -12,7 +12,6 @@ module Spontaneous::Cli
     def apply
       prepare! :migrate
       Sequel.extension :migration
-      connection_params = ::Spontaneous.db_settings
       say "  >> Running migrations..."
       Sequel::Migrator.apply(Spontaneous.database, ::Spontaneous.gem_dir('db/migrations'))
       say "  >> Done"

data/lib/spontaneous/cli/site.rb

@@ -126,6 +126,10 @@ module Spontaneous
         render_site
       end
 
+      no_commands do
+        alias_method :rerender, :render
+      end
+
       desc "revision", "Shows the site status"
       def revision(*args)
         show_site_revision

data/lib/spontaneous/collections/entry_set.rb

@@ -82,12 +82,23 @@ module Spontaneous::Collections
       store[sid]
     end
 
+    # TODO: replace this with optimized version that can return a list of
+    # ids for a particular box without loading the box's content
+    def ids(box)
+      for_box(box).map(&:id)
+    end
+
     def insert(index, box, entry)
       box_id = box.schema_id.to_s
       store[box_id].insert(index, entry)
       owner.entry_modified!(entry)
     end
 
+    # Called after the modification of box contents to keep the
+    # raw data in-sync with the owner's structure
+    def update(piece_store)
+      @piece_store = piece_store
+    end
 
     def destroy!
       self.destroy

data/lib/spontaneous/data_mapper/content_model.rb

@@ -85,6 +85,8 @@ module Spontaneous
         mapper.get(id)
       end
 
+      # Allows for Page/123 => #<Page id=123...>
+      alias_method :/, :get
       alias_method :[], :get
 
       def primary_key_lookup(id)

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

@@ -38,7 +38,7 @@ module Spontaneous::DataMapper
       end
 
       def _deserialize_value(value)
-        Yajl::Parser.new(:symbolize_keys => true).parse(value || "null")
+        Spontaneous::parse_json(value || "null")
       end
 
       def _serialize_column(column, value)
@@ -47,7 +47,7 @@ module Spontaneous::DataMapper
       end
 
       def _serialize_value(value)
-        Yajl::Encoder.new.encode(value)
+        Spontaneous::encode_json(value)
       end
     end
   end

data/lib/spontaneous/extensions/array.rb

@@ -5,7 +5,9 @@ module Spontaneous
     module Array
       def render_using(renderer, *args)
         self.map { |e|
-          if e.respond_to?(:render_using)
+          if e.respond_to?(:render_inline_using)
+            e.render_inline_using(renderer, *args)
+          elsif e.respond_to?(:render_using)
             e.render_using(renderer, *args)
           elsif e.respond_to?(:render)
             e.render(*args)
@@ -16,7 +18,15 @@ module Spontaneous
       end
 
       def render(*args)
-        self.map { |e| e.respond_to?(:render) ? e.render(*args) : e }.join
+        self.map { |e|
+          if e.respond_to?(:render_inline)
+            e.render_inline(*args)
+          elsif e.respond_to?(:render)
+            e.render(*args)
+          else
+            e
+          end
+          }.join
       end
     end
   end