bali 1.0.0 → 1.1.0rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3659e22b543ed6745c0ad17dcef288a207732cd
-  data.tar.gz: ac39f8b6657b207d2d43e8acf8db06444e25d9f2
+  metadata.gz: 340aadebc55874ca95a0b864e0117d2d93e798c3
+  data.tar.gz: 7019bbc158e229ff267012ae472e6969fa03f5ef
 SHA512:
-  metadata.gz: f1ccdb82747ee1fbc4231d7c920f515682730d143db26ae6f8c75eb7e7e593616f8298eac0e2a883cd05e197aba92c72049429e5e725b365654fec5be5f7f7eb
-  data.tar.gz: b7f6f688501324e3766aba44d0e9e08e02a46d1c0663355b924ac694e218c7b1c762d39db04015d90f6de5968615183b178f10b316142f1f699bc44b0f1d505d
+  metadata.gz: 0a88ac2145d2c73d087b286e3046b30a839b50bb5564b2747b4a60822a571db72b5fe8de53d4eb7b97debb1f93b40a5220b2d4471bd6b696649d9440b112f879
+  data.tar.gz: 6be3dcc843c90c4c08e07303d863c7ae43550951980b1e28b86994c8432f26a1420011cd3efdccb494077cdac473360ba0654ca3bebe2e69c0e5340ab1581f42

data/.gitignore

@@ -7,3 +7,8 @@
 /pkg/
 /spec/reports/
 /tmp/
+
+*.swp
+*.swo
+*.gemspec
+*.gem

data/README.md

@@ -43,6 +43,7 @@ Rule in Bali is the law determining whether a user (called `subtarget`) can do o
       describe "finance user" do
         can :update, :delete, :edit
         can :delete, if: proc { |record| record.is_settled? }
+        can :cancel, unless: proc { |record| record.is_settled? }
       end # finance_user description
       describe :guest { cant_all }
       describe nil { cant_all }
@@ -137,3 +138,9 @@ Bali is proudly available as open source under the terms of the [MIT License](ht
 
 #### 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 parsing 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

data/bali.gemspec

@@ -23,5 +23,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "pry"
 
 end

data/lib/bali.rb

@@ -1,12 +1,20 @@
 require_relative "bali/version"
-require_relative "bali/rule_class"
-require_relative "bali/rule_group"
-require_relative "bali/rule"
+
+# foundations, onto which good-purposed gem is developed upon
+require_relative "bali/foundations/bali_statics"
+require_relative "bali/foundations/rule_class"
+require_relative "bali/foundations/rule_group"
+require_relative "bali/foundations/rule"
+
+# load the DSL syntax maker definition, ordered by proper order of invocation
+require_relative "bali/dsl/map_rules_dsl.rb"
+require_relative "bali/dsl/rules_for_dsl.rb"
 
 require_relative "bali/objector"
 
 # exception classes
 require_relative "bali/exceptions/dsl_error"
+
 module Bali
   # mapping class to a RuleClass
   RULE_CLASS_MAP = {}
@@ -18,177 +26,6 @@ module Bali
   REVERSE_ALIASED_RULE_CLASS_MAP = {}
 end
 
-module Bali
-  extend self
-
-  def rule_classes
-    RULE_CLASS_MAP
-  end
-
-  def rule_class_for(target)
-    if target.is_a?(Symbol)
-      class_name = ALIASED_RULE_CLASS_MAP[target]
-      return class_name.nil? ? nil : rule_class_for(class_name)
-    else
-      raise Bali::DslError, "Target must be a class" unless target.is_a?(Class)
-      rule_class = RULE_CLASS_MAP[target.to_s]
-      return rule_class.nil? ? nil : rule_class
-    end
-  end
-
-  # attempt to search the rule group, but if not exist, will return nil
-  def rule_group_for(target_class, subtarget)
-    rule_class = Bali.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
-      alias_target = rule_class.alias_name
-
-      raise Bali::DslError, "Target must be a class" unless target.is_a?(Class)
-
-      # remove any previous association of rule
-      begin 
-        last_associated_alias = Bali::REVERSE_ALIASED_RULE_CLASS_MAP[target]
-        if last_associated_alias
-          Bali::ALIASED_RULE_CLASS_MAP.delete(last_associated_alias)
-          Bali::REVERSE_ALIASED_RULE_CLASS_MAP.delete(target)
-          Bali::RULE_CLASS_MAP.delete(target)
-        end
-      end
-
-      # if "as" is present
-      if alias_target.is_a?(Symbol)
-        Bali::ALIASED_RULE_CLASS_MAP[alias_target] = target
-        Bali::REVERSE_ALIASED_RULE_CLASS_MAP[target] = alias_target
-      end
-
-      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
-
-module Bali
-  class Bali::MapRulesDsl
-    attr_accessor :current_rule_class
-
-    def initialize
-      @@lock = Mutex.new
-    end
-
-    def rules_for(target_class, target_alias_hash = {}, &block)
-      @@lock.synchronize do
-        self.current_rule_class = Bali::RuleClass.new(target_class)
-        self.current_rule_class.alias_name = target_alias_hash[:as] || target_alias_hash["as"]
-
-        Bali::MapRulesRulesForDsl.new(self).instance_eval(&block)
-
-        # done processing the block, now add the rule class
-        Bali.add_rule_class(self.current_rule_class)
-      end
-    end
-  end
-end
-
-module Bali
-  class Bali::MapRulesRulesForDsl
-    attr_accessor :map_rules_dsl
-    attr_accessor :current_rule_group
-
-    def initialize(map_rules_dsl)
-      @@lock = Mutex.new
-      self.map_rules_dsl = map_rules_dsl
-    end
-
-    def describe(subtarget, rules = {})
-      target_class = self.map_rules_dsl.current_rule_class.target_class
-      target_alias = self.map_rules_dsl.current_rule_class.alias_name
-      @@lock.synchronize do
-        rule_group = Bali::RuleGroup.new(target_class, target_alias, subtarget)
-        self.current_rule_group = rule_group
-
-        if block_given?
-          the_object = Object.new
-          # the_object would be the record, or the object of class as specified
-          # in rules_for
-          yield the_object
-        else
-          # auth_val is either can or cant
-          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
-        self.map_rules_dsl.current_rule_class.add_rule_group(rule_group)
-      end # mutex synchronize
-    end # describe
-
-
-    def process_auth_rules(auth_val, operations)
-      conditional_hash = nil
-      
-      # scan opreation for hash
-      operations.each do |elm|
-        if elm.is_a?(Hash)
-          conditional_hash = elm
-        end
-      end
-
-      if conditional_hash
-        op = operations[0]
-        rule = Bali::Rule.new(auth_val, op)
-        rule.decider = conditional_hash[:if] || conditional_hash["if"]
-        self.current_rule_group.add_rule(rule)
-      else
-        # no conditional hash, proceed adding operations one by one
-        operations.each do |op|
-          rule = Bali::Rule.new(auth_val, op)
-          self.current_rule_group.add_rule(rule)
-        end
-      end
-    end # process_auth_rules
-
-    def can(*operations)
-      process_auth_rules(:can, operations)
-    end
-
-    def cant(*operations)
-      process_auth_rules(:cant, operations)
-    end
-
-    def can_all
-      self.current_rule_group.zeus = true
-      self.current_rule_group.plant = false
-    end
-
-    def cant_all
-      self.current_rule_group.plant = true
-      self.current_rule_group.zeus = false
-    end
-
-  end # class
-end # module
-
 module Bali
   extend self
   def map_rules(&block)

data/lib/bali/dsl/map_rules_dsl.rb

@@ -0,0 +1,20 @@
+# grand scheme of things begin here
+class Bali::MapRulesDsl
+  attr_accessor :current_rule_class
+
+  def initialize
+    @@lock = Mutex.new
+  end
+
+  def rules_for(target_class, target_alias_hash = {}, &block)
+    @@lock.synchronize do
+      self.current_rule_class = Bali::RuleClass.new(target_class)
+      self.current_rule_class.alias_name = target_alias_hash[:as] || target_alias_hash["as"]
+
+      Bali::RulesForDsl.new(self).instance_eval(&block)
+
+      # done processing the block, now add the rule class
+      Bali.add_rule_class(self.current_rule_class)
+    end
+  end
+end

data/lib/bali/dsl/rules_for_dsl.rb

@@ -0,0 +1,94 @@
+# 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
+
+  def initialize(map_rules_dsl)
+    @@lock = Mutex.new
+    self.map_rules_dsl = map_rules_dsl
+  end
+
+  def describe(subtarget, rules = {})
+    target_class = self.map_rules_dsl.current_rule_class.target_class
+    target_alias = self.map_rules_dsl.current_rule_class.alias_name
+
+    @@lock.synchronize do
+      rule_group = Bali::RuleGroup.new(target_class, target_alias, subtarget)
+      self.current_rule_group = rule_group
+
+      if block_given?
+        the_object = Object.new
+        # the_object would be the record, or the object of class as specified
+        # in rules_for
+        yield the_object
+      else
+        # auth_val is either can or cant
+        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
+      self.map_rules_dsl.current_rule_class.add_rule_group(rule_group)
+    end # mutex synchronize
+  end # describe
+
+  # to define can and cant is basically using this method
+  def process_auth_rules(auth_val, operations)
+    conditional_hash = nil
+    
+    # scan operations for options
+    operations.each do |elm|
+      if elm.is_a?(Hash)
+        conditional_hash = elm
+      end
+    end
+
+    if conditional_hash
+      op = operations[0]
+      rule = Bali::Rule.new(auth_val, op)
+      if conditional_hash[:if] || conditional_hash["if"]
+        rule.decider = conditional_hash[:if] || conditional_hash["if"]
+        rule.decider_type = :if
+      elsif conditional_hash[:unless] || conditional_hash[:unless]
+        rule.decider = conditional_hash[:unless] || conditional_hash["unless"]
+        rule.decider_type = :unless
+      end
+      self.current_rule_group.add_rule(rule)
+    else
+      # no conditional hash, proceed adding operations one by one
+      operations.each do |op|
+        rule = Bali::Rule.new(auth_val, op)
+        self.current_rule_group.add_rule(rule)
+      end
+    end
+  end # process_auth_rules
+
+  def can(*operations)
+    process_auth_rules(:can, operations)
+  end
+
+  def cant(*operations)
+    process_auth_rules(:cant, operations)
+  end
+
+  def can_all
+    self.current_rule_group.zeus = true
+    self.current_rule_group.plant = false
+  end
+
+  def cant_all
+    self.current_rule_group.plant = true
+    self.current_rule_group.zeus = false
+  end
+end # class

data/lib/bali/foundations/bali_statics.rb

@@ -0,0 +1,59 @@
+module Bali
+  extend self
+
+  def rule_classes
+    Bali::RULE_CLASS_MAP
+  end
+
+  def rule_class_for(target)
+    if target.is_a?(Symbol)
+      class_name = Bali::ALIASED_RULE_CLASS_MAP[target]
+      return class_name.nil? ? nil : rule_class_for(class_name)
+    else
+      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
+  end
+
+  # attempt to search the rule group, but if not exist, will return nil
+  def rule_group_for(target_class, subtarget)
+    rule_class = Bali.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
+      alias_target = rule_class.alias_name
+
+      raise Bali::DslError, "Target must be a class" unless target.is_a?(Class)
+
+      # remove any previous association of rule
+      begin 
+        last_associated_alias = Bali::REVERSE_ALIASED_RULE_CLASS_MAP[target]
+        if last_associated_alias
+          Bali::ALIASED_RULE_CLASS_MAP.delete(last_associated_alias)
+          Bali::REVERSE_ALIASED_RULE_CLASS_MAP.delete(target)
+          Bali::RULE_CLASS_MAP.delete(target)
+        end
+      end
+
+      # if "as" is present
+      if alias_target.is_a?(Symbol)
+        Bali::ALIASED_RULE_CLASS_MAP[alias_target] = target
+        Bali::REVERSE_ALIASED_RULE_CLASS_MAP[target] = alias_target
+      end
+
+      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

data/lib/bali/{rule.rb → foundations/rule.rb}

@@ -1,4 +1,4 @@
-# for internal use, representing rule
+# for internal use, representing one, single, atomic rule
 class Bali::Rule
   # auth_val is either :can or :cant
   attr_reader :auth_val
@@ -8,6 +8,8 @@ class Bali::Rule
 
   # if decider is defined, a rule is executed only if decider evaluates to true
   attr_accessor :decider
+  # either unless or if
+  attr_reader :decider_type
 
   def initialize(auth_val, operation)
     self.auth_val = auth_val
@@ -23,11 +25,20 @@ class Bali::Rule
     end
   end
 
+  def decider_type=(dectype)
+    if dectype == :if || dectype == :unless
+      @decider_type = dectype
+    else
+      raise Bali::DslError, "decider type can only be either if or unless"
+    end
+  end
+
   def is_discouragement?
     self.auth_val == :cant
   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)
   end
 end

data/lib/bali/objector.rb

@@ -10,12 +10,12 @@ module Bali::Objector
   end
 
   def cant?(subtarget, operation)
-    self.class.can?(subtarget, operation, self)
+    self.class.cant?(subtarget, operation, self)
   end
 end
 
 module Bali::Objector::Statics
-  def can?(subtarget, operation, record = self)
+  def can?(subtarget, operation, record = self, options = {})
     # if performed on a class-level, don't call its class or it will return
     # Class. That's not what is expected.
     if self.is_a?(Class)
@@ -31,31 +31,46 @@ module Bali::Objector::Statics
     # get the specific rule
     rule = rule_group.get_rule(:can, operation)
 
-    # godly subtarget is allowed to do as he wishes
-    # so long that the rule is not specificly defined
-    return true if rule_group.zeus? && rule.nil?
-    
     # plan subtarget is not allowed unless spesificly defined
     return false if rule_group.plant? && rule.nil?
 
-    # default to false when asked about can? but no rule to be found
-    return false if rule.nil?
-
-    if rule.has_decider?
-      # must test first
-      decider = rule.decider
-      if decider.arity == 0
-        decider.() == true
-      else
-        decider.(record) == true
+    # godly subtarget is allowed to do as he wishes
+    # so long that the rule is not specificly defined
+    # or overwritten by subsequent rule
+    if rule_group.zeus?
+      if rule.nil?
+        # check further whether cant is defined to overwrite this can_all
+        if self.cant?(subtarget, operation, record, cross_check: true)
+          return false
+        else
+          return true
+        end
       end
+    end
+    
+    if rule.nil?
+      # default if can? for undefined rule is false, after related clause
+      # cannot be found in cant?
+      return false if options[:cross_check]
+      return !self.cant?(subtarget, operation, record, cross_check: true)
     else
-      # rule is properly defined
-      return true
+      if rule.has_decider?
+        # must test first
+        decider = rule.decider
+        if decider.arity == 0
+          return (rule.decider_type == :if) ? decider.() == true : decider.() == false
+        else
+          return (rule.decider_type == :if) ? decider.(record) == true : decider.(record) == false
+        end
+      else
+        # rule is properly defined
+        return true
+      end
     end
+
   end
 
-  def cant?(subtarget, operation, record = self)
+  def cant?(subtarget, operation, record = self, options = {})
     if self.is_a?(Class)
       rule_group = Bali.rule_group_for(self, subtarget)
     else
@@ -73,18 +88,35 @@ module Bali::Objector::Statics
     return false if rule_group.zeus? && rule.nil?
 
     # plant subtarget is not allowed to do things unless specificly defined
-    return true if rule_group.plant? && rule.nil?
-
-    # default to true when asked about cant? but no rule to be found
-    return true if rule.nil?
-
-    if rule.has_decider?
-      decider = rule.decider
-      if decider.arity == 0
-        decider.() == true
-      else
-        decider.(record) == true
+    if rule_group.plant?
+      if rule.nil?
+        # check further whether defined in can?
+        if self.can?(subtarget, operation, record, cross_check: true)
+          return false # well, it is defined in can, so it must overwrite this cant_all rule
+        else
+          # plant, and then rule is not defined for further inspection. stright
+          # is not allowed to do this thing
+          return true
+        end
       end
     end
+
+    # if rule cannot be found, then true is returned for cant? unless 
+    # can? is defined exactly for the same target, and subtarget, and record (if given)
+    if rule.nil?
+      return true if options[:cross_check]
+      return !self.can?(subtarget, operation, record, cross_check: true)
+    else
+      if rule.has_decider?
+        decider = rule.decider
+        if decider.arity == 0
+          return (rule.decider_type == :if) ? decider.() == true : decider.() == false
+        else
+          return (rule.decider_type == :if) ? decider.(record) == true : decider.(record) == false
+        end
+      else
+        return true # rule is properly defined
+      end # if rule has decider
+    end # if rule is nil
   end
 end

data/lib/bali/version.rb

@@ -1,3 +1,3 @@
 module Bali
-  VERSION = "1.0.0"
+  VERSION = "1.1.0rc1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bali
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0rc1
 platform: ruby
 authors:
 - Adam Pahlevi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-08-20 00:00:00.000000000 Z
+date: 2015-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: "Bali (Bulwark Authorization Library) is a universal authorization library,
   in the sense that \n                          it does not assume you to use specific
   Ruby library/gem/framework."
@@ -73,11 +87,14 @@ files:
 - bin/console
 - bin/setup
 - lib/bali.rb
+- lib/bali/dsl/map_rules_dsl.rb
+- lib/bali/dsl/rules_for_dsl.rb
 - lib/bali/exceptions/dsl_error.rb
+- lib/bali/foundations/bali_statics.rb
+- lib/bali/foundations/rule.rb
+- lib/bali/foundations/rule_class.rb
+- lib/bali/foundations/rule_group.rb
 - lib/bali/objector.rb
-- lib/bali/rule.rb
-- lib/bali/rule_class.rb
-- lib/bali/rule_group.rb
 - lib/bali/version.rb
 homepage: https://github.com/saveav/bali
 licenses:
@@ -94,9 +111,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.5