spontaneous 0.2.0.beta9 → 0.2.0.beta10

data/lib/spontaneous/media/store.rb

@@ -8,14 +8,14 @@ module Spontaneous::Media
 
     extend self
 
-    def create(config)
+    def create(name, config)
       case config[:provider]
       when "Local", "local"
-        Local.new(config[:local_root], config[:url], config[:accepts])
+        Local.new(name, config[:local_root], config[:url], config[:accepts])
       else
         bucket =  config.delete(:bucket)
         accepts = config.delete(:accepts)
-        Cloud.new(config, bucket, accepts)
+        Cloud.new(name, config, bucket, accepts)
       end
     end
   end

data/lib/spontaneous/media/store/backend.rb

@@ -2,6 +2,22 @@
 
 module Spontaneous::Media::Store
   class Backend
+    attr_reader :name
+    attr_accessor :url_mapper
+
+    def initialize(name)
+      @name = name
+      @url_mapper = default_url_mapper
+    end
+
+    def default_url_mapper
+      Proc.new { |path| path }
+    end
+
+    def to_url(path)
+      @url_mapper.call(path)
+    end
+
     def accepts?(mimetype)
       return true if @accepts.nil?
       true

data/lib/spontaneous/media/store/cloud.rb

@@ -41,9 +41,15 @@ module Spontaneous::Media::Store
     # Don't verify my ssl certs when uploading images
     ::Excon.defaults[:ssl_verify_peer] = false
 
-    def initialize(config, bucket_name, accepts = nil)
+    def initialize(name, config, bucket_name, accepts = nil)
+      super(name)
       @config, @bucket_name, @accepts = config, bucket_name, accepts
-      @public_host = @config.delete(:public_host)
+      if (host = @config.delete(:public_host))
+        self.public_host = host
+      end
+      if (mapper = @config.delete(:url_mapper))
+        self.url_mapper = mapper
+      end
     end
 
     def open(relative_path, headers, mode, &block)
@@ -100,30 +106,64 @@ module Spontaneous::Media::Store
       @bucket ||= backend.directories.get(@bucket_name)
     end
 
-    def public_url(path)
-      if @public_host
-        "#{@public_host}/#{join_path(path)}"
-      else
+    def url_path(path)
+      "/" << join_path(path)
+    end
+
+    def default_url_mapper
+      Proc.new { |path|
         if @config[:provider] == "AWS"
-          public_url_aws(path)
+          aws_to_url(path)
         else
-          bucket.files.new(:key => join_path(path)).public_url
+          bucket.files.new(key: path).public_url
         end
-      end
+      }
     end
 
     # AWS Redirects to the bucketname.s3.amazonaws.com style of public URL
     # if you use the s3.amazonaws.com/bucketname/ style so to avoid a lot of
     # slow redirects when loading a page's media we use the fastest available
     # version
-    def public_url_aws(path)
+    def aws_to_url(path)
       if bucket_name =~ AWS_BUCKET_SUBDOMAIN_RESTRICTON_REGEX
-        "https://#{bucket_name}.s3.amazonaws.com/#{join_path(path)}"
+        "https://#{bucket_name}.#{aws_s3_endpoint}#{path}"
+      else
+        "https://#{aws_s3_endpoint}/#{bucket_name}#{path}"
+      end
+    end
+
+    def aws_s3_endpoint
+      case (region = @config[:region])
+      when nil, "", "us-east-1"
+        "s3.amazonaws.com"
       else
-        "https://s3.amazonaws.com/#{bucket_name}/#{join_path(path)}"
+        "s3-#{region}.amazonaws.com"
+      end
+    end
+
+    def public_host=(host)
+      @public_host = host
+      unless host.blank?
+        self.url_mapper = host_url_mapper(host)
       end
     end
 
+    def host_url_mapper(host)
+      uri = URI.parse(host)
+      lambda { |path|
+        return path if path.blank?
+        begin
+          path_uri = URI.parse(path)
+          return path if path_uri.absolute?
+          url = uri.clone
+          url.path = path
+          url.to_s
+        rescue => e
+          path
+        end
+      }
+    end
+
     def root
      "/"
     end

data/lib/spontaneous/media/store/local.rb

@@ -4,8 +4,9 @@ module Spontaneous::Media::Store
   class Local < Backend
     attr_reader :root
 
-    def initialize(root_directory, url_path, accepts = nil)
-      @root, @url_path, @accepts = ::File.expand_path(root_directory), url_path, accepts
+    def initialize(name, root_directory, url_path_root, accepts = nil)
+      super(name)
+      @root, @url_path_root, @accepts = ::File.expand_path(root_directory), url_path_root, accepts
     end
 
     def copy(existing_file, media_path, headers = {})
@@ -54,9 +55,11 @@ module Spontaneous::Media::Store
     end
 
     def public_url(path)
-      File.join(@url_path, join_path(path))
+      File.join(@url_path_root, join_path(path))
     end
 
+    alias_method :url_path, :public_url
+
     def local?
       true
     end

data/lib/spontaneous/model.rb

@@ -99,5 +99,8 @@ module Spontaneous
     def content_model
       model.content_model
     end
+    def site
+      content_model.schema.site
+    end
   end
 end

data/lib/spontaneous/model/core/entries.rb

@@ -57,7 +57,8 @@ module Spontaneous::Model::Core
     end
 
     def entry_modified!(modified_entry)
-      self.entry_store = all_contents.serialize_db
+      self.entry_store = store = all_contents.serialize_db
+      all_contents.update(store)
     end
 
     def contents
@@ -108,25 +109,43 @@ module Spontaneous::Model::Core
     end
 
 
+    # TODO: This insert process is too fragile & requires too many intermediate #saves
+    # Perhaps some unified insertion process would simplify the requirements
+    #
+    # e.g. page.box.create(OtherPage, slug: 'something')
+    #      page.box.build(OtherPage, slug: 'something')
+    #
+    # A lot of the problems come from the child's potential lack of an id
+    # because it's a new record. If I wrap the process then I do two things:
+    #
+    #   1. prevent the creation of pages without a containing box
+    #   2. control the 'new' state of the added instance so I don't have to
+    #      manage two pathways
+    #
+    # This would entail making Content::new private or something.
+    #
     def insert_page(index, child_page, box)
-      child_page.owner = self
-      if page
-        child_page.depth = page.depth + 1
-        page.unordered_children << child_page
-        child_page.parent = page
-        child_page.update_path
+      insert_with_style(:page, index, child_page, box) do
+        child_page.owner = self
+        if page
+          child_page.depth = page.depth + 1
+          page.unordered_children << child_page
+          child_page.parent = page
+          child_page.update_path
+        end
       end
-      insert_with_style(:page, index, child_page, box)
     end
 
     def insert_piece(index, piece, box)
-      piece.owner = self
-      piece.page = page if page
-      piece.depth = (content_depth || 0) + 1
-      insert_with_style(:piece, index, piece, box)
+      insert_with_style(:piece, index, piece, box) do
+        piece.owner = self
+        piece.page = page if page
+        piece.depth = (content_depth || 0) + 1
+        piece.save
+      end
     end
 
-    def insert_with_style(type, index, content, box)
+    def insert_with_style(type, index, content, box, &block)
       self.pieces << content
       entry_style = style_for_content(content, box)
       content.box_sid = box.schema_id if box
@@ -149,6 +168,8 @@ module Spontaneous::Model::Core
         logger.error { "Attempting to modify visible only pieces" }
         raise e
       end
+      yield if block_given?
+      content.save
 
       entry
     end

data/lib/spontaneous/model/core/entry.rb

@@ -24,7 +24,9 @@ module Spontaneous::Model::Core
       owner.boxes.sid(box_sid) if owner
     end
 
-    alias_method :container,  :box
+    def container
+      box
+    end
 
     def first?
       container.contents.first == self

data/lib/spontaneous/model/page/controllers.rb

@@ -12,6 +12,7 @@ module Spontaneous::Model::Page
       end
 
       def default_controller_base_class
+        return ::PageController if defined?(::PageController)
         Spontaneous::Rack::PageController
       end
 
@@ -20,7 +21,6 @@ module Spontaneous::Model::Page
       # namespace
       def controller_superclass(namespace, base_class)
         return base_class unless base_class.nil?
-        return ::PageController if defined?(::PageController)
         search = ancestors.select { |klass| klass.respond_to?(:controllers) }
         controller_superclass = [namespace, :__nil__].uniq.flat_map { |n|
           search.map { |type| type.controllers[n] }
@@ -69,7 +69,6 @@ module Spontaneous::Model::Page
     end
 
     def process_root_action(site, env, format)
-      env[S::Constants::PATH_INFO] = S::Constants::SLASH
       run_controller(site, :__nil__, env, format)
     end
 

data/lib/spontaneous/model/page/paths.rb

@@ -5,12 +5,12 @@ module Spontaneous::Model::Page
     extend Spontaneous::Concern
 
     module ClassMethods
-      def generate_default_slug
-        "page-#{Time.now.strftime('%Y%m%d-%H%M%S')}"
+      def generate_default_slug(root = 'page')
+        "#{root}-#{Time.now.strftime('%Y%m%d-%H%M%S')}"
       end
 
-      def is_default_slug?(slug)
-        /^page-\d{8}-\d{6}$/ === slug
+      def is_default_slug?(slug, root = 'page')
+        /^#{root}-\d{8}-\d{6}$/ === slug
       end
 
       def create_root(slug, values = {})
@@ -94,11 +94,15 @@ module Spontaneous::Model::Page
     end
 
     def has_generated_slug?
-      self.class.is_default_slug?(slug)
+      self.class.is_default_slug?(slug, default_slug_root)
     end
 
     def generate_default_slug
-      self.class.generate_default_slug
+      self.class.generate_default_slug(default_slug_root)
+    end
+
+    def default_slug_root
+      'page'
     end
 
     def is_conflicting_slug?(slug)
@@ -165,6 +169,13 @@ module Spontaneous::Model::Page
       tree_root.is_private_root?
     end
 
+    # Loads the current calculated path of this page from the database.
+    # Used by Box#path! (which is itself used by #calculate_path_with_slug below)
+    # It's necessary to grab this from the db because there are too many cached
+    # values between the box & the up-to-date value
+    def path!
+      model.dataset.select(:path).get_unfiltered_raw(id).try(:[], :path)
+    end
 
     def update_path
       self.path = calculate_path
@@ -186,7 +197,7 @@ module Spontaneous::Model::Page
       if parent.nil?
         root? ? Spontaneous::SLASH : "##{slug}"
       else
-        File.join(parent.path, slug)
+        File.join(container.path!, slug)
       end
     end
 

data/lib/spontaneous/output/context.rb

@@ -90,14 +90,6 @@ module Spontaneous::Output::Context
       content.last
     end
 
-    def first?
-      __target.owner.pieces.first == self
-    end
-
-    def last?
-      __target.owner.pieces.last == self
-    end
-
     # template takes an existing first-pass template, converts it to a second pass template
     # and then returns the result for inclusion.
     # This lets you share templates between the publish step and the request step.

data/lib/spontaneous/output/template/renderer.rb

@@ -127,6 +127,8 @@ module Spontaneous::Output::Template
   end
 
   class PublishedRenderer < Renderer
+    attr_reader :revision
+
     def initialize(site, revision, cache = Spontaneous::Output.cache_templates?)
       super(site, cache)
       @revision = revision

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

@@ -69,10 +69,6 @@ module Spontaneous::Plugins::Application
         instance.config
       end
 
-      def db_settings
-        YAML.load_file(root /  "config/database.yml")[environment]
-      end
-
       def database
         Spontaneous::Site.instance.database
       end

data/lib/spontaneous/prototypes/field_prototype.rb

@@ -130,6 +130,10 @@ module Spontaneous::Prototypes
     end
 
     def default(instance = nil)
+      instance_class.make_default_value(instance, default_value_for_instance(instance))
+    end
+
+    def default_value_for_instance(instance)
       case (default = @options[:default])
       when Proc
         default[instance]

data/lib/spontaneous/publishing/immediate.rb

@@ -28,10 +28,5 @@ module Spontaneous::Publishing
     def rerender
       Rerender.new(@site, @revision, @steps).rerender
     end
-
-    def rerender_revision
-      logger.info {  "Re-rendering revision #{@revision}"}
-      render_revision
-    end
   end
 end

data/lib/spontaneous/publishing/progress.rb

@@ -136,8 +136,8 @@ module Spontaneous::Publishing
         send_event
       end
 
-      def send_event(stage = current_stage, percentage = percentage)
-        ::Simultaneous.send_event('publish_progress', {:state => stage, :progress => percentage}.to_json)
+      def send_event(stage = current_stage, _percentage = percentage)
+        ::Simultaneous.send_event('publish_progress', {:state => stage, :progress => _percentage}.to_json)
       rescue Errno::ECONNREFUSED
       rescue Errno::ENOENT
       end

data/lib/spontaneous/publishing/rerender.rb

@@ -8,10 +8,7 @@ module Spontaneous::Publishing
       model.scope(revision, true) do
         pipeline.run(site, revision, [], progress)
       end
-    end
-
-    def progress
-      @progress ||= Progress::Stdout.new
+      progress.done
     end
   end
 end

data/lib/spontaneous/publishing/simultaneous.rb

@@ -5,24 +5,26 @@ module Spontaneous
   module Publishing
     class Simultaneous
 
-      def self.task_name
-        # TODO: add site name to this to make it unique on a server
-        :publish
+      def self.publish_task
+        [:publish, "site publish"]
       end
 
-      def self.register_task
-        task = "site publish"
+      def self.rerender_task
+        [:rerender, "site render"]
+      end
+
+      def self.register_tasks
         niceness = Spontaneous::Site.config.publish_niceness || 15
-        logfile =  "log/publish.log"
         task_options = {
-          :niceness => niceness,
-          :logfile  => logfile
+          niceness: niceness,
+          logfile: "log/publish.log"
         }
-        task_params = {}
-        Spontaneous::Simultaneous.register(task_name, task, task_options, task_params)
+        [publish_task, rerender_task].each do |task_name, task_cmd|
+          Spontaneous::Simultaneous.register(task_name, task_cmd, task_options, task_params = {})
+        end
       end
 
-      register_task
+      register_tasks
 
       attr_reader :revision
 
@@ -30,16 +32,16 @@ module Spontaneous
         @revision, @content_model = revision, content_model
       end
 
-      def task_name
-        self.class.task_name
-      end
-
       def publish_pages(page_list)
-        Spontaneous::Simultaneous.fire(task_name, {"pages" => page_list})
+        Spontaneous::Simultaneous.fire(:publish, {"pages" => page_list})
       end
 
       def publish_all
-        Spontaneous::Simultaneous.fire(task_name)
+        Spontaneous::Simultaneous.fire(:publish)
+      end
+
+      def rerender
+        Spontaneous::Simultaneous.fire(:rerender)
       end
     end # Simultaneous
   end # Publishing