spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/lib/spontaneous/field/webvideo.rb

@@ -2,309 +2,159 @@
 
 require 'open-uri'
 require 'nokogiri'
+require 'erb'
 
 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}'"
+    class Provider
+      def self.id
+        name.demodulize.underscore
       end
-      values
-    end
-
 
-    def render(format=:html, *args)
-      case format
-      when :html
-        to_html(*args)
-      when :json
-        to_json(*args)
-      else
-        value(format)
+      def self.match(field, url)
+        # Implement in subclasses
       end
-    end
 
+      attr_reader :attributes
 
-    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)
+      def initialize(field, attributes = {})
+        @field, @attributes = field, attributes
       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)}}
+      def metadata
+        @attributes
       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)
+      def video_id
+        attributes[:video_id]
       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}'")
-        "[{}]"
+      def src(options = {})
+        # Implement in subclasses
+        video_id
       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")
+      # Don't show an unknown/default provider in the template
+      #
+      # TODO: Make default provider use the oembed api to create the right
+      # embed code for any video service (that supports the oembed system)
+      # Difficulty will be making that embed code adaptable to sizes configured
+      # in the field prototype & templates.
+      def to_html(options = {})
+        ""
+      end
 
-        { "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
+      def as_json(options = {})
         {}
       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 default_player_options
+        { :width => 640,
+          :height => 360,
+          :fullscreen => true,
+          :api => false,
+          :autoplay => false,
+          :loop => false,
+          :showinfo => true
+        }.merge(@field.prototype.options[:player] || {})
+      end
 
+      def hash_to_attributes(attributes)
+        attributes.to_a.map { |name, value| "#{name}=\"#{escape_html(value)}\"" }.join(" ")
+      end
 
-    def to_vimeo_html(options = {})
-      params = vimeo_attributes(options)
+      def escape_html(input)
+        ERB::Util.html_escape(input)
+      end
 
-      attributes = make_html_attributes(params[:attr])
-      %(<iframe #{attributes}></iframe>)
+      def make_query_options!(hash)
+        hash.each { |k, v|
+          hash[k] = 1 if v == true
+          hash[k] = 0 if v == false
+        }
+      end
     end
 
-    def vimeo_attributes(options = {})
-
-      o = make_vimeo_options(options)
-
-      attributes = {
-        :type => "text/html",
-        :frameborder => "0",
-        :width => o.delete(:width),
-        :height => o.delete(:height)
+    def self.providers
+      @providers ||= {
+        nil => Spontaneous::Field::WebVideo::Fallback
       }
-      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)
+    def self.provider(provider)
+      providers[provider.id] = provider
     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}"
+    def outputs
+      [:provider, :video_id]
     end
 
-    def to_youtube_html(options = {})
-      params = youtube_attributes(options)
-      attributes = make_html_attributes(params[:attr])
-      %(<iframe #{attributes}></iframe>)
+    # Earlier versions used :id to store the video id
+    # so to support them I need to try it first.
+    def video_id
+      values[:video_id]
     end
 
+    def generate_outputs(input)
+      values = {}
+      values[:html] = escape_html(input)
 
-    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}
+      metadata = nil
+      Spontaneous::Field::WebVideo.providers.each do |_, p|
+        break if metadata = p.match(self, input)
+      end
+      metadata ||= Provider.new(self, :video_id => input, :provider => nil).metadata
+      values.merge(metadata || {})
     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
+    def render(format=:html, *args)
+      case format
+      when :html
+        to_html(*args)
+      when :json
+        to_json(*args)
       else
-        o[:showinfo] = false
-        o[:showsearch] = false
+        value(format)
       end
+    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)
+    def to_html(*args)
+      provider.to_html(*args)
     end
 
-    def youtube_src(options = {})
-      o = make_youtube_options(options)
-      make_query_options!(o)
-      youtube_src_with_options(o)
+    def provider_id
+      values[:provider]
     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}"
+    def provider
+      provider = Spontaneous::Field::WebVideo.providers.fetch(provider_id, fallback_provider)
+      provider.new(self, values)
     end
 
-    def make_html_attributes(attributes)
-      attributes.to_a.map { |name, value| "#{name}=\"#{escape_html(value)}\"" }.join(" ")
+    def fallback_provider
+      Spontaneous::Field::WebVideo.providers.fetch("fallback")
     end
 
+    def to_json(*args)
+      opts = args.extract_options!
+      Spontaneous.encode_json(provider.as_json(opts))
+    end
 
-    def make_query_options!(hash)
-      hash.each { |k, v|
-        hash[k] = 1 if v == true
-        hash[k] = 0 if v == false
-      }
+    def src(opts = {})
+      provider.src(opts)
+    end
+
+    def ui_preview_value
+      # render(:html, :width => 480, :height => 270)
+      src
     end
 
     self.register(:webvideo)
   end
 end
+
+%w(fallback vimeo youtube vine).each do |provider|
+  require ::File.dirname(__FILE__) + "/webvideo/#{provider}.rb"
+end

data/lib/spontaneous/field.rb

@@ -75,6 +75,6 @@ module Spontaneous
   end
 end
 
-[:string, :long_string, :file, :image, :date, :markdown, :location, :webvideo, :select].each do |type|
+[:string, :long_string, :html, :file, :image, :date, :markdown, :location, :webvideo, :select, :tags, :boolean].each do |type|
   require "spontaneous/field/#{type}"
 end

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

@@ -1,4 +1,4 @@
-source :rubygems
+source "https://rubygems.org"
 
 # You can either fix the version of Spontaneous that this site uses
 gem 'spontaneous', '~> <%= Spontaneous::VERSION %>'
@@ -7,27 +7,18 @@ gem 'spontaneous', '~> <%= Spontaneous::VERSION %>'
 
 gem '<%= @database[:gem].name %>', '<%= @database[:gem].requirement %>'
 
+# Your favorite ExecJS compatible engine
+gem 'therubyracer',    '~> 0.11.1'
+
 # Deploy with Capistrano
 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
+# the xapian-ruby dependency below. It is not included by default
 # because the xapian library takes a very long time to build.
 #gem 'xapian-ruby', "~> 1.2.12"
-#gem 'xapian-fu',   "~> 1.3"
 
 # group :production do
 #   gem 'thin',    '~> 1.3.1'
 #   gem 'unicorn', '~> 4.2'
 # end
-
-
-# source gemfiles from Plugins & Features
-Dir['*/**/Gemfile'].each do |path|
-  gemfile = File.expand_path(path)
-  unless gemfile == File.expand_path(__FILE__)
-    dependencies = File.read(gemfile).gsub(/^\s*source.+$/, '')
-    eval(dependencies)
-  end
-end
-

data/lib/spontaneous/generators/site/assets/README.md

@@ -0,0 +1,20 @@
+Assets
+======
+
+Spontaneous uses [Sprockets](https://github.com/sstephenson/sprockets)
+to manage assets.
+
+Place any stylesheet, javascript or images under "assets" (following any
+structure that you like) and then during publishing Spontaneous will bundle,
+compile, compress and fingerprint these files.
+
+To reference assets within templates use the `asset_path` helper which will
+intelligently translate Sprocket's "logical paths" into the compressed &
+fingerprinted version.
+
+Within SASS templates Sprockets provides a set of useful helpers including
+`asset_url` and `asset_data_uri`.
+
+(See: <https://github.com/sstephenson/sprockets/blob/master/lib/sprockets/sass_functions.rb>.)
+
+For more information on using Sprockets see its [GitHub page](https://github.com/sstephenson/sprockets).

data/lib/spontaneous/generators/site/assets/css/site.scss

@@ -0,0 +1,8 @@
+//
+// Bundle your stylesheets using Sprocket's directives and then
+// reference the stylesheets in your page using the `stylesheets` helper:
+//
+//   ${ stylesheets('css/site') }
+//
+// e.g.
+// = require css/reset

data/lib/spontaneous/generators/site/assets/js/site.js

@@ -0,0 +1,6 @@
+// Bundle your scripts using Sprocket's directives and then
+// reference the scripts in your page using the `scripts` helper:
+//
+//   ${ scripts('js/site') }
+//
+// = require js/vendor/jquery

data/lib/spontaneous/generators/site/config/deploy.rb.tt

@@ -6,10 +6,19 @@ require "spontaneous/capistrano"
 require "bundler/capistrano"
 
 default_run_options[:pty]   = true
+# run capistrano in a login shell so that ruby version managers can do their thing
+# otherwise it's just a constant problem trying to use the installed/configured
+# version of ruby
+default_run_options[:shell] = '/bin/bash -l'
+
 
 ssh_options[:port]          = 22
 ssh_options[:forward_agent] = true
 
+set :ruby_version,          "<%= RUBY_VERSION %>-p<%= RUBY_PATCHLEVEL %>"
+
+set :domain,                "<%= @domain %>"
+set :cms,                   "edit.<%= @domain %>"
 set :application,           "<%= @domain %>"
 server                      "<%= @domain %>", :app, :web, :db, :media
 set :user,                  "<%= @username %>"

data/lib/spontaneous/generators/site/config/user_levels.yml

@@ -3,20 +3,31 @@
 # Feel free to add your own
 # the 'root' user level is added automatically and
 # will always be higher than any you add here
+#
 # Similary the 'none' level will always be lower
 # The order is important -- later leves are higher levels
-# higher levels will always be able to do everything that a lower level can do
-# 'publish' defines the particular level's access to the publishing process
-# This is set per-level -- higher levels don't inherit the value from lower levels
+#
+# Higher levels will always be able to do everything that a lower level can do
+#
+# Flags:
+#
+# Flags are set per-level -- higher levels don't inherit the value from lower levels.
+#
+# - 'publish' defines the particular level's access to the publishing process. The default is false
+#
+# - 'admin' allows users to administer the site's user accounts. The default is false
+
 
 - :name:    editor
   :publish: false
 
 - :name:    admin
   :publish: true
+  :admin: true
 
 - :name:    designer
   :publish: true
+  :admin: true
 
 # - :name:    my_level
 #   :publish: true

data/lib/spontaneous/generators/site/public/README.md

@@ -0,0 +1,12 @@
+Public Files
+============
+
+Any files you place in here will be publicly available on your site
+under the root (`/`) path. For instance "favicon.ico" will be publicly
+available as http://example.com/favicon.ico etc.
+
+Any CSS stylesheets, Javascript source files or images that you use
+should be placed under the "assets" directory where Spontaneous can
+manage them using Sprockets' powerful bundling, compression and
+fingerprinting functions (see `assets/README.md` for more
+information).

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

@@ -8,7 +8,7 @@
 	<meta charset="UTF-8">
 	<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
   <title>${ title } ­ <%= @domain %></title>
-	${ stylesheets '/css/site' }
+	${ stylesheets 'css/site' }
 </head>
 <body>
   %{ block :content }
@@ -16,6 +16,6 @@
 		${ fields }
 		${ boxes  }
   %{ endblock :content }
-	${ scripts %w(/js/site) }
+	${ scripts %w(js/site) }
 </body>
 </html>