spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/field_types/webvideo_field.rb

@@ -1,313 +0,0 @@
-# encoding: UTF-8
-
-require 'open-uri'
-require 'nokogiri'
-
-module Spontaneous
-  module FieldTypes
-    class WebVideoField < Field
-      include Spontaneous::Plugins::Field::EditorClass
-
-      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
-end

data/lib/spontaneous/field_types.rb

@@ -1,38 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module FieldTypes
-
-    autoload :Field, "spontaneous/field_types/field"
-
-    @@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] || StringField
-    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
-
-  end
-end
-
-[:string, :long_string, :file, :image, :date, :markdown, :location, :webvideo, :select].each do |type|
-  require "spontaneous/field_types/#{type}_field"
-end

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

@@ -1,4 +0,0 @@
-# encoding: UTF-8
-
-class Site < Spontaneous::Site
-end

data/lib/spontaneous/plugins/field/editor_class.rb

@@ -1,13 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous::Plugins::Field
-  module EditorClass
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def editor_class
-        ui_class
-      end
-    end
-  end
-end

data/lib/spontaneous/plugins/page/site_timestamps.rb

@@ -1,28 +0,0 @@
-# encoding: UTF-8
-
-require 'rack'
-
-module Spontaneous::Plugins::Page
-  module SiteTimestamps
-    extend ActiveSupport::Concern
-
-    def after_update
-      ::Spontaneous::State.site_modified! if field?(title_field) && fields[title_field].modified?
-      super
-    end
-
-    # Update the Site's modification time to force clients
-    # to reload their map data
-    def after_create
-      ::Spontaneous::State.site_modified!
-      super
-    end
-
-    # Update the Site's modification time to force clients
-    # to reload their map data
-    def after_destroy
-      ::Spontaneous::State.site_modified!
-      super
-    end
-  end
-end

data/lib/spontaneous/plugins/page_search.rb

@@ -1,63 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous::Plugins
-  module PageSearch
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def root
-        first_visible(:path => Spontaneous::SLASH)
-      end
-
-      def uid(uid)
-        first_visible(:uid => uid)
-      end
-
-      def path(path)
-        page = first_visible(:path => path)
-        # page = aliased_path(path) if page.nil?
-        page
-      end
-
-      def first_visible(params)
-        page = Spontaneous::Content.first(params)
-        # don't want to return nil if a page matching the params exists but is hidden
-        # if we return blank we force searches via other routes (such as aliased pages)
-        if page and Spontaneous::Content.visible_only? and page.hidden?
-          return false
-        end
-        page
-      end
-
-      # def aliased_path(path)
-      #   puts "looking for aliased path #{path}"
-      #   @_ps ||= Hash.new { |h, k| h[k] = prepare_aliased_path_query(k) }
-      #   p = path.split(S::SLASH)
-      #   root = p[0..-2].join(S::SLASH)
-      #   visible = Spontaneous::Content.visible_only?
-      #   @_ps[visible].call(:root => root, :slug => p.last)
-      # end
-
-      protected
-
-      # def prepare_aliased_path_query(visible_only=false)
-      #   # select c2.*
-      #   # from content as c1, content as c2, content as c3 \\
-      #   # where c1.path = '/aliases'
-      #   #   and c2.parent_id = c1.id
-      #   #   and c2.target_id = c3.id
-      #   #   and c3.slug = 'b';
-      #   params = {
-      #     :c1__path => :$root,
-      #     :c2__parent_id => :c1__id,
-      #     :c2__target_id => :c3__id,
-      #     :c3__slug => :$slug
-      #   }
-      #   params.merge!(:c3__hidden => false) if visible_only
-
-      #   query = S::Content._unfiltered_dataset.select(Sequel::LiteralString.new("c2.*")).from(:content___c1, :content___c2, :content___c3).where(params)
-      #   query.prepare(:first, :aliased_page)
-      # end
-    end # ClassMethods
-  end
-end

data/lib/spontaneous/plugins/schema_id.rb

@@ -1,68 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous::Plugins
-  module SchemaId
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def schema_id
-        Spontaneous.instance.schema_id(self)
-      end
-
-      def schema_name
-        "type//#{self.name}"
-      end
-
-      def schema_owner
-        nil
-      end
-
-      def owner_sid
-        nil
-      end
-
-      # In the case where a new class has been added to the schema
-      # the STI values have been set up on a class whose schema id is undefined
-      # so we need to correct this once a new ID has been generated
-      # Bit dodgy, what I should do instead is rewrite the STI code to always defer
-      # to the schema for its values
-      def update_schema_id(new_id)
-        sti_key_array << new_id.to_s
-        superclass.sti_subclass_added(new_id.to_s, self) if superclass
-      end
-    end # ClassMethods
-
-    # InstanceMethods
-
-    [:type, :style, :box].each do |c|
-      column = "#{c}_sid"
-      self.class_eval(<<-RUBY)
-          def #{column}
-            @_#{column} ||= Spontaneous.schema.uids[@values[:#{column}]]
-          end
-
-          def #{column}=(sid)
-            @_#{column} = Spontaneous.schema.uids[sid]
-            @values[:#{column}] = @_#{column}.to_s
-            @_#{column}
-          end
-      RUBY
-    end
-
-    def schema_id
-      self.class.schema_id
-    end
-
-    def schema_name
-      self.class.schema_name
-    end
-
-    def schema_owner
-      self.class.schema_owner
-    end
-
-    def owner_sid
-      self.class.owner_sid
-    end
-  end # SchemaId
-end

data/lib/spontaneous/plugins/site/publishing.rb

@@ -1,75 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous::Plugins::Site
-  module Publishing
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def default_publishing_method
-        resolve_publishing_method(Spontaneous::Site.config.publishing_method || :immediate)
-      end
-
-      def publishing_method
-        @publishing_method ||= default_publishing_method
-      end
-
-      def publishing_method=(method)
-        @publishing_method = resolve_publishing_method(method)
-      end
-
-      def resolve_publishing_method(method)
-        klass_name = method.to_s.camelize
-        begin
-          S::Publishing.const_get(klass_name)
-        rescue NameError => e
-          puts "Unknown method #{method} (#{klass_name})"
-          S::Publishing::Immediate
-        end
-      end
-
-      def publish_pages(page_list=nil)
-        publishing_method.new(self.revision).publish_pages(page_list)
-      end
-
-      def publish_all
-        publishing_method.new(self.revision).publish_all
-      end
-
-      def rerender
-        publishing_method.new(self.published_revision).rerender_revision
-      end
-
-      def publishing_status
-        status = rest = nil
-        # if r = S::Site.pending_revision
-        status, *rest = publishing_method.status.split(':')
-        rest = rest.join(':')
-        # end
-        Hash[[:status, :progress].zip([status, rest])] rescue ""
-      end
-
-      def publishing_status=(status)
-        publishing_method.status = status
-      end
-
-      def with_published(&block)
-        S::Content.with_published(&block)
-      end
-
-      protected
-
-      def set_published_revision(revision)
-        instance = S::State.instance
-        instance.published_revision = revision
-        instance.revision = revision + 1
-        instance.save
-      end
-
-      def pending_revision=(revision)
-        instance = S::State.instance
-        instance.pending_revision = revision
-        instance.save
-      end
-    end # ClassMethods
-  end # Publishing
-end # Spontaneous::Plugins::Site

data/lib/spontaneous/rack/fiber_pool.rb

@@ -1,26 +0,0 @@
-require 'rack/fiber_pool'
-
-module Spontaneous::Rack
-  class FiberPool
-    def initialize(app, options = {})
-      @target_app = app
-      @options    = options
-    end
-
-    def call(env)
-      app.call(env)
-    end
-
-    def app
-      @app ||= wrap_target_app
-    end
-
-    def wrap_target_app
-      if Spontaneous.async?
-        ::Rack::FiberPool.new(@target_app, @options)
-      else
-        @target_app
-      end
-    end
-  end
-end