bali 2.4.0 → 6.0.1

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    M2I3NWNjNmVlNWM4YzQyMGU0YzAyNzBmZGJmNTBjMTUxMGYxOWMxYg==
-  data.tar.gz: !binary |-
-    MzhkMjlhYzA4NDU3M2M4ODE1ODkxZTU0ZDA3NDJjZGUwODNmOTZhYg==
+SHA256:
+  metadata.gz: 5f2c3170fb8da9fc0a76becddae855901f97cef723cd9db86073e0e2c15d177c
+  data.tar.gz: e9555504164bfb3155d281cfbf4d40629c347d178b76b7eaed2c83caacdcfc4a
 SHA512:
-  metadata.gz: !binary |-
-    MTJhOTRkODJhMWM5OTIzNjA0NTQ0OWVjMTMzOTgwZDFlZDBhZjQzNjQ0N2Y2
-    YWViMDExYzMyZjI5Y2YyOTYxNDdhZWJmYWU5YTVlNDYwODgwZDA1NDhhZWRm
-    NTliMTI1ZGEyMjNjY2QyNGEwNTM5YjNjNDc5OGIxYjk2MTYyNTI=
-  data.tar.gz: !binary |-
-    NTMzMzBjNTczZmM2MDE1YmI0NjA0ZjY1MDRhZGZmNWRiNTRjZGYzMDRmMWI4
-    Zjk4ZTEzNGZkZDg0NzFmZjg0YjYwNDQ2OGVlYjgwNzkwNTY4MGFlZDE1NjI3
-    ZDI1ZjlhNmFhODA4OGQzZDFhMjBkNjdjMjk1ZTI0YTkzZmQ4MTY=
+  metadata.gz: d2241cfc888b7b1c3ea4210c6a0dfc26ba790e8c190631b86d616000fbe4e927bea425f73b1547025c849f9ffc6b01c9f5389129ba9707258c79bf6a31c2c248
+  data.tar.gz: 472f04be142d2e7c42549f2927218c3ca57e880c11c86f2a6d409d0682ea76303299a33f065e070fa8ab38821a408a5ad37507f5d7189210d5baf68c231d4be4

data/.gitignore

@@ -7,10 +7,12 @@
 /pkg/
 /spec/reports/
 /tmp/
+/spec/test_app/tmp
 
 *.swp
 *.swo
 *.gemspec
 *.gem
+*.log
 
 plugins

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --color
+--require spec_helper

data/.travis.yml

@@ -1,4 +1,46 @@
 language: ruby
+
+env:
+  global:
+    - CC_TEST_REPORTER_ID=76cedf4d3aa437009b269ff68b901102ca24baeb46245eb94fca42e21bba20a7
+
 rvm:
-  - 2.2.2
-before_install: gem install bundler -v 1.10.6
+ - 2.6.5
+
+before_install:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+  - sudo apt update -qq
+  - gem i bundler -v '<2'
+
+cache: bundler
+
+script:
+  - bundle exec rspec
+
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT
+
+matrix:
+  include:
+    - rvm: 2.7.0
+      gemfile: gemfiles/Gemfile-rails.6.0.x
+    - rvm: 2.6.3
+      gemfile: gemfiles/Gemfile-rails.6.0.x
+    - rvm: 2.6.3
+      gemfile: gemfiles/Gemfile-rails.5.2.x
+    - rvm: 2.4.4
+      gemfile: gemfiles/Gemfile-rails.5.2.x
+    - rvm: 2.6.3
+      gemfile: gemfiles/Gemfile-rails.5.1.x
+    - rvm: 2.6.3
+      gemfile: gemfiles/Gemfile-rails.5.0.x
+    - rvm: 2.4.4
+      gemfile: gemfiles/Gemfile-rails.5.0.x
+    - rvm: ruby-head
+      gemfile: gemfiles/Gemfile-rails.edge
+
+  allow_failures:
+    - rvm: ruby-head
+    - gemfile: gemfiles/Gemfile-rails.edge

data/gemfiles/Gemfile-rails.5.0.x

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'rails', '~> 5.0.0'
+gem 'rspec-rails', '~> 3.9'
+gem 'sqlite3', '< 1.4'

data/gemfiles/Gemfile-rails.5.1.x

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'rails', '~> 5.1.0'
+gem 'rspec-rails', '~> 3.9'

data/gemfiles/Gemfile-rails.5.2.x

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'rails', git: 'https://github.com/rails/rails', branch: '5-2-stable'
+gem 'rspec-rails', '~> 3.9'

data/gemfiles/Gemfile-rails.6.0.x

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+gem 'rails', '~> 6.0.0'

data/gemfiles/Gemfile-rails.edge

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec path: '..'
+
+git_source(:github) do |repo_name|
+  repo_name = "#{repo_name}/#{repo_name}" unless repo_name.include?("/")
+  "https://github.com/#{repo_name}.git"
+end
+
+github 'rails/rails' do
+  gem 'rails'
+end
+
+gem 'rspec-rails', '~> 4.0'

data/lib/bali.rb

@@ -1,33 +1,44 @@
 require_relative "bali/version"
 
-# load the DSL syntax maker definition, ordered by proper order of invocation
-require_relative "bali/dsl/map_rules_dsl"
-require_relative "bali/dsl/rules_for_dsl"
-
-require_relative "bali/objector"
-require_relative "bali/printer"
+begin
+  require "rails"
+  require "rails/generators"
+rescue LoadError => e
+  # ignores
+end
 
-require_relative "bali/foundations/all_foundations"
-require_relative "bali/integrators/all_integrators"
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/generators")
+loader.ignore("#{__dir__}/bali/rails")
+loader.ignore("#{__dir__}/bali/rspec")
+loader.setup
 
 module Bali
-  # mapping class to a RuleClass
-  RULE_CLASS_MAP = {}
+  extend self
+
+  def config
+    @config ||= Bali::Config.new
+  end
 
-  # {
-  #   User: :roles,
-  #   AdminUser: :admin_roles
-  # }
-  TRANSLATED_SUBTARGET_ROLES = {}
+  def configure
+    yield config
+  end
 
-  extend self
-  def map_rules(&block)
-    dsl_map_rules = Bali::MapRulesDsl.new
-    dsl_map_rules.instance_eval(&block)
+  if defined? Rails
+    require "bali/railtie"
+    require "bali/rails/action_controller"
+    require "bali/rails/action_view"
+    require "bali/rails/active_record"
   end
 
-  def clear_rules
-    Bali::RULE_CLASS_MAP.clear
-    true
+  if defined? RSpec
+    begin
+      require "rspec/matchers"
+      require "bali/rspec/able_to_matcher"
+    rescue LoadError => e
+    end
   end
 end
+
+loader.eager_load

data/lib/bali/config.rb

@@ -0,0 +1,12 @@
+class Bali::Config
+  attr_accessor :rules_path
+  attr_accessor :suffix
+
+  def initialize
+    if Rails.respond_to?(:root) && Rails.root
+      @rules_path = Rails.root.join("app", "rules")
+    end
+
+    @suffix = "Rules"
+  end
+end

data/lib/bali/dsl_error.rb

@@ -0,0 +1,3 @@
+# Error class to represent incorrect usage of syntax
+class Bali::DslError < Bali::Error
+end

data/lib/bali/judge.rb

@@ -0,0 +1,221 @@
+class Bali::Judge
+  # Fuzy value is possible when the evaluation is not yet clear cut, for example in this case:
+  #
+  # role :finance do
+  #   cant :view
+  # end
+  #
+  # others do
+  #   can :view
+  #   can :index
+  # end
+  #
+  # Checking cant view for finance role results in a definite false, but
+  # checking on index for the same role results in FUZY_TRUE. Eventually, all FUZY value will be
+  # normal TRUE or FALSE if no definite counterpart is found.
+
+  FUZY_FALSE = -2
+  FUZY_TRUE = 2
+  DEFINITE_FALSE = -1
+  DEFINITE_TRUE = 1
+
+  attr_accessor :term,
+    :actor,
+    :role,
+    :operation,
+    :record,
+    :should_cross_check
+
+  class << self
+    def default_judgement_value(term)
+      case term
+      when :can then false
+      when :cant then true
+      end
+    end
+
+    def check(term, actor_or_roles, operation, record)
+      if operation.nil?
+        # eg: user.can? :sign_in
+        operation = actor_or_roles
+        actor_or_roles = nil
+      end
+
+      judgement_value = default_value = default_judgement_value(term)
+      roles = Bali::Role.formalize actor_or_roles
+
+      roles.each do |role|
+        judge = Bali::Judge.new(
+          term: term,
+          role: role,
+          actor: actor_or_roles,
+          operation: operation,
+          record: record
+        )
+
+        judgement_value = judge.judgement
+        break if judgement_value != default_value
+      end
+
+      judgement_value
+    end
+  end
+
+  def initialize(term:,
+    actor:,
+    role:,
+    operation:,
+    record:,
+    should_cross_check: true)
+
+    @term = term
+    @role = role
+    @actor = actor
+    @operation = operation
+    @record = record
+    @should_cross_check = should_cross_check
+  end
+
+  def judgement
+    judgement = natural_value if no_rule_group?
+
+    if judgement.nil? && rule.nil?
+      cross_check_value = nil
+      # default if can? for undefined rule is false, after related clause
+      # cant be found in cant?
+      cross_check_value = cross_check_judge.judgement if should_cross_check
+
+      # if cross check value nil, then the reverse rule is not defined,
+      # let's determine whether they can do anything or not
+      if cross_check_value.nil?
+        judgement = deduce_from_defined_disposition
+      else
+        # process value from cross checking
+        if otherly_rule && (cross_check_value == FUZY_FALSE || cross_check_value == FUZY_TRUE)
+          # give chance to check at others block
+          @rule = otherly_rule
+        else
+          judgement = reverse_value(cross_check_value)
+        end
+      end
+    end
+
+    judgement ||= deduce_by_evaluation ||
+      deduce_from_fuzy_rules ||
+      natural_value
+
+    return !should_cross_check ?
+      judgement :
+
+      # 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
+      judgement > 0
+  end
+
+  private
+
+    def record_class
+      record.is_a?(Class) ? record : record.class
+    end
+
+    def ruler
+      @ruler ||= Bali::Ruler.for record_class
+    end
+
+    def rule_group_for(role)
+      ruler.nil? ? nil : ruler[role]
+    end
+
+    def rule_group
+      @rule_group ||= rule_group_for role
+    end
+
+    def other_rule_group
+      @other_rule_group ||= rule_group_for nil
+    end
+
+    def no_rule_group?
+      rule_group.nil? && other_rule_group.nil?
+    end
+
+    def rule
+      # rule group may be nil, for when user checking for undefined rule group
+      @rule ||= rule_group ? rule_group.find_rule(term, operation) : nil
+    end
+
+    def otherly_rule
+      @otherly_rule ||= other_rule_group ? other_rule_group.find_rule(term, operation) : nil
+    end
+
+    def cross_check_judge
+      @cross_check_judge ||= begin
+        Bali::Judge.new(
+          term: reversed_term,
+          role: role,
+          operation: operation,
+          record: record,
+          should_cross_check: false,
+          actor: actor
+        )
+      end
+    end
+
+    def reversed_term
+      case term
+      when :can then :cant
+      when :cant then :can
+      end
+    end
+
+    def natural_value
+      term == :cant ? DEFINITE_TRUE : DEFINITE_FALSE
+    end
+
+    def reverse_value(value)
+      case value
+      when DEFINITE_TRUE then DEFINITE_FALSE
+      when DEFINITE_FALSE then DEFINITE_TRUE
+      when FUZY_FALSE then FUZY_TRUE
+      when FUZY_TRUE then FUZY_FALSE
+      end
+    end
+
+    def evaluate(rule, actor, record)
+      conditional = rule.conditional
+      evaluation  = case conditional.arity
+                    when 0 then conditional.()
+                    when 1 then conditional.(record)
+                    when 2 then conditional.(record, actor)
+                    end
+
+      evaluation ? DEFINITE_TRUE : DEFINITE_FALSE
+    end
+
+    def deduce_by_evaluation
+      return unless rule
+
+      rule.conditional? ?
+        evaluate(rule, actor, record) :
+        judgement = DEFINITE_TRUE
+    end
+
+    def deduce_from_defined_disposition
+      return unless rule_group
+
+      if rule_group.can_all?
+        reverse_value(natural_value)
+      elsif rule_group.cant_all?
+        natural_value
+      end
+    end
+
+    def deduce_from_fuzy_rules
+      reversed_otherly_rule = other_rule_group.find_rule(reversed_term, operation)
+
+      if reversed_otherly_rule
+        term == :cant ? FUZY_TRUE : FUZY_FALSE
+      end
+    end
+
+end

data/lib/bali/printer.rb

@@ -2,62 +2,73 @@ require "stringio"
 require "date"
 
 # module that would allow all defined rules to be printed for check
-module Bali::Printer
-  module_function
-    
+class Bali::Printer
+  include Singleton
+
   SEPARATOR = " " * 6
   SUBTARGET_TITLE_SEPARATOR = SEPARATOR + ("-" * 80) + "\n"
 
-  def pretty_print
+  def self.printable
+    instance.printable
+  end
+
+  def self.pretty_print
+    printable
+  end
+
+  def load_rule_classes
+    return unless Bali.config.rules_path.present?
+
+    Dir["#{Bali.config.rules_path}/**/*.rb"].each do |rule_class_path|
+      require rule_class_path
+    end
+  rescue LoadError
+    # ignore
+  end
+
+  def printable
+    load_rule_classes
     output = StringIO.new
 
     # build up the string for pretty printing rules
-    Bali::RULE_CLASS_MAP.each do |klass, rule_class|
-      output << "===== #{klass.to_s} =====\n\n"
-      
-      rule_class.rule_groups.each do |subtarget, rule_group|
-        print_rule_group(rule_group, output)
-      end
+    rule_classes = ObjectSpace.each_object(Class).select { |cls| cls < Bali::Rules }
+    rule_classes.sort! { |a, b| a.to_s <=> b.to_s }
+    rule_classes.each do |rule_class|
+      output << "===== #{rule_class.model_class} =====\n\n"
 
-      if rule_class.others_rule_group.rules.any?
-        print_rule_group(rule_class.others_rule_group, output)
+      rule_class.ruler.roles.each do |subtarget, role|
+        print_role role, output
       end
+
       output << "\n\n"
     end
 
-    output << "\n\n"
-    output << DateTime.now.strftime("Printed at %d-%m-%Y %I:%M%p %Z")
+    output << DateTime.now.strftime("Printed at %Y-%m-%d %I:%M%p %Z")
 
     output.string
   end
 
-  def print_rule_group(rule_group, target_io)
-    target = rule_group.target.to_s
-    subtarget = rule_group.subtarget.to_s.capitalize
-    subtarget = "Others" if subtarget == "__*__"
-    is_zeus = rule_group.zeus?
-    is_plant = rule_group.plant?
+  def print_role role, target_io
+    subtarget = role.name.to_s.capitalize
+    subtarget = "By default" if subtarget.blank?
+    can_all = role.can_all?
     counter = 0
 
-    target_io << "#{SEPARATOR}#{subtarget}, can all: #{is_zeus}, cannot all: #{is_plant}\n"
+    target_io << "#{SEPARATOR}#{subtarget}\n"
     target_io << SUBTARGET_TITLE_SEPARATOR
-    
-    if is_zeus
+
+    if can_all
       target_io << "#{SEPARATOR}  #{counter+=1}. #{subtarget} can do anything except if explicitly stated otherwise\n"
-    elsif is_plant
-      target_io << "#{SEPARATOR}  #{counter+=1}. #{subtarget} cannot do anything except if explicitly stated otherwise\n"
     end
-  
-    rule_group.rules.each do |rule|
+
+    role.rules.each do |rule|
       written_rule = StringIO.new
-      written_rule << "#{SEPARATOR}  #{counter+=1}. #{subtarget} #{rule.auth_val} #{rule.operation} #{target}"
-      if rule.has_decider?
+      written_rule << "#{SEPARATOR}  #{counter+=1}. #{subtarget} #{rule.term} #{rule.operation}"
+      if rule.conditional?
         written_rule << ", with condition"
       end
       written_rule << "\n"
       target_io << written_rule.string
     end
-
-    target_io << "\n"
   end
 end