spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/field/webvideo.rb

@@ -0,0 +1,310 @@
+# encoding: UTF-8
+
+require 'open-uri'
+require 'nokogiri'
+
+module Spontaneous::Field
+  class WebVideo < Base
+    has_editor
+
+    def outputs
+      [:type, :id]
+    end
+
+    def id
+      value(:id)
+    end
+
+    def video_type
+      value(:type)
+    end
+
+
+    def generate_outputs(input)
+      values = {}
+      values[:html] = escape_html(input)
+      case input
+      when "", nil
+        # ignore this
+      when /youtube\.com.*\?.*v=([^&]+)/, /youtu.be\/([^&]+)/
+        id = $1
+        values.update(retrieve_youtube_metadata(id))
+        values[:id] = id
+        values[:type] = "youtube"
+      when /vimeo\.com\/(\d+)/
+        id = $1
+        values[:type] = "vimeo"
+        values.update(retrieve_vimeo_metadata(id))
+        values[:id] = id.to_s
+      else
+        logger.warn "WebVideo field doesn't recognise the URL '#{input}'"
+      end
+      values
+    end
+
+
+    def render(format=:html, *args)
+      case format
+      when :html
+        to_html(*args)
+      when :json
+        to_json(*args)
+      else
+        value(format)
+      end
+    end
+
+
+    def to_html(*args)
+      opts = args.extract_options!
+      case video_type
+      when "youtube"
+        to_youtube_html(opts)
+      when "vimeo"
+        to_vimeo_html(opts)
+      else
+        value(:html)
+      end
+    end
+
+
+    def to_json(*args)
+      opts = args.extract_options!
+      params = \
+        case video_type
+      when "youtube"
+        youtube_attributes(opts)
+      when "vimeo"
+        vimeo_attributes(opts)
+      else
+        {:tagname => "iframe", :tag => "<iframe/>", :attr => {:src => value(:html)}}
+      end
+      Spontaneous.encode_json(params)
+    end
+
+    def src(opts = {})
+      case video_type
+      when "youtube"
+        youtube_src(opts)
+      when "vimeo"
+        vimeo_src(opts)
+      else
+        value(:html)
+      end
+    end
+
+    def ui_preview_value
+      # render(:html, :width => 480, :height => 270)
+      src
+    end
+
+    def retrieve_vimeo_metadata(id)
+      url = "http://vimeo.com/api/v2/video/%s.json" % id
+      response = \
+        begin
+          open(url).read
+      rescue => e
+        logger.error("Unable to retrieve metadata for video ##{id} from Vimeo: '#{e}'")
+        "[{}]"
+      end
+      metadata = Spontaneous.parse_json(response) rescue [{}]
+      metadata = metadata.first || {}
+    end
+
+    def retrieve_youtube_metadata(id)
+      url = "http://gdata.youtube.com/feeds/api/videos/%s?v=2" % id
+      begin
+        doc = Nokogiri::XML(open(url))
+        entry = doc.xpath("xmlns:entry")
+
+        { "title" => entry.xpath("xmlns:title").text.strip,
+          "description" => entry.xpath("media:group/media:description").text.strip,
+          "thumbnail_large" => entry.xpath('media:group/media:thumbnail[@yt:name="hqdefault"]').first["url"].strip,
+          "thumbnail_small" => entry.xpath('media:group/media:thumbnail[@yt:name="default"]').first["url"].strip,
+          "user_name" => entry.xpath("xmlns:author/xmlns:name").text.strip,
+          "upload_date" => Time.parse(entry.xpath("xmlns:published").text.strip).strftime("%Y-%m-%d %H:%M:%S"),
+          "tags" => entry.xpath("media:group/media:keywords").text.strip,
+          "duration" => entry.xpath("media:group/yt:duration").first['seconds'].to_i,
+          "stats_number_of_likes" => entry.xpath("yt:rating").first['numLikes'].to_i,
+          "stats_number_of_plays" => entry.xpath("yt:statistics").first['viewCount'].to_i,
+          "stats_number_of_comments" => entry.xpath("gd:comments/gd:feedLink").first['countHint'].to_i }
+      rescue
+        {}
+      end
+    end
+
+    def default_player_options
+      {
+        :width => 640,
+        :height => 360,
+        :fullscreen => true,
+        :api => false,
+        :autoplay => false,
+        :loop => false,
+        :showinfo => true
+      }.merge(prototype.options[:player] || {})
+    end
+
+
+    def to_vimeo_html(options = {})
+      params = vimeo_attributes(options)
+
+      attributes = make_html_attributes(params[:attr])
+      %(<iframe #{attributes}></iframe>)
+    end
+
+    def vimeo_attributes(options = {})
+
+      o = make_vimeo_options(options)
+
+      attributes = {
+        :type => "text/html",
+        :frameborder => "0",
+        :width => o.delete(:width),
+        :height => o.delete(:height)
+      }
+      attributes.update(:webkitAllowFullScreen => "yes", :allowFullScreen => "yes") if o[:fullscreen]
+
+      make_query_options!(o)
+      attributes[:src] = vimeo_src_with_options(o)
+
+      {:tagname => "iframe", :tag => "<iframe/>", :attr => attributes}
+    end
+
+    def make_vimeo_options(options = {})
+      o  = default_player_options
+      vimeo_options = o.delete(:vimeo) || {}
+
+      o.merge!(vimeo_options)
+
+      if o.delete(:showinfo)
+        o[:portrait] = true
+        o[:title] = true
+        o[:byline] = true
+      else
+        o[:portrait] = false
+        o[:title] = false
+        o[:byline] = false
+      end
+
+      vimeo_options = options.delete(:vimeo) || {}
+
+      o = {
+        :portrait => true,
+        :title => true,
+        :byline => true,
+        :player_id => "vimeo#{owner.id}id#{value(:id)}"
+      }.merge(o).merge(vimeo_options).merge(options)
+      o
+    end
+
+    def vimeo_src(options = {})
+      o = make_vimeo_options(options)
+      make_query_options!(o)
+      vimeo_src_with_options(o)
+    end
+
+    def vimeo_src_with_options(o)
+      params = {
+        "title" => o[:title],
+        "byline" => o[:byline],
+        "portrait" => o[:portrait],
+        "autoplay" => o[:autoplay],
+        "loop" => o[:loop],
+        "api" => o[:api],
+        "player_id" => o[:player_id] }
+        params.update("color" => o[:color]) if o.key?(:color)
+        params = ::Rack::Utils.build_query(params)
+        "http://player.vimeo.com/video/#{value(:id)}?#{params}"
+    end
+
+    def to_youtube_html(options = {})
+      params = youtube_attributes(options)
+      attributes = make_html_attributes(params[:attr])
+      %(<iframe #{attributes}></iframe>)
+    end
+
+
+    def youtube_attributes(options = {})
+      o = make_youtube_options(options)
+
+      attributes = {
+        :type => "text/html",
+        :frameborder => "0",
+        :width => o.delete(:width),
+        :height => o.delete(:height)
+      }
+
+      make_query_options!(o)
+
+      attributes[:src] = youtube_src_with_options(o)
+
+      attributes.update(:webkitAllowFullScreen => "yes", :allowFullScreen => "yes") if o[:fullscreen]
+
+      {:tagname => "iframe", :tag => "<iframe/>", :attr => attributes}
+    end
+
+    def make_youtube_options(options = {})
+      o  = default_player_options
+      youtube_options = o.delete(:youtube) || {}
+
+      o.merge!(youtube_options)
+
+      if o.delete(:showinfo)
+        o[:showinfo] = true
+        o[:showsearch] = true
+      else
+        o[:showinfo] = false
+        o[:showsearch] = false
+      end
+
+      youtube_options = options.delete(:youtube) || {}
+      o = {
+        :theme => "dark",
+        :hd => true,
+        :controls => true,
+        :showinfo => true,
+        :showsearch => true,
+        :autohide => 2,
+        :rel => true
+      }.merge(o).merge(youtube_options).merge(options)
+    end
+
+    def youtube_src(options = {})
+      o = make_youtube_options(options)
+      make_query_options!(o)
+      youtube_src_with_options(o)
+    end
+
+    def youtube_src_with_options(o)
+      params = ::Rack::Utils.build_query({
+        "modestbranding" => 1,
+        "theme" => o[:theme],
+        "hd" => o[:hd],
+        "fs" => o[:fullscreen],
+        "controls" => o[:controls],
+        "autoplay" => o[:autoplay],
+        "showinfo" => o[:showinfo],
+        "showsearch" => o[:showsearch],
+        "loop" => o[:loop],
+        "autohide" => o[:autohide],
+        "rel" => o[:rel],
+        "enablejsapi" => o[:api] })
+        "http://www.youtube.com/embed/#{value(:id)}?#{params}"
+    end
+
+    def make_html_attributes(attributes)
+      attributes.to_a.map { |name, value| "#{name}=\"#{escape_html(value)}\"" }.join(" ")
+    end
+
+
+    def make_query_options!(hash)
+      hash.each { |k, v|
+        hash[k] = 1 if v == true
+        hash[k] = 0 if v == false
+      }
+    end
+
+    self.register(:webvideo)
+  end
+end

data/lib/spontaneous/field.rb

@@ -0,0 +1,80 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Field
+    autoload :Base,         "spontaneous/field/base"
+    autoload :FieldVersion, "spontaneous/field/field_version"
+    autoload :Update,       "spontaneous/field/update"
+
+    @@type_map = {}
+
+    def self.register(klass, *labels)
+      labels.each do |label|
+        @@type_map[label.to_sym] = klass
+      end
+    end
+
+    def self.[](label)
+      @@type_map[label.to_sym] || String
+    end
+
+    def self.serialize_field(field)
+      [field.schema_id.to_s, field.version, field.unprocessed_value, field.processed_values]
+    end
+
+    def self.deserialize_field(serialized_field)
+      {
+        :id => serialized_field[0],
+        :version => serialized_field[1],
+        :unprocessed_value => serialized_field[2],
+        :processed_values => serialized_field[3]
+      }
+    end
+
+    # Used to test for the validity of asynchronous updates.
+    #
+    # A to-the-second resolution would actually probably be fine as
+    # real updates will come from the user in meat-space time but
+    # why not use the full resolution available...
+    def self.timestamp(time = Time.now)
+      (time.to_f * 10000000).to_i
+    end
+
+    def self.update(content, params, user, asynchronous = false)
+      fields = Hash[params.map { |sid, value| [content.fields.sid(sid), value] }]
+      Update.perform(fields, user, asynchronous)
+    end
+
+    def self.update_asynchronously(content, params, user)
+      update(content, params, user, true)
+    end
+
+    def self.set(field, value, user, asynchronous = false)
+      Update.perform({field => value}, user, asynchronous)
+    end
+
+    def self.set_asynchronously(field, value, user)
+      set(field, value, user, true)
+    end
+
+    def self.find(*ids)
+      fields = ids.map { |id| resolve_id(id) }.compact
+      return fields.first if ids.length == 1
+      fields
+    end
+
+    def self.resolve_id(id)
+      content_id, box_sid, field_sid = id.split("/")
+      field_sid, box_sid = box_sid, field_sid if field_sid.nil?
+      content = target = Spontaneous::Content.get(content_id)
+      return nil if target.nil?
+      target  = content.boxes.sid(box_sid) if box_sid
+      return nil if target.nil?
+      target.fields.sid(field_sid)
+    end
+  end
+end
+
+[:string, :long_string, :file, :image, :date, :markdown, :location, :webvideo, :select].each do |type|
+  require "spontaneous/field/#{type}"
+end

data/lib/spontaneous/generators/site/Gemfile.tt

@@ -13,8 +13,8 @@ gem 'capistrano', '~> 2.9'
 # If you want to enable the built in search functionality then you must un-comment
 # the xapian-full & xapian-fu dependencies below. They are not included by default
 # because the xapian library takes a very long time to build.
-#gem 'xapian-full', "~> 1.2.3"
-#gem 'xapian-fu', "~> 1.3"
+#gem 'xapian-ruby', "~> 1.2.12"
+#gem 'xapian-fu',   "~> 1.3"
 
 # group :production do
 #   gem 'thin',    '~> 1.3.1'

data/lib/spontaneous/generators/site/config/environments/development.rb.tt

@@ -1,5 +1,5 @@
 
-publishing_method :simultaneous
+background_mode :simultaneous
 
 simultaneous_connection "/tmp/simultaneous.<%= @site_name %>.sock"
 

data/lib/spontaneous/generators/site/config/environments/production.rb.tt

@@ -1,5 +1,5 @@
 
-publishing_method :simultaneous
+background_mode :simultaneous
 
 simultaneous_connection ENV["SIMULTANEOUS_SOCKET"]
 spontaneous_binary      ENV["SPONTANEOUS_BINARY"]

data/lib/spontaneous/generators/site/lib/content.rb.tt

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+
+class Content < Spontaneous::Model(:content)
+end
+
+Site = Spontaneous.site(Content)

data/lib/spontaneous/generators/site/schema/box.rb.tt

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 
-class Box < Spontaneous::Box
-end
+require 'content'
 
+class Box < Content::Box
+end

data/lib/spontaneous/generators/site/schema/page.rb.tt

@@ -1,6 +1,8 @@
 # encoding: UTF-8
 
-class Page < Spontaneous::Page
+require 'content'
+
+class Page < Content::Page
   # pages must respond to the title method
   # so if you remove this 'title' field, then you must replace it with
   # a #title method

data/lib/spontaneous/generators/site/schema/piece.rb.tt

@@ -1,4 +1,6 @@
 # encoding: UTF-8
 
-class Piece < Spontaneous::Piece
+require 'content'
+
+class Piece < Content::Piece
 end

data/lib/spontaneous/generators/site/templates/layouts/standard.html.cut.tt

@@ -12,7 +12,9 @@
 </head>
 <body>
   %{ block :content }
-    <h2>Welcome to <%= @domain %></h2>
+		<h2>Welcome to <%= @domain %></h2>
+		${ fields }
+		${ boxes  }
   %{ endblock :content }
 	${ scripts %w(/js/site) }
 </body>

data/lib/spontaneous/generators/site.rb

@@ -42,20 +42,21 @@ module Spontaneous
           self.destination_root = self.destination_root / @site_name
           directory "config"
           directory "schema"
+          directory "lib"
           directory "templates"
           directory "public"
           template "Gemfile.tt", "Gemfile"
           template "Capfile.tt", "Capfile"
           template "Rakefile.tt", "Rakefile"
-          template "lib/site.rb.tt", "lib/site.rb"
-          empty_directory "lib/tasks"
+          # template "lib/site.rb.tt", "lib/site.rb"
+          # empty_directory "lib/tasks"
           empty_directory "log"
           empty_directory "tmp"
           empty_directory "cache/media"
           empty_directory "cache/tmp"
           empty_directory "cache/revisions"
           copy_file ".gitignore"
-          template "lib/tasks/site.rake.tt", "lib/tasks/#{@site_name}.rake"
+          # template "lib/tasks/site.rake.tt", "lib/tasks/#{@site_name}.rake"
         else
           @valid = false
           say "Invalid database selection '#{options.database}'. Valid options are: #{self.class.available_dbs.keys.join(', ')}", :red

data/lib/spontaneous/image_size.rb

@@ -15,7 +15,6 @@ module Spontaneous
         else
           File.open(file, 'rb') { |io| read_size(io) }
         end
-
       end
 
       def read_size(file)
@@ -24,6 +23,7 @@ module Spontaneous
       end
 
       def image_type(file)
+        return Formats::EMPTY if file.size == 0
         img_top = file.read(16)
         bytes = img_top.unpack("C*")
         file.seek(0,0)
@@ -64,6 +64,13 @@ module Spontaneous
           end
         end
 
+        class EMPTY
+          def initialize(file)
+          end
+          def size
+            [0, 0]
+          end
+        end
         class GIF < Abstract
           def read_size
             @file.read_o(6)

data/lib/spontaneous/layout.rb

@@ -7,8 +7,12 @@ module Spontaneous
     end
 
     class Default < Layout
+      # If no named layouts have been defined first look for a layout
+      # matching the class of our owner, then default to the 'standard'
+      # layout.
       def try_paths
-        [["layouts", "standard"]]
+        named_layout = self.class.to_directory_name(owner)
+        [["layouts", named_layout], ["layouts", "standard"]]
       end
     end
 

data/lib/spontaneous/loader.rb

@@ -98,7 +98,7 @@ module Spontaneous
     def is_site_page?(backtrace)
       path, line, context = backtrace.split(":")
       path = File.expand_path(path)
-      root = Site.instance.root
+      root = Spontaneous::Site.instance.root
       path.start_with?(root)
     end
 
@@ -242,9 +242,6 @@ module Spontaneous
       # Removes the specified class and constant.
       #
       def remove_constant(const)
-        # return if Padrino::Reloader.exclude_constants.any? { |base| (const.to_s =~ /^#{base}/ || const.superclass.to_s =~ /^#{base}/) } &&
-        # !Padrino::Reloader.include_constants.any? { |base| (const.to_s =~ /^#{base}/ || const.superclass.to_s =~ /^#{base}/) }
-
         Spontaneous.schema.delete(const)
 
         parts = const.to_s.split("::")
@@ -378,7 +375,7 @@ module Spontaneous
       end
 
       def is_schema_class?(klass)
-        (klass < Spontaneous::Page or klass < Spontaneous::Piece or klass < Spontaneous::Box)
+        (klass < Spontaneous::Content or klass < Content::Box)
       end
 
       def remove_constant(const)

data/lib/spontaneous/media/file.rb

@@ -23,6 +23,7 @@ module Spontaneous::Media
     def copy(existing_file)
       @source = existing_file.respond_to?(:path) ? existing_file.path : existing_file
       storage.copy(existing_file, storage_path, mimetype)
+      self
     end
 
     def url
@@ -46,11 +47,15 @@ module Spontaneous::Media
     end
 
     def padded_id
-      owner.media_id.to_s.rjust(5, "0")
+      Spontaneous::Media.pad_id(owner.media_id)
     end
 
     def padded_revision
-      Spontaneous::Site.working_revision.to_s.rjust(4, "0")
+      Spontaneous::Media.pad_revision(revision)
+    end
+
+    def revision
+      Spontaneous::Site.working_revision
     end
 
     def media_dir
@@ -74,5 +79,9 @@ module Spontaneous::Media
     end
 
     alias_method :filepath, :path
+
+    def serialize
+      { :url => url, :mimetype => mimetype, :path => path, :filename => filename }
+    end
   end
 end

data/lib/spontaneous/media/temp_file.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+require 'fileutils'
+
+module Spontaneous::Media
+  # Represents a temporary file used to provide a media file that is visible
+  # publically under a /media/tmp/* URL for passing to file fields for
+  # asynchronous processing
+  class TempFile < File
+
+    def storage
+      Spontaneous::Site.default_storage
+    end
+
+    def media_dir
+      F.join("tmp", padded_id)
+    end
+
+    def storage_path
+      ["tmp", padded_id, filename]
+    end
+  end
+end