spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/field_types/date_field.rb

@@ -1,13 +1,56 @@
 # encoding: UTF-8
 
-
 module Spontaneous
   module FieldTypes
     class DateField < Field
       include Spontaneous::Plugins::Field::EditorClass
+
+      DEFAULT_FORMAT = "%A, %-d %B, %Y"
+
+      def self.export(user)
+        super.merge({
+          :date_format => prototype.options[:format] || DEFAULT_FORMAT
+        })
+      end
+
+      def value(output = :html, *args)
+        return date if date.is_a?(String)
+        case output
+        when :html
+          date.strftime(html_format)
+        else
+          date.strftime(format)
+        end
+      end
+
+      def outputs
+        [:julian]
+      end
+
+      def preprocess(value)
+        return value if value.blank?
+        Date.parse(value)
+      end
+
+      def html_format
+        %(<time datetime="%Y-%m-%d">#{ format }</time>)
+      end
+
+      def generate_julian(date)
+        return date.jd if date.is_a?(Date)
+        date.to_s
+      end
+
+      def date
+        return "" if values[:julian].blank?
+        Date.jd values[:julian].to_i
+      end
+
+      def format
+        prototype.options[:format] ||  DEFAULT_FORMAT
+      end
     end
 
     DateField.register
   end
 end
-

data/lib/spontaneous/field_types/field.rb

@@ -25,13 +25,14 @@ module Spontaneous
           end
         end
       end
-      # def self.prototype=(prototype)
-      #   @prototype = prototype
-      # end
 
-      # def self.prototype
-      #   @prototype
-      # end
+      def self.prototype=(prototype)
+        @prototype = prototype
+      end
+
+      def self.prototype
+        @prototype
+      end
 
       def self.accepts
         %w(text/.+)
@@ -44,6 +45,12 @@ module Spontaneous
       end
 
 
+      # Provides the ability for specific field types to customize the schema values
+      # they return to the UI
+      def self.export(user)
+        {}
+      end
+
       attr_accessor :owner, :name, :unprocessed_value, :template_params, :version
       attr_reader   :processed_values
 
@@ -57,7 +64,7 @@ module Spontaneous
 
 
       def outputs
-        [:html]
+        [:html, :plain]
       end
 
       def unprocessed_value=(v)
@@ -228,11 +235,30 @@ module Spontaneous
       alias_method :empty?, :blank?
 
 
-      def /(field)
+      def or(field)
         return field if self.blank?
         self
       end
-      alias_method :'|', :/
+
+      alias_method :'/', :or
+      alias_method :'|', :or
+
+      def versions
+        owner.field_versions(self)
+      end
+
+      def previous_version
+        versions.first
+      end
+
+      def create_version
+        Spontaneous::FieldVersion.create(
+          :content_id => owner.id,
+          :field_sid => self.schema_id.to_s,
+          :version => version,
+          :value => @initial_value,
+          :user => owner.current_editor)
+      end
 
       protected
 
@@ -264,6 +290,13 @@ module Spontaneous
         @unprocessed_value = new_value
       end
 
+      def method_missing(method, *args)
+        if outputs.include?(method)
+          value(method)
+        else
+          super
+        end
+      end
     end
   end
 end

data/lib/spontaneous/field_types/file_field.rb

@@ -0,0 +1,68 @@
+# encoding: UTF-8
+
+require 'tempfile'
+
+module Spontaneous::FieldTypes
+  class FileField < Field
+    include Spontaneous::Plugins::Field::EditorClass
+
+    def outputs
+      [:html, :filesize, :filename]
+    end
+
+    def preprocess(image_path)
+      filename = mimetype = nil
+      case image_path
+      when Hash
+        mimetype = image_path[:type]
+        filename = image_path[:filename]
+        image_path = image_path[:tempfile].path
+      when String
+        filename = ::File.basename(image_path)
+      end
+      return image_path unless File.exist?(image_path)
+
+      media_file = Spontaneous::Media::File.new(owner, filename, mimetype)
+      media_file.copy(image_path)
+      set_unprocessed_value(filename)
+      media_file
+    end
+
+    def generate_filesize(input)
+      if input.respond_to?(:filesize)
+        input.filesize
+      else
+        if ::File.exist?(input)
+          ::File.size(input)
+        else
+          0
+        end
+      end
+    end
+
+    def generate_filename(input)
+      if input.respond_to?(:filename)
+        input.filename
+      else
+        ::File.basename(input.to_s)
+      end
+    end
+
+    def generate_html(input)
+      return input if input.is_a?(String)
+      input.url
+    end
+
+    def export(user = nil)
+      super(user).merge({
+        :processed_value => processed_values
+      })
+    end
+
+    def path
+      value(:html)
+    end
+  end
+
+  FileField.register
+end

data/lib/spontaneous/field_types/image_field.rb

@@ -7,6 +7,57 @@ require 'delegate'
 module Spontaneous
   module FieldTypes
 
+    class ImageOptimizer
+      def self.run(source_image)
+        self.new(source_image).run
+      end
+
+      def self.jpegtran_binary
+        @jpegtran ||= find_binary("jpegtran")
+      end
+
+      def self.jpegoptim_binary
+        @jpegoptim ||= find_binary("jpegoptim")
+      end
+
+      def self.find_binary(name)
+        binary = `which #{name}`.chomp
+        return nil if binary.length == 0
+        binary
+      end
+
+      # def self.find_binary(name)
+      #   binaries = ["/usr/bin/env #{name}"]
+      #   puts "testing name #{name}"
+      #   binaries.detect { |bin| status = Spontaneous.system("#{bin} -h"); p status; status == 1  }.tap do |b|
+      #     puts "found #{b.inspect}"
+      #   end
+      # end
+
+      def initialize(source_image)
+        @source_image = source_image
+      end
+
+      def run
+        jpegoptim!(@source_image)
+        jpegtran!(@source_image)
+      end
+
+      def jpegoptim!(input)
+        run_optimization(self.class.jpegoptim_binary, "-o -q --strip-all --preserve --force #{input} 2>&1 1>/dev/null")
+      end
+
+      def jpegtran!(input)
+        run_optimization(self.class.jpegtran_binary, "-optimize -progressive -copy none -outfile #{input} #{input}")
+      end
+
+      def run_optimization(binary, args)
+        return unless binary
+        command = [binary, args].join(" ")
+        Spontaneous.system(command)
+      end
+    end
+
     module ImageFieldUtilities
       attr_accessor :template_params
 
@@ -269,6 +320,14 @@ module Spontaneous
           end
         end
 
+        def smush_it!
+          ::Spontaneous::Utils::SmushIt.smush!(image.path, current_image_format)
+        end
+
+        def optimize!
+          ImageOptimizer.run(image.path) if current_image_format == "jpg"
+        end
+
         def border_radius(radius, bg_color = nil)
           @image.format('png') if bg_color.nil? or bg_color == 'transparent'
           puts @image.path
@@ -319,6 +378,10 @@ module Spontaneous
             image.method_missing(method, *params, &block)
           end
         end
+
+        def current_image_format
+          image[:format].downcase.gsub(/^jpeg$/, "jpg")
+        end
       end
 
       MAX_DIM = 2 ** ([42].pack('i').size * 8) - 1 unless defined?(MAX_DIM)

data/lib/spontaneous/field_types/select_field.rb

@@ -0,0 +1,109 @@
+# encoding: UTF-8
+
+module Spontaneous::FieldTypes
+  # Provides a select field in the UI.
+  #
+  # Options for the select are provided by passing an :options value in the field config.
+  #
+  # This form gives a fixed list of options whose values & labels are the same:
+  #
+  #   class Something < Piece
+  #     field :choices, :select, :options => [ "First Option", "Second Option" ]
+  #   end
+  #
+  # This will generate a select tag showing "First Option" and "Second Option" in the
+  # editing UI.
+  #
+  # If you want to have the generated <option/> tag values to be different from the label,
+  # then pass an array of arrays as the options:
+  #
+  #   class Something < Piece
+  #     field :choices, :select, :options => [ ["value1", "Label 1"], ["value2", "Label 2"] ]
+  #   end
+  #
+  # You can provide a dynamic set by passing a Proc as the value of the :options parameter:
+  #
+  #   field :choices, :select, :options => proc { |page, box|
+  #     Things.all.map { |thing| [thing.id, thing.name] }
+  #   }
+  #
+  # In this case the options list will be generated dynamically every time the field is edited.
+  #
+  # To retrieve the selected value from the field, use the standard field.value form.
+  # In the case of the example above, the field would return either "value1" or "value2".
+  #
+  # To retrieve the associated label use `field.value(:label)` or `field.label`
+  # ("Value 1" or "Value 2" in the exampel above).
+  #
+  class SelectField < Field
+    include Spontaneous::Plugins::Field::EditorClass
+
+    def self.static_option_list?
+      return false if configured_option_list.is_a?(Proc)
+      true
+    end
+
+    def self.configured_option_list
+      @configured_option_list ||= normalize_options_list(prototype.options[:options])
+    end
+
+    def self.normalize_options_list(options)
+      return options if options.is_a?(Proc)
+      options.map { |opt|
+        case opt
+        when Array
+          opt
+        else
+          [opt, opt]
+        end.map { |opt| opt.to_s }
+      }
+    end
+
+    def self.export(user)
+      default_value = super
+      return default_value unless static_option_list?
+      default_value.merge({
+        :option_list => configured_option_list
+      })
+    end
+
+    def self.option_list(owner)
+      case (opts = configured_option_list)
+      when Proc
+        opts.call(owner)
+      when Array
+        opts
+      else
+        []
+      end
+    end
+
+    def option_list
+      self.class.option_list(self.owner)
+    end
+
+    def outputs
+      [:html, :label]
+    end
+
+    def generate(output, value)
+      return "" if value.blank?
+      value[[:html, :label].index(output)]
+    end
+
+    def preprocess(value)
+      Spontaneous::JSON.parse(value)
+    end
+
+    def label
+      value(:label)
+    end
+
+    def ui_preview_value
+      unprocessed_value
+    end
+
+    self.register
+  end # OptionsField
+end
+

data/lib/spontaneous/field_types/string_field.rb

@@ -5,10 +5,15 @@ module Spontaneous
     class StringField < Field
       include Spontaneous::Plugins::Field::EditorClass
 
+      def preprocess(value)
+        Spontaneous::Utils::SmartQuotes.smarten(value.to_s)
+      end
+
       def generate_html(value)
         escape_html(value)
       end
     end
-    StringField.register
+
+    StringField.register :string, :title
   end
 end

data/lib/spontaneous/field_types/webvideo_field.rb

@@ -83,9 +83,20 @@ module Spontaneous
         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)
+        # render(:html, :width => 480, :height => 270)
+        src
       end
 
       def retrieve_vimeo_metadata(id)
@@ -145,6 +156,23 @@ module Spontaneous
 
       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) || {}
 
@@ -168,23 +196,28 @@ module Spontaneous
           :byline => true,
           :player_id => "vimeo#{owner.id}id#{value(:id)}"
         }.merge(o).merge(vimeo_options).merge(options)
+        o
+      end
 
-        attributes = {
-          :type => "text/html",
-          :frameborder => "0",
-          :width => o.delete(:width),
-          :height => o.delete(:height)
-        }
-        attributes.update(:webkitAllowFullScreen => "yes", :allowFullScreen => "yes") if o[:fullscreen]
-
+      def vimeo_src(options = {})
+        o = make_vimeo_options(options)
         make_query_options!(o)
-
-        attributes[:src] = "http://player.vimeo.com/video/#{value(:id)}?title=#{o[:title]}&byline=#{o[:byline]}&portrait=#{o[:portrait]}&autoplay=#{o[:autoplay]}&loop=#{o[:loop]}&api=#{o[:api]}&player_id=#{o[:player_id]}#{o.key?(:color) ? "&color=#{o[:color]}" : ""}"
-
-        {:tagname => "iframe", :tag => "<iframe/>", :attr => attributes}
-
+        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)
@@ -194,7 +227,25 @@ module Spontaneous
 
 
       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) || {}
 
@@ -218,23 +269,30 @@ module Spontaneous
           :autohide => 2,
           :rel => true
         }.merge(o).merge(youtube_options).merge(options)
+      end
 
-        attributes = {
-          :type => "text/html",
-          :frameborder => "0",
-          :width => o.delete(:width),
-          :height => o.delete(:height)
-        }
-
+      def youtube_src(options = {})
+        o = make_youtube_options(options)
         make_query_options!(o)
-
-        attributes[:src] = "http://www.youtube.com/embed/#{value(:id)}?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]}"
-        attributes.update(:webkitAllowFullScreen => "yes", :allowFullScreen => "yes") if o[:fullscreen]
-
-
-        {:tagname => "iframe", :tag => "<iframe/>", :attr => attributes}
+        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(" ")

data/lib/spontaneous/field_types.rb

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

data/lib/spontaneous/field_version.rb

@@ -0,0 +1,8 @@
+
+module Spontaneous
+  class FieldVersion < Sequel::Model(:spontaneous_field_versions)
+    plugin :timestamps
+
+    many_to_one :user, :class => Spontaneous::Permissions::User
+  end
+end

data/lib/spontaneous/generators/page.rb

@@ -31,7 +31,7 @@ module Spontaneous
         self.destination_root = options[:root]
         empty_directory "schema"
         template 'page.rb.tt', "schema/#{disk_name}.rb"
-        copy_file 'inline.html.cut', "templates/#{disk_name}.html.#{Spontaneous::Render.extension}"
+        copy_file 'inline.html.cut', "templates/#{disk_name}.html.#{Spontaneous::Output::Template.extension}"
       end
     end
   end

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

@@ -1,7 +1,4 @@
-#load 'deploy' if respond_to?(:namespace) # cap2 differentiator
-
-# Uncomment if you are using Rails' asset pipeline
-# load 'deploy/assets'
+load 'deploy' if respond_to?(:namespace) # cap2 differentiator
 
 #Dir['vendor/gems/*/recipes/*.rb','vendor/plugins/*/recipes/*.rb'].each { |plugin| load(plugin) }
 

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

@@ -7,16 +7,23 @@ gem 'mysql2', '~> 0.2'
 # 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
+# because the xapian library takes a very long time to build.
+#gem 'xapian-full', "~> 1.2.3"
+#gem 'xapian-fu', "~> 1.3"
 
 ## TODO: replace this path based gem with a version once the gem is live
 #gem 'spontaneous', '<%= Spontaneous::VERSION %>'
-gem 'spontaneous', :path => "/Users/garry/Dropbox/Development/spontaneous3/working"
-## TODO: Remove this line when Simultaneous is published
-gem 'simultaneous', :path => "/Users/garry/Dropbox/Development/spontaneous3/simultaneous"
 
-# group :development, :test do
-#   gem 'webrat'
-# end
+gem 'spontaneous', :git => "git://github.com/SpontaneousCMS/spontaneous.git"
+gem 'simultaneous', :git => "git://github.com/SpontaneousCMS/simultaneous.git"
+
+group :production do
+  gem 'thin',    '~> 1.3.1'
+  gem 'unicorn', '~> 4.2'
+end
+
 
 # source gemfiles from Plugins & Features
 Dir['*/**/Gemfile'].each do |path|

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

@@ -0,0 +1,28 @@
+ENV["SPOT_MODE"] = "console"
+
+require File.expand_path("../boot.rb", __FILE__)
+
+require "spontaneous/capistrano"
+require "bundler/capistrano"
+
+default_run_options[:pty]   = true
+
+ssh_options[:port]          = 22
+ssh_options[:forward_agent] = true
+
+set :application,           "<%= @domain %>"
+server                      "<%= @domain %>", :app, :web, :db, :media
+set :user,                  "<%= @username %>"
+set :use_sudo,              false
+
+
+set :scm,                   "git"
+set :repository,            "git@<%= @domain %>:spontaneous.git"
+
+set :deploy_to,             "/home/#{fetch(:user)}/spontaneous"
+
+namespace :deploy do
+  task :restart, :roles => [:app, :web] do
+    run "sv kill /home/#{fetch(:user)}/service/enabled/back"
+  end
+end

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

@@ -1,7 +1,12 @@
 
 publishing_method :simultaneous
 
-simultaneous_connection "/tmp/simultaneous.sock"
+simultaneous_connection ENV["SIMULTANEOUS_SOCKET"]
+spontaneous_binary      ENV["SPONTANEOUS_BINARY"]
+
+server_connection       ENV["SPONTANEOUS_SERVER"]
 
 # used by publishing mech to determine a restart strategy
-handler :unicorn
+handler                 :unicorn
+after_publish_restart   ENV["POST_PUBLISH_COMMAND"]
+