spontaneous 0.1.0.alpha1

data/lib/spontaneous/permissions/access_group.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+module Spontaneous::Permissions
+  class AccessGroup < Sequel::Model(:spontaneous_groups)
+    many_to_many :members, :class => :'Spontaneous::Permissions::User', :join_table => :spontaneous_groups_users, :left_key => :group_id, :right_key => :user_id
+
+    def level_for(content)
+      if selector.matches(content)
+        level
+      else
+        UserLevel.none
+      end
+    end
+
+    def selector
+      @selector ||= Spontaneous::ContentQuery.new(access_selector)
+    end
+
+    def level_for(content)
+      if selector.matches?(content)
+        level
+      else
+        UserLevel.none
+      end
+    end
+
+    def level
+      if disabled
+        UserLevel.none
+      else
+        UserLevel[level_name]
+      end
+    end
+
+    def level=(level)
+      self.level_name = level.to_s
+    end
+
+    def invisible?
+      !user_id.blank?
+    end
+
+    def validate
+      super
+      errors.add(:name, 'is required') if name.blank?
+    end
+  end
+end
+
+

data/lib/spontaneous/permissions/access_key.rb

@@ -0,0 +1,35 @@
+# encoding: UTF-8
+
+module Spontaneous::Permissions
+  class AccessKey < Sequel::Model(:spontaneous_access_keys)
+    plugin :timestamps
+    many_to_one :user, :class => :'Spontaneous::Permissions::User'
+
+    def self.authenticate(key_id)
+      if key = self.for_id(key_id)
+        key.access!
+        return key
+      end
+      nil
+    end
+
+    def self.valid?(key_id, user)
+      return true if (key = self.for_id(key_id)) and key.user == user
+      false
+    end
+
+    def self.for_id(key_id)
+      self[:key_id => key_id]
+    end
+
+    def before_create
+      self.key_id = Spontaneous::Permissions.random_string(44)
+      self.last_access_at = Time.now
+      super
+    end
+
+    def access!
+      self.update(:last_access_at => Time.now)
+    end
+  end
+end

data/lib/spontaneous/permissions/user.rb

@@ -0,0 +1,167 @@
+# encoding: UTF-8
+
+module Spontaneous::Permissions
+  class User < Sequel::Model(:spontaneous_users)
+    extend Forwardable
+
+    plugin :timestamps
+
+    one_to_one   :group,        :class => :'Spontaneous::Permissions::AccessGroup'
+    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)
+
+    def_delegators :group, :level, :access_selector
+
+    def self.encrypt_password(clear_password, salt)
+      Digest::SHA1.hexdigest("--#{salt}--#{clear_password}--")
+    end
+
+    def self.authenticate(login, clear_password)
+      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!
+          return access_key
+        end
+      end
+      nil
+    end
+
+    attr_accessor :password, :password_confirmation
+
+    ##
+    # Find the highest access level available from all the groups we
+    # belong to
+    # TODO: actually match the content against the memberships
+    def level_for(content)
+      memberships.map { |m| m.level_for(content) }.sort.last
+    end
+
+    def last_access_at
+      access_keys.map(&:last_access_at).sort.last
+    end
+
+    def logged_in!
+      self.last_login_at = Time.now
+      key = AccessKey.new
+      self.add_access_key(key)
+      self.save
+      key
+    end
+
+    def encrypt_password(clear_password)
+      self.class.encrypt_password(clear_password, salt)
+    end
+
+    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
+      super
+    end
+
+    def after_create
+      super
+      ensure_group!
+    end
+
+    def password=(new_password)
+      updating_password!
+      @password = new_password
+    end
+
+    def password_confirmation=(new_password)
+      updating_password!
+      @password_confirmation = new_password
+    end
+
+    def level=(level)
+      ensure_group!
+      group.level = level
+      group.save
+    end
+
+    def raise_on_save_failure
+      false
+    end
+
+    def memberships
+      groups.push(group)
+    end
+
+    def developer?
+      level.developer?
+    end
+
+    def export
+      {
+        :name => name,
+        :email => email,
+        :login => login,
+        :developer => !!developer?
+      }
+    end
+
+    def serialise_http
+      Spontaneous.serialise_http(export)
+    end
+
+    protected
+
+    def validate
+      super
+      errors.add(:name, 'is required') if name.blank?
+      errors.add(:email, 'is required') if email.blank?
+      errors.add(:email, 'is invalid') unless email =~ /^[^@]+@.+$/
+
+      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 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
+      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
+        end
+      end
+    end
+
+
+    def updating_password!
+      @_updating_password = true
+    end
+
+    def updating_password?
+      @_updating_password
+    end
+
+    def ensure_group!
+      if group.nil?
+        self.group = AccessGroup.create(:user_id => id, :name => "_#{name}_", :level_name => UserLevel.none.to_s)
+      end
+    end
+  end
+end
+

data/lib/spontaneous/permissions/user_level.rb

@@ -0,0 +1,177 @@
+# encoding: UTF-8
+
+require 'hwia'
+require 'yaml'
+
+module Spontaneous::Permissions
+  class UserLevel
+
+    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
+    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
+    end
+
+    class Level
+      @@instances = Hash.new
+
+      def self.[](value, description)
+        name = description.delete(:name)
+        if @@instances.key?(value.to_i)
+          @@instances[value.to_i]
+        else
+          @@instances[value.to_i] = self.new(name, value.to_i, description)
+        end
+      end
+
+      attr_reader  :name, :value
+      alias_method :to_i, :value
+
+      def initialize(name, value, permissions)
+        @name, @value, @permissions = name.to_sym, value.to_i, permissions
+      end
+
+      def >(level)
+        return false if level.equal?(Root)
+        return true  if level.equal?(None)
+        @value > level.to_i
+      end
+
+      def >=(level)
+        return false if level.equal?(Root)
+        return true  if level.equal?(None)
+        @value >= level.to_i
+      end
+
+      def <(level)
+        return true  if level.equal?(Root)
+        return false if level.equal?(None)
+        @value < level.to_i
+      end
+
+      def <=>(level)
+        return -1 if level.equal?(Root)
+        return  1 if level.equal?(None)
+        @value <=> level.to_i
+      end
+
+      def ==(level)
+        return false if level.equal?(Root)
+        return false if level.equal?(None)
+        return @value == level.to_i
+      end
+
+      def can_publish?
+        @permissions[:publish]
+      end
+
+      def developer?
+        @permissions[:developer]
+      end
+
+      def to_s
+        @name.to_s
+      end
+
+      def to_sym
+        @name.to_sym
+      end
+    end
+
+    class << self
+      def minimum
+        get(all[1]) || None
+      end
+
+      def [](level)
+        get(level)
+      end
+
+      def get(level)
+        store[level]
+      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] }
+      end
+
+      def root
+        Root
+      end
+
+      def none
+        None
+      end
+
+      def level_file
+        @level_file ||= 'config/user_levels.yml'
+      end
+
+      def level_file=(file)
+        @level_file = file
+      end
+
+      def reset!
+        @initialised = false
+        @store = nil
+      end
+
+      def init!
+        return if @initialised
+        store[:none] = None
+        store[:root] = Root
+        numeric = 1
+        if File.exists?(level_file)
+          levels = YAML.load_file(level_file)
+          levels.each_with_index do |description, index|
+            level = Level[(index+1), description]
+            store[level.name] = level
+          end
+        else
+          logger.warn {
+            "User level file '#{level_file}' missing, unable to load User Levels"
+          }
+        end
+        @initialised = true
+      end
+
+      def store
+        if !@store
+          @store = StrHash.new
+          init!
+        end
+        @store
+      end
+
+      def method_missing(method, *args)
+        if level = get(method)
+          level
+        else
+          super
+        end
+      end
+    end
+  end
+end
+

data/lib/spontaneous/permissions.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+require 'base58'
+
+module Spontaneous
+  module Permissions
+
+    autoload :UserLevel, "spontaneous/permissions/user_level"
+    autoload :User, "spontaneous/permissions/user"
+    autoload :AccessGroup, "spontaneous/permissions/access_group"
+    autoload :AccessKey, "spontaneous/permissions/access_key"
+
+    @@active_user = nil
+
+    class << self
+      # Convenience shortcut so we can do Permissions[:root]
+      def [](level_name)
+        UserLevel[level_name]
+      end
+
+      def root
+        UserLevel.root
+      end
+
+      def has_level?(level)
+        return true unless active_user
+        active_user.level >= level
+      end
+
+      def with_user(user)
+        self.active_user = user
+        yield if block_given?
+      ensure
+        self.active_user = nil
+      end
+
+      def active_user
+        Thread.current[:_permissions_active_user]
+      end
+
+      def active_user=(user)
+        Thread.current[:_permissions_active_user] = user
+      end
+
+      protected(:active_user=)
+
+      def random_string(length)
+        bytes = ((length * Math.log10(58))/(8 * Math.log10(2))).ceil + 2
+        string = Base58.encode(OpenSSL::Random.random_bytes(bytes).unpack("h*").first.to_i(16))
+        string[0...(length)]
+      end
+
+    end
+  end
+end

data/lib/spontaneous/piece.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+
+
+module Spontaneous
+  class Piece < Content
+    plugin Plugins::Supertype
+
+    set_inheritance_root
+
+    def export
+      super.merge(export_styles)
+    end
+
+    def export_styles
+      h = {
+        :style => style_sid.to_s,
+      }
+      if container
+        h.merge!({
+          :styles => container.available_styles(self).map { |s| s.schema_id.to_s }
+        })
+      else
+        h.merge!({
+          :styles => self.styles.map { |s| s.schema_id.to_s }
+        })
+      end
+    end
+
+  end
+end

data/lib/spontaneous/plugins/aliases.rb

@@ -0,0 +1,128 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Plugins
+  module Aliases
+
+    def self.configure(base)
+      base.many_to_one :target, :class => base, :reciprocal => :aliases
+      base.one_to_many :aliases, :class => base, :key => :target_id, :reciprocal => :target
+      base.add_association_dependencies :aliases => :destroy
+    end
+
+    module ClassMethods
+      def alias_of(*class_list)
+        @alias_classes = class_list
+        extend  ClassAliasMethods
+        include AliasMethods
+        include PageAliasMethods if page?
+      end
+
+      alias_method :aliases, :alias_of
+
+      def targets
+        targets = []
+        target_classes.each do |target_class|
+          targets += target_class.sti_subclasses_array
+        end
+        S::Content.filter(sti_key => targets.map { |t| t.to_s }).all
+      end
+
+      def target_classes
+        @target_classes ||= @alias_classes.map { |c| c.to_s.constantize }
+      end
+
+      def alias?
+        false
+      end
+    end
+
+    module InstanceMethods
+      def alias_title
+        fields[:title].to_s
+      end
+
+      def alias_icon_field
+        if field = fields.detect { |f| f.image? }
+          field
+        else
+          nil
+        end
+      end
+    end
+
+    module ClassAliasMethods
+      def alias?
+        true
+      end
+    end
+
+    # included only in instances that are aliases
+    module AliasMethods
+      def alias?
+        true
+      end
+
+      def field?(field_name)
+        super || target.class.field?(field_name)
+      end
+
+      def method_missing(method, *args)
+        if target && target.respond_to?(method)
+          if block_given?
+            target.__send__(method, *args, &Proc.new)
+          else
+            target.__send__(method, *args)
+          end
+        else
+          super
+        end
+      end
+
+
+      def find_named_style(style_name)
+        super or target.find_named_style(style_name)
+      end
+
+      def style
+        if self.class.styles.empty?
+          target.resolve_style(style_sid)
+        else
+          self.resolve_style(self.style_sid) or target.resolve_style(self.style_sid)
+        end
+      end
+
+      def styles
+        @styles ||= Spontaneous::Collections::PrototypeSet.new(target, :styles)
+      end
+
+      def export
+        super.merge(:target => target.shallow_export, :alias_title => target.alias_title, :alias_icon => target.alias_icon_field.export)
+      end
+    end
+
+    module PageAliasMethods
+      def path
+        @_path ||= [parent.path, target.slug].join(S::SLASH)
+      end
+
+      def calculate_path
+        ""
+      end
+
+      def layout
+        # if this alias class has no layouts defined, then just use the one set on the target
+        if self.class.layouts.empty?
+          target.resolve_layout(self.style_sid)
+        else
+          # but if it does have layouts defined, use them
+          self.resolve_layout(self.style_sid) or target.resolve_layout(self.style_sid)
+        end
+      end
+
+      def find_named_layout(layout_name)
+        super or target.find_named_layout(layout_name)
+      end
+    end
+  end
+end