spontaneous 0.1.0.alpha1

data/lib/spontaneous/change.rb

@@ -0,0 +1,107 @@
+# encoding: UTF-8
+
+module Spontaneous
+  class Change < Sequel::Model(:changes)
+    class << self
+      alias_method :sequel_plugin, :plugin
+    end
+
+    sequel_plugin :yajl_serialization, :modified_list
+
+    @@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
+      end
+
+      def outstanding
+        dependencies = dependency_map
+        dependencies.map { |d| Spontaneous::Collections::ChangeSet.new(d) }
+      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
+      end
+
+      def valid
+        invalid, valid = self.all.partition { |change| change.modified.empty? }
+        self.filter(:id => invalid.map { |change| change.id }).delete
+        valid
+      end
+
+      def export
+        outstanding.map { |change_set| change_set.export }
+      end
+
+      def serialise_http
+        Spontaneous.serialise_http(export)
+      end
+    end
+
+
+    def after_initialize
+      super
+      self.modified_list ||= []
+    end
+
+    def push(page)
+      self.modified_list << page.id
+    end
+
+    def before_update
+      self.modified_list.uniq!
+    end
+
+    def modified
+      @modified ||= modified_list.map { |id| Content[id] }.compact
+    end
+
+    alias_method :pages, :modified
+
+    def &(change)
+      self.modified_list & change.modified_list
+    end
+
+    def export
+      {
+        :id => self.id,
+        :created_at => self.created_at.to_s,
+        :page_ids => modified_list
+      }
+    end
+  end
+end

data/lib/spontaneous/cli/adapter.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Cli
+    module Adapter
+      class << self
+        def start(options)
+          ::Spontaneous::Server.run!(options)
+        end
+      end
+    end # Adapter
+  end # Cli
+end # Spontaneous

data/lib/spontaneous/cli/base.rb

@@ -0,0 +1,184 @@
+require 'thor'
+
+module Spontaneous
+  module Cli
+    class Base < ::Spontaneous::Cli::Thor
+      Spontaneous = ::Spontaneous
+      include Thor::Actions
+      namespace :default
+
+      class InvalidGenerator < Error
+        attr_reader :name
+        def initialize(name)
+          @name = name
+          super()
+        end
+      end
+
+
+
+
+
+
+
+      desc :console, "Gives you console access to the current site"
+      def console
+        ENV["SPOT_MODE"] = "console"
+        prepare :console
+        ARGV.clear
+        require 'irb'
+        boot!
+        IRB.setup(nil)
+        irb = IRB::Irb.new
+        IRB.conf[:MAIN_CONTEXT] = irb.context
+        irb.context.evaluate("require 'irb/completion'", 0)
+        irb.context.evaluate("require '#{File.expand_path(File.dirname(__FILE__) + '/console')}'", 0)
+        # irb.context.evaluate("include Spontaneous", 0)
+        trap("SIGINT") do
+          irb.signal_handle
+        end
+        catch(:IRB_EXIT) do
+          irb.eval_input
+        end
+      end
+
+      desc :generate, "Executes the Spontaneous generator with given options."
+      def generate(*args)
+        require File.expand_path('../../../spontaneous', __FILE__)
+        ARGV.shift
+        generator_name = ARGV.shift
+        generator = nil
+        d = Spontaneous::Generators
+        case generator_name
+        when ''
+          raise InvalidGenerator.new(generator_name)
+        when 'site'
+          generator = d::Site
+        when 'page'
+          prepare(:generator)
+          boot!
+          generator = d::Page
+        when /[a-zA-Z0-9-]+(\.[a-z]+)+/
+          # generator called as 'spot generate domain.com'
+          ARGV.unshift(generator_name)
+          generator = d::Site
+        else
+          raise InvalidGenerator.new(generator_name)
+        end
+        generator.start(ARGV) if generator
+      rescue InvalidGenerator => e
+        say "Unrecognised generator '#{e.name}'. Available options are:\n\n  #{available_generators.join("\n  ")}\n"
+      end
+
+      desc :browse, "Launces a browser pointing to the current development CMS"
+      def browse
+        prepare :browse
+        require 'launchy'
+        boot!
+        ::Launchy::Browser.run("http://localhost:#{Site.config.port}/@spontaneous")
+      end
+
+
+      desc :init, "Creates databases and initialises a new Spontaneous site"
+      def init
+        prepare :init
+        require File.expand_path('../../../spontaneous', __FILE__)
+        Sequel.extension :migration
+        connection_params = Spontaneous.db_settings
+        connection_params[:user] = 'root'
+        database = connection_params.delete(:database)
+        password = connection_params.delete(:password)
+        catch(:error) do
+          Sequel.connect(connection_params) do |connection|
+            ["", "_test"].map { |ext| "#{database}#{ext}"}.each do |db|
+              begin
+                say "  >> Creating database `#{db}`"
+                connection.run("CREATE DATABASE `#{db}` CHARACTER SET UTF8")
+              rescue => e
+                say " >>> Unable to create #{connection_params[:adapter]} database `#{db}`:\n   > #{e}", :red
+                # throw :error
+              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
+
+      desc :migrate, "Runs migrations"
+      def migrate
+        prepare :init
+        boot!
+        Sequel.extension :migration
+        connection_params = Spontaneous.db_settings
+        say "  >> Running migrations..."
+        Sequel::Migrator.apply(Spontaneous.database, Spontaneous.gem_dir('db/migrations'))
+        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
+
+
+      def available_generators
+        Spontaneous::Generators.available.map do |g|
+          g.name.demodulize.underscore
+        end
+      end
+
+
+
+
+    end # Base
+  end # Cli
+end # Spontaneous

data/lib/spontaneous/cli/media.rb

@@ -0,0 +1,13 @@
+
+module Spontaneous
+  module Cli
+    class Media < ::Thor
+      namespace :media
+
+      desc "#{namespace}:cleanup", "Removes stale temp files"
+      def cleanup
+        puts "CLEANING UP!!"
+      end
+    end
+  end
+end

data/lib/spontaneous/cli/server.rb

@@ -0,0 +1,50 @@
+
+module Spontaneous
+  module Cli
+    class Server < ::Spontaneous::Cli::Thor
+      namespace :server
+
+      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
+
+
+      desc "#{namespace}:front", "Starts Spontaneous in front/public mode"
+      # method_option :adapter, :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
+      method_option :host, :type => :string,  :aliases => "-h", :desc => "Bind to HOST address"
+      method_option :port, :type => :numeric, :aliases => "-p", :desc => "Use PORT"
+      def front
+        start_server(:front)
+      end
+
+      desc "#{namespace}:back", "Starts Spontaneous in back/CMS mode"
+      # method_option :adapter, :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
+      method_option :host, :type => :string,  :aliases => "-h", :desc => "Bind to HOST address"
+      method_option :port, :type => :numeric, :aliases => "-p", :desc => "Use PORT"
+      def back
+        start_server(:back)
+      end
+
+      private
+
+      def start_server(mode)
+        prepare mode.to_sym
+        ENV["SPOT_MODE"] = mode.to_s
+        require File.expand_path(File.dirname(__FILE__) + "/adapter")
+        boot!
+        Spontaneous::Cli::Adapter.start(options)
+      end
+
+    end
+  end
+end
+

data/lib/spontaneous/cli/site.rb

@@ -0,0 +1,46 @@
+
+module Spontaneous
+  module Cli
+    class Site < ::Spontaneous::Cli::Thor
+      Spontaneous = ::Spontaneous
+      namespace :site
+
+      default_task :browse
+
+      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
+        boot!
+        ::Site.publishing_method = :immediate
+        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)
+        else
+          say ">  Publishing all", :green, true
+          ::Site.publish_all
+        end
+      end
+
+      desc "#{namespace}:revision", "Shows the site status"
+      def revision
+        prepare :revision
+        boot!
+        say "Site is at revision #{::Site.revision}", :green
+      end
+
+      desc "#{namespace}:browse", "Launces a browser pointing to the current development CMS"
+      def browse
+        prepare :browse
+        require 'launchy'
+        boot!
+        ::Launchy::Browser.run("http://localhost:#{::Site.config.port}/@spontaneous")
+      end
+    end
+  end
+end

data/lib/spontaneous/cli/sync.rb

@@ -0,0 +1,42 @@
+
+module Spontaneous
+  module Cli
+    class Sync < ::Spontaneous::Cli::Thor
+      Spontaneous = ::Spontaneous
+      namespace :sync
+      default_task :down
+
+      class SyncTask < ::Thor::Group
+        protected
+
+        def arse(n)
+          puts 'arse '+n
+        end
+      end
+
+      class Down < SyncTask
+        desc "Syncs down"
+        def one
+          arse('one')
+        end
+        def two
+          arse('two')
+        end
+      end
+
+      class Up < SyncTask
+        desc "Syncs up"
+      end
+
+      desc "#{namespace}:down", "Makes the local copy a clone of the live server"
+      def down
+        Down.start
+      end
+
+      desc "#{namespace}:up", "Makes the local copy a clone of the live server"
+      def up
+        Down.start
+      end
+    end
+  end
+end

data/lib/spontaneous/cli/tasks.rb

@@ -0,0 +1,9 @@
+require 'thor'
+
+module Spontaneous
+  # class Cli
+    # module Tasks
+    # end
+  # end
+end
+

data/lib/spontaneous/cli.rb

@@ -0,0 +1,83 @@
+require 'thor'
+require 'thor/runner'
+
+module Spontaneous
+  module Cli
+    class Thor < ::Thor
+
+      class_option :site, :type => :string, :aliases => ["-s", "--root"], :desc => "Site root dir"
+      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!
+        begin
+          require File.expand_path('config/boot.rb')
+        rescue Spontaneous::SchemaModificationError => error
+          fix_schema(error)
+        end
+      end
+
+      def fix_schema(error)
+        modification = error.modification
+        actions = modification.actions
+        say(actions.description, :red)
+        say("Please choose one of the solutions below", :yellow)
+        actions.each_with_index do |a, i|
+          say("  #{i+1}: #{a.description}")
+        end
+        choice = ( ask "Choose action : ").to_i rescue nil
+        if choice and choice <= actions.length and choice > 0
+          action = actions[choice - 1]
+          begin
+            Spontaneous::Schema.apply(action)
+          rescue Spontaneous::SchemaModificationError => error
+            fix_schema(error)
+          end
+        else
+          say("Invalid choice '#{choice.inspect}'\n", :red)
+          fix_schema(error)
+        end
+      end
+
+      def prepare(task)
+        if options.help?
+          help(task.to_s)
+          raise SystemExit
+        end
+        ENV["SPOT_ENV"] ||= options.environment.to_s
+        ENV["RACK_ENV"] = ENV["SPOT_ENV"] # Also set this for middleware
+        ENV["SPOT_MODE"] ||= options.mode.to_s
+        chdir(options.site)
+        unless File.exist?('config/boot.rb')
+          puts "=> Could not find boot file in: #{options.chdir}/config/boot.rb\n=> Are you sure this is a Spontaneous site?"
+          raise SystemExit
+        end
+      end
+
+      def chdir(dir)
+        return unless dir
+        begin
+          Dir.chdir(dir.to_s)
+        rescue Errno::ENOENT
+          puts "=> Specified site '#{dir}' does not appear to exist"
+        rescue Errno::EACCES
+          puts "=> Specified site '#{dir}' cannot be accessed by the current user"
+        end
+      end
+    end
+
+    class Runner < ::Thor::Runner
+      remove_task :install#, :undefine => true
+
+      private
+
+      def thorfiles(*args)
+        task_dir = File.expand_path('../cli', __FILE__)
+        Dir["#{task_dir}/*.rb"]
+      end
+    end
+  end
+end
+

data/lib/spontaneous/collections/box_set.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Collections
+  class BoxSet < PrototypeSet
+
+    attr_reader :owner
+
+    def initialize(owner)
+      super()
+      @owner = owner
+      initialize_from_prototypes
+    end
+
+    def initialize_from_prototypes
+      owner.class.boxes.each do |box_prototype|
+        box = box_prototype.get_instance(owner)
+        add_box(box)
+      end
+    end
+
+    alias_method :get_without_ranges, :[]
+
+    def [](*args)
+      if args.length == 1
+        get_single(args[0])
+      else
+        args.map { |index| get_single(index) }.flatten
+      end
+    end
+
+    def export
+      self.map { |item| item.export }
+    end
+
+    protected
+
+    def get_single(index)
+      case index
+      when Range
+        order[index].map { | name | named(name) }
+      else
+        get_without_ranges(index)
+      end
+    end
+
+    def add_box(box)
+      self[box._prototype.name] = box
+      getter_name = box._prototype.name
+      singleton_class.class_eval do
+        define_method(getter_name) { |*args| box.tap { |b| b.template_params = args } }
+      end
+    end
+  end
+end
+

data/lib/spontaneous/collections/change_set.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+
+module Spontaneous::Collections
+  class ChangeSet
+    attr_reader :changes
+
+    def initialize(changes)
+      @changes = changes.map do |change_or_id|
+        change_or_id.is_a?(Spontaneous::Change) ? change_or_id : Spontaneous::Change[change_or_id]
+      end
+    end
+
+    def pages
+      @pages ||= page_ids.map { |id| Spontaneous::Content[id] }
+    end
+
+    def page_ids
+      @page_ids ||= changes.inject([]) { |a, c| a += c.modified_list; a }.uniq.sort
+    end
+
+    def export
+      h = {
+        :changes => changes.map { |c| c.export },
+      }
+      # use compact because it's possible that some pages have been deleted since
+      # the change was created and the best way to deal with them is to silently
+      # ignore them and let the publishing mech delete them as usual
+      h[:pages] = pages.compact.map  do |page|
+        {
+          :id => page.id,
+          :title => page.title.to_s,
+          :path => page.path,
+          :depth => page.depth
+        }
+      end
+      h
+    end
+    # def serialise_http
+    #   Spontaneous.serialise_http(export)
+    # end
+  end
+end
+