dry-logic 0.1.0

data/lib/dry/logic/rule.rb

@@ -0,0 +1,91 @@
+module Dry
+  module Logic
+    class Rule
+      include Dry::Equalizer(:name, :predicate)
+
+      attr_reader :name, :predicate
+
+      class Negation < Rule
+        include Dry::Equalizer(:rule)
+
+        attr_reader :rule
+
+        def initialize(rule)
+          @rule = rule
+        end
+
+        def call(*args)
+          rule.(*args).negated
+        end
+
+        def to_ary
+          [:not, rule.to_ary]
+        end
+      end
+
+      def initialize(name, predicate)
+        @name = name
+        @predicate = predicate
+      end
+
+      def predicate_id
+        predicate.id
+      end
+
+      def type
+        :rule
+      end
+
+      def call(*args)
+        Logic.Result(args, predicate.call, self)
+      end
+
+      def to_ary
+        [type, [name, predicate.to_ary]]
+      end
+      alias_method :to_a, :to_ary
+
+      def and(other)
+        Conjunction.new(self, other)
+      end
+      alias_method :&, :and
+
+      def or(other)
+        Disjunction.new(self, other)
+      end
+      alias_method :|, :or
+
+      def xor(other)
+        ExclusiveDisjunction.new(self, other)
+      end
+      alias_method :^, :xor
+
+      def then(other)
+        Implication.new(self, other)
+      end
+      alias_method :>, :then
+
+      def negation
+        Negation.new(self)
+      end
+
+      def new(predicate)
+        self.class.new(name, predicate)
+      end
+
+      def curry(*args)
+        self.class.new(name, predicate.curry(*args))
+      end
+    end
+  end
+end
+
+require 'dry/logic/rule/key'
+require 'dry/logic/rule/value'
+require 'dry/logic/rule/each'
+require 'dry/logic/rule/set'
+require 'dry/logic/rule/composite'
+require 'dry/logic/rule/check'
+require 'dry/logic/rule/group'
+
+require 'dry/logic/result'

data/lib/dry/logic/rule/check.rb

@@ -0,0 +1,15 @@
+module Dry
+  module Logic
+    class Rule::Check < Rule
+      alias_method :result, :predicate
+
+      def call(*)
+        Logic.Result(nil, result.call, self)
+      end
+
+      def type
+        :check
+      end
+    end
+  end
+end

data/lib/dry/logic/rule/composite.rb

@@ -0,0 +1,63 @@
+module Dry
+  module Logic
+    class Rule::Composite < Rule
+      include Dry::Equalizer(:left, :right)
+
+      attr_reader :name, :left, :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def name
+        :"#{left.name}_#{type}_#{right.name}"
+      end
+
+      def to_ary
+        [type, [left.to_ary, right.to_ary]]
+      end
+      alias_method :to_a, :to_ary
+    end
+
+    class Rule::Implication < Rule::Composite
+      def call(*args)
+        left.(*args) > right
+      end
+
+      def type
+        :implication
+      end
+    end
+
+    class Rule::Conjunction < Rule::Composite
+      def call(*args)
+        left.(*args).and(right)
+      end
+
+      def type
+        :and
+      end
+    end
+
+    class Rule::Disjunction < Rule::Composite
+      def call(*args)
+        left.(*args).or(right)
+      end
+
+      def type
+        :or
+      end
+    end
+
+    class Rule::ExclusiveDisjunction < Rule::Composite
+      def call(*args)
+        left.(*args).xor(right)
+      end
+
+      def type
+        :xor
+      end
+    end
+  end
+end

data/lib/dry/logic/rule/each.rb

@@ -0,0 +1,13 @@
+module Dry
+  module Logic
+    class Rule::Each < Rule
+      def call(input)
+        Logic.Result(input, input.map { |element| predicate.(element) }, self)
+      end
+
+      def type
+        :each
+      end
+    end
+  end
+end

data/lib/dry/logic/rule/group.rb

@@ -0,0 +1,21 @@
+module Dry
+  module Logic
+    class Rule::Group < Rule
+      attr_reader :rules
+
+      def initialize(identifier, predicate)
+        name, rules = identifier.to_a.first
+        @rules = rules
+        super(name, predicate)
+      end
+
+      def call(*input)
+        Logic.Result(input, predicate.(*input), self)
+      end
+
+      def type
+        :group
+      end
+    end
+  end
+end

data/lib/dry/logic/rule/key.rb

@@ -0,0 +1,17 @@
+module Dry
+  module Logic
+    class Rule::Key < Rule
+      def self.new(name, predicate)
+        super(name, predicate.curry(name))
+      end
+
+      def type
+        :key
+      end
+
+      def call(input)
+        Logic.Result(input[name], predicate.(input), self)
+      end
+    end
+  end
+end

data/lib/dry/logic/rule/set.rb

@@ -0,0 +1,22 @@
+module Dry
+  module Logic
+    class Rule::Set < Rule
+      def call(input)
+        Logic.Result(input, predicate.map { |rule| rule.(input) }, self)
+      end
+
+      def type
+        :set
+      end
+
+      def at(*args)
+        self.class.new(name, predicate.values_at(*args))
+      end
+
+      def to_ary
+        [type, [name, predicate.map(&:to_ary)]]
+      end
+      alias_method :to_a, :to_ary
+    end
+  end
+end

data/lib/dry/logic/rule/value.rb

@@ -0,0 +1,13 @@
+module Dry
+  module Logic
+    class Rule::Value < Rule
+      def call(input)
+        Logic.Result(input, predicate.(input), self)
+      end
+
+      def type
+        :val
+      end
+    end
+  end
+end

data/lib/dry/logic/rule_compiler.rb

@@ -0,0 +1,81 @@
+require 'dry/logic/rule'
+
+module Dry
+  module Logic
+    class RuleCompiler
+      attr_reader :predicates
+
+      def initialize(predicates)
+        @predicates = predicates
+      end
+
+      def call(ast)
+        ast.map { |node| visit(node) }
+      end
+
+      def visit(node)
+        name, nodes = node
+        send(:"visit_#{name}", nodes)
+      end
+
+      def visit_check(node)
+        name, predicate = node
+        Rule::Check.new(name, visit(predicate))
+      end
+
+      def visit_not(node)
+        visit(node).negation
+      end
+
+      def visit_key(node)
+        name, predicate = node
+        Rule::Key.new(name, visit(predicate))
+      end
+
+      def visit_val(node)
+        name, predicate = node
+        Rule::Value.new(name, visit(predicate))
+      end
+
+      def visit_set(node)
+        name, rules = node
+        Rule::Set.new(name, call(rules))
+      end
+
+      def visit_each(node)
+        name, rule = node
+        Rule::Each.new(name, visit(rule))
+      end
+
+      def visit_predicate(node)
+        name, args = node
+        predicates[name].curry(*args)
+      end
+
+      def visit_and(node)
+        left, right = node
+        visit(left) & visit(right)
+      end
+
+      def visit_or(node)
+        left, right = node
+        visit(left) | visit(right)
+      end
+
+      def visit_xor(node)
+        left, right = node
+        visit(left) ^ visit(right)
+      end
+
+      def visit_implication(node)
+        left, right = node
+        visit(left) > visit(right)
+      end
+
+      def visit_group(node)
+        identifier, predicate = node
+        Rule::Group.new(identifier, visit(predicate))
+      end
+    end
+  end
+end

data/lib/dry/logic/version.rb

@@ -0,0 +1,5 @@
+module Dry
+  module Logic
+    VERSION = '0.1.0'.freeze
+  end
+end

data/rakelib/rubocop.rake

@@ -0,0 +1,18 @@
+begin
+  require 'rubocop/rake_task'
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << '--display-cop-names'
+  end
+
+  namespace :rubocop do
+    desc 'Generate a configuration file acting as a TODO list.'
+    task :auto_gen_config do
+      exec 'bundle exec rubocop --auto-gen-config'
+    end
+  end
+
+rescue LoadError
+end

data/spec/shared/predicates.rb

@@ -0,0 +1,41 @@
+require 'dry/logic/predicates'
+
+RSpec.shared_examples 'predicates' do
+  let(:none?) { Dry::Logic::Predicates[:none?] }
+
+  let(:str?) { Dry::Logic::Predicates[:str?] }
+
+  let(:int?) { Dry::Logic::Predicates[:int?] }
+
+  let(:filled?) { Dry::Logic::Predicates[:filled?] }
+
+  let(:min_size?) { Dry::Logic::Predicates[:min_size?] }
+
+  let(:lt?) { Dry::Logic::Predicates[:lt?] }
+
+  let(:gt?) { Dry::Logic::Predicates[:gt?] }
+
+  let(:key?) { Dry::Logic::Predicates[:key?] }
+
+  let(:eql?) { Dry::Logic::Predicates[:eql?] }
+end
+
+RSpec.shared_examples 'a passing predicate' do
+  let(:predicate) { Dry::Logic::Predicates[predicate_name] }
+
+  it do
+    arguments_list.each do |(left, right)|
+      expect(predicate.call(left, right)).to be(true)
+    end
+  end
+end
+
+RSpec.shared_examples 'a failing predicate' do
+  let(:predicate) { Dry::Logic::Predicates[predicate_name] }
+
+  it do
+    arguments_list.each do |(left, right)|
+      expect(predicate.call(left, right)).to be(false)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+begin
+  require 'byebug'
+rescue LoadError; end
+
+require 'dry-logic'
+
+SPEC_ROOT = Pathname(__dir__)
+
+Dir[SPEC_ROOT.join('shared/**/*.rb')].each(&method(:require))
+Dir[SPEC_ROOT.join('support/**/*.rb')].each(&method(:require))
+
+include Dry::Logic
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+end

data/spec/unit/predicate_spec.rb

@@ -0,0 +1,27 @@
+require 'dry/logic/predicate'
+
+RSpec.describe Dry::Logic::Predicate do
+  describe '#call' do
+    it 'returns result of the predicate function' do
+      is_empty = Dry::Logic::Predicate.new(:is_empty) { |str| str.empty? }
+
+      expect(is_empty.('')).to be(true)
+
+      expect(is_empty.('filled')).to be(false)
+    end
+  end
+
+  describe '#curry' do
+    it 'returns curried predicate' do
+      min_age = Dry::Logic::Predicate.new(:min_age) { |age, input| input >= age }
+
+      min_age_18 = min_age.curry(18)
+
+      expect(min_age_18.args).to eql([18])
+
+      expect(min_age_18.(18)).to be(true)
+      expect(min_age_18.(19)).to be(true)
+      expect(min_age_18.(17)).to be(false)
+    end
+  end
+end