spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/asset.rb

@@ -0,0 +1,75 @@
+require 'sprockets'
+require 'uglifier'
+require 'sass'
+
+module Spontaneous
+  module Asset
+    autoload :Source, "spontaneous/asset/source"
+    autoload :File,   "spontaneous/asset/file"
+
+    # Takes assets from a source directory & compiles them to some destination directory.
+    # This is deliberatly dumb about the path to the
+    class AppCompiler
+      attr_reader :environment, :manifest
+
+      def initialize(gem_path, dest_path, options = {})
+        @options     = {:compress => true}.merge(options)
+        @gem_path    = gem_path
+        @dest_path   = dest_path
+        @environment = Sprockets::Environment.new(gem_path / "application" )
+        @manifest    = Sprockets::Manifest.new(@environment, @dest_path / "public/@spontaneous/assets")
+
+        @environment.append_path(gem_path / "application/js")
+        @environment.append_path(gem_path / "application/css")
+
+        if @options[:compress]
+          @environment.register_bundle_processor "application/javascript", :uglifier do |context, data|
+            Uglifier.compile(data)
+          end
+
+          @environment.register_bundle_processor "text/css", :sass_compressor do |context, css|
+            # By this point the SCSS has already been compiled, so SASS is merely a CSS compressor
+            # and I can ignore crap around loadpaths or filenames.
+            engine = ::Sass::Engine.new(css, :style => :compressed, :syntax => :scss, :quiet => true, :custom => { :resolver => self })
+            engine.render
+          end
+        end
+      end
+
+
+      def compile
+        # @environment.each_logical_path.select { |path| path =~ /^static/ }.each do |path|
+        #   puts path
+        #   # @manifest.compile(path)
+        # end
+
+        @manifest.compile("spontaneous.js", "login.js", "require.js", "vendor/jquery.js", "spontaneous.css")
+      end
+
+      def image_path(path)
+        path
+      end
+    end
+  end
+end
+# module Spontaneous
+#   module Sass
+#     module Helpers
+#       def image_url(asset)
+#         ::Sass::Script::String.new "url(" + resolver.image_path(asset.value) + ")"
+#       end
+#
+#       def resolver
+#         p options#[:quiet]
+#         options[:custom][:resolver]
+#       end
+#     end
+#   end
+# end
+# module Sass
+#   module Script
+#     module Functions
+#       include Spontaneous::Sass::Helpers
+#     end
+#   end
+# end

data/lib/spontaneous/box.rb

@@ -140,7 +140,7 @@ module Spontaneous
         field_store = []
         default_values.each do |field_name, value|
           if self.field?(field_name)
-            field = self.class.field_prototypes[field_name].to_field
+            field = self.class.field_prototypes[field_name].to_field(self)
             field.unprocessed_value = value
             field_store << field.serialize_db
           end
@@ -212,7 +212,7 @@ module Spontaneous
       @modified = true
       # piece = contents[new_position]
       # new_position = owner.pieces.index(piece)
-      owner.pieces.set_position(entry, new_position)
+      owner.contents.set_position(entry, new_position)
     end
 
     def modified?
@@ -220,10 +220,12 @@ module Spontaneous
     end
 
     def contents
-      owner.pieces.for_box(self)
+      owner.contents.for_box(self)
     end
 
-    alias_method :pieces, :contents
+    def pieces
+      contents.select { |e| e.is_a?(Spontaneous::Piece) }
+    end
 
     def [](index)
       contents[index]

data/lib/spontaneous/capistrano/deploy.rb

@@ -0,0 +1,47 @@
+
+Capistrano::Configuration.instance(:must_exist).load do
+  set :normalize_asset_timestamps, false
+
+  set :bundle_cmd,              "bundle"
+  set :bundle_flags,            "--deployment --quiet --binstubs --shebang ruby-local-exec"
+
+  # Remove tmp/pids from list of shared dirs that get symlinked into the release
+  set :shared_children,   %w(public/system log)
+
+  set :media_dir,   lambda { "#{deploy_to}/media" }
+  set :revision_dir, lambda { "#{deploy_to}/revisions" }
+  set :upload_dir, lambda { "#{deploy_to}/uploadcache" }
+
+  namespace :spot do
+    task :symlink_cache do
+      cache_dir = File.join(latest_release, 'cache')
+      run "mkdir #{cache_dir}; ln -s #{deploy_to}/media #{cache_dir}; ln -s #{deploy_to}/revisions #{cache_dir}; ln -s #{deploy_to}/uploadcache #{cache_dir}/tmp"
+    end
+
+    task :symlink_application do
+      run "cd #{release_path} && ln -s `bundle show spontaneous`/application public/.spontaneous"
+    end
+
+    # 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 ."
+    end
+
+    task :bundle_assets do
+      run "cd #{release_path} && bundle exec spot assets:compile --destination=#{release_path}"
+    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"
+    end
+  end
+
+  after 'deploy:finalize_update', 'spot:symlink_cache'
+  after 'deploy:finalize_update', 'spot:symlink_tmpdir'
+  after 'bundle:install', 'spot:symlink_application'
+  after 'bundle:install', 'spot:bundle_assets'
+end

data/lib/spontaneous/capistrano/sync.rb

@@ -0,0 +1,81 @@
+
+Capistrano::Configuration.instance(:must_exist).load do
+  # TODO: make opts take a list of excludes and turn this into params for the rsync
+  def rsync(origin, destination, opts = {})
+    cmd = %(rsync -rtDzv --chmod=ugo=rwX -e 'ssh -p #{ssh_options[:port]}' --force #{origin}/ #{destination})
+    system cmd
+  end
+
+  def remote_directory(server, path)
+    "#{user}@#{server}:#{path}"
+  end
+
+  namespace :sync do
+    desc "Sync the local version to the remote one"
+    task :default do
+      down
+    end
+
+    desc "Sync the remote system to the local one"
+    task :up do
+      database.up
+      media.up
+    end
+
+    desc "Sync the local version to the remote one"
+    task :down do
+      database.down
+      media.down
+    end
+
+    namespace :database do
+      desc "Sync the local database to the server version"
+      task :default do
+        down
+      end
+
+      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"
+        run %(cd #{current_path} && ./bin/rake db:dump dumpfile=#{dumpfilename} )
+        dump_file = "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
+        dumper.dump(dump_file)
+        remote_dump_file = File.join(deploy_to, dumpfilename)
+        top.upload(dump_file, remote_dump_file)
+        run %(cd #{current_path} && bundle exec rake db:load dumpfile=#{remote_dump_file} )
+      end
+    end
+
+    namespace :media do
+      desc ""
+      task :default do
+        down
+      end
+
+      desc ""
+      task :down do
+        roles[:media].each do |server|
+          top.rsync(remote_directory(server, media_dir), "cache/media/")
+        end
+      end
+
+      desc ""
+      task :up do
+        roles[:media].each do |server|
+          top.rsync("cache/media", remote_directory(server, media_dir))
+        end
+      end
+    end
+  end
+end

data/lib/spontaneous/capistrano.rb

@@ -0,0 +1,13 @@
+# Load Spontaneous specific deployment tasks
+%w(deploy sync).each do |task|
+  load File.expand_path("../capistrano/#{task}.rb", __FILE__)
+end
+
+# Fix for ActiveSupport breaking Capistrano's #capture method.
+# See this thread:
+# https://github.com/capistrano/capistrano/issues/168
+Capistrano::Configuration::Namespaces::Namespace.class_eval do
+  def capture(*args)
+    parent.capture *args
+  end
+end

data/lib/spontaneous/change.rb

@@ -1,66 +1,26 @@
 # encoding: UTF-8
 
 module Spontaneous
-  class Change < Sequel::Model(:changes)
-    class << self
-      alias_method :sequel_plugin, :plugin
-    end
-
-    sequel_plugin :serialization, :yajl, :modified_list
+  class Change
 
-    @@instance = nil
 
     class << self
-      def record
-        entry_point = @@instance.nil?
-        @@instance ||= self.new(:modified_list => [])
-        yield if block_given?
-      ensure
-        if entry_point and !@@instance.modified_list.empty?
-          @@instance.save
-        end
-        @@instance = nil if entry_point
-      end
-
-      def recording?
-        !@@instance.nil?
-      end
-
-      def push(page)
-        if @@instance
-          @@instance.push(page)
-        end
+      def outstanding
+        unpublished_changes
       end
 
-      def outstanding
-        dependencies = dependency_map
-        dependencies.map { |d| Spontaneous::Collections::ChangeSet.new(d) }
+      def unpublished_changes
+        changes = unpublished_pages.map { |page| Change.new(page) }
       end
 
-      def dependency_map
-        grouped_changes = self.valid.map { |c| [c] }
-        begin
-          modified = false
-          grouped_changes.each_with_index do |inner, i|
-            inner_ids = inner.map { |c| c.modified_list }.flatten
-            grouped_changes[(i+1)..-1].each_with_index do |outer, j|
-              outer_ids = outer.map { |c| c.modified_list }.flatten
-              unless (inner_ids & outer_ids).empty?
-                modified = true
-                grouped_changes.delete(outer)
-                grouped_changes[i] += outer
-              end
-            end
-          end
-        end while modified
-
-        grouped_changes
+      def unpublished_pages
+        S::Page.filter { (modified_at > last_published_at) | {:first_published_at => nil} }.order(:modified_at.desc).all
       end
 
-      def valid
-        invalid, valid = self.all.partition { |change| change.modified.empty? }
-        self.filter(:id => invalid.map { |change| change.id }).delete
-        valid
+      def include_dependencies(page_list)
+        changes = page_list.map { |page| Change.new(page) }
+        pages = changes.map { |change| change.all_pages }.flatten.uniq
+        pages
       end
 
       def export
@@ -72,36 +32,68 @@ module Spontaneous
       end
     end
 
+    attr_reader :page
 
-    def after_initialize
-      super
-      self.modified_list ||= []
+    def initialize(page)
+      @page = page
     end
 
-    def push(page)
-      self.modified_list << page.id
+    def all_pages
+      [page].concat(dependent)
     end
 
-    def before_update
-      self.modified_list.uniq!
+    # Calculates all the pages we would have to publish along with this in order to root
+    # this page into the site hierarchy.
+    #
+    # Returns: a list of dependent pages in ancestor order (ascending depth with root first)
+    def dependent
+      @dependent ||= page.ancestors.reverse.take_while { |ancestor| ancestor.never_published? }.reverse
     end
 
-    def modified
-      @modified ||= modified_list.map { |id| Content[id] }.compact
+    def page_id
+      page.id
     end
 
-    alias_method :pages, :modified
+    def export_page(page)
+      { :id => page.id,
+        :title => page.title.to_s,
+        :depth => page.depth,
+        :url => page.path,
+        :side_effects => export_side_effects(page),
+        :published_at => export_timestamp(page.last_published_at),
+        :modified_at => export_timestamp(page.modified_at) }
+    end
+
+    def export_side_effects(page)
+    side_effects = Hash.new { |h, k| h[k] = [] }
+       page.pending_modifications.map do |modification|
+         side_effects[modification.type] << {
+           :count => modification.count,
+           :created_at => export_timestamp(modification.created_at),
+           :old_value => modification.old_value,
+           :new_value => modification.new_value
+         }
+      end
+      side_effects
+    end
 
-    def &(change)
-      self.modified_list & change.modified_list
+    def modified_at
+      page.modified_at
+    end
+
+    def export_timestamp(timestamp)
+      return nil if timestamp.nil?
+      timestamp.httpdate
     end
 
     def export
-      {
-        :id => self.id,
-        :created_at => self.created_at.to_s,
-        :page_ids => modified_list
-      }
+      export_page(page).merge({
+        :dependent => dependent.map { |p| export_page(p) }
+      })
+    end
+
+    def inspect
+      %(#<Spontaneous::Change page=#{page.id} dependent=#{dependent.map(&:id).inspect}>)
     end
   end
 end

data/lib/spontaneous/cli/assets.rb

@@ -0,0 +1,29 @@
+module Spontaneous
+  module Cli
+    class Assets < ::Spontaneous::Cli::Thor
+      Spontaneous = ::Spontaneous
+      namespace :assets
+      default_task :compile
+
+
+      # class Up < SyncTask
+      #   desc "Syncs up"
+      # end
+
+      desc "#{namespace}:compile", "Compiles assets for the Spontaneous UI"
+      method_option :destination, :type => :string, :aliases => "-d", :required => true, :desc => "Compile assets into DESTINATION"
+      def compile
+        prepare(:compile)
+        # options[:mode] = :console
+        # Find path to install of Spontaneous using bundler and then
+        # use this path as params to compiler
+        spec = Bundler.load.specs.find{|s| s.name == "spontaneous" }
+        p spec.full_gem_path
+
+        compiler = Spontaneous::Asset::AppCompiler.new(spec.full_gem_path, options.destination)
+        compiler.compile
+      end
+    end
+  end
+end
+

data/lib/spontaneous/cli/base.rb

@@ -127,54 +127,6 @@ module Spontaneous
         say "  >> Done"
       end
 
-      desc :adduser, "Add a user"
-      def adduser
-        prepare :adduser
-        boot!
-        users = Spontaneous::Permissions::User.count
-        attrs = {}
-        width = 12
-        valid_login = /^[a-z0-9_]{3,}$/
-        levels = Spontaneous::Permissions::UserLevel.all.map(&:to_s)
-        level = nil
-
-        say("\nAll fields are required:\n", :green)
-        begin
-          attrs[:login] = ask "Login : ".rjust(width, " ")
-          say("Login must consist of at least 3 letters, numbers and underscores", :red) unless valid_login === attrs[:login]
-        end while attrs[:login] !~ valid_login
-
-        attrs[:name] = ask "Name : ".rjust(width, " ")
-        attrs[:email] = ask "Email : ".rjust(width, " ")
-
-        begin
-          attrs[:password] = ask "Password : ".rjust(width, " ")
-          say("Password must be at least 6 characters long", :red) unless attrs[:password].length > 5
-        end while attrs[:password].length < 6
-
-        if users == 0
-          level = "root"
-        else
-          begin
-            level = ask("User level [#{levels.join(', ')}] : ")
-            say("Invalid level '#{level}'", :red) unless levels.include?(level)
-          end while !levels.include?(level)
-        end
-
-        attrs[:password_confirmation] = attrs[:password]
-        user = Spontaneous::Permissions::User.new(attrs)
-
-        if user.save
-          user.update(:level => level)
-          say("\nUser '#{user.login}' created with level '#{user.level}'", :green)
-        else
-          errors = user.errors.map do | a, e |
-            " - '#{a.to_s.capitalize}' #{e.first}"
-          end.join("\n")
-          say("\nInvalid user details:\n"+errors, :red)
-        end
-      end
-
       private
 
 

data/lib/spontaneous/cli/console.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require 'watchr'
+# require 'watchr'
 
 module Spontaneous::Cli
   class Console < ::Spontaneous::Cli::Thor

data/lib/spontaneous/cli/server.rb

@@ -13,12 +13,12 @@ module Spontaneous
 
       class_option :no_browser, :type => :boolean, :default => false, :aliases => "-b", :desc => "Don't launch browser"
 
-      desc "#{namespace}:start", "Starts Spntaneous in development mode"
+      desc "#{namespace}:start", "Starts Spontaneous in development mode"
       def start
         File.open(".Procfile", 'wb') do |procfile|
-          procfile.write(%(back: #{binary} server:back\n))
-          procfile.write(%(front: #{binary} server:front\n))
-          procfile.write(%(simultaneous: #{binary} server:simultaneous\n))
+          procfile.write(%(back: #{binary} server:back --root=#{options.site}\n))
+          procfile.write(%(front: #{binary} server:front --root=#{options.site}\n))
+          procfile.write(%(simultaneous: #{binary} server:simultaneous --root=#{options.site}\n))
           procfile.flush
           engine = ::Foreman::Engine.new(procfile.path)
           engine.start
@@ -48,8 +48,10 @@ module Spontaneous
         boot!
         connection = options[:connection] || ::Spontaneous.config.simultaneous_connection
         fork {
+          ENV.delete("BUNDLE_GEMFILE")
           puts("#{Simultaneous.server_binary} -c #{connection} --debug")
           exec("#{Simultaneous.server_binary} -c #{connection} --debug")
+          # sleep 10
         }
         Process.wait
       end

data/lib/spontaneous/cli/site.rb

@@ -3,16 +3,15 @@ require 'spontaneous/cli'
 module Spontaneous
   module Cli
     class Site < ::Spontaneous::Cli::Thor
-      Spontaneous = ::Spontaneous
       namespace :site
 
       default_task :browse
 
-      class DumpTask < ::Thor::Group
+      module DumpTask
         protected
 
         def db_adapter
-          ::Spontaneous::Utils::Database.dumper_for_database(database)
+          @db_adapter ||= ::Spontaneous::Utils::Database.dumper_for_database(database)
         end
 
         def sqldump(path)
@@ -32,11 +31,11 @@ module Spontaneous
         end
 
         def database_dumpfile
-          dump_path / "database.mysql.gz"
+          dump_path / "database.#{db_adapter.name}.gz"
         end
 
         def database
-          Spontaneous.database
+          ::Spontaneous.database
         end
 
         def dump_path
@@ -44,16 +43,19 @@ module Spontaneous
         end
 
         def dump_root
-          Spontaneous.cache_dir('dump')
+          ::Spontaneous.cache_dir('dump')
         end
 
         def relative_dir(path)
           path = Pathname.new(path)
-          path.relative_path_from(Pathname.new(Spontaneous.root)).to_s
+          path.relative_path_from(Pathname.new(::Spontaneous.root)).to_s
         end
       end
 
-      class Dump < DumpTask
+
+      class Dump < ::Thor::Group
+        include DumpTask
+
         def create_dump_dir
           ::FileUtils.mkdir_p(dump_path)
         end
@@ -64,15 +66,17 @@ module Spontaneous
         end
 
         def archive_media
-          tmp = relative_dir(Spontaneous.media_dir('tmp'))
-          src = relative_dir(Spontaneous.media_dir)
+          tmp = relative_dir(::Spontaneous.media_dir('tmp'))
+          src = relative_dir(::Spontaneous.media_dir)
           say "Creating media archive at '#{relative_dir(media_archive)}'", :green
           cmd = %(tar czf #{media_archive} --exclude #{tmp} #{src})
           system(cmd)
         end
       end
 
-      class Load < DumpTask
+      class Load < ::Thor::Group
+        include DumpTask
+
         def find_latest_dump
           root = Pathname.new(dump_root)
           @id = root.entries.
@@ -109,24 +113,31 @@ module Spontaneous
       end
 
       desc "#{namespace}:publish", "Publishes the site"
-      method_option :changes, :type => :array, :desc => "List of changesets to include"
+      method_option :pages, :type => :array, :desc => "List of pages to publish"
       method_option :logfile, :type => :string, :desc => "Location of logfile"
       def publish
         prepare :publish
-        # TODO: set up logging
         boot!
         ::Site.publishing_method = :immediate
-        Spontaneous::Logger.setup(:logfile => options.logfile) if options.logfile
+        ::Spontaneous::Logger.setup(:logfile => options.logfile) if options.logfile
         say "Creating revision #{::Site.revision}", :green, true
-        if options.changes
-          say ">  Publishing changes #{options.changes.inspect}", :green, true
-          ::Site.publish_changes(options.changes)
+        if options.pages
+          say ">  Publishing pages #{options.pages.inspect}", :green, true
+          ::Site.publish_pages(options.pages)
         else
           say ">  Publishing all", :green, true
           ::Site.publish_all
         end
       end
 
+      desc "#{namespace}:render", "Re-renders the current content"
+      def render
+        prepare :render
+        boot!
+        ::Site.publishing_method = :immediate
+        ::Site.rerender
+      end
+
       desc "#{namespace}:revision", "Shows the site status"
       def revision
         prepare :revision