spontaneous 0.1.0.alpha1

data/lib/spontaneous/schema/uid.rb

@@ -0,0 +1,221 @@
+# encoding: UTF-8
+
+
+require 'base58'
+
+module Spontaneous
+  module Schema
+    class UID
+      @@instance_lock  = Mutex.new
+      @@uid_lock  = Mutex.new
+      @@uid_index = 0
+      @@instances = {}
+
+      extend Enumerable
+      include Comparable
+
+      def self.load(id, reference)
+        @@instance_lock.synchronize do
+          unless instance = @@instances[id]
+            instance = self.new(id, reference)
+            # check to make sure that the uid is valid first
+            # this ensures that UIDs are not created before their owners
+            # have uids
+            if instance.valid?
+              @@instances[id] = instance
+            else
+              instance = nil
+            end
+          end
+          instance
+        end
+      end
+
+      def self.create(reference)
+        unless instance = @@instances.values.detect { |i| i.reference == reference }
+          instance = self.load(generate(reference), reference)
+        end
+        instance
+      end
+
+      def existing_references
+        @@instances.values.map { |i| i.reference }
+      end
+
+      def self.create_for(obj)
+        create(obj.schema_name)
+      end
+
+      def self.destroy(uid)
+        @@instance_lock.synchronize do
+          @@instances.delete(uid.to_s)
+          uid.after_destroy
+        end
+      end
+
+      def self.clear!
+        @@instances = {}
+      end
+
+      def self.[](id)
+        return id if self === id
+        return nil if id.blank?
+        @@instances[id]
+      end
+
+      def self.get_id(reference)
+        self.find { |uid| uid.reference == reference }
+      end
+
+      def self.each
+        uids = @@instances.map { |id, instance| instance }
+        if block_given?
+          uids.each { |instance| yield(instance) }
+        else
+          uids.each
+        end
+      end
+
+      def self.get_inc
+        @@uid_lock.synchronize do
+          @@uid_index = (@@uid_index + 1) % 0xFFFF
+        end
+      end
+
+      def self.generate(ref = nil)
+        generate58(ref)
+      end
+
+      def self.generate58(ref)
+        # reverse the time so that sequential ids are more obviously different
+        oid =  Base58.encode((Time.now.to_f * 1000).to_i).reverse
+        oid << Base58.encode(get_inc).rjust(3, '0')
+      end
+
+      def self.generate16(ref)
+        oid = ''
+        # 4 bytes current time
+        oid = (Time.now.to_f * 1000).to_i.to_s(16)
+        # 2 bytes inc
+        oid << get_inc.to_s(16).rjust(4, '0')
+      end
+
+      def self.export
+        Hash[ @@instances.map { |id, ref| [id, ref.reference] } ]
+      end
+
+      REFERENCE_SEP = "/".freeze
+
+      attr_reader :reference, :name, :category
+
+      def initialize(id, reference)
+        @id = id.freeze
+        read_reference(reference)
+      end
+
+      def read_reference(reference)
+        @reference = reference
+        @category, @owner_sid, @name = reference.split(REFERENCE_SEP)
+        @category = @category.to_sym
+      end
+
+      class << self
+        protected :new
+      end
+
+      def destroy
+        self.class.destroy(self)
+      end
+
+      def after_destroy
+        case @category
+        when :box
+          Spontaneous::Content.filter(:box_sid  => @id).delete
+        end
+      end
+
+      def rewrite!(target)
+        target = target.schema_name if target.respond_to?(:schema_name)
+        read_reference(target)
+        @target = nil
+      end
+
+      def target
+        @target ||= find_target
+      end
+
+      def valid?
+        case @category
+        when :type
+          true
+        else
+          owner_sid
+        end
+      end
+
+      def orphaned?
+        target.nil?
+      end
+
+      def find_target
+        case @category
+        when :type
+          begin
+            @name.constantize
+          rescue NameError => e
+            nil
+          end
+        else
+          if owner
+            prototypes = \
+              case @category
+              when :box
+                owner.box_prototypes
+              when :field
+                owner.field_prototypes
+              when :style
+                owner.style_prototypes
+              when :layout
+                owner.layout_prototypes
+              end
+            prototypes[name.to_sym]
+          else
+            nil
+          end
+        end
+      end
+
+      def owner
+        return nil if owner_sid.nil?
+        owner_sid.target
+      end
+
+      alias_method :schema_owner, :owner
+
+      def owner_sid
+        self.class[@owner_sid]
+      end
+
+      def ==(obj)
+        super or obj == @id
+      end
+
+      def hash
+        @id.hash
+      end
+
+      def to_s
+        @id
+      end
+
+      def <=>(other)
+        self.to_s <=> other.to_s
+      end
+
+      def inspect
+        %(#<#{self.class}:"#{@id}" => "#{reference}">)
+      end
+    end
+
+  end
+end

data/lib/spontaneous/schema.rb

@@ -0,0 +1,295 @@
+# encoding: UTF-8
+
+
+
+module Spontaneous
+  module Schema
+    autoload :UID, 'spontaneous/schema/uid'
+    autoload :SchemaModification, 'spontaneous/schema/schema_modification'
+    # schema class <=> uid map backed by a file
+    class PersistentMap
+      attr_reader :map, :inverse_map
+
+      def initialize(path)
+        @path = path
+        load_map
+      end
+
+      def schema_id(obj)
+        reference_to_id(obj.schema_name)
+      end
+
+      def reference_to_id(reference)
+        UID.get_id(reference)
+      end
+
+      def [](id)
+        if uid = UID[id]
+          uid.target
+        else
+          nil
+        end
+      end
+
+      def load_map
+        if exists?
+          map = YAML.load_file(@path)
+          map.each do | uid, reference |
+            UID.load(uid, reference)
+          end
+        end
+      end
+
+      def exists?
+        ::File.exists?(@path)
+      end
+
+      # def invert_map
+      #   @inverse_map = generate_inverse
+      # end
+
+      # def generate_inverse
+      #   Hash[ UID.map { |uid| [uid.reference, uid]} ]
+      # end
+
+      def orphaned_ids
+        UID.select { |uid| uid.orphaned? }
+      end
+
+      def reload!
+        # invert_map
+      end
+    end
+
+    # schema class <=> uid map with no backing, each run will generate different uids and
+    # no schema validation errors will ever be thrown
+    # used for tests
+    class TransientMap < PersistentMap
+
+      def initialize(path)
+      end
+
+      def schema_id(obj)
+        if id = super
+          id
+        else
+          UID.create(obj.schema_name)
+        end
+      end
+
+      def orphaned_ids
+        []
+      end
+
+      def exists?
+        true
+      end
+    end
+
+    class << self
+      def schema_loader_class
+        @schema_loader_class ||= PersistentMap
+      end
+
+      def schema_loader_class=(klass)
+        UID.clear!
+        @map = nil
+        @schema_loader_class = klass
+      end
+
+      # validate the schema & attempt to fix anything that can be resolved without human
+      # interaction (i.e. pure additions)
+      def validate!
+        begin
+          validate_schema
+        rescue Spontaneous::SchemaModificationError => e
+          changes = e.modification
+          # if the map file is missing, then this is a first run and we can just
+          # create the thing by populating it with the current schema
+          if !map.exists?
+            logger.warn("Generating new schema")
+            generate_new_schema
+          else
+            if changes.resolvable?
+              logger.warn("Schema changed...")
+              while changes and changes.resolvable? do
+                logger.warn("Fixing automatically")
+                changes.resolve!
+                map.reload!
+                changes = perform_validation
+              end
+              write_schema
+              reload!
+            else
+              logger.warn("Unable to resolve schema changes")
+              raise e
+            end
+          end
+        end
+      end
+
+      def apply(action)
+        apply_fix(action.action, action.source, action.dest)
+      end
+
+      def apply_fix(action, source, dest=nil)
+        uid = S::Schema::UID[source]
+        case action
+        when :delete
+          uid.destroy
+        when :rename
+          uid.rewrite!(dest)
+        end
+        write_schema
+        reload!
+        validate!
+      end
+
+      def generate_new_schema
+        logger.info("Generating new schema map at #{schema_map_file}")
+        self.schema_loader_class = TransientMap
+        classes.each do | schema_class |
+          generate_schema_for(schema_class)
+        end
+        write_schema
+        self.schema_loader_class = PersistentMap
+      end
+
+      def write_schema
+        File.atomic_write(schema_map_file) do |file|
+          file.write(UID.export.to_yaml)
+        end
+      end
+
+      def generate_schema_for(obj)
+        UID.create_for(obj)
+        [:boxes, :fields, :styles, :layouts].each do |category|
+          if obj.respond_to?(category)
+            objects = obj.send(category)
+            objects.each do | c |
+              generate_schema_for(c)
+            end
+          end
+        end
+      end
+
+      # look for differences between identities found in schema map and
+      # those defined in the schema classes and raise an error if any
+      # are found
+      def validate_schema
+        modification = perform_validation
+        unless modification.nil?
+          raise Spontaneous::SchemaModificationError.new(modification)
+        end
+      end
+
+      def perform_validation
+        modification = nil
+        @missing_from_map = Hash.new { |hash, key| hash[key] = [] }
+        @missing_from_schema = []
+        validate_classes
+
+        unless @missing_from_map.empty? and @missing_from_schema.empty?
+          modification = SchemaModification.new(@missing_from_map, @missing_from_schema)
+        end
+        modification
+      end
+
+      def validate_classes
+        # will check that each of the classes in the schema has a
+        # corresponding id
+        self.classes.each do | schema_class |
+          schema_class.schema_validate
+        end
+
+        # now check that each of the ids in the map has a
+        # corresponding entry in the schema
+        find_orphaned_ids
+      end
+
+      def find_orphaned_ids
+        map.orphaned_ids.each do |uid|
+          @missing_from_schema << uid
+        end
+      end
+
+      def missing_id!(category, obj)
+        @missing_from_map[category] << obj
+      end
+
+
+      def export
+        self.content_classes.inject({}) do |hash, klass|
+          hash[klass.name] = klass.export
+          hash
+        end
+      end
+
+      def serialise_http
+        Spontaneous.serialise_http(export)
+      end
+
+      # all classes including boxes
+      def classes
+        @classes ||= []
+      end
+
+      # just subclasses of Content (excluding boxes)
+      # only need this for the serialisation (which doesn't include boxes)
+      def content_classes
+        classes = []
+        Content.subclasses.each do |klass|
+          classes << klass unless [Spontaneous::Page, Spontaneous::Piece].include?(klass)
+          recurse_classes(klass, classes)
+        end
+        classes.uniq
+      end
+
+      def recurse_classes(root_class, list)
+        root_class.subclasses.each do |klass|
+          list << klass unless list.include?(klass)
+          recurse_classes(klass, list)
+        end
+      end
+
+      # should only be used in tests
+      def reset!
+        Content.schema_reset!
+        @classes = []
+        reload!
+      end
+
+      def reload!
+        @map = nil
+        UID.clear!
+      end
+
+      def delete(klass)
+        classes.delete(klass)
+      end
+
+      def schema_map_file
+        @schema_map_file ||= Spontaneous.root / "config" / "schema.yml"
+      end
+
+      def schema_map_file=(path)
+        # force a reloading of the schema map
+        @map = nil
+        @schema_map_file = path
+      end
+
+      def map
+        @map ||= self.schema_loader_class.new(schema_map_file)
+      end
+
+      def schema_id(obj)
+        map.schema_id(obj)
+      end
+
+      def [](schema_id)
+        map[schema_id]
+      end
+    end
+  end
+end
+

data/lib/spontaneous/server.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+# Rack::Handler.register('unicorn', 'Unicorn') if defined?(Unicorn)
+
+## thanks again to the stirling work of the Padrino guys & gals.
+module Spontaneous
+
+  module Server
+
+    Handlers = %w[thin mongrel webrick] unless const_defined?(:Handlers)
+
+
+    def self.run!(options={})
+      host = options["host"] || Site.config.host || "0.0.0.0"
+      port = options["port"] || Site.config.port || 2012
+      adapter = options["adapter"] || Site.config.adapter
+
+      handler = nil
+
+      if adapter
+        begin
+          handler = ::Rack::Handler.get(adapter.downcase)
+        rescue => e
+          puts e
+          puts e.backtrace
+          raise LoadError, "Rack handler #{adapter} not supported. Please use one of #{Handlers.join(', ')}"
+          exit
+        end
+      else
+        handler = detect_handler
+      end
+      puts "=> Spontaneous:#{Spontaneous.mode.to_s.ljust(5, " ")} running on port #{host}:#{port} (PID #{$$})"
+
+      handler.run Spontaneous::Rack.application.to_app, :Host => host, :Port => port do |server|
+        term = Proc.new do
+          server.respond_to?(:stop!) ? server.stop! : server.stop
+          puts "=> Spontaneous:#{Spontaneous.mode.to_s.ljust(5, " ")} exiting..."
+        end
+        trap(:INT, &term)
+        trap(:TERM, &term)
+      end
+    rescue RuntimeError => e
+      if e.message =~ /no acceptor/
+        puts "=> Unable to run server, port #{port} is already in use"
+      else
+        raise e
+      end
+    rescue Errno::EADDRINUSE
+      puts "=> Unable to run server,  port #{port} is already in use"
+    end
+
+    def self.detect_handler
+      Handlers.each do |handler_name|
+        begin
+          return ::Rack::Handler.get(handler_name.downcase)
+        rescue Exception => e
+          puts e
+          puts e.backtrace
+        end
+      end
+      raise LoadError, "No handlers available: #{Handlers.join(', ')}"
+    end
+  end # Server
+end # Spontaneous
+

data/lib/spontaneous/site.rb

@@ -0,0 +1,87 @@
+# encoding: UTF-8
+
+module Spontaneous
+  class Site < Spontaneous::Facet
+    extend Plugins
+
+    plugin Plugins::Site::Instance
+    plugin Plugins::Site::Publishing
+    plugin Plugins::Site::Revisions
+    plugin Plugins::Site::Selectors
+    plugin Plugins::Site::Map
+
+    attr_accessor :database
+    attr_reader :environment, :mode
+
+    def initialize(root, env, mode)
+      super(root)
+      @environment, @mode = env, mode
+    end
+
+    def initialize!
+      load_config!
+      connect_to_database!
+      find_plugins!
+      load_facets!
+      init_facets!
+    end
+
+    def init_facets!
+      facets.each do |facet|
+        facet.init!
+      end
+    end
+
+    def load_facets!
+      Spontaneous::Loader.load!
+    end
+
+    def load_paths
+      load_paths = []
+      [:lib, :schema].each do |category|
+        facets.each do |facet|
+          load_paths += facet.paths.expanded(category)
+        end
+      end
+      load_paths
+    end
+
+    def connect_to_database!
+      self.database = Sequel.connect(db_settings)
+      self.database.logger = logger if config.log_queries
+    end
+
+    def db_settings
+      config_dir = paths.expanded(:config).first
+      @db_settings = YAML.load_file(File.join(config_dir, "database.yml"))
+      self.config.db = @db_settings[environment]
+    end
+
+    def config
+      @config ||= Spontaneous::Config.new(environment, mode)
+    end
+
+    def find_plugins!
+      paths.expanded(:plugins).each do |glob|
+        Dir[glob].each do |path|
+          load_plugin(path)
+        end
+      end
+    end
+
+    def plugins
+      @plugins ||= []
+    end
+
+    def facets
+      [self] + plugins
+    end
+
+    def load_plugin(plugin_root)
+      plugin = Spontaneous::Application::Plugin.new(plugin_root)
+      self.plugins <<  plugin
+      plugin
+    end
+
+  end
+end

data/lib/spontaneous/state.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  class State <  Sequel::Model(:spontaneous_state)
+    class << self
+      alias_method :sequel_plugin, :plugin
+    end
+
+
+    @@instance = nil
+
+    class << self
+
+      def instance
+        return @@instance if @@instance
+        unless instance = self.first
+          instance = State.create(:revision => 1, :published_revision => 0)
+        end
+        instance
+      end
+
+      # def with_cache(&block)
+      #   yield if @@instance
+      #   @@instance = self.instance
+      #   yield
+      # ensure
+      #   @@instance = nil
+      # end
+
+      def working_revision
+        instance.revision
+      end
+
+      def revision
+        instance.revision
+      end
+
+      def published_revision
+        if ENV.key?(Spontaneous::SPOT_REVISION_NUMBER)
+          ENV[Spontaneous::SPOT_REVISION_NUMBER]
+        else
+          instance.published_revision
+        end
+      end
+
+      def pending_revision
+        instance.pending_revision
+      end
+
+    end
+  end
+end