spontaneous 0.1.0.alpha1 → 0.2.0.alpha1

data/lib/spontaneous/box_style.rb

@@ -5,59 +5,76 @@ module Spontaneous
   class BoxStyle < Style
     attr_reader :box
 
+    def self.excluded_classes
+      [Spontaneous::Box].tap do |classes|
+        classes.push(::Box) if defined?(::Box)
+      end
+    end
+
     def self.to_directory_name(klass)
-      return nil if klass == Spontaneous::Box
+      return nil if excluded_classes.include?(klass)
       super
     end
 
-    def initialize(box)
+    def initialize(box, owner = nil)
       @box = box
-      @owner = box._owner.class
+      @owner = box.owner.class
     end
 
     def inline_template(format)
       nil
     end
 
-    def supertype_template(format)
-      supertype = box.class.supertype
-      if supertype && supertype != Spontaneous::Box
-        self.class.new(supertype).template(format)
-      else
-        nil
-      end
+    def try_supertype_styles
+      []
     end
 
+
+
+
     def name
       box._name.to_s
     end
 
     def try_paths
       prototype = box._prototype
-      box_directory_name = self.class.to_directory_name(prototype.box_base_class)
-      paths = [ [owner_directory_name, box._name.to_s] ]
+      box_name = box._name.to_s
+
+      paths = owner_directory_paths(box_name)
+
+      if style_name = prototype.default_style
+        name = style_name.to_s
+        paths.concat(owner_directory_paths(name))
+        paths.concat(box_directory_paths(name))
+      end
 
       if box.styles.empty?
-        paths.push(box_directory_name)
+        paths.concat(box_directory_names)
       else
-        if style_name = prototype.default_style
-          name = style_name.to_s
-          paths.push([owner_directory_name, name])
-          paths.push([box_directory_name, name])
-        else
+        unless style_name = prototype.default_style
           box.styles.each do |style|
             name = style.name.to_s
-            paths.push([owner_directory_name, name])
-            paths.push([box_directory_name, name])
+            paths.concat(owner_directory_paths(name))
+            paths.concat(box_directory_paths(name))
           end
         end
       end
-
       paths
     end
 
+    def box_directory_names
+      box_class = box._prototype.box_base_class
+      box_supertypes = [box_class].concat(class_ancestors(box_class)).reject { |type| self.class.excluded_classes.include?(type) }
+      return [nil] if box_supertypes.empty?
+      box_supertypes.map { |type| self.class.to_directory_name(type) }
+    end
+
+    def box_directory_paths(name)
+      box_directory_names.map { |d| [d, name] }
+    end
+
     def anonymous_template
-      Proc.new { "{{ render_content }}" }
+      Proc.new { '#{ render_content }' }
     end
   end
 end

data/lib/spontaneous/change.rb

@@ -6,7 +6,7 @@ module Spontaneous
       alias_method :sequel_plugin, :plugin
     end
 
-    sequel_plugin :yajl_serialization, :modified_list
+    sequel_plugin :serialization, :yajl, :modified_list
 
     @@instance = nil
 
@@ -67,7 +67,7 @@ module Spontaneous
         outstanding.map { |change_set| change_set.export }
       end
 
-      def serialise_http
+      def serialise_http(user = nil)
         Spontaneous.serialise_http(export)
       end
     end

data/lib/spontaneous/cli.rb

@@ -9,6 +9,7 @@ module Spontaneous
       class_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development, :desc => "Spontaneous Environment"
       class_option :mode, :type => :string,  :aliases => "-m", :default => :back, :desc => "Spontaneous mode ('front' or 'back')"
       class_option :help, :type => :boolean, :desc => "Show help usage"
+
       protected
 
       def boot!

data/lib/spontaneous/cli/base.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'thor'
 
 module Spontaneous
@@ -82,6 +84,7 @@ module Spontaneous
       desc :init, "Creates databases and initialises a new Spontaneous site"
       def init
         prepare :init
+        site = Spontaneous::Site.instantiate(Dir.pwd, options.environment, :back)
         require File.expand_path('../../../spontaneous', __FILE__)
         Sequel.extension :migration
         connection_params = Spontaneous.db_settings
@@ -98,13 +101,18 @@ module Spontaneous
                 say " >>> Unable to create #{connection_params[:adapter]} database `#{db}`:\n   > #{e}", :red
                 # throw :error
               end
+              begin
+                connection.run("USE `#{db}`")
+                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 `#{db}`:\n   > #{e}", :red
+              end
             end
           end
           boot!
-          Spontaneous.database.logger = nil
-          say "  >> Running migrations..."
-          Sequel::Migrator.apply(Spontaneous.database, Spontaneous.gem_dir('db/migrations'))
-          say "  >> Done"
         end
       end
 

data/lib/spontaneous/cli/console.rb

@@ -0,0 +1,72 @@
+# encoding: UTF-8
+
+require 'watchr'
+
+module Spontaneous::Cli
+  class Console < ::Spontaneous::Cli::Thor
+    Spontaneous = ::Spontaneous
+    include Thor::Actions
+    namespace :console
+
+    default_task :open
+
+    desc "#{namespace}:open", "Gives you console access to the current site"
+    def open
+      # script = Watchr::Script.new
+      # script.watch('(lib|schema)/.*\\.rb') { puts 'reload!' } # doesn't block
+      # Thread.new do
+      #   Watchr::Controller.new(script, Watchr.handler.new).run
+      # end
+
+
+      ENV["SPOT_MODE"] = "console"
+      prepare :console
+      ARGV.clear
+      ARGV.concat [ "--readline", "--prompt-mode", "simple" ]
+      require 'irb'
+      boot!
+
+      require 'irb/completion'
+      require 'irb/ext/save-history'
+
+      history_file = Spontaneous.root / ".irb_history"
+
+      IRB.setup(nil)
+      IRB.conf[:SAVE_HISTORY] = 100
+      IRB.conf[:HISTORY_FILE] = history_file
+
+      irb = IRB::Irb.new
+      IRB.conf[:MAIN_CONTEXT] = irb.context
+
+      irb.context.evaluate((<<-INIT), __LINE__)
+
+        module Readline
+          module History
+            def self.write_log(line)
+              File.open('#{history_file}', 'ab') {|f| f << "\#{line}\n"}
+            end
+          end
+
+          alias :old_readline :readline
+          def readline(*args)
+            ln = old_readline(*args)
+            begin
+              History.write_log(ln) unless ln.strip.empty?
+            rescue
+            end
+            ln
+          end
+        end
+
+
+      INIT
+
+      trap("SIGINT") do
+        irb.signal_handle
+      end
+      catch(:IRB_EXIT) do
+        irb.eval_input
+      end
+    end
+  end # Console
+end # Spontaneous::Cli

data/lib/spontaneous/cli/server.rb

@@ -1,22 +1,29 @@
+# encoding: UTF-8
+
+require 'spontaneous'
+require 'simultaneous'
+require 'foreman'
+require 'foreman/engine'
 
 module Spontaneous
   module Cli
     class Server < ::Spontaneous::Cli::Thor
       namespace :server
+      default_task :start
 
-      default_task :back
-
-      # desc :start, "Starts Spontaneous"
-
-      # def both
-      #   pids = []
-      #   trap(:INT) { }
-      #   pids << fork { front }
-      #   pids << fork { back }
-      #   Process.wait
-      #   pids.each { | pid | Process.kill(:TERM, pid) rescue nil }
-      # end
+      class_option :no_browser, :type => :boolean, :default => false, :aliases => "-b", :desc => "Don't launch browser"
 
+      desc "#{namespace}:start", "Starts Spntaneous 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.flush
+          engine = ::Foreman::Engine.new(procfile.path)
+          engine.start
+        end
+      end
 
       desc "#{namespace}:front", "Starts Spontaneous in front/public mode"
       # method_option :adapter, :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
@@ -34,8 +41,25 @@ module Spontaneous
         start_server(:back)
       end
 
+      desc "#{namespace}:simultaneous", "Launches the Simultaneous server"
+      method_option :connection, :type => :string, :aliases => "-c", :desc => "Use CONNECTION"
+      def simultaneous
+        prepare(:start)
+        boot!
+        connection = options[:connection] || ::Spontaneous.config.simultaneous_connection
+        fork {
+          puts("#{Simultaneous.server_binary} -c #{connection} --debug")
+          exec("#{Simultaneous.server_binary} -c #{connection} --debug")
+        }
+        Process.wait
+      end
+
       private
 
+      def binary
+        ::Spontaneous.gem_dir("bin/spot")
+      end
+
       def start_server(mode)
         prepare mode.to_sym
         ENV["SPOT_MODE"] = mode.to_s

data/lib/spontaneous/cli/site.rb

@@ -7,10 +7,184 @@ module Spontaneous
 
       default_task :browse
 
+
+      class MySQL
+        def initialize(database)
+          @database = database
+        end
+
+        def load(path)
+          options = [
+            "mysql",
+            option(:password),
+            option(:user),
+            option(:default_character_set),
+            database_name
+          ]
+          if path =~ /\.gz$/
+            options = ["gunzip", "<", path, "|"].concat(options)
+          end
+
+          command = options.join(" ")
+          system(command)
+        end
+
+        def dump(path, tables = nil)
+          options = [
+            option(:password),
+            option(:user),
+            option(:default_character_set),
+            database_name
+          ]
+          unless tables.nil?
+            options.push(tables.join(" "))
+          end
+
+          options.push( "| gzip") if path =~ /\.gz$/
+
+          command = %(mysqldump #{options.join(" ")} > #{path} )
+          system(command)
+        end
+
+        def database_name
+          @database.opts[:database]
+        end
+
+        def user
+          @database.opts[:user]
+        end
+
+        def password
+          @database.opts[:password]
+        end
+
+        def default_character_set
+          "UTF8"
+        end
+
+        def option(option, add_if_nil=false)
+          value = self.send(option)
+          if !value.nil? or add_if_nil
+            "--#{option.to_s.gsub(/_/, '-')}=#{value}"
+          else
+            ""
+          end
+        end
+      end
+
+      class DumpTask < ::Thor::Group
+        protected
+
+        def db_adapter
+          dumper_class = \
+            case database
+            when ::Sequel::Mysql2::Database
+              MySQL
+            else
+              raise "Unsupported adapter #{database.class}"
+            end
+
+          unless dumper_class.nil?
+            dumper = dumper_class.new(database)
+          end
+        end
+
+        def sqldump(path)
+          db_adapter.dump(path)
+        end
+
+        def sqlload(path)
+          db_adapter.load(path)
+        end
+
+        def id
+          @id ||= Time.now.strftime("%Y%m%d%H%M%S")
+        end
+
+        def media_archive
+          dump_path / "media.tgz"
+        end
+
+        def database_dumpfile
+          dump_path / "database.mysql.gz"
+        end
+
+        def database
+          Spontaneous.database
+        end
+
+        def dump_path
+          dump_root / id
+        end
+
+        def dump_root
+          Spontaneous.cache_dir('dump')
+        end
+
+        def relative_dir(path)
+          path = Pathname.new(path)
+          path.relative_path_from(Pathname.new(Spontaneous.root)).to_s
+        end
+      end
+
+      class Dump < DumpTask
+        def create_dump_dir
+          ::FileUtils.mkdir_p(dump_path)
+        end
+
+        def dump_database
+          say "Creating media archive at '#{relative_dir(database_dumpfile)}'", :green
+          sqldump(database_dumpfile)
+        end
+
+        def archive_media
+          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
+        def find_latest_dump
+          root = Pathname.new(dump_root)
+          @id = root.entries.
+            reject { |dir| dir.file? or dir.basename.to_s =~ /^\./ }.
+            map { |p| p.to_s }.
+            sort.
+            last
+        end
+
+        def import_db_data
+          say "Importing database from '#{relative_dir(database_dumpfile)}'", :green
+          sqlload(database_dumpfile)
+        end
+
+        def extract_media
+          say "Extracting media from '#{relative_dir(media_archive)}'", :green
+          cmd = %(tar xzf #{media_archive})
+          system(cmd)
+        end
+      end
+
+      desc "#{namespace}:dump", "Dumps the current site to an archive on the local machine"
+      def dump
+        prepare :dump
+        boot!
+        Dump.start
+      end
+
+      desc "#{namespace}:load", "Uploads a dump of the current site to a remote server"
+      def load
+        prepare :load
+        boot!
+        Load.start
+      end
+
       desc "#{namespace}:publish", "Publishes the site"
       method_option :changes, :type => :array, :desc => "List of changesets to include"
       method_option :logfile, :type => :string, :desc => "Location of logfile"
-
       def publish
         prepare :publish
         # TODO: set up logging