spontaneous 0.1.0.alpha1

data/lib/spontaneous/plugins/allowed_types.rb

@@ -0,0 +1,173 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module AllowedTypes
+    class AllowedType
+      attr_accessor :allow_subclasses
+
+      def initialize(type, options={})
+        @type = type
+        @options = options
+        # check_instance_class
+        # check_styles
+      end
+
+      def check_instance_class
+        instance_class
+      end
+
+      def check_styles
+        @options[:styles] = [@options[:style]] if @options.key?(:style)
+        if @options.key?(:styles) and styles = @options[:styles]
+          styles.each do |s|
+            if instance_class.find_named_style(s).nil?
+              raise Spontaneous::UnknownStyleException.new(s, instance_class)
+            end
+          end
+        end
+      end
+
+      def instance_class
+        case @type
+        when Class
+          @type
+        when Symbol, String
+          @type.to_s.constantize
+        end
+      end
+
+      def styles
+        configured_styles || all_styles
+      end
+
+      def configured_styles
+        if (@options.key?(:styles) and styles = @options[:styles]) or \
+          (@options.key?(:style) and styles = [@options[:style]].flatten)
+          styles.map { |s| instance_class.find_named_style(s) }
+        end
+      end
+
+      def includes?(type)
+        if allow_subclasses
+          instance_class.subclasses.include?(type)
+        else
+          instance_class == type
+        end
+      end
+
+      def instance_classes
+        if allow_subclasses
+          instance_class.subclasses
+        else
+          [instance_class]
+        end
+      end
+
+      def all_styles
+        instance_class.styles
+      end
+
+      def default_style
+        styles.first
+      end
+
+      def prototype
+        @options[:prototype]
+      end
+
+      def user_level
+        level = @options[:level] || @options[:user_level] || Spontaneous::Permissions::UserLevel.minimum.to_sym
+        Spontaneous::Permissions[level]
+      end
+
+      def readable?
+        Spontaneous::Permissions.has_level?(user_level)
+      end
+      alias_method :addable?, :readable?
+    end
+
+    module ClassMethods
+      ##
+      # Sets up an allowed type for a particular content type
+      # this determines the list of types that appears in the editing UI
+      #
+      # Parameters:
+      #   type  => A String, Symbol or Class defining the content type that is allowed
+      #
+      # Options:
+      #
+      #   :styles    => The list of (inline) style names that can be used by the pieces
+      #   :prototype => The name of the prototype to use when creating pieces of this type
+      #
+      # TODO: finish these!
+      def allow(type, options={})
+        allowed_types_config << AllowedType.new(type, options)
+      end
+
+      # TODO: implement this in a way that doesn't require searching through constants at load-time
+      def allow_subclasses(type, options = {})
+        parent_type = AllowedType.new(type)
+        parent_type.allow_subclasses = true
+        allowed_types_config << parent_type
+        # parent_type.instance_class.subclasses.each do |subclass|
+        #   allow(subclass, options)
+        # end
+      end
+
+      def allowed_types_config
+        @_allowed_types ||= []
+      end
+
+      def allowed
+        (supertype ? supertype.allowed : []).concat(allowed_types_config)
+      end
+      def allowed_types
+        types = []
+        allowed.each { |a| types.concat(a.instance_classes) }
+        types
+      end
+    end
+
+    module InstanceMethods
+      def allowed
+        self.class.allowed
+      end
+
+      def allowed_types
+        self.class.allowed_types
+      end
+
+      def allowed_type(content)
+        klass = content.is_a?(Class) ? content : content.class
+        self.class.allowed.find { |a| a.includes?(klass) }
+      end
+
+      def prototype_for_content(content, box = nil)
+        if allowed = allowed_type(content)
+          allowed.prototype
+        else
+          nil
+        end
+      end
+
+      # TODO: BOXES remove box reference here
+      def style_for_content(content, box = nil)
+        if allowed = allowed_type(content)
+          allowed.default_style
+        else
+          content.default_style
+        end
+      end
+
+      def available_styles(content)
+        if allowed = allowed_type(content)
+          allowed.styles
+        else
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/application/facets.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins::Application
+  module Facets
+    module ClassMethods
+      def instance
+        @instance ||= nil
+      end
+
+      def instance=(instance)
+        # unless @instance
+        @instance = instance
+          # facets << instance
+        # end
+      end
+
+      def facets
+        Spontaneous::Site.instance.facets
+      end
+
+    end
+  end
+end
+

data/lib/spontaneous/plugins/application/paths.rb

@@ -0,0 +1,137 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins::Application
+  module Paths
+
+    def self.configure(base)
+    end
+
+    module ClassMethods
+      def load_paths
+        Spontaneous.instance.load_paths
+      end
+
+      def template_paths
+        paths = []
+        Spontaneous.facets.each do |facet|
+          paths += facet.paths.expanded(:templates)
+        end
+        paths
+      end
+
+      def log_dir(*path)
+        relative_dir(root / "log", *path)
+      end
+
+      def config_dir(*path)
+        relative_dir(root / "config", *path)
+      end
+
+      def template_root=(template_root)
+        Spot::Render.template_root = template_root.nil? ? nil : File.expand_path(template_root)
+      end
+
+      def template_root(*path)
+        relative_dir(Spot::Render.template_root, *path)
+      end
+
+      def template_path(*args)
+        File.join(template_root, *args)
+      end
+
+      def schema_root=(schema_root)
+        @schema_root = schema_root
+      end
+
+      def schema_root(*path)
+        @schema_root ||= root / "schema"
+        relative_dir(@schema_root, *path)
+      end
+
+      def schema_map
+        Spontaneous::Schema.schema_map_file
+      end
+
+      def schema_map=(path)
+        Spontaneous::Schema.schema_map_file = path
+      end
+
+      def media_dir=(dir)
+        @media_dir = File.expand_path(dir)
+      end
+
+      def media_dir(*path)
+        @media_dir ||= File.expand_path(root / "cache/media")
+        relative_dir(@media_dir, *path)
+      end
+
+      def media_path(*args)
+        Spontaneous::Media.media_path(*args)
+      end
+
+      def shard_path(hash=nil)
+        if hash
+          path = ['tmp', hash[0..1], hash[2..3], hash]
+          Spontaneous::Media.media_path(*path).tap do |path|
+            ::FileUtils.mkdir_p(::File.dirname(path))
+          end
+        else
+          Spontaneous::Media.media_path('tmp')
+        end
+      end
+
+      def root(*path)
+        @root ||= File.expand_path(ENV[Spontaneous::SPOT_ROOT] || Dir.pwd)
+        relative_dir(@root, *path)
+      end
+
+      def root=(root)
+        @root = File.expand_path(root)
+      end
+
+      def revision_root(*path)
+        @revision_dir ||= File.expand_path(root / 'cache/revisions')
+        relative_dir(@revision_dir, *path)
+      end
+
+      def revision_root=(revision_dir)
+        @revision_dir = File.expand_path(revision_dir)
+      end
+
+      def revision_dir(revision=nil, root = revision_root)
+        return root / 'current' if revision.nil?
+        root / revision.to_s.rjust(5, "0")
+      end
+
+      def gem_dir(*path)
+        relative_dir(Spontaneous.gem_root, *path)
+      end
+
+      def application_dir(*path)
+        @application_dir ||= File.expand_path("application", Spontaneous.gem_root)
+        relative_dir(@application_dir, *path)
+      end
+
+      def static_dir(*path)
+        application_dir / "static"
+        relative_dir(application_dir / "static", *path)
+      end
+
+      def js_dir(*path)
+        relative_dir(application_dir / "js", *path)
+      end
+
+      def css_dir(*path)
+        relative_dir(application_dir / "css", *path)
+      end
+
+      private
+
+      def relative_dir(root, *path)
+        File.join(root, *path)
+      end
+    end # ClassMethods
+  end # Paths
+end
+

data/lib/spontaneous/plugins/application/render.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+
+require 'cutaneous'
+
+module Spontaneous::Plugins::Application
+  module Render
+
+    def self.configure(base)
+    end
+
+    module ClassMethods
+      attr_accessor :render_engine
+
+      def template_ext
+        template_engine.extension
+      end
+
+      def template_engine
+        @template_engine ||= Cutaneous
+      end
+
+      def template_engine=(engine)
+        @template_engine = engine
+      end
+    end # ClassMethods
+  end # Render
+end # Spontaneous::Plugins::Application
+

data/lib/spontaneous/plugins/application/serialisation.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins::Application
+  module Serialisation
+    module ClassMethods
+      include Spontaneous::JSON
+      def serialise_http(object)
+        encode_json(object)
+      end
+
+      def deserialise_http(serialised_object)
+        decode_json(serialised_object)
+      end
+    end
+  end
+end

data/lib/spontaneous/plugins/application/state.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins::Application
+  module State
+
+    def self.configure(base)
+    end
+
+    module ClassMethods
+
+      def init(options={})
+        # return false if loaded?
+        self.environment = (options.delete(:environment) || ENV["SPOT_ENV"] || :development)
+        self.mode = options.delete(:mode) || ENV["SPOT_MODE"] || :back
+        Spontaneous::Logger.setup(:log_level => options[:log_level], :logfile => options[:logfile], :cli => options[:cli])
+        Spontaneous.instance = Spontaneous::Site.instantiate(root, environment, mode)
+        Spontaneous.instance.initialize!
+        Spontaneous::Schema.validate! if self.mode == :console
+        Thread.current[:spontaneous_loaded] = true
+      end
+
+      def loaded?
+        Thread.current[:spontaneous_loaded]
+      end
+
+
+      def config
+        Spontaneous::Site.instance.config
+      end
+
+      def db_settings
+        YAML.load_file(root /  "config/database.yml")[environment]
+      end
+
+      def database
+        Spontaneous::Site.instance.database
+      end
+
+      def database=(database)
+        Spontaneous::Site.instance.database = database
+      end
+
+      def mode=(mode)
+        @mode = mode.to_sym
+      end
+
+      def mode
+        @mode
+      end
+
+      def front?
+        mode == :front
+      end
+
+      def back?
+        mode == :back
+      end
+
+      def environment=(env)
+        @environment = env.to_sym rescue environment
+      end
+
+      alias_method :env=, :environment=
+
+      def environment
+        @environment ||= (ENV["SPOT_ENV"] || :development).to_sym
+      end
+
+      alias_method :env, :environment
+
+      def development?
+        environment == :development
+      end
+
+      def production?
+        environment == :production
+      end
+
+      def test?
+        environment == :test
+      end
+    end # ClassMethods
+  end # State
+end
+

data/lib/spontaneous/plugins/boxes.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module Boxes
+    module ClassMethods
+      def box(name, options = {}, &block)
+        name = name.to_sym
+        unless boxes.key?(name)
+          box_prototypes[name] = Spontaneous::Prototypes::BoxPrototype.new(self, name, options, &block)
+          unless method_defined?(name)
+            class_eval <<-BOX
+              def #{name}
+                boxes[:#{name}]
+              end
+            BOX
+          end
+        end
+      end
+
+      def boxes
+        box_prototypes
+      end
+
+      def box_prototypes
+        @box_prototypes ||= Spontaneous::Collections::PrototypeSet.new(superclass, :box_prototypes)
+      end
+
+      def has_boxes?
+        !box_prototypes.empty?
+      end
+
+      def box_order(*new_order)
+        box_prototypes.order = new_order.flatten
+      end
+
+      def box?(box_name)
+        box_prototypes.key?(box_name.to_sym)
+      end
+    end
+
+    module InstanceMethods
+
+      def reload
+        @boxes = nil
+        super
+      end
+
+      def boxes(*args)
+        @boxes ||= Spontaneous::Collections::BoxSet.new(self)
+      end
+
+      def iterable
+        boxes
+      end
+
+      def box?(box_name)
+        self.class.box?(box_name.to_sym)
+      end
+
+      def box_data(box)
+        # TODO: use schema id to retrieve box data
+        box_id = box.schema_id.to_s
+        (self.box_store || []).detect { |data| data[:box_id] == box_id } || {}
+      end
+
+      def box_field_store(box)
+        box_data(box)[:fields]
+      end
+
+      def box_modified!(modified_box)
+        self.box_store = serialize_boxes
+      end
+
+      def serialize_boxes
+        boxes.map { |box| box.serialize_db }
+      end
+
+      def box_style_id(box_name)
+        nil
+      end
+    end
+  end
+end
+

data/lib/spontaneous/plugins/controllers.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Controllers
+    ACTION_SEPARATOR = "@".freeze
+
+
+    module ClassMethods
+      def controllers
+        @controllers ||= Spontaneous::Collections::PrototypeSet.new(supertype, :controllers)
+      end
+
+      def controller_base_class
+        return ::PageController if defined?(::PageController)
+        default_controller_base_class
+      end
+
+      def default_controller_base_class
+        Spontaneous::PageController
+      end
+
+      def controller(namespace, base_class = controller_base_class, &block)
+        controller_class_name = "#{namespace.to_s.camelize}Controller"
+        controller_class = Class.new(base_class)
+        controller_class.class_eval(&block) if block_given?
+        self.const_set(controller_class_name, controller_class) unless self.const_defined?(controller_class_name)
+        controllers[namespace.to_sym] = controller_class
+      end
+    end # ClassMethods
+
+    module InstanceMethods
+      # resolve and call the relevant action handler and return the results to the controller
+      def process_action(action_path, env, format)
+        env = env.dup
+        namespace, *p = action_path.split(S::Constants::SLASH)
+        path = [S::Constants::EMPTY].concat(p).join(S::Constants::SLASH)
+        env[S::Constants::PATH_INFO] = path
+        controller_class = self.class.controllers[namespace.to_sym]
+        return 404 unless controller_class
+        app = controller_class.new(self, format)
+        app.call(env)
+      end
+
+      # generate an action URL of the form
+      # <path to page>/@<action namespace>/<action path>
+      def action_url(namespace, path)
+        [self.path, "#{ACTION_SEPARATOR}#{namespace}", path].join(S::Constants::SLASH).gsub(%r{//}, '/')
+      end
+    end # InstanceMethods
+  end # Actions
+end