spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/cli/user.rb

@@ -0,0 +1,107 @@
+
+module Spontaneous
+  module Cli
+    class User < ::Spontaneous::Cli::Thor
+      Spontaneous = ::Spontaneous
+      namespace :user
+
+      default_task :add
+
+      desc "#{namespace}:add", "Add a new user"
+
+      method_option :login,  :type => :string, :aliases => "-l",
+        :desc => "The user's login -- must be unique"
+      method_option :name,   :type => :string, :aliases => "-n",
+        :desc => "The user's name"
+      method_option :email,  :type => :string, :aliases => "-e",
+        :desc => "The user's email address"
+      method_option :passwd, :type => :string, :aliases => ["-p", "--password"],
+        :desc => "The user's password"
+      method_option :level, :type => :string, :aliases => "-a",
+        :desc => "The user's access level"
+
+      def add
+        prepare :adduser, :console
+        boot!
+        users = Spontaneous::Permissions::User.count
+        attrs = {}
+        width = 14
+        valid_login = /^[a-z0-9_]{3,}$/
+        levels = Spontaneous::Permissions::UserLevel.all.map(&:to_s)
+        level = nil
+
+        say("\nAll fields are required:\n", :green)
+        if options.login
+          attrs[:login] = options.login
+          say "Login : ".rjust(width, " ")+" ", :white
+          say options.login, :green
+        else
+          begin
+            attrs[:login] = ask "Login : ".rjust(width, " ")
+            say("Login must consist of at least 3 letters, numbers and underscores", :red) unless valid_login === attrs[:login]
+          end while attrs[:login] !~ valid_login
+        end
+
+        attrs[:name] = options.name || ask("Name : ".rjust(width, " "))
+
+        if options.name
+          say "Name : ".rjust(width, " ")+" ", :white
+          say options.name, :green
+        end
+
+        attrs[:email] = options.email || ask("Email : ".rjust(width, " "))
+
+        if options.email
+          say "Email : ".rjust(width, " ")+" ", :white
+          say options.email, :green
+        end
+
+        if options.passwd
+          attrs[:password] = options.passwd
+          say "Password : ".rjust(width, " ")+" ", :white
+          say options.passwd, :green
+        else
+          begin
+            attrs[:password] = ask "Password : ".rjust(width, " ")
+            say("Password must be at least 6 characters long", :red) unless attrs[:password].length > 5
+          end while attrs[:password].length < 6
+        end
+
+
+        if users == 0
+          level = "root"
+        else
+          if options.level
+            level = options.level
+            say "User level : ".rjust(width, " ")+" ", :white
+            say options.level, :green
+            unless levels.include?(level)
+              say("\nInvalid level '#{level}'", :red)
+              say("Valid levels are: #{levels.join(", ")}", :red)
+              exit 127
+            end
+          else
+            begin
+              level = ask("User level [#{levels.join(', ')}] : ")
+              say("Invalid level '#{level}'", :red) unless levels.include?(level)
+            end while !levels.include?(level)
+          end
+        end
+
+        user = Spontaneous::Permissions::User.new(attrs)
+
+        if user.save
+          user.update(:level => level)
+          say("\nUser '#{user.login}' created with level '#{user.level}'", :green)
+        else
+          errors = user.errors.map do | a, e |
+            " - '#{a.to_s.capitalize}' #{e.first}"
+          end.join("\n")
+          say("\nInvalid user details:\n"+errors, :red)
+          exit 127
+        end
+      end
+    end
+  end
+end
+

data/lib/spontaneous/cli.rb

@@ -42,14 +42,14 @@ module Spontaneous
         end
       end
 
-      def prepare(task)
+      def prepare(task, mode = nil)
         if options.help?
           help(task.to_s)
           raise SystemExit
         end
         ENV["SPOT_ENV"] ||= options.environment.to_s
         ENV["RACK_ENV"] = ENV["SPOT_ENV"] # Also set this for middleware
-        ENV["SPOT_MODE"] ||= options.mode.to_s
+        ENV["SPOT_MODE"] = mode.to_s unless mode.nil?
         chdir(options.site)
         unless File.exist?('config/boot.rb')
           puts "=> Could not find boot file in: #{options.chdir}/config/boot.rb\n=> Are you sure this is a Spontaneous site?"
@@ -69,11 +69,106 @@ module Spontaneous
       end
     end
 
-    class Runner < ::Thor::Runner
-      remove_task :install#, :undefine => true
+    class Runner < ::Thor
+      namespace "default"
+
+      remove_task :help
+
+      map %w(-T) => :list, %w(--version -v) => :version
+
+      desc "version", "Show Spontaneous version"
+      def version
+        require 'spontaneous/version'
+        say "Spontaneous #{Spontaneous::VERSION}"
+      end
+
+      desc "list [SEARCH]", "List the available tasks (--substring means .*SEARCH)"
+      method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
+      def list(search="")
+        initialize_thorfiles
+
+        search = ".*#{search}" if options["substring"]
+        search = /^#{search}.*/i
+        group  = options[:group] || "standard"
+
+        klasses = Thor::Base.subclasses.select do |k|
+          (options[:all] || k.group == group) && k.namespace =~ search
+        end
+
+        display_klasses(false, false, klasses)
+      end
+
+      # Override Thor#help so it can give information about any class and any method.
+      #
+      desc "help [TASK]", "Describe available tasks or one specific task"
+      def help(task = nil, subcommand = false)
+        task ? self.class.task_help(shell, task) : self.class.help(shell, subcommand)
+      end
+
+
+      # Override Thor#help so it can give information about any class and any method.
+      #
+      def help(meth = nil)
+        if meth && !self.respond_to?(meth)
+          initialize_thorfiles(meth)
+          klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
+          klass.start(["-h", task].compact, :shell => self.shell)
+        else
+          list
+        end
+      end
+
+      # If a task is not found on Thor::Runner, method missing is invoked and
+      # Thor::Runner is then responsable for finding the task in all classes.
+      #
+      def method_missing(meth, *args)
+        meth = meth.to_s
+        initialize_thorfiles(meth)
+        klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
+        args.unshift(task) if task
+        klass.start(args, :shell => self.shell)
+      end
 
       private
 
+      # Display information about the given klasses. If with_module is given,
+      # it shows a table with information extracted from the yaml file.
+      #
+      def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
+        klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
+
+        raise Error, "No tasks available" if klasses.empty?
+        show_modules if with_modules && !thor_yaml.empty?
+
+        list = Hash.new { |h,k| h[k] = [] }
+        groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
+
+        # Get classes which inherit from Thor
+        (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_tasks(false) }
+
+        list.delete("thor")
+
+        # Order namespaces with default coming first
+        list = list.sort{ |a,b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
+        list.each { |n, tasks| display_tasks(n, tasks) unless tasks.empty? }
+      end
+
+      def display_tasks(namespace, list) #:nodoc:
+        list.sort!{ |a,b| a[0] <=> b[0] }
+
+        say shell.set_color(namespace, :blue, true)
+        say "-" * namespace.size
+
+        print_table(list, :truncate => true)
+        say
+      end
+
+      def initialize_thorfiles(relevant_to=nil, skip_lookup=false)
+        thorfiles(relevant_to, skip_lookup).each do |f|
+          Thor::Util.load_thorfile(f, nil, options[:debug]) unless Thor::Base.subclass_files.keys.include?(File.expand_path(f))
+        end
+      end
+
       def thorfiles(*args)
         task_dir = File.expand_path('../cli', __FILE__)
         Dir["#{task_dir}/*.rb"]
@@ -83,6 +178,7 @@ module Spontaneous
     autoload :Adapter,  "spontaneous/cli/adapter"
     autoload :Base,     "spontaneous/cli/base"
     autoload :Site,     "spontaneous/cli/site"
+    autoload :User,     "spontaneous/cli/user"
   end
 end
 

data/lib/spontaneous/collections/entry_set.rb

@@ -65,9 +65,9 @@ module Spontaneous::Collections
       owner.entry_modified!(nil)
     end
 
-    def destroy
+    def destroy(origin)
       store.each do |box_id, entries|
-        entries.dup.each { |e| e.destroy(false) }
+        entries.dup.each { |e| e.destroy(false, origin) }
       end
     end
 

data/lib/spontaneous/collections/field_set.rb

@@ -8,45 +8,71 @@ module Spontaneous::Collections
     def initialize(owner, initial_values)
       super()
       @owner = owner
-      initialize_from_prototypes(initial_values)
+      @field_data = initial_values
+      initialize_from_prototypes
     end
 
-    def initialize_from_prototypes(initial_values)
-      values = (initial_values || []).map do |value|
-        value = S::FieldTypes.deserialize_field(value)
-        [Spontaneous.schema.uids[value[:id]], value]
-      end
-      values = Hash[values]
-      owner.field_prototypes.each do |field_prototype|
-        field = field_prototype.to_field(values[field_prototype.schema_id])
-        add_field(field)
-      end
-    end
 
     def serialize_db
       self.map { |field| field.serialize_db }
     end
 
     def export(user)
-      owner.class.field_names.map do |name|
-        self[name].export(user)
-      end
+      owner.class.field_names.
+        select { |name| owner.field_writable?(user, name) }.
+        map { |name| self[name].export(user) }
     end
 
     def saved
       self.each { |field| field.mark_unmodified }
     end
 
+    # Lazily load fields by name
+    def named(name)
+      super || load_field(owner.field_prototypes[name.to_sym])
+    end
+
     protected
 
-    def add_field(field)
-      field.owner = owner
-      getter_name = field.name
-      setter_name = "#{field.name}="
-      self[field.name.to_sym] = field
+    def initialize_from_prototypes
+      owner.field_prototypes.each do |field_prototype|
+        add_field(field_prototype)
+      end
+    end
+
+    def field_values
+      @field_values ||= parse_field_data(@field_data)
+    end
+
+    def parse_field_data(initial_values)
+      values = (initial_values || []).map do |value|
+        value = S::FieldTypes.deserialize_field(value)
+        [Spontaneous.schema.uids[value[:id]], value]
+      end
+      Hash[values]
+    end
+
+    # overwritten because otherwise the iterators in PrototypeSet don't
+    # know which keys we are supposed to have
+    def local_order
+      owner.field_prototypes.keys
+    end
+
+    def add_field(field_prototype)
+      name = field_prototype.name
+      getter_name = name
+      setter_name = "#{name}="
       singleton_class.class_eval do
-        define_method(getter_name) { |*args| field.tap { |f| f.template_params = args } }
-        define_method(setter_name) { |value| field.value = value }
+        define_method(getter_name) { |*args| named(name).tap { |f| f.template_params = args } }
+        define_method(setter_name) { |value| named(name).value = value }
+      end
+    end
+
+    def load_field(field_prototype)
+      return nil if field_prototype.nil?
+      field_prototype.to_field(owner, field_values[field_prototype.schema_id]).tap do |field|
+        field.owner = owner
+        self[field_prototype.name] = field
       end
     end
   end

data/lib/spontaneous/collections/prototype_set.rb

@@ -4,19 +4,19 @@ module Spontaneous::Collections
   class PrototypeSet
     include Enumerable
 
-    attr_reader :store
+    attr_reader :store, :local_order
 
     def initialize(superobject = nil, superset_name = nil)
       @superobject, @superset_name = superobject, superset_name
       @has_superset = !!(@superobject && @superobject.respond_to?(@superset_name))
       @store = {}
-      @order = []
+      @local_order = []
     end
 
     def []=(name, value)
       key = name.to_sym
       @store[key] = value
-      @order << key unless order.include?(key)
+      add_key(key)
     end
 
     def [](key)
@@ -28,6 +28,10 @@ module Spontaneous::Collections
       end
     end
 
+    def add_key(key)
+      local_order << key unless order.include?(key)
+    end
+
     def key?(key)
       keys.include?(key.to_sym)
     end
@@ -49,7 +53,7 @@ module Spontaneous::Collections
     end
 
     def local_first
-      if (key = @order.first)
+      if (key = local_order.first)
         named(key)
       else
         superset? ? superset.local_first : nil
@@ -69,7 +73,7 @@ module Spontaneous::Collections
     end
 
     def local_values
-      @order.map { |name| named(name) }
+      local_order.map { |name| named(name) }
     end
 
     def sid(schema_id)
@@ -99,26 +103,26 @@ module Spontaneous::Collections
     # set.order = [:b, :d]
     # set.order #=> [:b, :d, :a, :c]
     #
-    def order=(new_order)
+    def order=(newlocal_order)
       # clear any previous custom order
       @custom_order = nil
-      old_order = order.dup
+      oldlocal_order = order.dup
       order = []
-      new_order.each do |name|
+      newlocal_order.each do |name|
         key = name.to_sym
-        if old_order.include?(key)
-          old_order.delete(key)
+        if oldlocal_order.include?(key)
+          oldlocal_order.delete(key)
           order << key
         end
       end
-      order += old_order
+      order += oldlocal_order
       @custom_order = order
     end
 
 
     def order
       return @custom_order if @custom_order
-      superset? ? (superset.order + @order) : @order
+      superset? ? (superset.order + local_order) : local_order
     end
 
     alias_method :names, :order
@@ -146,7 +150,7 @@ module Spontaneous::Collections
       @superset ||= @superobject.send(@superset_name) if superset?
     end
 
-    protected
+
 
     def method_missing(method, *args)
       if key?(method)
@@ -155,5 +159,8 @@ module Spontaneous::Collections
         super
       end
     end
+
+    protected :local_order, :method_missing
+
   end # PrototypeSet
 end # Spontaneous

data/lib/spontaneous/constants.rb

@@ -10,6 +10,7 @@ module Spontaneous
     QUESTION = "?".freeze
     LF = "\n".freeze
     PATH_INFO = "PATH_INFO".freeze
+    REQUEST_METHOD = "REQUEST_METHOD".freeze
 
     SPOT_REVISION_NUMBER = "SPOT_REVISION".freeze
     SPOT_ROOT = "SPOT_ROOT".freeze
@@ -20,5 +21,7 @@ module Spontaneous
     RE_FLATTEN = /[^\.a-z0-9-]+/.freeze
     RE_FLATTEN_REPEAT = /\-+/.freeze
     RE_FLATTEN_TRAILING = /(^\-|\-$)/.freeze
+
+    VISIBILITY_PATH_SEP = ".".freeze
   end
 end

data/lib/spontaneous/content.rb

@@ -14,10 +14,10 @@ module Spontaneous
     include Plugins::SchemaId
 
     sequel_plugin :content_table_inheritance, :type_sid
-    sequel_plugin :serialization, :yajl, :field_store, :entry_store, :box_store
+    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=>:modified_at
+    sequel_plugin :timestamps, :create=>:created_at, :update_on_create => true
     sequel_plugin :identity_map
     sequel_plugin :association_dependencies
     sequel_plugin :defaults_setter
@@ -38,9 +38,10 @@ module Spontaneous
       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 :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
 
@@ -56,10 +57,12 @@ module Spontaneous
     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?
@@ -70,6 +73,13 @@ module Spontaneous
       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
@@ -108,5 +118,12 @@ module Spontaneous
       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/errors.rb

@@ -32,9 +32,9 @@ module Spontaneous
   end
 
 
-  class UnknownFormatException < Error
-    def initialize(unsupported_format)
-      super("Format '#{unsupported_format}' has no matching mime type")
+  class UnknownOutputException < Error
+    def initialize(content_class, unsupported_output_name)
+      super("Type '#{content_class}' does not output '#{unsupported_output_name}'")
     end
   end
 

data/lib/spontaneous/extensions/array.rb

@@ -3,6 +3,18 @@
 module Spontaneous
   module Extensions
     module Array
+      def render_using(renderer, *args)
+        self.map { |e|
+          if e.respond_to?(:render_using)
+            e.render_using(renderer, *args)
+          elsif e.respond_to?(:render)
+            e.render(*args)
+          else
+            e
+          end
+        }.join
+      end
+
       def render(*args)
         self.map { |e| e.respond_to?(:render) ? e.render(*args) : e }.join
       end

data/lib/spontaneous/extensions/enumerable.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+module Enumerable
+  def slice_between(&b)
+    Enumerator.new {|y|
+      first = true
+      buf = []
+      prev = nil
+      self.each {|elt|
+        if first
+          first = false
+          buf << elt
+          prev = elt
+        else
+          if b.call(prev, elt)
+            y << buf
+            buf = [elt]
+          else
+            buf << elt
+          end
+          prev = elt
+        end
+      }
+      if !buf.empty?
+        y << buf
+      end
+    }
+  end
+end
+

data/lib/spontaneous/extensions/nil.rb

@@ -2,9 +2,11 @@
 
 module Spontaneous::Extensions
   module NilClass
-    def /(alternative)
+    def or(alternative)
       alternative
     end
+
+    alias_method :/, :or
   end # String
 end # Extensions
 

data/lib/spontaneous/extensions/string.rb

@@ -8,6 +8,17 @@ module Spontaneous
         File.join(self, path.to_s)
       end
 
+      def or(alternative)
+        return alternative if empty?
+        self
+      end
+
+      alias_method :'|', :or
+
+      def value(format = :html)
+        self
+      end
+
       HTML_ESCAPE_TABLE = {
         '&' => '&',
         '<' => '&lt;',
@@ -34,6 +45,11 @@ module Spontaneous
         self.gsub(/(\\|<\/|\r\n|[\n\r"'])/) { JS_ESCAPE_MAP[$1] }
       end
 
+      # Makes it easier to pass either a field or a String around
+      # in templates
+      def to_html
+        self
+      end
     end
   end
 end