troles 0.5.0

data/lib/troles/common/config/schema_helpers.rb

@@ -0,0 +1,95 @@
+module Troles::Common
+  class Config
+    module SchemaHelpers
+      def valid_field_name? name
+        return false if !name || name.empty?
+        raise ArgumentException, "Role field must not be named role or roles as these names are reserved by troles!" if [:role, :roles].include? name.to_sym
+        true
+      end
+
+      def boolean? value
+        [true, false].include? value
+      end
+
+      # TODO: Needs extraction into helper module!
+
+      def belongs_to_for from, to, options = {}
+        make_relationship :belongs_to, from, to, options
+      end
+
+      def has_many_for from, to, options = {}
+        make_relationship :has_many, from, to, options
+      end
+
+      def has_one_for from, to, options = {}
+        make_relationship :has_one, from, to, options
+      end
+
+      # To setup sth like this:
+      #
+      # class UserAccount < ActiveRecord::Base    
+      #   has_and_belongs_to_many :troles, :class_name => 'Role'
+      # end
+      # 
+      # class Role < ActiveRecord::Base    
+      #   has_and_belongs_to_many :user_accounts, :class_name => 'User'
+      # end
+      def has_and_belongs_many from, to, options = {}
+        make_relationship :has_and_belongs_to_many, from, to, :key => role_field
+        make_relationship :has_and_belongs_to_many, to, from, options
+      end
+
+      def get_model_type class_name
+        return :user if class_name == clazz
+        return :role if class_name == role_model
+        raise "Not a known model: #{class_name}"
+      end
+
+      # options: 
+      # - :opts, extras options, fx to set the :through relationship
+      # - :key (usually to enforce use of role_field as key name)      
+      def make_relationship type, from, to, options = {}
+        # puts "type: #{type}, #{from}, #{to}"
+        from_type = get_model_type from
+        to_type = get_model_type to
+
+        model_key = options[:key] ? options[:key] : send("#{from_type}_key")
+
+        class_name = send "#{to_type}_class_name"
+
+        options = {:class_name => class_name}
+        options.merge!(options[:opts]) if options[:opts]
+        puts "#{from}.#{type} :#{model_key}, #{options.inspect}" if log_on?
+        from.send(type, model_key, options)
+      end
+
+      def user_class_name
+        clazz.to_s
+      end
+
+      def user_key
+        make_key user_class_name
+      end
+
+      def join_class_name
+        join_model.to_s
+      end
+
+      def join_key
+        make_key join_class_name
+      end
+
+      def role_class_name
+        role_model.to_s
+      end
+
+      def role_key
+        make_key role_class_name
+      end
+
+      def make_key name
+        name.gsub(/::/, '__').underscore.pluralize      
+      end
+    end
+  end
+end

data/lib/troles/common/config/static_roles.rb

@@ -0,0 +1,14 @@
+module Troles::Common
+  class Config
+    module StaticRoles    
+      def static_roles_for_class= value
+        raise ArgumentError, "Must be a boolean" if !boolean?(value)
+        @static_roles_for_class = value      
+      end
+
+      def static_roles_for_class?
+        @static_roles_for_class || false
+      end
+    end
+  end
+end

data/lib/troles/common/config/valid_roles.rb

@@ -0,0 +1,21 @@
+module Troles::Common
+  class Config
+    module ValidRoles    
+      def add_valid_roles *roles
+        valid_roles =valid_roles & roles
+      end
+
+      def valid_roles= *roles
+        vrs = roles.flatten.map{|r| r.to_s.alpha_numeric}.map(&:to_sym).uniq
+        raise ArgumentError, "The #{strategy} strategy can only accept 2 valid roles" if (vrs.size > 2) && strategy == :bit_one
+        raise ArgumentError, "The role names you want to be valid are not valid role names. Must be alphanumeric, was: #{roles.flatten}" if vrs.empty?
+        @valid_roles ||= vrs
+      end
+
+      def valid_roles
+        raise "No valid roles defined" if !@valid_roles || @valid_roles.empty?
+        @valid_roles      
+      end
+    end
+  end
+end

data/lib/troles/common/config.rb

@@ -0,0 +1,96 @@
+module Troles::Common
+  class Config
+    autoload :ValidRoles,     'troles/common/config/valid_roles'        
+    autoload :StaticRoles,    'troles/common/config/static_roles'
+    autoload :Schema,         'troles/common/config/schema'
+    autoload :SchemaHelpers,  'troles/common/config/schema_helpers'
+
+    def self.sub_modules
+      [:valid_roles, :static_roles, :schema]
+    end
+    
+    sub_modules.each do |name|    
+      send :include, "Troles::Common::Config::#{name.to_s.camelize}".constantize
+    end
+
+    attr_accessor :clazz, :strategy, :log_on, :generic
+    attr_writer   :orm
+    
+    def initialize clazz, options = {}
+      @clazz = clazz
+      # set instance var for each pair in options
+      apply_options! options
+    end
+
+    class << self
+      attr_reader :default_orm, :auto_load
+      attr_accessor :log_on
+
+      def log_on?
+        log_on || false
+      end
+      
+      def default_orm= orm
+        @default_orm ||= orm
+      end
+      
+      def auto_load= mode
+        raise "Autoload must be set to true or false" if ![true, false].include? mode
+        @auto_load = mode
+      end
+
+      def auto_load?
+        @auto_load
+      end      
+    end
+
+    def log_on?
+      log_on || Troles::Config.log_on
+    end
+
+    def role_field
+      @role_field ||= begin
+        default_role_field
+      end
+    end
+
+    def role_field= field_name
+      name = field_name.to_s.alpha_numeric.to_sym
+      raise ArgumentException, "Not a valid role field name: #{field_name}"  if !valid_field_name?(name)
+      @role_field ||= name
+    end
+
+    def default_role_field
+      singularity == :many ? :troles : :trole
+    end
+
+    def orm
+      @orm || self.class.default_orm
+    end
+
+    def apply_options! options = {}
+      options.each_pair do |key, value| 
+        send("#{key}=", value) if self.respond_to?(:"#{key}")
+      end      
+    end
+
+    def singularity
+      @singularity ||= (strategy =~ /_many$/) ? :many : :one
+    end
+
+    # def singularity= value
+    #   raise ArgumentError, "Must be :many or :one" if ![:one, :many].include?(value)      
+    #   @singularity ||= value
+    # end
+
+    def configure! options = {}
+      apply_options! options
+      configure_role_field
+    end
+            
+    def generic?
+      return true if orm.nil?
+      @generic.nil? ? false : @generic
+    end
+  end
+end

data/lib/troles/common/dependencies.rb

@@ -0,0 +1,9 @@
+require 'sugar-high/kind_of'
+require 'sugar-high/string'
+require 'sugar-high/array'
+require 'sugar-high/class_ext'
+require 'active_support/inflector'
+require 'troles/meta'
+
+
+

data/lib/troles/common/event_manager.rb

@@ -0,0 +1,40 @@
+# 
+# @author Kristian Mandrup
+#
+# Handles event handlinm/publication for when the roles of a role subject change
+# This is currently a singleton (class methods only) by design
+#
+module Troles::Common
+  module EventManager
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # TODO:
+    module ClassMethods
+      attr_accessor :subscribers
+
+      def subscribers
+        @subscribers ||= []
+      end
+      
+      def publish_change event, options
+        # from = options[:from]
+        subscribers.each do |subscriber|
+          subscriber.notify(event) if subscriber.respond_to?(:notify)
+        end
+        true
+      end
+      
+      def add_subscribers subscribers
+        self.subscribers << subscribers
+      end
+
+      def remove_subscribers subscribers
+        self.subscribers - subscribers
+      end      
+    end
+       
+    extend ClassMethods
+  end
+end

data/lib/troles/common/macros/configuration/base_loader.rb

@@ -0,0 +1,40 @@
+module Troles::Macros
+  class Configuration  
+    class BaseLoader
+      attr_reader :strategy, :orm
+      
+      def initialize strategy, orm
+        @strategy = strategy
+        @orm = orm || Troles::Config.default_orm
+      end
+
+      def singularity
+        (strategy =~ /_many$/) ? :many : :one
+      end
+      
+      def try_module full_name
+        begin
+          full_name.constantize
+          true
+        rescue
+          # puts "module #{full_name} not found!"
+          false
+        end
+      end
+
+      def base_class
+        "Base#{singularity.to_s.camelize}"
+      end
+
+      def namespace
+        singularity == :many ? 'Troles' : 'Trole'      
+      end
+
+      def orm_namespace
+        ns = namespace
+        ns << "::#{orm.to_s.camelize}" if orm
+        ns
+      end      
+    end
+  end
+end

data/lib/troles/common/macros/configuration/config_loader.rb

@@ -0,0 +1,19 @@
+module Troles::Macros
+  class Configuration  
+    class ConfigLoader < BaseLoader
+            
+      def initialize strategy, orm
+        super
+      end
+
+      def config_class
+        begin       
+          "#{orm_namespace}::Config".constantize
+        rescue
+          # use generic if no ORM specific strategy found!
+          "#{namespace}::Config".constantize
+        end        
+      end
+    end
+  end
+end

data/lib/troles/common/macros/configuration/storage_loader.rb

@@ -0,0 +1,20 @@
+module Troles::Macros
+  class Configuration  
+    class StorageLoader < BaseLoader
+
+      def initialize strategy, orm
+        super
+      end
+
+      def storage_class
+        begin
+          "#{orm_namespace}::Storage::#{strategy.to_s.camelize}".constantize
+        rescue
+          # use generic if no ORM specific strategy found!
+          "#{namespace}::Storage::#{strategy.to_s.camelize}".constantize
+        end        
+      end      
+    end
+  end
+end
+

data/lib/troles/common/macros/configuration/strategy_loader.rb

@@ -0,0 +1,38 @@
+module Troles::Macros
+  class Configuration  
+    class StrategyLoader < BaseLoader
+
+      def initialize strategy, orm
+        super
+      end      
+      
+      def strategy_module
+        @strategy_module ||= orm_strategy_module || generic_strategy_module        
+      end  
+
+      protected
+
+      def orm_strategy_module
+        @orm_strategy_module ||= begin         
+          mods_found = ["#{orm_namespace}::Strategy::#{strategy.to_s.camelize}", "#{namespace}::Strategy::#{base_class}"].select do |full_name|
+            try_module(full_name)
+          end
+          !mods_found.empty? ? mods_found.first.constantize : nil
+        end
+      end
+
+      def generic_strategy_module strategy_name, options
+        @generic_module ||= begin
+          base_class = base_name(strategy_name) 
+  
+          # use generic if no ORM specific strategy found!
+          ns = namespace(strategy_name, options)
+          mods_found = ["#{namespace}::Strategy::#{strategy.to_s.camelize}", "#{namespace}::Strategy::#{base_class}"].select do |full_name|
+            try_module(full_name)
+          end        
+          !mods_found.empty? ? mods_found.first.constantize : nil
+        end
+      end
+    end
+  end
+end

data/lib/troles/common/macros/configuration.rb

@@ -0,0 +1,89 @@
+module Troles  
+  module Macros    
+    class Configuration
+      autoload :BaseLoader,     'troles/common/macros/configuration/base_loader'
+      autoload :ConfigLoader,   'troles/common/macros/configuration/config_loader'
+      autoload :StrategyLoader, 'troles/common/macros/configuration/strategy_loader'
+      autoload :StorageLoader,  'troles/common/macros/configuration/storage_loader'      
+      
+      attr_reader :strategy, :singularity, :orm, :auto_load, :options, :role_subject_class
+      
+      def initialize role_subject_class, strategy, options = {}
+        @role_subject_class = role_subject_class
+        @strategy = strategy
+        @orm = options[:orm] || Troles::Config.default_orm
+        @auto_load = options[:auto_load] || Troles::Config.auto_load?
+        options[:strategy] = strategy
+        @options = options
+      end
+
+      def strategy_module
+        strategy_loader.strategy_module
+      end
+            
+      def load_adapter
+        return false if !auto_load?
+
+        path = "#{namespace}/adapters/#{orm.to_s.underscore}"
+        begin
+          require path
+        rescue
+          raise "Adapter for :#{orm} could not be found at: #{path}"
+        end
+      end
+  
+      def apply_strategy_options!
+        role_subject_class.troles_config.apply_options! options
+
+        # StrategyOptions.new(clazz)
+        # extract_macros(options).each{|m| apply_macro m}
+      end      
+
+      def define_hooks
+        storage_class = storage_loader.storage_class
+        role_subject_class.send :define_method, :storage do 
+          @storage ||= storage_class
+        end
+        
+        config_class = config_loader.config_class
+        puts "config_class: #{config_class}" if Troles::Config.log_on
+        role_subject_class.singleton_class.class_eval %{
+          def troles_config
+            @troles_config ||= #{config_class}.new #{role_subject_class}, #{options.inspect}
+          end
+        }
+      end
+
+      protected
+
+      def namespace
+        singularity == :many ? 'troles' : 'trole'      
+      end
+
+      def singularity
+        @singularity ||= (strategy =~ /_many$/) ? :many : :one
+      end
+
+      def storage_loader
+        @storage_loader ||= StorageLoader.new strategy, orm
+      end
+
+      def config_loader
+        @config_loader ||= ConfigLoader.new strategy, orm
+      end
+
+      def strategy_loader
+        @strategy_loader ||= StrategyLoader.new strategy, orm
+      end
+
+
+      def auto_load?
+        (auto_load && orm) || false
+      end
+  
+      # def extract_macros options = {}
+      #   [:static_role].select {|o| options[o]}
+      # end
+    end
+  end
+end

data/lib/troles/common/macros/static_roles.rb

@@ -0,0 +1,9 @@
+module Troles
+  module Macros
+    module StaticRoles
+      def static_roles?
+        true
+      end
+    end
+  end  
+end

data/lib/troles/common/macros/strategy_options.rb

@@ -0,0 +1,21 @@
+module Troles  
+  module Macros    
+    class StrategyOptions
+      attr_reader :clazz
+  
+      def initialize clazz
+        @clazz = clazz
+      end
+
+      # @param [Symbol] name of the macro to run
+      def apply_macro name
+        # overrides default method that returns false
+        begin 
+          clazz.send :include,  "Troles::Macros::#{strategy_name.to_s.camelize}".constantize
+        rescue
+        end
+      end
+    end
+  end
+end
+    

data/lib/troles/common/macros.rb

@@ -0,0 +1,38 @@
+# 
+# @author Kristian Mandrup
+#
+# Macros that can be used directly on the role subject class 
+# These methods are added to the ruby core 'Module' module
+#
+# Usage:
+#   class User
+#     troles_strategy :bit_many
+#
+
+puts "Troles macros enabled!"
+
+module Troles  
+  module Macros
+    autoload :Configuration, 'troles/common/macros/configuration'
+    
+    def troles_strategy strategy, options = {}, &block
+      configuration = Configuration.new self, strategy, options
+
+      configuration.load_adapter
+      # puts "strategy module: #{configuration.strategy_module}"
+      send :include, configuration.strategy_module
+
+      configuration.define_hooks
+      configuration.apply_strategy_options!
+      
+      if strategy == :bit_one 
+        troles_config.valid_roles = [:user, :admin] # default binary roles 
+      end
+      
+      yield troles_config if block_given?
+      troles_config
+    end     
+  end  
+end
+
+Module.send :include, Troles::Macros

data/lib/troles/common/marshaller/bitmask.rb

@@ -0,0 +1,43 @@
+# require 'troles/common/marshaller/generic'
+
+module Troles::Common
+  module Marshaller
+    class Bitmask < Generic
+      attr_reader :role_subject, :valid_roles
+
+      def initialize role_subject
+        super
+      end
+
+      def read
+        valid_roles.reject do |r| 
+          num = as_number(ds_field_value) 
+          ((num || 0) & calc_index(r)).zero?
+        end
+      end
+
+      def write *roles
+        roles = roles.uniq.compact
+        return as_number(false) if roles.empty?
+        roles.to_symbols.map { |r| calc_index(r) }.inject { |sum, bitvalue| sum + bitvalue }          
+      end
+      
+      protected
+
+      def as_number value
+        case value
+        when TrueClass, FalseClass
+          value ? 2 : 1
+        when Fixnum
+          value 
+        else
+          raise ArgumentError, "Cant be converted to a bit index, #{value}"
+        end
+      end
+        
+      def calc_index(r)
+        2**valid_roles.index(r)
+      end        
+    end
+  end
+end

data/lib/troles/common/marshaller/generic.rb

@@ -0,0 +1,24 @@
+module Troles::Common
+  module Marshaller
+    class Generic
+      attr_reader :role_subject, :valid_roles
+
+      def initialize role_subject
+        raise "The roles subject is not valid: #{role_subject}" if !role_subject || !role_subject.respond_to?(:has_role?)
+        @role_subject = role_subject
+        @valid_roles = role_subject.class.valid_roles
+      end
+      
+      protected
+
+      def ds_field_value  
+        role_subject.send ds_field_name
+      end      
+
+      def ds_field_name  
+        @ds_field_name ||= role_subject.class.role_field
+      end      
+    end
+  end
+end
+

data/lib/troles/common/marshaller.rb

@@ -0,0 +1,14 @@
+# 
+# @author Kristian Mandrup
+#
+# Marshallers can be used by Storages to handle conversion from 
+# between a role list of symbols and the data format stored in the datastore
+# One example is the Bitmask marshaller, which converts between an Integer and a role list
+# One could imagine other custom marshallers, such as using encrypted strings etc.
+# 
+module Troles::Common
+  module Marshaller
+    autoload :Generic,   'troles/common/marshaller/generic'
+    autoload :Bitmask,   'troles/common/marshaller/bitmask'
+  end
+end

data/lib/troles/common/operations/read.rb

@@ -0,0 +1,28 @@
+module Troles::Common
+  class Operations
+    module Read      
+      # The roles list of the role subject
+      # @return [Array<Symbol>] the list of roles
+      def list
+        role_subject.role_list
+      end
+
+      # Test if the role subject has exactly the given roles
+      # @param [Array<Symbol>] role list to test
+      # @return [true, false] true if role subject has exactly those roles, false otherwise 
+      def has? *roles
+        list == roles.to_symbols_uniq
+      end
+
+      # Which of the given roles are used by the role subject
+      # @param [Array<Symbol>] roles to test for inclusion      
+      #
+      # Usage:
+      #  - user.roles.used(:admin, :editor).include? :editor
+      #
+      def used *roles
+        list & roles.to_symbols_uniq
+      end
+    end
+  end
+end