bali 2.2.0 → 2.4.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZTcxZjc2ZmMyNDgzYWVmMDNjOWNhMzNmNjZiZmNjYTcwMjkzZGE0YQ==
+    M2I3NWNjNmVlNWM4YzQyMGU0YzAyNzBmZGJmNTBjMTUxMGYxOWMxYg==
   data.tar.gz: !binary |-
-    ZTYwYzIwMWE2Nzg1ZjM5YmIwM2RjNTcwY2E2MDQ4OTQ0ZTUzNWZmOA==
+    MzhkMjlhYzA4NDU3M2M4ODE1ODkxZTU0ZDA3NDJjZGUwODNmOTZhYg==
 SHA512:
   metadata.gz: !binary |-
-    MDdkNTNhODc2NTRkNmY1NTBmNDk3MTQ3Mzc5YWUwMjBkNmQzODkzYTliOTA3
-    MGJkMjBkMWE0ZTE1ODZkYTY0MmFhMmJmMzMxNTMwM2I0ZWU1ZDE1Y2ZmOWUz
-    N2I0NDg5MGYxZjU1NzMyOWU3MzcwOTJhMmUxOTBkNTQ0YWEzNGQ=
+    MTJhOTRkODJhMWM5OTIzNjA0NTQ0OWVjMTMzOTgwZDFlZDBhZjQzNjQ0N2Y2
+    YWViMDExYzMyZjI5Y2YyOTYxNDdhZWJmYWU5YTVlNDYwODgwZDA1NDhhZWRm
+    NTliMTI1ZGEyMjNjY2QyNGEwNTM5YjNjNDc5OGIxYjk2MTYyNTI=
   data.tar.gz: !binary |-
-    YmI1YjcxMmNmOGFjOWFmZjk1NDA0MGIzZWFlMmEwNTk3ODgxNzVkYzRmZjQz
-    ZTNkNTU4ZWYwYTBjNWNiZDdjZTNjODA2ZTBjNzc0NDRhZTU3MmQ0NWJiZmI0
-    MGViMWE0ZjllNzZjM2U0N2ViYjNjZDYzY2ZlOWRkOTJkNWVhNjM=
+    NTMzMzBjNTczZmM2MDE1YmI0NjA0ZjY1MDRhZGZmNWRiNTRjZGYzMDRmMWI4
+    Zjk4ZTEzNGZkZDg0NzFmZjg0YjYwNDQ2OGVlYjgwNzkwNTY4MGFlZDE1NjI3
+    ZDI1ZjlhNmFhODA4OGQzZDFhMjBkNjdjMjk1ZTI0YTkzZmQ4MTY=

data/.gitignore

@@ -12,3 +12,5 @@
 *.swo
 *.gemspec
 *.gem
+
+plugins

data/lib/bali.rb

@@ -20,11 +20,6 @@ module Bali
   # }
   TRANSLATED_SUBTARGET_ROLES = {}
 
-  # pub/sub for plugin that extend bali
-  LISTENABLE_EVENTS = {}
-end
-
-module Bali
   extend self
   def map_rules(&block)
     dsl_map_rules = Bali::MapRulesDsl.new

data/lib/bali/dsl/map_rules_dsl.rb

@@ -3,51 +3,48 @@ class Bali::MapRulesDsl
   attr_accessor :current_rule_class
 
   def initialize
-    @@lock = Mutex.new
+    @@lock ||= Mutex.new
   end
 
   # defining rules
   def rules_for(target_class, options_hash = {}, &block)
     @@lock.synchronize do
-      raise Bali::DslError "rules_for must describe a target which is a class" unless target_class.is_a?(Class)
       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
-        raise Bali::DslError, "inherits must take a class" unless parent_class.is_a?(Class)
-        rule_class_from_parent = Bali::Integrators::Rule.rule_class_for(parent_class)
-        raise Bali::DslError, "not yet defined a rule class for #{parent_class}" if rule_class_from_parent.nil?
+        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::Integrators::Rule.add_rule_class(self.current_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)
-    raise Bali::DslError, "Subtarget must be a class" unless subtarget_class.is_a?(Class)
-    raise Bali::DslError, "Field name must be a symbol/string" if !(field_name.is_a?(Symbol) || field_name.is_a?(String))
-
     Bali::TRANSLATED_SUBTARGET_ROLES[subtarget_class.to_s] = field_name
     nil
   end
 
   def describe(*params)
-    raise Bali::DslError, "describe block must be within rules_for block"
+    fail Bali::DslError, "describe block must be within rules_for block"
   end
 
   def role(*params)
-    raise Bali::DslError, "role block must be within rules_for block"
+    fail Bali::DslError, "role block must be within rules_for block"
   end
 
   def can(*params)
-    raise Bali::DslError, "can block must be within role block"
+    fail Bali::DslError, "can block must be within role block"
   end
 
   def cant(*params)
@@ -56,15 +53,15 @@ class Bali::MapRulesDsl
   end
 
   def cannot(*params)
-    raise Bali::DslError, "cant block must be within role block"
+    fail Bali::DslError, "cant block must be within role block"
   end
 
   def can_all(*params)
-    raise Bali::DslError, "can_all block must be within role block"
+    fail Bali::DslError, "can_all block must be within role block"
   end
 
   def clear_rules
-    raise Bali::DslError, "clear_rules must be called within role block"
+    fail Bali::DslError, "clear_rules must be called within role block"
   end
 
   def cant_all(*params)
@@ -73,6 +70,6 @@ class Bali::MapRulesDsl
   end
 
   def cannot_all(*params)
-    raise Bali::DslError, "cant_all block must be within role block"
+    fail Bali::DslError, "cant_all block must be within role block"
   end
 end

data/lib/bali/dsl/rules_for_dsl.rb

@@ -6,11 +6,9 @@ class Bali::RulesForDsl
 
   # all to be processed subtargets
   attr_accessor :current_subtargets
-  # rules defined with hash can: [] and cannot: []
-  attr_accessor :shortcut_rules
 
   def initialize(map_rules_dsl)
-    @@lock = Mutex.new
+    @@lock ||= Mutex.new
     self.map_rules_dsl = map_rules_dsl
   end
 
@@ -22,17 +20,29 @@ class Bali::RulesForDsl
   def role(*params)
     @@lock.synchronize do
       bali_scrap_actors(*params)
-      bali_scrap_shortcut_rules(*params)
       current_subtargets.each do |subtarget|
+        bali_set_subtarget(subtarget)
+
         if block_given?
-          bali_process_subtarget(subtarget) do
-            yield
-          end
+          yield
         else
-          bali_process_subtarget(subtarget)
-        end
-      end
-    end
+          # 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)
@@ -61,12 +71,12 @@ class Bali::RulesForDsl
     true
   end
 
-  def can(*operations)
-    bali_process_auth_rules(:can, operations)
+  def can(*args)
+    Bali::Integrator::Rule.add_can(self.current_rule_group, *args)
   end
 
-  def cannot(*operations)
-    bali_process_auth_rules(:cannot, operations)
+  def cannot(*args)
+    Bali::Integrator::Rule.add_cannot(self.current_rule_group, *args)
   end
 
   def cant(*operations)
@@ -75,13 +85,11 @@ class Bali::RulesForDsl
   end
 
   def can_all
-    self.current_rule_group.zeus = true
-    self.current_rule_group.plant = false
+    Bali::Integrator::RuleGroup.make_zeus(self.current_rule_group)
   end
 
   def cannot_all
-    self.current_rule_group.plant = true
-    self.current_rule_group.zeus = false
+    Bali::Integrator::RuleGroup.make_plant(self.current_rule_group)
   end
 
   def cant_all
@@ -104,19 +112,10 @@ class Bali::RulesForDsl
       nil
     end
 
-    def bali_scrap_shortcut_rules(*params)
-      self.shortcut_rules = {}
-      params.each do |passed_argument|
-        if passed_argument.is_a?(Hash)
-          self.shortcut_rules = passed_argument
-        end
-      end
-      nil
-    end
-
-    def bali_process_subtarget(subtarget)
-      target_class = self.map_rules_dsl.current_rule_class.target_class
+    # 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)
 
@@ -124,65 +123,8 @@ class Bali::RulesForDsl
         rule_group = Bali::RuleGroup.new(target_class, subtarget)
       end
 
+      rule_class.add_rule_group rule_group
       self.current_rule_group = rule_group
-
-      if block_given?
-        yield
-      else
-        # auth_val is either can or cannot
-        shortcut_rules.each do |auth_val, operations|
-          if operations.is_a?(Array)
-            operations.each do |op|
-              rule = Bali::Rule.new(auth_val, op)
-              rule_group.add_rule(rule)
-            end
-          else
-            operation = operations # well, basically is 1 only
-            rule = Bali::Rule.new(auth_val, operation)
-            rule_group.add_rule(rule)
-          end
-        end # each rules
-      end # block_given?
-
-      # add current_rule_group
-      rule_class.add_rule_group(rule_group)
-
-      nil
     end
 
-    # to define can and cant is basically using this method
-    def bali_process_auth_rules(auth_val, args)
-      conditional_hash = nil
-      operations = []
-
-      # scan args for options
-      args.each do |elm|
-        if elm.is_a?(Hash)
-          conditional_hash = elm
-        else
-          operations << elm
-        end
-      end
-
-      # add operation one by one
-      operations.each do |op|
-        rule = Bali::Rule.new(auth_val, op)
-        bali_embed_conditions(rule, conditional_hash)
-        self.current_rule_group.add_rule(rule)
-      end
-    end # bali_process_auth_rules
-
-    # process conditional statement in rule definition
-    def bali_embed_conditions(rule, conditional_hash = nil)
-      return if conditional_hash.nil?
-
-      condition_type = conditional_hash.keys[0].to_s.downcase
-      condition_type_symb = condition_type.to_sym
-
-      if condition_type_symb == :if || condition_type_symb == :unless
-        rule.decider = conditional_hash.values[0]
-        rule.decider_type = condition_type_symb
-      end
-      nil
-    end
 end # class

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

@@ -79,7 +79,7 @@ module Bali::Judger
 
     def rule_group
       unless @rule_group_checked
-        @rule_group = Bali::Integrators::Rule.rule_group_for(record_class, subtarget)
+        @rule_group = Bali::Integrator::RuleGroup.for(record_class, subtarget)
         @rule_group_checked = true
       end
       @rule_group
@@ -87,7 +87,7 @@ module Bali::Judger
 
     def other_rule_group
       unless @other_rule_group_checked
-        @other_rule_group = Bali::Integrators::Rule.rule_group_for(record_class, "__*__")
+        @other_rule_group = Bali::Integrator::RuleGroup.for(record_class, "__*__")
         @other_rule_group_checked = true
       end
       @other_rule_group

data/lib/bali/foundations/rule/rule.rb

@@ -32,7 +32,7 @@ class Bali::Rule
     elsif aval == :cant
       @auth_val = :cannot
     else
-      raise Bali::DslError, "auth_val can only either be :can or :cannot"
+      fail Bali::DslError, "auth_val can only either be :can or :cannot"
     end
   end
 
@@ -40,7 +40,7 @@ class Bali::Rule
     if dectype == :if || dectype == :unless
       @decider_type = dectype
     else
-      raise Bali::DslError, "decider type can only be either if or unless, got: #{dectype}"
+      fail Bali::DslError, "decider type not allowed"
     end
   end
 
@@ -50,7 +50,6 @@ class Bali::Rule
   end
 
   def has_decider?
-    raise Bali::DslError, "has decider but not sure if it is if or unless type decider" if self.decider.is_a?(Proc) && self.decider_type.nil?
-    self.decider.is_a?(Proc)
+    self.decider.is_a?(Proc) && !self.decider_type.nil?
   end
 end

data/lib/bali/foundations/rule/rule_class.rb

@@ -13,26 +13,17 @@ class Bali::RuleClass
   attr_accessor :others_rule_group
 
   def initialize(target_class)
-    if target_class.is_a?(Class)
-      @target_class = target_class
-    else
-      raise Bali::DslError, "Target class must be a Class"
-    end
-
+    @target_class = target_class
     self.rule_groups = {}
     self.others_rule_group = Bali::RuleGroup.new(target_class, "__*__")
   end
 
   def add_rule_group(rule_group)
-    if rule_group.is_a?(Bali::RuleGroup)
-      target_user = rule_group.subtarget
-      if target_user == "__*__" || target_user == :"__*__"
-        self.others_rule_group = rule_group
-      else
-        self.rule_groups[rule_group.subtarget] = rule_group
-      end
+    target_user = rule_group.subtarget
+    if target_user == "__*__" || target_user == :"__*__"
+      self.others_rule_group = rule_group
     else
-      raise Bali::DslError, "Rule group must be an instance of Bali::RuleGroup, got: #{rule_group.class.name}"
+      self.rule_groups[rule_group.subtarget] = rule_group
     end
   end
 

data/lib/bali/foundations/rule/rule_group.rb

@@ -51,12 +51,10 @@ class Bali::RuleGroup
   end
 
   def add_rule(rule)
-    raise Bali::DslError, "Rule must be of class Bali::Rule, got: #{rule.class.name}" unless rule.is_a?(Bali::Rule)
-
     # operation cannot be defined twice
     operation = rule.operation.to_sym
 
-    raise Bali::DslError, "Rule is defined twice for operation #{operation}" if self.cants[operation] && self.cans[operation]
+    return if self.cants[operation] && self.cans[operation]
 
     if rule.is_discouragement?
       self.cants[operation] = rule
@@ -80,7 +78,7 @@ class Bali::RuleGroup
     when :cannot, "cannot"
       rule = self.cants[operation.to_sym]
     else
-      raise Bali::DslError, "Undefined operation: #{auth_val}"
+      fail Bali::DslError, "Undefined operation: #{auth_val}"
     end
 
     rule

data/lib/bali/integrators/all_integrators.rb

@@ -1,4 +1,8 @@
-module Bali::Integrators
+module Bali
+  module Integrator
+  end
 end
 
-require_relative "rules_integrator"
+require_relative "rule_class_integrator"
+require_relative "rule_group_integrator"
+require_relative "rule_integrator"

data/lib/bali/integrators/rule_class_integrator.rb

@@ -0,0 +1,27 @@
+module Bali
+  module Integrator
+    # high-level functions to access and manage RuleClass classes
+    module RuleClass
+      
+      module_function
+
+      # return all rule classes
+      def all
+        Bali::RULE_CLASS_MAP
+      end
+
+      # return all rule class of a target
+      def for(target)
+        Bali::RULE_CLASS_MAP[target.to_s]
+      end
+
+      # add a new rule class
+      def add(rule_class)
+        target = rule_class.target_class
+
+        Bali::RULE_CLASS_MAP[target.to_s] = rule_class
+        rule_class
+      end # add_rule_class
+    end
+  end
+end

data/lib/bali/integrators/rule_group_integrator.rb

@@ -0,0 +1,29 @@
+module Bali
+  module Integrator
+    module RuleGroup
+
+      module_function
+
+      # attempt to search the rule group, 
+      # but if not exist, will return nil
+      def for(target_class, subtarget)
+        rule_class = Bali::Integrator::RuleClass.for(target_class)
+        rule_class.nil? ? nil : rule_class.rules_for(subtarget)
+      end
+
+      # make a rule group a zeus, that is, he can do everything, unless
+      # specified more specifically otherwise by a definite rule
+      def make_zeus(rule_group)
+        rule_group.zeus = true
+        rule_group.plant = false
+      end
+
+      # make a rule group a plant, that is, he cannot do everything, unless
+      # specified more specifically otherwise by a definite rule
+      def make_plant(rule_group)
+        rule_group.plant = true
+        rule_group.zeus = false
+      end
+    end
+  end
+end

data/lib/bali/integrators/rule_integrator.rb

@@ -0,0 +1,56 @@
+module Bali
+  module Integrator
+    module Rule
+
+      module_function
+
+      # process conditional statement in rule definition
+      # conditional hash: {if: proc} or {unless: proc}
+      def embed_condition(rule, conditional_hash = nil)
+        return if conditional_hash.nil?
+
+        condition_type = conditional_hash.keys[0].to_s.downcase
+        condition_type_symb = condition_type.to_sym
+
+        if condition_type_symb == :if || condition_type_symb == :unless
+          rule.decider = conditional_hash.values[0]
+          rule.decider_type = condition_type_symb
+        end
+        nil
+      end
+
+      # to define can and cant is basically using this method
+      # args can comprises of symbols, and hash (for condition)
+      def add(auth_val, rule_group, *args)
+        conditional_hash = nil
+        operations = []
+
+        # scan args for options
+        args.each do |elm|
+          if elm.is_a?(Hash)
+            conditional_hash = elm
+          else
+            operations << elm
+          end
+        end
+
+        # add operation one by one
+        operations.each do |op|
+          rule = Bali::Rule.new(auth_val, op)
+          Bali::Integrator::Rule.embed_condition(rule, conditional_hash)
+          rule_group.add_rule(rule)
+        end
+      end # bali_process_auth_rules
+
+      # add can rule programatically
+      def add_can(rule_group, *args)
+        add :can, rule_group, *args
+      end
+
+      # add cannot rule programatically
+      def add_cannot(rule_group, *args)
+        add :cannot, rule_group, *args
+      end
+    end
+  end
+end

data/lib/bali/version.rb

@@ -1,3 +1,3 @@
 module Bali
-  VERSION = "2.2.0"
+  VERSION = "2.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bali
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Adam Pahlevi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-23 00:00:00.000000000 Z
+date: 2016-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,11 +64,7 @@ files:
 - .gitignore
 - .rspec
 - .travis.yml
-- CHANGELOG.md
-- CODE_OF_CONDUCT.md
 - Gemfile
-- LICENSE.txt
-- README.md
 - Rakefile
 - bali.gemspec
 - bin/console
@@ -89,7 +85,9 @@ files:
 - lib/bali/foundations/rule/rule_class.rb
 - lib/bali/foundations/rule/rule_group.rb
 - lib/bali/integrators/all_integrators.rb
-- lib/bali/integrators/rules_integrator.rb
+- lib/bali/integrators/rule_class_integrator.rb
+- lib/bali/integrators/rule_group_integrator.rb
+- lib/bali/integrators/rule_integrator.rb
 - lib/bali/objector.rb
 - lib/bali/printer.rb
 - lib/bali/version.rb

data/CHANGELOG.md

@@ -1,80 +0,0 @@
-## Changelog
-
-== Version 1.0.0beta1
-
-1. Initial version
-
-== Version 1.0.0rc1
-
-1. Fix bug where user can't check on class
-2. Adding new clause: cant_all
-
-== Version 1.0.0rc2
-
-1. [Fix bug when class's name, as a constant, is reloaded](http://stackoverflow.com/questions/2509350/rails-class-object-id-changes-after-i-make-a-request) (re-allocated to different address in the memory)
-2. Allow describing rule for `nil`, useful if user is not authenticated thus role is probably `nil`
-3. Remove pry from development dependency
-
-== Version 1.0.0rc3
-
-1. Each target class should includes `Bali::Objector`, for the following reasons:
-   - Makes it clear that class do want to include the Bali::Objector
-   - Transparant, and thus less confusing as to where "can?" and "cant" come from
-   - When ruby re-parse the class's codes for any reasons, parser will be for sure include Bali::Objector
-2. Return `true` to any `can?` for undefined target/subtarget alike
-3. Return `false` to any `cant?` for undefined target/subtarget alike
-
-== Version 1.0.0
-
-1. Released the stable version of this gem
-
-== Version 1.1.0rc1
-
-1. Ability for rule class to be parsed later by passing `later: true` to rule class definition
-2. Add `Bali.parse` and `Bali.parse!` (`Bali.parse!` executes "later"-tagged rule class, Bali.parse executes automatically after all rules are defined)
-3. Added more thorough testing specs
-4. Proc can be served under `unless` for defining the rule's decider
-
-== Version 1.1.0rc2
-
-1. Ability to check `can?` and `cant?` for subtarget with multiple roles
-2. Describe multiple rules at once for multiple subtarget
-
-== Version 1.2.0
-
-1. Passing real object as subtarget's role, instead of symbol or array of symbol
-2. Clause can also yielding user, along with the object in question
-
-== Version 2.0.0rc1
-
-1. `Bali::AuthorizationError` subclass of `StandardError` tailored for raising error regarding with authorisation
-2. Deprecating `cant`, `cant?`, and `cant_all` in favor of `cannot`, `cannot?` and `cannot_all`
-3. new objectors `can!` and `cannot!` to raise error on inappropriate access
-
-== Version 2.0.0
-
-1. Release!
-
-== Version 2.1.0
-
-1. `others` block would allow for rule definitions within it to be applied for all undefined subtargets of a target
-2. Fixing bug when roles_for of a user object retrieves `nil` as the user's role, it won't acknowledge that the user is indeed having `nil`-role and raising an error instead.
-3. Inherits rules by passing `:inherits` option when defining `rules_for`
-4. `clear_rules` within `describe` or `others` block to remove all inherited rules (or any rules previously defined) for that subtarget
-5. Adding `Bali::Printer` that would enable for rules to be printed by calling `.pretty_print` on it
-
-== Version 2.1.1
-
-1. Bug fixes on `clear_rules` which it clear rules defined in `others` even when not asked to
-2. Bug fixes on `Bali::Printer` where inherited rules print the wrong target class due to another bug in an internal file (but doesn't hamper rules-checking logic)
-
-== Version 2.1.2
-
-1. `nil` will be printed <nil> when objecting with can! or cannot! for better readability.
-2. Bug fixes on declaring multiple rules with decider. Previously, others were ignored--now, every single rule will get defined whether decider is present or not.
-
-== Version 2.2.0
-
-1. Deprecating `describe` block in favour of `role` block, `describe` is to be deprecated in version 3.0.
-2. Using strategy pattern, heavy refactoring 
-3. Human-readable authorisation error message when invoking !-version of can/cannot, for eg: Role general_user is not allowed to perform operation `update` on My::Transaction 

data/CODE_OF_CONDUCT.md

@@ -1,13 +0,0 @@
-# Contributor Code of Conduct
-
-As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
-
-We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
-
-Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
-
-This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Adam Pahlevi
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

data/README.md

@@ -1,158 +0,0 @@
-# Bali
-
-[ ![Codeship Status for saveav/bali](https://codeship.com/projects/d2f3ded0-20cf-0133-e425-0eade5a669ff/status?branch=release)](https://codeship.com/projects/95727)
-
-[![Code Climate](https://codeclimate.com/github/saveav/bali/badges/gpa.svg)](https://codeclimate.com/github/saveav/bali)
-
-Bali is a powerful, framework-agnostic, thread-safe Ruby language authorization library. It is a universal authorization library, in the sense that it does not assume you to use specific Ruby library/gem/framework in order for successful use of this gem.
-
-Bali is short for Bulwark Authorization Library.
-
-## Installation
-
-It can be installed directly by using bundler's install:
-
-    $ gem install bali
-
-Otherwise, if you are using a framework such as Rails, you can add this into your gemfile:
-
-```ruby
-gem 'bali'
-```
-
-And then execute:
-
-    $ bundle
-
-## Deprecation notice
-
-1. `cant` and `cant_all` which are used to declare rules will be deprecated on version 3.0, in favor of `cannot` and `cannot_all`. The reason behind this is that `can` and `cant` only differ by 1 letter, it is thought to be better to make it less ambiguous.
-2. `cant?` and subsequently new-introduced `cant!` will be deprecated on version 3.0, in favor of `cannot?` and `cannot!` for the same reason as above.
-3. Since version 2.1.3, `describe` block is replaced with `role` block. `describe` block will be deprecated on version 3.0.
-
-## Usage
-
-Please access [wiki pages](https://github.com/saveav/bali/wiki) for a more detailed, guided explanation, and see what Bali can do. This usage is a simple demonstration what average, standard use of Bali would looks like.
-
-Say:
-
-```ruby
-class My::Transaction
-  include Bali::Objector
-
-  attr_accessor :is_settled
-  attr_accessor :payment_channel
-
-  alias :is_settled? :is_settled
-end
-
-class My::Employee
-  include Bali::Objector
-
-  # working experience in the company
-  attr_accessor :exp_years
-
-  # role/roles of this employee
-  attr_accessor :roles
-end
-```
-
-Your task is to define rule, with context to `My::Transaction` object, in which:
-
-1. Supreme user can do everything
-2. Admin user can do everything, but:
-   - Can only cancel transaction if the transaction is done using credit card, and the transaction itself is not settled yet
-3. General user can:
-   - Download transaction
-4. Finance user can:
-   - Index transaction
-   - Download transaction
-   - Delete transaction if the transaction is settled
-   - Cancel transaction if the transaction is settled
-5. Monitoring user can:
-   - Index transaction
-   - Download transaction
-6. Sales team can:
-   - Index transaction
-   - Download transaction
-6. Unlogged in user can:
-   - Index transaction
-   - Download transaction
-   - Report fraud
-7. Guest user can:
-   - Index transaction
-   - Download transaction
-   - Report fraud
-
-The specification above seems very terrifying, but with Bali, those can be defined in a succinct way, as follow:
-
-```ruby
-  Bali.map_rules do
-    rules_for My::Transaction do
-      role(:supreme_user) { can_all }
-      role :admin_user do
-        can_all
-        # a more specific rule would be executed even if can_all is present
-        can :cancel,
-          if: proc { |record| record.payment_channel == "CREDIT_CARD" &&
-                              !record.is_settled? }
-      end
-      role "general user", can: [:download]
-      role "finance" do
-        can :delete, if: proc { |record| record.is_settled? }
-        can :cancel, unless: proc { |record| record.is_settled? }
-      end # finance_user description
-      role :guest, nil { can :report_fraud }
-      role :client do
-        can :create
-      end
-      others do
-        cannot_all
-        can :download, :index
-        cannot :create
-      end
-    end # rules_for
-  end
-```
-
-## Can and Cant? testing
-
-Assuming that there exist a variable `transaction` which is an instance of `My::Transaction`:
-
-```ruby
-transaction.cant?(:general_user, :delete)         # => false
-transaction.can("general user", :download)        # => true
-transaction.can?(:finance, :delete)               # depends on context
-transaction.can?(:monitoring, :index)             # => true
-transaction.can?(:sales, :download)               # => true
-transaction.can?(:admin_user, :cancel)            # depends on context
-transaction.can?(:supreme_user, :cancel)          # => true
-transaction.can?(:guest, :download)               # => false
-transaction.can?(nil, :download)                  # => true
-transaction.can?(nil, :report_fraud)              # => true
-transaction.can?(:undefined_subtarget, :see)      # => false
-transaction.cant?(:undefined_subtarget, :index)   # => true
-transaction.can?(:client, :create)                # => true
-transaction.can?(:finance, :create)               # => false
-transaction.can?(:admin, :create)                 # => true
-```
-
-Rule can also be tested on a class:
-
-```ruby
-My::Transaction.can?(:client, :create)              # => true
-My::Transaction.can?(:guest, :create)               # => false
-My::Employee.can?(:undefined_subtarget, :create)    # => false
-```
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/saveav/bali. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
-
-## License
-
-Bali is proudly available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
-## Changelog
-
-Please refer to CHANGELOG.md to see it

data/lib/bali/integrators/rules_integrator.rb

@@ -1,37 +0,0 @@
-module Bali::Integrators::Rule
-  extend self
-
-  def rule_classes
-    Bali::RULE_CLASS_MAP
-  end
-
-  def rule_class_for(target)
-    raise Bali::DslError, "Target must be a class" unless target.is_a?(Class)
-    rule_class = Bali::RULE_CLASS_MAP[target.to_s]
-    return rule_class.nil? ? nil : rule_class
-  end
-
-  # attempt to search the rule group, but if not exist, will return nil
-  def rule_group_for(target_class, subtarget)
-    rule_class = rule_class_for(target_class)
-    if rule_class
-      rule_group = rule_class.rules_for(subtarget)
-      return rule_group
-    else
-      return nil
-    end
-  end
-
-  def add_rule_class(rule_class)
-    if rule_class.is_a?(Bali::RuleClass)
-      target = rule_class.target_class
-
-      raise Bali::DslError, "Target must be a class" unless target.is_a?(Class)
-
-      Bali::RULE_CLASS_MAP[target.to_s] = rule_class
-      rule_class
-    else
-      raise Bali::DslError, "Only allow instance of Bali::RuleClass"
-    end
-  end # add_rule_class
-end