spontaneous 0.2.0.beta5 → 0.2.0.beta6

data/db/migrations/20130813111009_increase_path_length.rb

@@ -1,7 +1,17 @@
 Sequel.migration do
+
   up do
+    length = case self.adapter_scheme
+    when :mysql, :mysql2
+      # http://stackoverflow.com/questions/1814532/1071-specified-key-was-too-long-max-key-length-is-767-bytes/1814594#1814594
+      # reasons to move away from mysql...
+      255
+    else
+      2048
+    end
+
     [:content, :spontaneous_content_archive, :spontaneous_content_history].each do |table|
-      set_column_type table, :path, 'varchar(2048)'
+      set_column_type table, :path, "varchar(#{length})"
     end
   end
 
@@ -11,4 +21,3 @@ Sequel.migration do
     end
   end
 end
-

data/db/migrations/20140506171823_add_index_to_target_id.rb

@@ -0,0 +1,11 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    add_index :content, :target_id
+  end
+
+  down do
+    drop_index :content, :target_id
+  end
+end

data/db/migrations/20140514090204_add_content_hash.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    [:content, :spontaneous_content_archive, :spontaneous_content_history].each do |table|
+      alter_table table do
+        add_column :content_hash, :varchar, size: 32
+        add_column :published_content_hash, :varchar, size: 32
+        add_column :content_hash_changed, :boolean, default: true
+      end
+    end
+    alter_table :content do
+      add_index :content_hash_changed
+    end
+
+    # testing environment
+    if defined?(Content)
+
+      self.logger = nil
+
+      state = Spontaneous::State.first
+
+      published_revision = state.nil? ? nil : state[:published_revision]
+
+      content_hash = published_content_hash = nil
+
+      model = Spontaneous::Model(:content)
+
+      update_content_hashes = Proc.new do |content|
+        published_content_hash = nil
+        content_hash = content.calculate_content_hash!
+        if published_revision
+          model.mapper.scope(published_revision, false) do
+            published = model[content.id]
+            published_content_hash = published.calculate_content_hash! if published
+          end
+        end
+        p [content.id, content.class, content.path, content_hash, published_content_hash] #if published_content_hash != content_hash
+        model.dataset.unfiltered.where(id: content.id).update(content_hash: content_hash, published_content_hash: published_content_hash, content_hash_changed: (content_hash != published_content_hash))
+      end
+
+      Content::Piece.dataset.order(Sequel.desc(:depth)).each(&update_content_hashes)
+      Content::Page.dataset.order(Sequel.desc(:depth)).each(&update_content_hashes)
+    end
+  end
+
+  down do
+    alter_table :content do
+      drop_index :content_hash_changed
+    end
+    [:spontaneous_content_archive, :spontaneous_content_history].each do |table|
+      alter_table table do
+        drop_column :content_hash
+        drop_column :published_content_hash
+        drop_column :content_hash_changed
+      end
+    end
+  end
+end

data/db/migrations/20140519150253_add_content_hash_timestamp.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+Sequel.migration do
+  up do
+    [:content, :spontaneous_content_archive, :spontaneous_content_history].each do |table|
+      alter_table table do
+        add_column :content_hash_changed_at, :timestamp
+      end
+      self[table].update(content_hash_changed_at: :modified_at)
+    end
+  end
+
+  down do
+    [:content, :spontaneous_content_archive, :spontaneous_content_history].each do |table|
+      alter_table table do
+        drop_column :content_hash_changed_at
+      end
+    end
+  end
+end

data/lib/spontaneous.rb

@@ -108,7 +108,6 @@ module Spontaneous
   include Plugins::Application::Serialisation
   include Plugins::Application::Features
   include Plugins::Application::System
-  extend  Revision::GlobalMethods
 end
 
 Dir["#{File.expand_path("../spontaneous", __FILE__)}/extensions/*.rb"].each { |file| require file }

data/lib/spontaneous/asset/environment.rb

@@ -5,7 +5,7 @@ module Spontaneous::Asset
   module Environment
     def self.new(context)
       if context.publishing?
-        Publish.new(context.site, context.revision)
+        Publish.new(context.site, context.revision, context.development?)
       else
         Preview.new(context.site)
       end
@@ -42,7 +42,7 @@ module Spontaneous::Asset
 
 
     class Preview
-      attr_reader :environment
+      attr_reader :environment, :site
 
       def initialize(site)
         @site = site
@@ -160,21 +160,88 @@ module Spontaneous::Asset
     end
 
     class Publish < Preview
-      def initialize(site, revision)
+      def initialize(site, revision, development)
         super(site)
-        @revision = Spontaneous.revision(revision)
+        @revision = site.revision(revision)
+        @development = development
+        # environment.logger = Logger.new($stdout)
         environment.css_compressor = :scss
         environment.js_compressor  = :uglifier
         environment.context_class.manifest = manifest
         environment.context_class.asset_mount_point = asset_mount_point
       end
 
-      def manifest
-        @manifest ||= Sprockets::Manifest.new(environment, manifest_file)
+      def development?
+        @development || false
+      end
+
+      # A proxy to the sprockets manifest that compiles assets on the first run
+      # then re-uses them on the second
+      class Manifest
+        def initialize(environment, revision, development)
+          @environment = environment
+          @revision = revision
+          @development = development || false
+          @manifest = Sprockets::Manifest.new(environment.environment, manifest_file)
+        end
+
+        def development?
+          @development
+        end
+
+        def manifest_file
+          File.join(asset_compilation_dir, "manifest.json")
+        end
+
+        def assets
+          @manifest.assets
+        end
+
+        def compile(*args)
+          assets = @manifest.assets
+          unless (args.all? { |key| assets.key?(key) })
+            compile!(*args)
+          end
+          copy_assets_to_revision(args)
+        end
+
+        def compile!(*args)
+          @manifest.compile(*args)
+          copy_assets_to_revision(args)
+        end
+
+        def copy_assets_to_revision(logical_paths)
+          assets = @manifest.assets
+          paths = logical_paths.map { |a| assets[a] }.compact
+          source, dest = shared_asset_dir, revision_asset_dir
+          paths.each do |asset|
+            copy_asset_to_revision(source, dest, asset)
+          end
+        end
+
+        def copy_asset_to_revision(source, dest, asset)
+          to = dest + asset
+          return if to.exist?
+          from = source + asset
+          to.dirname.mkpath
+          FileUtils.cp(from, to)
+        end
+
+        def asset_compilation_dir
+          development? ? revision_asset_dir : shared_asset_dir
+        end
+
+        def revision_asset_dir
+          @revision.path(@environment.asset_mount_point)
+        end
+
+        def shared_asset_dir
+          @environment.site.path!('assets/tmp')
+        end
       end
 
-      def manifest_file
-        File.join(bundle_dir, "manifest.json")
+      def manifest
+        @manifest ||= Manifest.new(self, @revision, development?)
       end
 
       def find(sources, options)
@@ -189,18 +256,13 @@ module Spontaneous::Asset
         assets.concat(remote).sort { |a, b| a[1] <=> b[1] }.map(&:first)
       end
 
-      def bundle_dir
-        @revision.path(asset_mount_point)
-      end
-
       def to_url(asset)
         return nil if asset.nil?
         "/" << asset_mount_point << "/" << asset
       end
 
       def context_extension
-        Proc.new {
-
+        Proc.new do
           class << self
             attr_accessor :manifest, :asset_mount_point
           end
@@ -218,7 +280,7 @@ module Spontaneous::Asset
           def make_absolute(logical)
             "/" << self.class.asset_mount_point << "/" << logical
           end
-        }
+        end
       end
     end
   end

data/lib/spontaneous/box.rb

@@ -12,6 +12,7 @@ module Spontaneous
     include Spontaneous::Model::Box::AllowedTypes
     include Spontaneous::Model::Core::Permissions
     include Spontaneous::Model::Core::Media
+    include Spontaneous::Model::Core::ContentHash::BoxMethods
 
     # use underscores to protect against field name conflicts
     attr_reader :_name, :_prototype, :owner
@@ -79,6 +80,24 @@ module Spontaneous
       @owner.model
     end
 
+    # All renderable objects must implement #target to enable aliases & content objects
+    # to be treated identically
+    def target
+      self
+    end
+
+    def renderable
+      self
+    end
+
+    def render(format = :html, params = {}, parent_context = nil)
+      render_inline(format, params, parent_context)
+    end
+
+    def render_using(renderer, format = :html, params = {}, parent_context = nil)
+      render_inline_using(renderer, format, params, parent_context)
+    end
+
     def page?
       false
     end
@@ -216,6 +235,8 @@ module Spontaneous
       owner.page
     end
 
+    alias_method :to_page, :page
+
     def depth
       owner.content_depth
     end

data/lib/spontaneous/capistrano/deploy.rb

@@ -25,7 +25,7 @@ Capistrano::Configuration.instance(:must_exist).load do
     # Capistrano automatically creates a tmp directory - I don't like that
     # and would prefer to share tmp between instances
     task :symlink_tmpdir do
-      run "cd #{release_path} && rmdir tmp ; ln -nfs #{deploy_to}/shared/tmp ."
+      run "cd #{release_path} && rm -r tmp ; ln -nfs #{deploy_to}/shared/tmp ."
     end
 
     task :bundle_assets do

data/lib/spontaneous/capistrano/sync.rb

@@ -36,20 +36,21 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Sync the local database to the server version"
       task :down do
-        puts "syncing database DOWN"
-        dumpfilename = ENV['dumpfile'] || "#{Time.now.to_i}.mysql.gz"
+        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} )
-        dump_file = "tmp/#{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}"
       end
 
       desc "Sync the server's version of the database to the local one"
       task :up do
-        puts "syncing database UP"
-        dumpfilename = ENV['dumpfile'] || "#{Time.now.to_i}.mysql.gz"
-        dump_file = "tmp/#{dumpfilename}"
-        dumper = ::Spontaneous::Utils::Database.dumper_for_database
+        puts "  * Syncing database UP"
+        dumper = Spontaneous::Utils::Database.dumper_for_database
+        dumpfilename = ENV['dumpfile'] || dumper.dumpfilename
+        dump_file = File.join("tmp", dumpfilename)
         dumper.dump(dump_file)
         remote_dump_file = File.join(deploy_to, dumpfilename)
         top.upload(dump_file, remote_dump_file)

data/lib/spontaneous/change.rb

@@ -15,7 +15,9 @@ module Spontaneous
       end
 
       def unpublished_pages(site)
-        site.model::Page.filter { (modified_at > last_published_at) | {:first_published_at => nil} }.order(Sequel.desc(:modified_at)).all
+        site.model.with_editable { # published content never has changes...
+          site.model::Page.filter(content_hash_changed: true).order(Sequel.desc(:content_hash_changed_at)).all
+        }
       end
 
       def include_dependencies(page_list)
@@ -90,7 +92,7 @@ module Spontaneous
     end
 
     def modified_at
-      page.modified_at
+      page.content_hash_changed_at
     end
 
     def export_timestamp(timestamp)

data/lib/spontaneous/cli/fields.rb

@@ -9,7 +9,13 @@ module Spontaneous
 
       desc "update", "Performs asynchronous updates on provided fields"
       method_option :fields, :type => :array, :desc => "List of field IDs to update"
-      def update
+      def update(*args)
+        update_fields
+      end
+
+      private
+
+      def update_fields
         prepare! :update, :console
         site = Spontaneous::Site.instance
         fields = Spontaneous::Field.find(site.model, *options.fields)
@@ -18,8 +24,6 @@ module Spontaneous
         send_completion_event(updater)
       end
 
-      private
-
       def send_completion_event(updater)
         unlocked_pages = updater.pages.reject { |p| p.locked_for_update? }
         simultaneous_event('page_lock_status', unlocked_pages.map(&:id).to_json)

data/lib/spontaneous/cli/generate.rb

@@ -32,6 +32,8 @@ module Spontaneous::Cli
       end
     end
 
+    protected
+
     def generate_site(args)
       ::Spontaneous::Generators::Site.start(args.drop_while { |e| %w(generate site).include?(e) })
     end

data/lib/spontaneous/cli/init.rb

@@ -19,29 +19,25 @@ module Spontaneous::Cli
     method_option :create_user, :type => :boolean, :default => true, :desc => "Enable creation of a root user"
 
     def init
-      prepare :init
+      initialize_size
+    end
 
-      site = ::Spontaneous::Site.instantiate(Dir.pwd, options.environment, :console)
-      Sequel.extension :migration
+    protected
 
+    def initialize_size
+      prepare :init
 
-      database, admin_connection_params, site_connection_params = generate_connection_params
+      @site = ::Spontaneous::Site.instantiate(Dir.pwd, options.environment, :console)
+      Sequel.extension :migration
 
-      [database, "#{database}_test"].each do |db|
-        config = site_connection_params.merge(:database => db)
-        create(db, admin_connection_params, config)
-        migrate(db, site_connection_params, config)
-      end
+      database_initializer.run
 
       boot!
 
       # Add a root user if this is a new site
       insert_root_user if (options.create_user && ::Spontaneous::Permissions::User.count == 0)
-
     end
 
-    protected
-
     def insert_root_user
       invoke "user:add", [],  options.account
       # Set up auto_login configuration with the name of the root user
@@ -55,92 +51,27 @@ module Spontaneous::Cli
       end
     end
 
-    def create(database, admin_config, site_config)
-      Sequel.connect(admin_config) do |connection|
-        begin
-          say "  >> Creating database `#{site_config[:database]}`", :green
-          create_database(connection, site_config)
-        rescue => e
-          say " >>> Unable to create #{admin_config[:adapter]} database `#{site_config[:database]}`:\n   > #{e}", :red
-        end
-      end
+    def database_initializer
+      @database_initializer ||= get_database_initializer
     end
 
-    def migrate(database, admin_config, site_config)
-      Sequel.connect(admin_config.merge(:database => site_config[:database])) do |connection|
-        begin
-          connection.logger = nil
-          say "  >> Running migrations..."
-          Sequel::Migrator.apply(connection, ::Spontaneous.gem_dir('db/migrations'))
-          say "  >> Done"
-        rescue => e
-          say " >>> Error running migrations on database `#{site_config[:database]}`:\n   > #{e}", :red
-          raise e
-        end
-      end
-    end
-
-    # Converts the site db parameters into 'admin' connection using the provided
-    # db credentials and the necessary :database settings
-    def generate_connection_params
-      site_connection_params = ::Spontaneous.db_settings
-      connection_params = site_connection_params.dup
-      connection_params[:user] = options.user unless options.user.blank?
-      connection_params[:password] = options.password unless options.password.blank?
-
-      database = connection_params.delete(:database)
-      case connection_params[:adapter]
+    def get_database_initializer
+      connection_params = @site.db_config
+      classname = case connection_params[:development][:adapter]
       when /mysql/
+        'MySQL'
       when /postgres/
-        # postgres requires that you connect to a db.
-        # "postgres" is guaranteed to exist
-        connection_params[:database] = "postgres"
-      end
-      [database, connection_params, site_connection_params]
-    end
-
-    def create_database(connection, config)
-      commands = case connection.database_type
-                 when :postgres
-                   create_postgres_database_commands(config)
-                 when :mysql
-                   create_mysql_database_commands(config)
-                 end
-      commands.each do |command, raise_error|
-        begin
-          connection.run(command)
-        rescue => e
-          raise e if raise_error
-        end
-      end
-    end
-
-    def create_mysql_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
-
-    # 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_postgres_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]
+        'Postgresql'
+      when /sqlite/
+        'Sqlite'
       end
-      cmds << [create_cmd, true]
+      klass = Spontaneous::Cli::Init.const_get(classname)
+      klass.new(connection_params, self)
     end
   end # Init
 end # Spontaneous::Cli
+
+require 'spontaneous/cli/init/db'
+require 'spontaneous/cli/init/postgresql'
+require 'spontaneous/cli/init/mysql'
+require 'spontaneous/cli/init/sqlite'