bali 2.4.0 → 6.0.0rc1

data/lib/bali/dsl/map_rules_dsl.rb

@@ -1,75 +0,0 @@
-# grand scheme of things begin here
-class Bali::MapRulesDsl
-  attr_accessor :current_rule_class
-
-  def initialize
-    @@lock ||= Mutex.new
-  end
-
-  # defining rules
-  def rules_for(target_class, options_hash = {}, &block)
-    @@lock.synchronize do
-      self.current_rule_class = Bali::RuleClass.new(target_class)
-
-      parent_class = options_hash[:inherits] || options_hash["inherits"]
-      if parent_class 
-        # in case there is inherits specification
-        parent_is_class = parent_class.class
-        fail Bali::DslError, 'inherits must take a class' unless parent_is_class
-        rule_class_from_parent = Bali::Integrator::RuleClass.for(parent_class)
-        fail Bali::DslError, "not yet defined a rule class for #{parent_class}" if rule_class_from_parent.nil?
-        self.current_rule_class = rule_class_from_parent.clone(target_class: target_class)
-      end
-
-      Bali::RulesForDsl.new(self).instance_eval(&block)
-
-      # done processing the block, now add the rule class
-      Bali::Integrator::RuleClass.add(self.current_rule_class)
-    end
-  end
-
-  # subtarget_class is the subtarget's class definition
-  # field_name is the field that will be consulted when instantiated object of this class is passed in can? or cant?
-  def roles_for(subtarget_class, field_name)
-    Bali::TRANSLATED_SUBTARGET_ROLES[subtarget_class.to_s] = field_name
-    nil
-  end
-
-  def describe(*params)
-    fail Bali::DslError, "describe block must be within rules_for block"
-  end
-
-  def role(*params)
-    fail Bali::DslError, "role block must be within rules_for block"
-  end
-
-  def can(*params)
-    fail Bali::DslError, "can block must be within role block"
-  end
-
-  def cant(*params)
-    puts "Deprecation Warning: declaring rules with cant will be deprecated on major release 3.0, use cannot instead"
-    cannot *params
-  end
-
-  def cannot(*params)
-    fail Bali::DslError, "cant block must be within role block"
-  end
-
-  def can_all(*params)
-    fail Bali::DslError, "can_all block must be within role block"
-  end
-
-  def clear_rules
-    fail Bali::DslError, "clear_rules must be called within role block"
-  end
-
-  def cant_all(*params)
-    puts "Deprecation Warning: declaring rules with cant_all will be deprecated on major release 3.0, use cannot instead"
-    cannot_all *params
-  end
-
-  def cannot_all(*params)
-    fail Bali::DslError, "cant_all block must be within role block"
-  end
-end

data/lib/bali/dsl/rules_for_dsl.rb

@@ -1,130 +0,0 @@
-# this class is used to define DSL after rules_for is invoked.
-# @author Adam Pahlevi Baihaqi
-class Bali::RulesForDsl
-  attr_accessor :map_rules_dsl
-  attr_accessor :current_rule_group
-
-  # all to be processed subtargets
-  attr_accessor :current_subtargets
-
-  def initialize(map_rules_dsl)
-    @@lock ||= Mutex.new
-    self.map_rules_dsl = map_rules_dsl
-  end
-
-  def current_rule_class
-    self.map_rules_dsl.current_rule_class
-  end
-  protected :current_rule_class
-
-  def role(*params)
-    @@lock.synchronize do
-      bali_scrap_actors(*params)
-      current_subtargets.each do |subtarget|
-        bali_set_subtarget(subtarget)
-
-        if block_given?
-          yield
-        else
-          # if no block, then rules are defined using shortcut notation, eg:
-          # role :user, can: [:edit]
-          # the last element of which params must be a hash
-          shortcut_rules = params[-1]
-          unless shortcut_rules.is_a?(Hash)
-            raise Bali::DslError, "Pass a hash for shortcut notation"
-          end
-
-          shortcut_can_rules = shortcut_rules[:can] || shortcut_rules["can"]
-          shortcut_cannot_rules = shortcut_rules[:cannot] || shortcut_rules["cannot"]
-
-          shortcut_rules.each do |auth_val, args|
-            Bali::Integrator::Rule.add(auth_val, self.current_rule_group, *args)
-          end # each shortcut rules
-        end # whether block is given or not
-      end # each subtarget
-    end # sync
-  end # role
-
-  def describe(*params)
-    puts "Bali Deprecation Warning: describing rules using describe will be deprecated on major release 3.0, use role instead"
-    if block_given?
-      role(*params) do
-        yield
-      end
-    else
-      role(*params)
-    end
-  end
-
-  # others block
-  def others(*params)
-    if block_given?
-      role("__*__") do
-        yield
-      end
-    end
-  end # others
-
-  # clear all defined rules
-  def clear_rules
-    self.current_rule_group.clear_rules
-    true
-  end
-
-  def can(*args)
-    Bali::Integrator::Rule.add_can(self.current_rule_group, *args)
-  end
-
-  def cannot(*args)
-    Bali::Integrator::Rule.add_cannot(self.current_rule_group, *args)
-  end
-
-  def cant(*operations)
-    puts "Deprecation Warning: declaring rules with cant will be deprecated on major release 3.0, use cannot instead"
-    cannot(*operations)
-  end
-
-  def can_all
-    Bali::Integrator::RuleGroup.make_zeus(self.current_rule_group)
-  end
-
-  def cannot_all
-    Bali::Integrator::RuleGroup.make_plant(self.current_rule_group)
-  end
-
-  def cant_all
-    puts "Deprecation Warning: declaring rules with cant_all will be deprecated on major release 3.0, use cannot_all instead"
-    cannot_all
-  end
-  
-  private
-    def bali_scrap_actors(*params)
-      self.current_subtargets = []
-      params.each do |passed_argument|
-        if passed_argument.is_a?(Symbol) || passed_argument.is_a?(String)
-          self.current_subtargets << passed_argument
-        elsif passed_argument.is_a?(NilClass)
-          self.current_subtargets << passed_argument
-        elsif passed_argument.is_a?(Array)
-          self.current_subtargets += passed_argument
-        end
-      end
-      nil
-    end
-
-    # set the current processing on a specific subtarget
-    def bali_set_subtarget(subtarget)
-      rule_class = self.map_rules_dsl.current_rule_class
-      target_class = rule_class.target_class
-
-      rule_group = rule_class.rules_for(subtarget)
-
-      if rule_group.nil?
-        rule_group = Bali::RuleGroup.new(target_class, subtarget)
-      end
-
-      rule_class.add_rule_group rule_group
-      self.current_rule_group = rule_group
-    end
-
-end # class

data/lib/bali/foundations/all_foundations.rb

@@ -1,17 +0,0 @@
-# ./exceptions
-require_relative "exceptions/bali_error"
-require_relative "exceptions/dsl_error"
-require_relative "exceptions/objection_error"
-require_relative "exceptions/authorization_error"
-
-# rule
-require_relative "rule/rule"
-require_relative "rule/rule_class"
-require_relative "rule/rule_group"
-
-# role extractor
-require_relative "role_extractor"
-
-require_relative "judger/judge"
-require_relative "judger/negative_judge"
-require_relative "judger/positive_judge"

data/lib/bali/foundations/exceptions/authorization_error.rb

@@ -1,38 +0,0 @@
-# Error that will be raised when subtarget cannot do something he wanted to do,
-# or when subtarget do something he should not be allowed to do.
-class Bali::AuthorizationError < Bali::Error
-  attr_accessor :operation
-  attr_accessor :auth_level
-  attr_accessor :role
-
-  # it may be nil, depends on whether rule checking is using symbol/user
-  attr_accessor :subtarget
-
-  # whether a class or an object
-  attr_accessor :target
-
-  def target_proper_class
-    if target.is_a?(Class)
-      target
-    else
-      target.class
-    end
-  end
-
-  def to_s
-    role = humanise_value(self.role)
-    operation = humanise_value(self.operation)
-    auth_level = humanise_value(self.auth_level)
-
-    if auth_level == :can
-      "Role #{role} is not allowed to perform operation `#{operation}` on #{target_proper_class}"
-    else
-      "Role #{role} is allowed to perform operation `#{operation}` on #{target_proper_class}"
-    end
-  end
-
-  private
-    def humanise_value(val)
-      val.nil? ? "<nil>" : val
-    end
-end

data/lib/bali/foundations/exceptions/dsl_error.rb

@@ -1,3 +0,0 @@
-# this error is thrown when there is incorrect syntax in the DSL
-class Bali::DslError < Bali::Error
-end

data/lib/bali/foundations/exceptions/objection_error.rb

@@ -1,3 +0,0 @@
-# this error is thrown when objection is cannot be executed
-class Bali::ObjectionError < Bali::Error
-end

data/lib/bali/foundations/judger/judge.rb

@@ -1,329 +0,0 @@
-module Bali::Judger
-  # FUZY-ed value is happen when it is not really clear, need further cross checking,
-  # whether it is really allowed or not. It happens for example in block with others, such as this:
-  #
-  # role :finance do
-  #   cannot :view
-  # end
-  # others do
-  #   can :view
-  #   can :index
-  # end
-  #
-  # In the example above, objecting cannot view on finance will result in STRONG_FALSE, but
-  # objecting can index on finance will result in FUZY_TRUE.
-  #
-  # Eventually, all FUZY value will be normal TRUE or FALSE if no definite counterpart
-  # is found/defined
-  BALI_FUZY_FALSE = -2
-  BALI_FUZY_TRUE = 2
-  BALI_FALSE = -1
-  BALI_TRUE = 1
-
-  class Judge
-    attr_accessor :original_subtarget
-    attr_accessor :subtarget
-    attr_accessor :operation
-    # record can be the class, or an instance of a class
-    attr_accessor :record
-
-    # determine if this judger should not call other judger
-    attr_accessor :cross_checking
-
-    # this class is abstract, shouldn't be initialized
-    def initialize(unconstructable = true)
-      if unconstructable
-        raise Bali::Error, "Bali::Judge::Judger is unconstructable, properly construct by using build to get a concrete class!"
-      end
-      self
-    end 
-
-    def self.build(auth_level, options = {})
-      judge = nil
-      if auth_level == :can
-        judge = Bali::Judger::PositiveJudge.new
-      elsif auth_level == :cannot
-        judge = Bali::Judger::NegativeJudge.new
-      else
-        raise Bali::Error, "Unable to find judge for `#{auth_level}` case"
-      end
-
-      judge.original_subtarget = options[:original_subtarget]
-      judge.subtarget = options[:subtarget]
-      judge.operation = options[:operation]
-      judge.record = options[:record]
-      judge.cross_checking = false
-
-      judge
-    end
-
-    def clone(options = {})
-      if options[:reverse]
-        new_judge = Bali::Judger::Judge.build(self.reverse_auth_level)
-      else
-        new_judge = Bali::Judger::Judge.build(self.auth_level)
-      end
-
-      new_judge.subtarget = subtarget
-      new_judge.operation = operation
-      new_judge.record = record
-      new_judge.cross_checking = cross_checking
-      new_judge.original_subtarget = original_subtarget
-
-      new_judge
-    end
-
-    def record_class
-      record.is_a?(Class) ? record : record.class
-    end
-
-    def rule_group
-      unless @rule_group_checked
-        @rule_group = Bali::Integrator::RuleGroup.for(record_class, subtarget)
-        @rule_group_checked = true
-      end
-      @rule_group
-    end
-
-    def other_rule_group
-      unless @other_rule_group_checked
-        @other_rule_group = Bali::Integrator::RuleGroup.for(record_class, "__*__")
-        @other_rule_group_checked = true
-      end
-      @other_rule_group
-    end
-
-    def rule
-      unless @rule_checked
-        # rule group may be nil, for when user checking for undefined rule group
-        if rule_group
-          @rule = rule_group.get_rule(auth_level, operation)
-        else
-          self.rule = nil
-        end
-      end
-      @rule
-    end
-
-    def rule=(the_rule)
-      @rule = the_rule
-      @rule_checked = true
-      @rule
-    end
-
-    def otherly_rule
-      unless @otherly_rule_checked
-        if other_rule_group
-          # retrieve rule from others group
-          @otherly_rule = other_rule_group.get_rule(auth_level, operation)
-          @otherly_rule_checked = true
-        end
-      end
-      @otherly_rule
-    end
-
-    # return either true or false
-    # options can specify if returning raw, by specifying holy: true
-    def judgement(options = {})
-      # the divine judgement will come to thee, O Thou 
-      # the doer of truth. return raw, untranslated to true/false.
-      our_holy_judgement = nil
-
-      # default of can? is false whenever RuleClass for that class is undefined
-      # or RuleGroup for that subtarget is not defined
-      if rule_group.nil?
-        if other_rule_group.nil?
-          # no more chance for checking
-          our_holy_judgement = natural_value 
-        end
-      end
-
-      if our_holy_judgement.nil? && need_to_check_for_intervention? 
-        our_holy_judgement = check_intervention
-      end
-
-      if our_holy_judgement.nil? && 
-          rule_group && rule_group.plant? &&
-          rule.nil? && otherly_rule.nil?
-        our_holy_judgement = natural_value
-      end
-
-      if our_holy_judgement.nil? && rule.nil?
-        cross_check_value = nil
-        # default if can? for undefined rule is false, after related clause
-        # cannot be found in cannot?
-        unless cross_checking
-          reversed_self = self.clone reverse: true
-          reversed_self.cross_checking = true
-          cross_check_value = reversed_self.judgement holy: true
-        end 
-
-        # if cross check value nil, then the reverse rule is not defined,
-        # let's determine whether he is zeus or plant
-        if cross_check_value.nil?
-          # rule_group can be nil for when user checking under undefined rule-group
-          if rule_group
-            if rule_group.plant?
-              our_holy_judgement = plant_return_value
-            end
-
-            if rule_group.zeus?
-              our_holy_judgement = zeus_return_value
-            end 
-          end # if rule_group exist
-        else
-          # process value from cross checking
-          
-          if can_use_otherly_rule?(cross_check_value, cross_checking)
-            # give chance to check at others block
-            self.rule = otherly_rule
-          else
-            our_holy_judgement = cross_check_reverse_value(cross_check_value)
-          end
-        end
-      end # if our judgement nil and rule is nil
-
-      # if our holy judgement is still nil, but rule is defined
-      if our_holy_judgement.nil? && rule
-        if rule.has_decider?
-          our_holy_judgement = get_decider_result(rule, original_subtarget, record)
-        else
-          our_holy_judgement = default_positive_return_value
-        end
-      end
-
-      # return fuzy if otherly rule defines contrary to this auth_level
-      if our_holy_judgement.nil? && rule.nil? && (other_rule_group && other_rule_group.get_rule(reverse_auth_level, operation))
-        if rule_group && (rule_group.zeus? || rule_group.plant?)
-          # don't overwrite our holy judgement with fuzy value if rule group
-          # zeus/plant, because zeus/plant is more definite than any fuzy values
-          # eventhough the rule is abstractly defined
-        else
-          our_holy_judgement = default_negative_fuzy_return_value
-        end
-      end
-
-      # if at this point still nil, well, 
-      # return the natural value for this judge
-      if our_holy_judgement.nil?
-        if otherly_rule
-          our_holy_judgement = BALI_FUZY_TRUE
-        else
-          our_holy_judgement = natural_value
-        end
-      end
-
-      holy = !!options[:holy]
-      return holy ? our_holy_judgement : translate_holy_judgement(our_holy_judgement)
-    end
-
-    private
-      # translate response for value above to traditional true/false
-      # holy judgement refer to non-standard true/false being used inside Bali
-      # which need to be translated from other beings to know
-      def translate_holy_judgement(bali_bool_value)
-        unless bali_bool_value.is_a?(Integer)
-          raise Bali::Error, "Expect bali value to be an Integer, got: `#{bali_bool_value}`" 
-        end
-        if bali_bool_value < 0
-          return false
-        elsif bali_bool_value > 0
-          return true
-        end
-      end
-
-      def can_use_otherly_rule?(cross_check_value, is_cross_checking)
-        # either if rule from others block is defined, and the result so far is fuzy
-        # or, otherly rule is defined, and it is still a cross check
-        # plus, the result is not a definite BALI_TRUE/BALI_FALSE
-        #
-        # rationalisation:
-        # 1. Definite answer such as BALI_TRUE and BALI_FALSE is to be prioritised over
-        #    FUZY answer, because definite answer is not gathered from others block where
-        #    FUZY answer is. Therefore, it is an intended result
-        # 2. If the answer is FUZY, otherly_rule only be considered if the result
-        #    is either FUZY TRUE or FUZY FALSE, or
-        # 3. Or, when already in cross check mode, we cannot retrieve cross_check_value
-        #    what we can is instead, if otherly rule is available, just to try the odd
-        (!otherly_rule.nil? && cross_check_value && !(cross_check_value == BALI_TRUE || cross_check_value == BALI_FALSE)) ||
-          (!otherly_rule.nil? && (cross_check_value == BALI_FUZY_FALSE || cross_check_value == BALI_FUZY_TRUE)) ||
-          (!otherly_rule.nil? && is_cross_checking && cross_check_value.nil?)
-      end
-
-      # if after cross check (checking for cannot) the return is false,
-      # meaning for us, (checking for can), the return have to be true
-      def cross_check_reverse_value(cross_check_value)
-        # either the return is not fuzy, or otherly rule is undefined
-        if cross_check_value == BALI_TRUE
-          return BALI_FALSE
-        elsif cross_check_value == BALI_FALSE
-          return BALI_TRUE
-        elsif cross_check_value == BALI_FUZY_FALSE 
-          return BALI_FUZY_TRUE
-        elsif cross_check_value == BALI_FUZY_TRUE
-          return BALI_FUZY_FALSE
-        else
-          raise Bali::Error, "Unknown how to process cross check value: `#{cross_check_value}`"
-        end
-      end # cross_check_reverse_value
-
-      def check_intervention
-        if rule.nil?
-          self_clone = self.clone reverse: true
-          self_clone.cross_checking = true
-
-          check_val = self_clone.judgement holy: true
-
-          # check further whether contradicting rule is defined to overwrite this
-          # super-power either can_all or cannot_all rule
-          if check_val == BALI_TRUE
-            # it is defined, must overwrite
-            return BALI_FALSE
-          else
-            # futher inspection said no such overwriting value is exist
-            return BALI_TRUE
-          end # check_val
-        end # if rule nil
-      end # check intervention
-
-      # what is the result when decider is executed
-      # rule: the rule object
-      # original subtarget: raw, unprocessed arugment passed as subtarget
-      def get_decider_result(rule, original_subtarget, record)
-        # must test first
-        decider = rule.decider
-        case decider.arity
-        when 0
-          if rule.decider_type == :if
-            return decider.() ? BALI_TRUE : BALI_FALSE
-          elsif rule.decider_type == :unless
-            unless decider.()
-              return BALI_TRUE
-            else
-              return BALI_FALSE
-            end
-          end
-        when 1
-          if rule.decider_type == :if
-            return decider.(record) ? BALI_TRUE : BALI_FALSE
-          elsif rule.decider_type == :unless
-            unless decider.(record)
-              return BALI_TRUE
-            else
-              return BALI_FALSE
-            end
-          end
-        when 2
-          if rule.decider_type == :if
-            return decider.(record, original_subtarget) ? BALI_TRUE : BALI_FALSE
-          elsif rule.decider_type == :unless
-            unless decider.(record, original_subtarget)
-              return BALI_TRUE
-            else
-              return BALI_FALSE
-            end
-          end
-        end
-      end
-  end # class
-end # module