spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/content.rb

@@ -1,129 +0,0 @@
-# encoding: UTF-8
-
-require File.expand_path("../../sequel/plugins/content_table_inheritance", __FILE__)
-
-module Spontaneous
-  class Content < Sequel::Model(:content)
-    class << self
-      alias_method :sequel_plugin, :plugin unless method_defined?(:sequel_plugin)
-    end
-
-    alias_method :each_attribute, :each
-
-    # need to load this first because it's used by the ContentTableInheritance plugin
-    include Plugins::SchemaId
-
-    sequel_plugin :content_table_inheritance, :type_sid
-    sequel_plugin :serialization, :ojson, :field_store, :entry_store, :box_store, :serialized_modifications
-    sequel_plugin :instance_hooks
-    sequel_plugin :skip_create_refresh
-    sequel_plugin :timestamps, :create=>:created_at, :update_on_create => true
-    sequel_plugin :identity_map
-    sequel_plugin :association_dependencies
-    sequel_plugin :defaults_setter
-    sequel_plugin :scoped_table_name
-
-    # overwrite the sequel version defined in IdentityMap to support
-    # revisions
-    def self.identity_map_key(pk)
-      "#{super}:#{revision}"
-    end
-
-    # must resolve my is_*? schizophrenia
-    def self.page?
-      false
-    end
-
-    def self.is_page?
-      page?
-    end
-
-    many_to_one :owner,      :key => :owner_id, :class => Content, :reciprocal => :_pieces
-    one_to_many :_pieces,    :key => :owner_id, :class => Content, :reciprocal => :owner
-    many_to_one :page,       :key => :page_id,  :class => Content, :reciprocal => :content
-    many_to_one :created_by, :key => :created_by_id, :class => Spontaneous::Permissions::User
-
-    include Enumerable
-
-    include Plugins::Entry
-    include Plugins::Boxes
-    include Plugins::Fields
-    include Plugins::Entries
-    include Plugins::Styles
-    include Plugins::SchemaTitle
-    include Plugins::Render
-    include Plugins::SchemaHierarchy
-    include Plugins::InstanceCode
-    include Plugins::Serialisation
-    include Plugins::Media
-    include Plugins::Publishing
-    include Plugins::Modifications
-    include Plugins::Aliases
-    include Plugins::Visibility
-    include Plugins::Prototypes
-    include Plugins::Permissions
-    include Plugins::ContentGroups
-
-    # marker method enabling a simple test for "cms content" vs "everything else"
-    def spontaneous_content?
-      true
-    end
-
-    def alias?
-      false
-    end
-
-    # Provides consistency between aliases & non-aliases
-    # so that a mixed list of both can be treated the same
-    # (for instance when ensuring uniqueness)
-    def target
-      self
-    end
-
-    def page?
-      false
-    end
-    alias_method :is_page?, :page?
-
-
-
-    # terminate the supertype chain here
-    def self.supertype
-      nil
-    end
-
-    def self.supertype?
-      !supertype.nil?
-    end
-
-    def start_inline_edit_marker
-      "spontaneous:previewedit:start:content id:#{id}"
-    end
-
-    def end_inline_edit_marker
-      "spontaneous:previewedit:end:content id:#{id}"
-    end
-
-    def to_s
-      %(#<#{self.class.name} id=#{id}>)
-    end
-
-    def each
-      iterable.each do |i|
-        yield i if block_given?
-      end
-    end
-
-    def formats
-      return page.formats if page
-      [:html]
-    end
-
-    def log_sql(io = $stdout)
-      db.logger = ::Logger.new(io)
-      yield if block_given?
-    ensure
-      db.logger = nil
-    end
-  end
-end

data/lib/spontaneous/field_types/date_field.rb

@@ -1,56 +0,0 @@
-# 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

@@ -1,302 +0,0 @@
-# encoding: UTF-8
-
-
-module Spontaneous
-  module FieldTypes
-    class Field
-      extend Plugins
-
-      def self.register(*labels)
-        labels = self.labels if labels.empty?
-        # logger.debug("Registering #{self} as #{labels.join(", ")}")
-        FieldTypes.register(self, *labels)
-        self
-      end
-
-      def self.labels
-        [self.name.demodulize.gsub(/Field$/, '').underscore]
-      end
-
-      def self.inherited(subclass, real_caller = nil)
-        if self.respond_to?(:editor_class)
-          editor_class = self.editor_class
-          subclass.singleton_class.send(:define_method, :editor_class) do
-            editor_class
-          end
-        end
-      end
-
-      def self.prototype=(prototype)
-        @prototype = prototype
-      end
-
-      def self.prototype
-        @prototype
-      end
-
-      def self.accepts
-        %w(text/.+)
-      end
-
-      def self.accepts?(mime_type)
-        accepts.find do |pattern|
-          Regexp.new(pattern).match(mime_type)
-        end
-      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
-
-      alias_method :values, :processed_values
-
-
-      def initialize(params={}, from_db=false)
-        @processed_values = {}
-        load(params, from_db)
-      end
-
-
-      def outputs
-        [:html, :plain]
-      end
-
-      def unprocessed_value=(v)
-        set_unprocessed_value(v)
-        unless @preprocessed
-          @modified = (@initial_value != v)
-          increment_version if @modified
-          self.processed_values = generate_outputs(@unprocessed_value)
-          owner.field_modified!(self) if owner
-        end
-      end
-
-      def increment_version
-        self.version += 1
-      end
-
-      def version
-        @version ||= 0
-      end
-
-      # value used to show conflicts between the current value and the value they're attempting to enter
-      def conflicted_value
-        unprocessed_value
-      end
-
-      def generate_outputs(value)
-        values = {}
-        value = preprocess(value)
-        outputs.each do |output|
-          process_method = "generate_#{output}"
-          values[output] = \
-            if respond_to?(process_method)
-              send(process_method, value)
-            else
-              generate(output, value)
-            end
-        end
-        values
-      end
-
-      # should be overwritten in subclasses that actually do something
-      # with the field value
-      def preprocess(value)
-        value
-      end
-
-      HTML_ESCAPE_TABLE = {
-        '&' => '&'
-      }
-
-      def escape_html(value)
-        value.to_s.gsub(%r{[#{HTML_ESCAPE_TABLE.keys.join}]}) { |s| HTML_ESCAPE_TABLE[s] }
-      end
-
-      def generate(output, value)
-        value
-      end
-
-      # attr_accessor :values
-
-      # override this to return custom values derived from (un)processed_value
-      # alias_method :value, :processed_value
-      def value(format=:html)
-        processed_values[format.to_sym] || unprocessed_value
-      end
-      alias_method :processed_value, :value
-
-      def image?
-        false
-      end
-
-      def indexable_value
-        unprocessed_value
-      end
-
-      def to_s(format = :html)
-        value(format).to_s
-      end
-
-      def render(format=:html, *args)
-        value(format)
-      end
-
-      def to_html(*args)
-        render(:html, *args)
-      end
-
-      def to_pdf(*args)
-        render(:pdf, *args)
-      end
-
-      def value=(value)
-        self.unprocessed_value = value
-      end
-
-      def mark_unmodified
-        @modified = nil
-      end
-
-      def modified?
-        @modified
-      end
-
-      attr_accessor :prototype
-      # def prototype
-      #   self.class.prototype
-      # end
-
-      def schema_id
-        self.prototype.schema_id
-      end
-
-
-      def schema_name
-        self.prototype.schema_name
-      end
-
-      def schema_owner
-        self.prototype.owner
-      end
-
-      def owner_sid
-        schema_owner.schema_id
-      end
-
-      def serialize_db
-        S::FieldTypes.serialize_field(self)
-      end
-
-      def update(params={})
-        params.each do |property, value|
-          setter = "#{property}=".to_sym
-          if respond_to?(setter)
-            self.send(setter, value)
-          end
-        end
-      end
-
-      # def start_inline_edit_marker
-      #   "spontaneous:previewedit:start:field id:#{owner.id} name:#{self.name}"
-      # end
-      # def end_inline_edit_marker
-      #   "spontaneous:previewedit:end:field id:#{owner.id} name:#{self.name}"
-      # end
-
-      def export(user)
-        {
-        :name => name.to_s,
-        :id => schema_id.to_s,
-        :unprocessed_value => unprocessed_value,
-        :processed_value => ui_preview_value,
-        :version => version
-        }
-      end
-
-      def ui_preview_value
-        value(:html)
-      end
-
-      def inspect
-        %(#<#{self.class.name}:#{self.object_id} #{self.serialize_db.inspect}>)
-      end
-
-      def blank?
-        unprocessed_value.blank?
-      end
-
-      alias_method :empty?, :blank?
-
-
-      def or(field)
-        return field if self.blank?
-        self
-      end
-
-      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
-
-      def load(params={}, from_db=false)
-        with_preprocessed_values(from_db) do
-          params.each do |property, value|
-            setter = "#{property}=".to_sym
-            if respond_to?(setter)
-              self.send(setter, value)
-            end
-          end
-        end
-      end
-
-      def processed_values=(values)
-        @processed_values = values
-      end
-
-      def with_preprocessed_values(state=true)
-        @preprocessed = state
-        yield
-      ensure
-        @preprocessed = nil
-      end
-
-      def set_unprocessed_value(new_value)
-        # initial_value should only be set once so that it can act as a test for field modification
-        @initial_value ||= new_value
-        @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

@@ -1,68 +0,0 @@
-# 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/markdown_field.rb

@@ -1,38 +0,0 @@
-# encoding: UTF-8
-
-require 'kramdown'
-
-module Spontaneous
-  module FieldTypes
-    class MarkdownField < Field
-      include Spontaneous::Plugins::Field::EditorClass
-
-      def outputs
-        [:html]
-      end
-
-      def generate_html(input)
-        input.to_html
-      end
-
-      def preprocess(input)
-        # convert lines ending with newlines into a <br/>
-        # as official Markdown syntax isn't suitable for
-        # casual users
-        # code taken from:
-        # http://github.github.com/github-flavored-markdown/
-        output = input.gsub(/^[\w\<][^\n]*\n+/) do |x|
-          x =~ /\n{2}/ ? x : (x.strip!; x << "  \n")
-        end
-
-        # prevent foo_bar_baz from ending up with an italic word in the middle
-        output.gsub!(/(^(?! {4}|\t)\w+_\w+_\w[\w_]*)/) do |x|
-          x.gsub('_', '\_') if x.split('').sort.to_s[0..1] == '__'
-        end
-        Kramdown::Document.new(output)
-      end
-    end
-
-    MarkdownField.register(:markdown, :text, :richtext)
-  end
-end

data/lib/spontaneous/field_types/string_field.rb

@@ -1,19 +0,0 @@
-# encoding: UTF-8
-
-module Spontaneous
-  module FieldTypes
-    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 :string, :title
-  end
-end