spontaneous 0.2.0.alpha2 → 0.2.0.alpha3

data/lib/spontaneous/permissions/user.rb

@@ -10,7 +10,7 @@ module Spontaneous::Permissions
     many_to_many :groups,       :class => :'Spontaneous::Permissions::AccessGroup', :join_table => :spontaneous_groups_users
     one_to_many  :access_keys,  :class => :'Spontaneous::Permissions::AccessKey'
 
-    set_restricted_columns(:crypted_password)
+    set_restricted_columns(:crypted_password, :salt)
 
     def_delegators :group, :level, :access_selector
 
@@ -18,18 +18,53 @@ module Spontaneous::Permissions
       Digest::SHA1.hexdigest("--#{salt}--#{clear_password}--")
     end
 
-    def self.authenticate(login, clear_password)
+    def self.authenticate(login, clear_password, ip_address = nil)
       if user = self[:login => login, :disabled => false]
         crypted_password = user.encrypt_password(clear_password)
         if crypted_password == user.crypted_password
-          access_key = user.logged_in!
+          access_key = user.logged_in!(ip_address)
           return access_key
         end
       end
       nil
     end
 
-    attr_accessor :password, :password_confirmation
+    def self.create(attributes = {})
+      level = attributes.delete(:level) || attributes.delete("level")
+      user =  super
+      user.update(:level => Spontaneous::Permissions[level]) if level && user
+      user
+    end
+
+    def self.export(user = nil)
+      users = self.order(:login).all
+      users = users.reject { |u| u.level > user.level } if user
+      exported = {}
+      exported[:users] = users.map { |u|
+        export_user(u)
+      }
+      base_level = user.nil? ? nil : user.level
+      exported[:levels] = UserLevel.all(base_level).map { |level|
+        { :level => level.to_s, :can_publish => level.can_publish?, :is_admin => level.admin? }
+      }
+      exported
+    end
+
+    def self.export_user(u)
+      keys = u.access_keys.map { |key|
+        {:last_access_at => key.last_access_at.httpdate, :last_access_ip => key.last_access_ip}
+      }
+      { :id    => u.id,
+        :name  => u.name,
+        :email => u.email,
+        :login => u.login,
+        :level => u.level.to_s,
+        :disabled => u.disabled?,
+        :keys  => keys }
+    end
+
+    attr_accessor :password
+    alias_method  :disabled?, :disabled
 
     ##
     # Find the highest access level available from all the groups we
@@ -43,13 +78,13 @@ module Spontaneous::Permissions
       access_keys.map(&:last_access_at).sort.last
     end
 
-    def logged_in!
+    def logged_in!(ip_address = nil)
       self.last_login_at = Time.now
-      generate_access_key
+      generate_access_key(ip_address)
     end
 
-    def generate_access_key
-      key = AccessKey.new
+    def generate_access_key(ip_address)
+      key = AccessKey.new(:last_access_ip => ip_address)
       self.add_access_key(key)
       self.save
       key
@@ -62,12 +97,28 @@ module Spontaneous::Permissions
     def before_save
       self.salt = Spontaneous::Permissions.random_string(32) if salt.blank?
       self.crypted_password = encrypt_password(password) unless password.blank?
-      if self.disabled
-        access_keys.each { | key | key.delete }
-      end
+      clear_access_keys! if disabled?
       super
     end
 
+    def clear_access_keys!
+      access_keys.each { | key | key.delete }
+    end
+
+    def enabled?
+      !disabled?
+    end
+
+    def disable!
+      self.disabled = true
+      self.save
+    end
+
+    def enable!
+      self.disabled = false
+      self.save
+    end
+
     def after_create
       super
       ensure_group!
@@ -78,11 +129,6 @@ module Spontaneous::Permissions
       @password = new_password
     end
 
-    def password_confirmation=(new_password)
-      updating_password!
-      @password_confirmation = new_password
-    end
-
     def level=(level)
       ensure_group!
       group.level = level
@@ -98,7 +144,15 @@ module Spontaneous::Permissions
     end
 
     def developer?
-      level.developer?
+      level.developer? || false
+    end
+
+    def can_publish?
+      level.can_publish? || false
+    end
+
+    def admin?
+      level.admin? || false
     end
 
     def export
@@ -106,7 +160,9 @@ module Spontaneous::Permissions
         :name => name,
         :email => email,
         :login => login,
-        :developer => !!developer?
+        :can_publish => can_publish?,
+        :developer => developer?,
+        :admin => admin?
       }
     end
 
@@ -118,36 +174,26 @@ module Spontaneous::Permissions
 
     def validate
       super
-      errors.add(:name, 'is required') if name.blank?
+      errors.add(:name,  'is required') if name.blank?
       errors.add(:email, 'is required') if email.blank?
-      errors.add(:email, 'is invalid') unless email =~ /^[^@]+@.+$/
+      errors.add(:email, 'is invalid')  unless email.blank? or email =~ /\A[^@]+@.+\z/
 
       if login.blank?
         errors.add(:login, 'is required')
       else
-        errors.add(:login, 'should only contain letters, numbers & underscore') unless login =~ /^[a-zA-Z0-9_]+$/
+        errors.add(:login, 'should only contain letters, numbers & underscore') unless login =~ /\A[a-zA-Z0-9_]+\z/
         errors.add(:login, 'should be at least 3 letters long') if login.length < 3
       end
 
-      if errors[:login].empty? && new?
-        if User[:login => login]
-          errors.add(:login, "must be unique, login '#{login}' already exists")
-        end
+      if (u = User[:login => login]) && (u.id != id)
+        errors.add(:login, "must be unique, login '#{login}' already exists")
       end
 
       if new? || updating_password?
         if password.blank?
           errors.add(:password, 'is required')
-        elsif password_confirmation.blank?
-          errors.add(:password_confirmation, 'is required')
-        else
-          if password != password_confirmation
-            errors.add(:password_confirmation, 'should match the password')
-          else
-            if password.length < 6
-              errors.add(:password, 'is too short. It should be at least 6 characters')
-            end
-          end
+        elsif password.length < 8
+          errors.add(:password, 'should be at least 6 characters long')
         end
       end
     end

data/lib/spontaneous/permissions/user_level.rb

@@ -7,27 +7,26 @@ module Spontaneous::Permissions
 
     class Root
       private(:initialize)
-      def self.>(level); true; end
-      def self.>=(level); true; end
-      def self.<=>(level); 1; end
-      def self.to_s; 'root'; end
-      def self.to_sym; :root; end
-      def self.can_publish?; true; end
-      def self.developer?; true; end
+      def self.>(level)     ; level < Root ; end
+      def self.>=(level)    ; true  ; end
+      def self.<=>(level)   ; 1     ; end
+      def self.to_s         ; 'root'; end
+      def self.to_sym       ; :root ; end
+      def self.can_publish? ; true  ; end
+      def self.developer?   ; true  ; end
+      def self.admin?       ; true  ; end
     end
 
     class None
       private(:initialize)
-      def self.>(level); false; end
-      def self.>=(level)
-        level.equal?(None)
-      end
-
-      def self.<=>(level); -1; end
-      def self.to_s; 'none'; end
-      def self.to_sym; :none; end
-      def self.can_publish?; false; end
-      def self.developer?; false; end
+      def self.>(level)     ; false ; end
+      def self.>=(level)    ; level.equal?(None); end
+      def self.<=>(level)   ; -1    ; end
+      def self.to_s         ; 'none'; end
+      def self.to_sym       ; :none ; end
+      def self.can_publish? ; false ; end
+      def self.developer?   ; false ; end
+      def self.admin?       ; false ; end
     end
 
     class Level
@@ -80,11 +79,16 @@ module Spontaneous::Permissions
       end
 
       def can_publish?
-        @permissions[:publish]
+        @permissions[:publish] || false
       end
 
       def developer?
-        @permissions[:developer]
+        @permissions[:developer] || false
+      end
+
+      # Users with admin level can access the user manager interface
+      def admin?
+        @permissions[:admin] || false
       end
 
       def to_s
@@ -110,9 +114,9 @@ module Spontaneous::Permissions
       end
 
       def all(base_level = nil)
-        list = store.to_a.sort { |a, b| a[1] <=> b[1] }
-        list.reject! { |l| l[1] > get(base_level) } if base_level
-        list.map { |l| l[0] }
+        list = store.values.sort { |a, b| a <=> b }
+        list.reject! { |l| l > get(base_level) } if base_level
+        list
       end
 
       def root

data/lib/spontaneous/plugins/aliases.rb

@@ -6,12 +6,12 @@ module Spontaneous::Plugins
     extend ActiveSupport::Concern
 
     included do
-      many_to_one :target, :class => self, :reciprocal => :aliases
-      one_to_many :aliases, :class => self, :key => :target_id, :reciprocal => :target
+      # '__target' rather than 'target' because we want to override the behaviour of the
+      # Content#target method only on classes that are aliases, and this is defined dynamically
+      many_to_one :__target, :class => self, :key => :target_id, :reciprocal => :aliases
+      one_to_many :aliases, :class => self, :key => :target_id, :reciprocal => :__target
       add_association_dependencies :aliases => :destroy
     end
-    # def self.configure(base)
-    # end
 
     module ClassMethods
       def alias_of(*args)
@@ -21,12 +21,15 @@ module Spontaneous::Plugins
         extend  ClassAliasMethods
         include AliasMethods
         include PieceAliasMethods unless page?
-        include PageAliasMethods if page?
+        include PageAliasMethods  if page?
+        # alias_method :target,  :__target
+        alias_method :target=, :__target=
       end
 
+
       alias_method :aliases, :alias_of
 
-      def targets(owner = nil, box = nil)
+      def targets(owner = nil, box = nil, options = {})
         targets = []
         classes = []
         proc_args = [owner, box].compact
@@ -39,7 +42,7 @@ module Spontaneous::Plugins
           end
         end
         query = S::Content.filter(sti_key => classes.map { |c| c.to_s })
-        if container_procs = @alias_options[:container]
+        if (container_procs = @alias_options[:container])
           containers = [container_procs].flatten.map { |p| p[*proc_args] }.flatten
           params = []
           containers.each do |container|
@@ -57,11 +60,24 @@ module Spontaneous::Plugins
           query = query.and(container_query)
         end
         targets.concat(query.all)
-        if filter = @alias_options[:filter] and filter.is_a?(Proc)
-          targets.select(&filter)
-        else
-          targets
+
+        if (filter = @alias_options[:filter]) and filter.is_a?(Proc)
+          filtered = []
+          targets.each { |target|
+            filtered << target if filter[*([target, owner, box][0...(filter.arity)])]
+          }
+          targets = filtered
+        end
+
+        if @alias_options[:unique] && box
+          existing = box.map { |entry| entry.target || entry }
+          targets.reject! { |target| existing.include?(target) }
+        end
+
+        if (query =  options[:search])
+          targets.select! { |target| query === target.alias_title }
         end
+        targets
       end
 
       def target_class(class_definition)
@@ -75,9 +91,26 @@ module Spontaneous::Plugins
 
 
     module ClassAliasMethods
+      def for_target(target_id)
+        self.create(:target_id => target_id)
+      end
+
       def alias?
         true
       end
+
+      def use_configured_generator(generator_name, *args)
+        return nil unless @alias_options.key?(generator_name)
+        (generator = @alias_options[generator_name]).call(*args)
+      end
+
+      def lookup_target(target_id)
+        use_configured_generator(:lookup, target_id)
+      end
+
+      def target_slug(target)
+        use_configured_generator(:slug, target)
+      end
     end
 
     # included only in instances that are aliases
@@ -86,10 +119,25 @@ module Spontaneous::Plugins
         true
       end
 
+      def target
+        (_target = self.class.lookup_target(self.target_id)) and return _target
+        __target
+      end
+
       def field?(field_name)
         super || target.class.field?(field_name)
       end
 
+      def respond_to_missing?(name, include_private = false)
+        return true if target && target.respond_to?(name)
+        super
+      end
+
+      def respond_to?(name, include_private = false)
+        return true if target && target.respond_to?(name)
+        super
+      end
+
       def method_missing(method, *args)
         if target && target.respond_to?(method)
           if block_given?
@@ -108,6 +156,7 @@ module Spontaneous::Plugins
       end
 
       def style
+        return self.resolve_style(self.style_sid) unless target.respond_to?(:resolve_style)
         if self.class.styles.empty?
           target.resolve_style(style_sid)
         else
@@ -120,9 +169,21 @@ module Spontaneous::Plugins
       end
 
       def export(user = nil)
-        super.merge(:target => target.shallow_export(user), :alias_title => target.alias_title, :alias_icon => target.exported_alias_icon)
+        super.merge(:target => exported_target(user), :alias_title => target.alias_title, :alias_icon => target.exported_alias_icon)
       end
 
+      def exported_target(user = nil)
+        case target
+        when S::Content
+          target.shallow_export(user)
+        else
+          target.to_json
+        end
+      end
+
+      def hidden?
+        super || target.nil? || (target.respond_to?(:hidden?) && target.hidden?)
+      end
     end
 
     module PieceAliasMethods
@@ -133,6 +194,9 @@ module Spontaneous::Plugins
 
     module PageAliasMethods
       def slug
+        unless target.respond_to?(:slug)
+          slug = self.class.target_slug(target) and return slug
+        end
         target.slug
       end
 

data/lib/spontaneous/plugins/allowed_types.rb

@@ -28,25 +28,42 @@ module Spontaneous::Plugins
       end
 
       def instance_class
-        case @type
+        resolve_instance_class(@type)
+      end
+
+      def resolve_instance_class(name)
+        case name
         when Class
-          @type
+          name
         when Symbol, String
-          @type.to_s.constantize
+          name.to_s.constantize
         end
       end
 
-      def styles
-        configured_styles || all_styles
+      def styles(content)
+        configured_styles(content) || all_styles(content)
       end
 
-      def configured_styles
-        if (@options.key?(:styles) and styles = @options[:styles]) or \
-          (@options.key?(:style) and styles = [@options[:style]].flatten)
+      def configured_styles(content)
+        if (styles = style_options)
           styles.map { |s| instance_class.find_named_style(s) }
         end
       end
 
+      def all_styles(content)
+        instance_class.styles
+      end
+
+      def default_style(content)
+        styles(content).first
+      end
+
+      def style_options
+        return Array(@options[:styles]) if @options.key?(:styles)
+        return Array(@options[:style])  if @options.key?(:style)
+        nil
+      end
+
       def includes?(type)
         if allow_subclasses
           instance_class.subclasses.include?(type)
@@ -63,14 +80,6 @@ module Spontaneous::Plugins
         end
       end
 
-      def all_styles
-        instance_class.styles
-      end
-
-      def default_style
-        styles.first
-      end
-
       def prototype
         @options[:prototype]
       end
@@ -86,6 +95,32 @@ module Spontaneous::Plugins
       alias_method :addable?, :readable?
     end
 
+    class AllowedGroup < AllowedType
+      def groups
+        @type
+      end
+
+      def instance_classes
+        schema = Spontaneous::Site.schema
+        names = groups.flat_map { |name| Spontaneous::Site.schema.groups[name] }
+        names.map { |name| resolve_instance_class(name) }.uniq
+      end
+
+      def includes?(type)
+        instance_classes.include?(type)
+      end
+
+      def configured_styles(content)
+        if (styles = style_options)
+          styles.map { |s| content.class.find_named_style(s) }
+        end
+      end
+
+      def all_styles(content)
+        content.class.styles
+      end
+    end
+
     module ClassMethods
       ##
       # Sets up an allowed type for a particular content type
@@ -114,6 +149,13 @@ module Spontaneous::Plugins
         # end
       end
 
+      def allow_group(*group_names)
+        options = group_names.extract_options!
+        allowed_types_config << AllowedGroup.new(group_names, options)
+      end
+
+      alias_method :allow_groups, :allow_group
+
       def allowed_types_config
         @_allowed_types ||= []
       end
@@ -155,7 +197,7 @@ module Spontaneous::Plugins
     # TODO: BOXES remove box reference here
     def style_for_content(content, box = nil)
       if allowed = allowed_type(content)
-        allowed.default_style
+        allowed.default_style(content)
       else
         content.default_style
       end
@@ -163,7 +205,7 @@ module Spontaneous::Plugins
 
     def available_styles(content)
       if allowed = allowed_type(content)
-        allowed.styles
+        allowed.styles(content)
       else
         content.class.styles
       end

data/lib/spontaneous/plugins/application/paths.rb

@@ -9,14 +9,6 @@ module Spontaneous::Plugins::Application
         Spontaneous.instance.load_paths
       end
 
-      def template_paths
-        paths = []
-        Spontaneous.facets.each do |facet|
-          paths += facet.paths.expanded(:templates)
-        end
-        paths
-      end
-
       def log_dir(*path)
         relative_dir(root / "log", *path)
       end
@@ -25,14 +17,6 @@ module Spontaneous::Plugins::Application
         relative_dir(root / "config", *path)
       end
 
-      # def template_root=(template_root)
-      #   Spot::Render.template_root = template_root.nil? ? nil : File.expand_path(template_root)
-      # end
-
-      def template_root(*path)
-        relative_dir(Spot::Render.template_root, *path)
-      end
-
       def template_path(*args)
         File.join(template_root, *args)
       end
@@ -54,10 +38,6 @@ module Spontaneous::Plugins::Application
         Spontaneous.schema.schema_map_file = path
       end
 
-      # def media_dir=(dir)
-      #   @media_dir = File.expand_path(dir)
-      # end
-
       def media_dir(*path)
         Spontaneous.instance.media_dir(*path)
       end
@@ -87,18 +67,10 @@ module Spontaneous::Plugins::Application
         Spontaneous.instance.root(*path)
       end
 
-      # def root=(root)
-      #   @root = File.expand_path(root)
-      # end
-
       def revision_root(*path)
         Spontaneous.instance.revision_root(*path)
       end
 
-      # def revision_root=(revision_dir)
-      #   @revision_dir = File.expand_path(revision_dir)
-      # end
-
       def revision_dir(revision=nil, root = nil)
         Spontaneous.instance.revision_dir(revision, root)
       end

data/lib/spontaneous/plugins/application/system.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+require 'fiber'
+
+module Spontaneous::Plugins::Application
+  module System
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def async?
+        defined?(::EM) && ::EM.reactor_running?
+      end
+
+      def system(cmd, timeout = 10)
+        return async_system(cmd) if async?
+        super(cmd)
+      end
+
+      # Invokes an asynchronous system call. Must be wrapped in a Fiber
+      # such as that provided by rack-fiber_pool
+      def async_system(cmd, timeout = 10)
+        deferrable = EM::DefaultDeferrable.new
+        fiber = Fiber.current
+        EM.system cmd do |output, status|
+          deferrable.succeed
+          fiber.resume [output, status]
+        end
+        deferrable.timeout timeout
+        deferrable.errback {  }
+        output, status = Fiber.yield
+        status.success?
+      end
+    end
+  end
+end

data/lib/spontaneous/plugins/boxes.rb

@@ -75,6 +75,10 @@ module Spontaneous::Plugins
       @boxes ||= Spontaneous::Collections::BoxSet.new(self)
     end
 
+    def pieces
+      boxes.flat_map { |b| b.pieces }
+    end
+
     def iterable
       boxes
     end

data/lib/spontaneous/plugins/content_groups.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Spontaneous::Plugins
+  module ContentGroups
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      attr_reader :group_memberships
+
+      def group(*group_names)
+        @group_memberships = group_names
+        Spontaneous::Site.schema.add_group_member(self, group_names)
+      end
+    end
+  end
+end