law 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d061854fe0fefb951cb900d1a806ef2129b4e061454d174320b3a0ebc787d88d
-  data.tar.gz: e0089a68100f76dafe3fd8530cef2a00a40b9f15a00953063e64987d5322aae3
+  metadata.gz: 3492ad53cbc6aec4593a8992e9e3725350306057ddfcde3e557e0f06e6a0b1d0
+  data.tar.gz: 7dfdf907d2bb6a0d87d31ce4b29b4f303435d969f56aa0729622e67193682d05
 SHA512:
-  metadata.gz: 8fa2fab862e7400f5954dc70e6c47501e955b08b650b82b445df6ae6f587544e50e236bd7f63be0eb85dfee4ef785e21188e866c69834fa85a1b9b1adb0444d5
-  data.tar.gz: 87d1e43d5d187eda7d788fa4cbef041280324e40afdb8c02cdc851e83384a6c898c19f57a03bfe36044c98d6adc840f59e84f5b1b2c3b3115cddcc14ff846439
+  metadata.gz: b646db6d863c688f091b2b78999a34be85c78895b4d79259e9f01d17fba9aaf4424e24b999834a6d61d99b38d3c7a4d9867d8de64b2eb4b2ad7cb82c6c86cfb9
+  data.tar.gz: 0472a5af9b1ed53608bc96badeaafbe090897504c5d309bdaf83ee2341bab2f566998c054bd4e0651c002fd5db7c77309b0f9edbebfa8cb634949e9f297da9e2

data/README.md

@@ -1,8 +1,17 @@
 # Law
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/law`. To experiment with that code, run `bin/console` for an interactive prompt.
+Enforce the laws of your Rails application with highly extensible access policies.
 
-TODO: Delete this and the text above, and describe your gem
+[![Gem Version](https://badge.fury.io/rb/law.svg)](https://badge.fury.io/rb/law)
+[![Build Status](https://semaphoreci.com/api/v1/freshly/law/branches/develop/badge.svg)](https://semaphoreci.com/freshly/law)
+[![Maintainability](https://api.codeclimate.com/v1/badges/c5667b201773ea79ff5e/maintainability)](https://codeclimate.com/github/Freshly/law/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/c5667b201773ea79ff5e/test_coverage)](https://codeclimate.com/github/Freshly/law/test_coverage)
+
+* [Installation](#installation)
+* [Usage](#usage)
+* [Development](#development)
+* [Contributing](#contributing)
+* [License](#license)
 
 ## Installation
 
@@ -32,7 +41,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/law.
+Bug reports and pull requests are welcome on GitHub at https://github.com/Freshly/law.
 
 ## License
 

data/lib/law/judgement.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# A **Judgement** determines if an **Actor** (represented by their **Roles**) are in violation of the given **Statute**.
+module Law
+  class Judgement < Spicerack::RootObject
+    class << self
+      def judge!(petition)
+        new(petition).judge!
+      end
+
+      def judge(petition)
+        new(petition).judge
+      end
+    end
+
+    attr_reader :petition, :violations, :applied_regulations
+
+    delegate :statute, :applicable_regulations, to: :petition
+
+    def initialize(petition)
+      @petition = petition
+      @violations = []
+      @applied_regulations = []
+    end
+
+    def adjudicated?
+      applied_regulations.present?
+    end
+
+    def authorized?
+      violations.blank?
+    end
+
+    def judge
+      judge!
+    rescue NotAuthorizedError => exception
+      error :not_authorized, exception: exception
+      false
+    end
+
+    def judge!
+      if statute.unregulated?
+        @applied_regulations = [ nil ]
+        return true
+      end
+
+      raise InjunctionError if applicable_regulations.blank?
+      raise AlreadyJudgedError if adjudicated?
+
+      @applied_regulations = applicable_regulations.map { |regulation| regulation.new(petition: petition) }
+      @violations = applied_regulations.reject(&:valid?)
+
+      raise NotAuthorizedError unless authorized?
+
+      true
+    end
+  end
+end

data/lib/law/law_base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "laws/actions"
+require_relative "laws/statutes"
+require_relative "laws/petitions"
+require_relative "laws/judgements"
+
+# A **Law** defines which **Statutes** are enforced against specifics **Actions**.
+module Law
+  class LawBase < Spicerack::InputObject
+    include Conjunction::Junction
+    suffixed_with "Law"
+
+    include Law::Laws::Judgements
+    include Law::Laws::Actions
+    include Law::Laws::Statutes
+    include Law::Laws::Petitions
+  end
+end

data/lib/law/laws/actions.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# A **Law** enforces various **Statutes** to restrict **Actions**.
+module Law
+  module Laws
+    module Actions
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :actions, instance_writer: false, default: {}
+
+        delegate :statute_for_action?, to: :class
+      end
+
+      class_methods do
+        def inherited(base)
+          base.actions = actions.dup
+          super
+        end
+
+        def statute_for_action?(action)
+          actions[action].present?
+        end
+
+        private
+
+        def define_action(*input_actions, enforces: nil)
+          raise ArgumentError, "invalid statute: #{enforces}" unless enforceable?(enforces)
+
+          input_actions.each do |action|
+            actions[action] = enforces
+            enforces.try(:enforced_by, self, action)
+            define_judgement_predicates_for_action(action)
+          end
+        end
+
+        def enforceable?(enforces)
+          enforces.nil? || enforces.respond_to?(:enforced_by)
+        end
+      end
+    end
+  end
+end

data/lib/law/laws/judgements.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# A **Law** is used to make a **Judgement** about whether an **Action** is authorized.
+module Law
+  module Laws
+    module Judgements
+      extend ActiveSupport::Concern
+
+      class_methods do
+        private
+
+        def define_judgement_predicates_for_action(action)
+          method_name = "#{action}?".to_sym
+          define_method(method_name) { authorized?(action) }
+          define_singleton_method(method_name) { |**options| new(**options).public_send(method_name) }
+        end
+      end
+
+      def judgement(action)
+        Law::Judgement.new(petition_for_action(action))
+      end
+
+      def authorize(action)
+        judgement(action).tap(&:judge)
+      end
+
+      def authorize!(action)
+        judgement(action).tap(&:judge!)
+      end
+
+      def authorized?(action)
+        judgement(action).judge
+      end
+    end
+  end
+end

data/lib/law/laws/petitions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# A **Law** creates a **Petition** for the **Statute** enforced against an **Action**; all other data must be specified.
+module Law
+  module Laws
+    module Petitions
+      extend ActiveSupport::Concern
+
+      included do
+        option :source
+        option :permissions, default: []
+        option :target
+        option :params, default: {}
+      end
+
+      def petition_for_action(action)
+        Law::Petition.new(
+          statute: actions[action] || _default_statute,
+          source: source,
+          permissions: permissions,
+          target: target,
+          params: params,
+        )
+      end
+    end
+  end
+end

data/lib/law/laws/statutes.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# A **Law** can have a default **Statute** to apply against **Actions** which do not otherwise specify.
+module Law
+  module Laws
+    module Statutes
+      extend ActiveSupport::Concern
+
+      included do
+        delegate :_default_statute, :default_statute?, to: :class
+      end
+
+      class_methods do
+        attr_reader :_default_statute
+
+        def inherited(base)
+          base.default_statute(_default_statute) if default_statute?
+          super
+        end
+
+        def default_statute?
+          _default_statute.present?
+        end
+
+        protected
+
+        def default_statute(statute)
+          raise ArgumentError, "invalid statute: #{enforces}" unless statute.respond_to?(:enforced_by)
+
+          @_default_statute = statute
+          statute.enforced_by(self, :__default__)
+        end
+      end
+    end
+  end
+end

data/lib/law/legalize.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# To make something permissible by the enforcement of **Laws**.
+module Law
+  module Legalize
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :judgement
+      helper_method :law if respond_to?(:helper_method)
+    end
+
+    def authorized?
+      judgement.try(:authorized?) || false
+    end
+
+    def adjudicated?
+      judgement.try(:adjudicated?) || false
+    end
+
+    def violations
+      judgement.try(:violations) || []
+    end
+
+    def law(object = nil, petitioner = nil, permissions: nil, parameters: nil, law_class: nil)
+      object ||= try(:controller_name)&.singularize&.camelize&.safe_constantize
+      petitioner ||= try(:current_user)
+      permissions ||= petitioner.try(:permissions)
+      law_class ||= object.try(:conjugate, Law::LawBase)
+
+      raise ArgumentError, "a Law is required" unless law_class.is_a?(Class)
+
+      law_class.new(permissions: permissions, source: petitioner, target: object, params: parameters)
+    end
+
+    def authorize!(**options)
+      authorize(**options) or raise Law::NotAuthorizedError
+    end
+
+    def authorize(action = nil, object: nil, petitioner: nil, permissions: nil, parameters: nil, law_class: nil)
+      action ||= try(:action_name)
+      parameters ||= try(:params)
+
+      raise ArgumentError, "an action is required" if action.nil?
+
+      options = { permissions: permissions, parameters: parameters, law_class: law_class }
+      @judgement = law(object, petitioner, **options).authorize(action)
+      authorized?
+    end
+  end
+end

data/lib/law/permission_list.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Law
+  class PermissionList < Collectible::CollectionBase
+    ensures_item_class Symbol
+  end
+end

data/lib/law/petition.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# A **Petition** is used to make a **Judgement** determining if an action would violate a given **Statute**.
+module Law
+  class Petition < Spicerack::InputObject
+    argument :statute, allow_nil: false
+    option :source
+    option :permissions, default: []
+    option :target
+    option :params, default: {}
+
+    def permission_list
+      Law::PermissionList.new(Array.wrap(permissions).flatten.compact)
+    end
+    memoize :permission_list
+
+    def applicable_regulations
+      statute.regulations.select { |regulation| permission_list.include? regulation.key }
+    end
+    memoize :applicable_regulations
+  end
+end

data/lib/law/regulation_base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "regulations/statutes"
+require_relative "regulations/core"
+
+# A **Regulation** is the "lock" which has a matching **Permission** "key".
+module Law
+  class RegulationBase < Spicerack::InputModel
+    include Regulations::Statutes
+    include Regulations::Core
+
+    def self.key
+      name.chomp("Regulation").underscore.to_sym
+    end
+  end
+end

data/lib/law/regulations/core.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# A **Regulation** accepts a **Petition** and applies **Validations** to ensure the request is acceptable.
+module Law
+  module Regulations
+    module Core
+      extend ActiveSupport::Concern
+
+      included do
+        argument :petition
+      end
+
+      private
+
+      def respond_to_missing?(method_name, include_private = false)
+        petition_delegate, delegated_method_name, is_setter = petition_delegator_for_method_name(method_name)
+        delegation_type(petition_delegate, delegated_method_name, is_setter) != :none || super
+      end
+
+      def method_missing(method_name, *arguments)
+        petition_delegate, delegated_method_name, is_setter = petition_delegator_for_method_name(method_name)
+
+        case delegation_type(petition_delegate, delegated_method_name, is_setter)
+        when :delegate
+          petition_delegate
+        when :method
+          petition_delegate.public_send(delegated_method_name, *arguments)
+        when :attribute_set
+          petition_delegate[delegated_method_name] = arguments.first
+        when :attribute_sym
+          petition_delegate[delegated_method_name]
+        when :attribute_str
+          petition_delegate[delegated_method_name.to_s]
+        else
+          super
+        end
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def delegation_type(petition_delegate, delegated_method_name, is_setter)
+        unless petition_delegate.nil?
+          return :delegate if delegated_method_name.blank? && !is_setter
+
+          method_name_to_test = is_setter ? "#{delegated_method_name}=".to_sym : delegated_method_name
+          return :method if petition_delegate.respond_to?(method_name_to_test)
+
+          if petition_delegate.respond_to?(:key?)
+            return :attribute_set if is_setter
+            return :attribute_sym if petition_delegate.key?(delegated_method_name)
+            return :attribute_str if petition_delegate.key?(delegated_method_name.to_s)
+          end
+        end
+
+        :none
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def petition_delegator_for_method_name(method_name)
+        parts = method_name.to_s.split("_")
+        petition_delegate = parts.shift.to_sym
+
+        return if petition_delegate.nil? || !petition.respond_to?(petition_delegate)
+
+        method_name = parts.join("_")
+        is_setter = method_name.delete_suffix!("=").present?
+
+        [ petition.public_send(petition_delegate), method_name.to_sym, is_setter ]
+      end
+    end
+  end
+end

data/lib/law/regulations/statutes.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# A **Regulation** is imposed by various **Statutes** to restrict **Actors** from perform actions.
+module Law
+  module Regulations
+    module Statutes
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :statutes, instance_writer: false, default: []
+      end
+
+      class_methods do
+        def inherited(base)
+          base.statutes = []
+          super
+        end
+
+        def imposed_by(statute)
+          statutes << statute
+        end
+      end
+    end
+  end
+end

data/lib/law/rspec/custom_matchers/be_default_for.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests references of statutes as defaults in laws.
+#
+#     class ExampleStatute < ApplicationStatute
+#     end
+#
+#     class ExampleLaw < ApplicationStatute
+#       default_statute ExampleStatute
+#     end
+#
+#     RSpec.describe ExampleStatute, type: :statute do
+#       it { is_expected.to be_default_for ExampleLaw }
+#     end
+
+RSpec::Matchers.define :be_default_for do |*laws|
+  match do
+    laws.each { |law| expect(test_subject.laws).to include(law => a_collection_including(:__default__)) }
+  end
+  description { "be default for #{Array.wrap(laws).join(", ")}" }
+  failure_message do
+    "expected #{test_subject} to be default for #{Array.wrap(laws).join(", ")}; #{test_subject.laws}"
+  end
+  failure_message_when_negated do
+    "expected #{test_subject} not to be default for #{Array.wrap(laws).join(", ")}; #{test_subject.laws}"
+  end
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/law/rspec/custom_matchers/be_enforced_by.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests references of statutes in laws.
+#
+#     class ExampleStatute < ApplicationStatute
+#     end
+#
+#     class ExampleLaw < ApplicationStatute
+#       define_action :new, enforces: ExampleRegulation
+#       define_action :create, enforces: ExampleRegulation
+#     end
+#
+#     RSpec.describe ExampleStatute, type: :statute do
+#       it { is_expected.to be_enforced_by ExampleLaw, :new, :create }
+#     end
+
+RSpec::Matchers.define :be_enforced_by do |statute, *methods|
+  match { expect(test_subject.laws).to include(statute => a_collection_including(*methods.flatten)) }
+  description { "be enforced by #{statute} on #{methods.flatten.join(", ")}" }
+  failure_message do
+    "expected #{test_subject} to be enforced by #{statute} on #{methods.flatten.join(", ")}; #{test_subject.laws}"
+  end
+  failure_message_when_negated do
+    "expected #{test_subject} not to be enforced by #{statute} on #{methods.flatten.join(", ")}; #{test_subject.laws}"
+  end
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/law/rspec/custom_matchers/be_imposed_by.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests references of statutes to regulations.
+#
+#     class ExampleRegulation < ApplicationRegulation
+#     end
+#
+#     class ExampleStatute < ApplicationStatute
+#       impose ExampleRegulation
+#     end
+#
+#     RSpec.describe ExampleRegulation, type: :regulation do
+#       it { is_expected.to be_imposed_by ExampleStatute }
+#     end
+
+RSpec::Matchers.define :be_imposed_by do |*statutes|
+  match { expect(test_subject.statutes).to include *Array.wrap(statutes).flatten }
+  description { "be imposed by #{Array.wrap(statutes).flatten}" }
+  failure_message do
+    "expected #{test_subject} to be imposed by #{Array.wrap(statutes).flatten}; #{test_subject.statutes}"
+  end
+  failure_message_when_negated do
+    "expected #{test_subject} not to be imposed by #{Array.wrap(statutes).flatten}; #{test_subject.statutes}"
+  end
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/law/rspec/custom_matchers/define_action.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests references of statutes in laws.
+#
+#     class ExampleStatute < ApplicationStatute
+#     end
+#
+#     class ExampleLaw < ApplicationStatute
+#       define_action :new, enforces: ExampleRegulation
+#       define_action :create, enforces: ExampleRegulation
+#       define_action :edit
+#     end
+#
+#     RSpec.describe ExampleLaw, type: :law do
+#       it { is_expected.to define_action :new, with_statute: ExampleRegulation }
+#       it { is_expected.to define_action :edit, with_statute: :default }
+#     end
+
+RSpec::Matchers.define :define_action do |action, with_statute:|
+  match do
+    for_default = with_statute == :default
+    expect(test_subject.actions[action]).to eq with_statute unless for_default
+    expect(test_subject.statute_for_action?(action)).to eq !for_default
+  end
+  description { "define action #{action} with statute #{with_statute}" }
+  failure_message do
+    "expected #{test_subject} to define action #{action}, statute: #{with_statute}; #{test_subject.actions[action]}"
+  end
+  failure_message_when_negated do
+    "expected #{test_subject} not to define action #{action}, statute: #{with_statute}; #{test_subject.actions[action]}"
+  end
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/law/rspec/custom_matchers/have_default_statute.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests references of statutes as defaults in laws.
+#
+#     class ExampleStatute < ApplicationStatute
+#     end
+#
+#     class ExampleLaw < ApplicationStatute
+#       default_statute ExampleStatute
+#     end
+#
+#     RSpec.describe ExampleLaw, type: :law do
+#       it { is_expected.to have_default_statute ExampleStatute }
+#     end
+
+RSpec::Matchers.define :have_default_statute do |statute|
+  match { expect(test_subject._default_statute).to eq statute }
+  description { "have default statute #{statute}" }
+  failure_message { "expected #{test_subject} to have default statute #{statute}; #{test_subject._default_statute}" }
+  failure_message_when_negated do
+    "expected #{test_subject} not to have default statute #{statute}; #{test_subject._default_statute}"
+  end
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/law/rspec/custom_matchers/impose_regulations.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests imposing of regulations by statutes.
+#
+#     class ExampleRegulation < ApplicationRegulation
+#     end
+#
+#     class ExampleStatute < ApplicationStatute
+#       impose ExampleRegulation
+#     end
+#
+#     RSpec.describe ExampleStatute, type: :statute do
+#       it { is_expected.to impose_regulations ExampleRegulation }
+#     end
+
+RSpec::Matchers.define :impose_regulations do |*regulations|
+  match { expect(test_subject.regulations).to include *Array.wrap(regulations).flatten }
+  description { "impose regulations #{Array.wrap(regulations).flatten}" }
+  failure_message do
+    "expected #{test_subject} to impose regulations #{Array.wrap(regulations).flatten}; #{test_subject.regulations}"
+  end
+  failure_message_when_negated do
+    "expected #{test_subject} not to impose regulations #{Array.wrap(regulations).flatten}; #{test_subject.regulations}"
+  end
+
+  def test_subject
+    subject.is_a?(Class) ? subject : subject.class
+  end
+end

data/lib/law/rspec/custom_matchers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "custom_matchers/be_default_for"
+require_relative "custom_matchers/be_enforced_by"
+require_relative "custom_matchers/be_imposed_by"
+require_relative "custom_matchers/define_action"
+require_relative "custom_matchers/have_default_statute"
+require_relative "custom_matchers/impose_regulations"

data/lib/law/rspec/shoulda_matcher_helper.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined?(Shoulda::Matchers::ActiveModel)
+  RSpec.configure do |config|
+    config.include(Shoulda::Matchers::ActiveModel, type: :regulation)
+  end
+end

data/lib/law/spec_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "rspec/custom_matchers"
+require_relative "rspec/shoulda_matcher_helper"

data/lib/law/statute_base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "statutes/regulations"
+require_relative "statutes/laws"
+
+# A **Statute** restricts actions to **Actors** by enforcing a collection of **Permissions**.
+module Law
+  class StatuteBase < Spicerack::RootObject
+    include Law::Statutes::Regulations
+    include Law::Statutes::Laws
+  end
+end

data/lib/law/statutes/laws.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# A **Statute** is enforced by **Laws**.
+module Law
+  module Statutes
+    module Laws
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :laws, instance_writer: false, default: Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      class_methods do
+        def inherited(base)
+          base.laws = Hash.new { |hash, key| hash[key] = [] }
+          super
+        end
+
+        def enforced_by(law, action)
+          laws[law] << action
+        end
+      end
+    end
+  end
+end

data/lib/law/statutes/regulations.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# A **Statute** is a collection of imposed **Regulations**.
+module Law
+  module Statutes
+    module Regulations
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :regulations, instance_writer: false, default: []
+        delegate :unregulated?, to: :class
+      end
+
+      class_methods do
+        def unregulated?
+          regulations.empty?
+        end
+
+        def inherited(base)
+          base.regulations = regulations.dup
+          super
+        end
+
+        private
+
+        def impose(*imposed_regulations)
+          imposed_regulations = imposed_regulations.flatten.compact
+
+          ensure_valid_regulations(imposed_regulations)
+
+          imposed_regulations.each do |regulation|
+            regulations << regulation
+            track_regulation(regulation)
+          end
+        end
+
+        def track_regulation(regulation)
+          regulation.imposed_by(self)
+        end
+
+        def ensure_valid_regulations(imposed_regulations)
+          raise ArgumentError, "a regulation is required" if imposed_regulations.empty?
+
+          invalid_regulations = imposed_regulations.reject { |permission| permission.respond_to?(:imposed_by) }
+          raise ArgumentError, "invalid regulations: #{invalid_regulations.join(", ")}" if invalid_regulations.present?
+        end
+      end
+    end
+  end
+end

data/lib/law/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Law
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/law.rb

@@ -1,6 +1,30 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/enumerable"
+
+require "spicery"
+
 require "law/version"
 
+require "law/regulation_base"
+
+require "law/permission_list"
+
+require "law/statute_base"
+
+require "law/petition"
+require "law/judgement"
+
+require "law/law_base"
+
+require "law/legalize"
+
 module Law
   class Error < StandardError; end
-  # Your code goes here...
+
+  class AlreadyJudgedError < Error; end
+
+  class NotAuthorizedError < Error; end
+  class InjunctionError < NotAuthorizedError; end
 end

metadata

@@ -1,29 +1,77 @@
 --- !ruby/object:Gem::Specification
 name: law
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Eric Garside
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2019-05-06 00:00:00.000000000 Z
+date: 2020-02-07 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.2.1
+- !ruby/object:Gem::Dependency
+  name: spicery
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.3.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.3.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.7.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -39,42 +87,130 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0.16'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-description: Illegal operations take on a whole new meaning
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+- !ruby/object:Gem::Dependency
+  name: rspice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.3.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.3.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: spicerack-styleguide
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.3.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.22.3.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Enforce the laws of your Rails application with highly extensible access
+  policies
 email:
 - garside@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
-- law.gemspec
 - lib/law.rb
+- lib/law/judgement.rb
+- lib/law/law_base.rb
+- lib/law/laws/actions.rb
+- lib/law/laws/judgements.rb
+- lib/law/laws/petitions.rb
+- lib/law/laws/statutes.rb
+- lib/law/legalize.rb
+- lib/law/permission_list.rb
+- lib/law/petition.rb
+- lib/law/regulation_base.rb
+- lib/law/regulations/core.rb
+- lib/law/regulations/statutes.rb
+- lib/law/rspec/custom_matchers.rb
+- lib/law/rspec/custom_matchers/be_default_for.rb
+- lib/law/rspec/custom_matchers/be_enforced_by.rb
+- lib/law/rspec/custom_matchers/be_imposed_by.rb
+- lib/law/rspec/custom_matchers/define_action.rb
+- lib/law/rspec/custom_matchers/have_default_statute.rb
+- lib/law/rspec/custom_matchers/impose_regulations.rb
+- lib/law/rspec/shoulda_matcher_helper.rb
+- lib/law/spec_helper.rb
+- lib/law/statute_base.rb
+- lib/law/statutes/laws.rb
+- lib/law/statutes/regulations.rb
 - lib/law/version.rb
-homepage: https://www.freshly.com/
+homepage: https://github.com/Freshly/law/tree/master
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/Freshly/law/tree/master
+  source_code_uri: https://github.com/Freshly/law/tree/master
+  changelog_uri: https://github.com/Freshly/law/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -90,9 +226,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Enforce the laws of your application
+summary: Give illegal operations a whole new meaning with this policy enforcement
 test_files: []

data/.gitignore

@@ -1,11 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-
-# rspec failure tracking
-.rspec_status

data/.rspec

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

data/.travis.yml

@@ -1,7 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.5.1
-before_install: gem install bundler -v 2.0.1

data/Gemfile

@@ -1,4 +0,0 @@
-source "https://rubygems.org"
-
-# Specify your gem's dependencies in law.gemspec
-gemspec

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-task :default => :spec

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "law"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/law.gemspec

@@ -1,29 +0,0 @@
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "law/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "law"
-  spec.version       = Law::VERSION
-  spec.authors       = ["Eric Garside"]
-  spec.email         = ["garside@gmail.com"]
-
-  spec.summary       = "Enforce the laws of your application"
-  spec.description   = "Illegal operations take on a whole new meaning"
-  spec.homepage      = "https://www.freshly.com/"
-  spec.license       = "MIT"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-end