dnf 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38d7f35e2dbe89fc5eefae38715e9ffb4fd30c5fb2387afa1af111e7ef3d6ad2
-  data.tar.gz: 793c5e967fa47434234bdd786c0e46084f0055d9ea76203d883d017dff542173
+  metadata.gz: 74bbea5fdc9ad7060421070e8befba31f219bc5ca1822b83632c3fd003544adf
+  data.tar.gz: 4e87cc325e331da97a77a224d2710c9ed98d036a6cd5cd8cc8905171377d294e
 SHA512:
-  metadata.gz: 368413587764ad6bfb6a3dae501b815238e2141eaa4aea776f8d781e436fcbc0b7d1f1669e7e7527e15a9eeb603917e88315a4309240102e36e65cfb733efd15
-  data.tar.gz: fafd471e6a1b1a6fc385cda79f9f8ae86148573f165ee7eff184bc1f4190533b66a0df0ea97cb3a9ec3ff35f3ce18dd91224a303a05e8bb074eed120d13543b1
+  metadata.gz: c9604fa877fe7ffdaa2ed172913bb450f9a224925aa890e86c06c2447881bbf49c12666a0bfb7ec397c6d41a22cc63509d391c4d6572b42d2c831ae089d99b40
+  data.tar.gz: e6b375c293bdd15ad9fac6143d7f3b278b58ede6128eec121412719c1e1d2d3f9d1c7d042557524aae8baeb5ec929789960f3ec3d28c1c4edca7fd705e9f7cff

data/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['3.2', '3.3']
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Run tests
+      run: bundle exec rspec

data/README.md

@@ -10,12 +10,25 @@ gem 'dnf'
 
 ## Usage
 
+Basic usage:
+
 ```ruby
 expression = "(!a | !b) & c"
 boolean_expression = Dnf::BooleanExpression.new(expression)
 boolean_expression.to_dnf # => "!a & c | !b & c"
 ```
 
+Config:
+
+```ruby
+Dnf::BooleanExpression.new(expression, {
+  variable_regex: /\w+/,
+  not_symbol: '!',
+  and_symbol: '&',
+  or_symbol: '|'
+})
+```
+
 ## License
 
 The gem is available as open source under the terms of the MIT License.

data/lib/dnf/boolean_expression.rb

@@ -1,9 +1,17 @@
 module Dnf
   class BooleanExpression
-    attr_reader :expression
+    attr_reader :expression, :config
 
-    def initialize(expression)
+    DEFAULT_CONFIG = {
+      variable_regex: /\w+/,
+      not_symbol: '!',
+      and_symbol: '&',
+      or_symbol: '|'
+    }
+
+    def initialize(expression, custom_config = {})
       @expression = expression
+      @config = DEFAULT_CONFIG.merge(custom_config)
     end
 
     def to_dnf
@@ -14,13 +22,66 @@ module Dnf
 
     private
 
+    def validate_expression(tokens)
+      raise ExpressionSyntaxError, "Expression cannot be empty" if tokens.empty?
+      validate_tokens(tokens)
+      validate_syntax(tokens)
+      validate_parentheses(tokens)
+    end
+
+    def validate_tokens(tokens)
+      valid_tokens = [
+        config[:not_symbol], config[:and_symbol], config[:or_symbol], '(', ')'
+      ]
+      tokens.each do |token|
+        next if valid_tokens.include?(token) || token.match?(/\A#{config[:variable_regex].source}\z/)
+        raise ExpressionSyntaxError, "Invalid token: #{token}"
+      end
+    end
+
+    def validate_syntax(tokens)
+      tokens.each_cons(2) do |prev, curr|
+        case prev
+        when config[:variable_regex], ')'
+          raise ExpressionSyntaxError, "Unexpected token: #{prev} #{curr}" unless curr == config[:and_symbol] || curr == config[:or_symbol] || curr == ')'
+        when config[:not_symbol]
+          raise ExpressionSyntaxError, "Unexpected token: #{prev} #{curr}" unless curr.match?(/\A#{config[:variable_regex].source}\z/) || curr == '('
+        when config[:and_symbol], config[:or_symbol], '('
+          raise ExpressionSyntaxError, "Unexpected token: #{prev} #{curr}" unless curr.match?(/\A#{config[:variable_regex].source}\z/) || curr == config[:not_symbol] || curr == '('
+        end
+      end
+      raise ExpressionSyntaxError, "Unexpected end: #{tokens.last}" unless tokens.last.match?(/\A#{config[:variable_regex].source}\z/) || tokens.last == ')'
+    end
+
+    def validate_parentheses(tokens)
+      stack = []
+      tokens.each do |token|
+        if token == '('
+          stack.push(token)
+        elsif token == ')'
+          raise ExpressionSyntaxError, "Mismatched parentheses" if stack.empty?
+          stack.pop
+        end
+      end
+      raise ExpressionSyntaxError, "Mismatched parentheses" unless stack.empty?
+    end
+
     def parse(expr)
       tokens = tokenize(expr)
+      validate_expression(tokens)
       parse_expression(tokens)
     end
 
     def tokenize(expr)
-      expr.scan(/\w+|[&|!()]/)
+      regex = Regexp.union(
+        config[:variable_regex],
+        config[:not_symbol],
+        config[:and_symbol],
+        config[:or_symbol],
+        /[()]/,
+        /\S+/
+      )
+      expr.scan(regex)
     end
 
     def parse_expression(tokens)
@@ -29,7 +90,7 @@ module Dnf
 
     def parse_or(tokens)
       left = parse_and(tokens)
-      while tokens.first == '|'
+      while tokens.first == config[:or_symbol]
         tokens.shift
         right = parse_and(tokens)
         left = [:or, left, right]
@@ -39,7 +100,7 @@ module Dnf
 
     def parse_and(tokens)
       left = parse_not(tokens)
-      while tokens.first == '&'
+      while tokens.first == config[:and_symbol]
         tokens.shift
         right = parse_not(tokens)
         left = [:and, left, right]
@@ -48,7 +109,7 @@ module Dnf
     end
 
     def parse_not(tokens)
-      if tokens.first == '!'
+      if tokens.first == config[:not_symbol]
         tokens.shift
         expr = parse_primary(tokens)
         [:not, expr]
@@ -119,11 +180,11 @@ module Dnf
       when :var
         expr[1]
       when :not
-        "!#{dnf_to_string(expr[1])}"
+        "#{config[:not_symbol]}#{dnf_to_string(expr[1])}"
       when :and
-        "#{dnf_to_string(expr[1])} & #{dnf_to_string(expr[2])}"
+        "#{dnf_to_string(expr[1])} #{config[:and_symbol]} #{dnf_to_string(expr[2])}"
       when :or
-        "#{dnf_to_string(expr[1])} | #{dnf_to_string(expr[2])}"
+        "#{dnf_to_string(expr[1])} #{config[:or_symbol]} #{dnf_to_string(expr[2])}"
       end
     end
   end

data/lib/dnf/errors.rb

@@ -0,0 +1,3 @@
+module Dnf
+  class ExpressionSyntaxError < StandardError; end
+end

data/lib/dnf/version.rb

@@ -1,3 +1,3 @@
 module Dnf
-  VERSION = '0.1.0'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/lib/dnf.rb

@@ -1,4 +1,5 @@
 require 'dnf/version'
+require 'dnf/errors'
 require 'dnf/boolean_expression'
 
 module Dnf

data/spec/dnf/boolean_expression_spec.rb

@@ -2,6 +2,51 @@ require 'spec_helper'
 require 'dnf'
 
 RSpec.describe Dnf::BooleanExpression do
+  
+  it 'allows custom regex for variables' do
+    expect(Dnf::BooleanExpression.new('👍 & (b | my-var-c)', variable_regex: /[\w\-👍]+/).to_dnf).to eq('👍 & b | 👍 & my-var-c')
+  end
+  
+  it 'allows custom symbols for boolean operators' do
+    expect(Dnf::BooleanExpression.new('¬a ∧ (b ∨ c)', not_symbol: '¬', and_symbol: '∧', or_symbol: '∨').to_dnf).to eq('¬a ∧ b ∨ ¬a ∧ c')
+  end
+  
+  it 'allows multiple symbols for boolean operators' do
+    expect(Dnf::BooleanExpression.new('!a && (b || c)', not_symbol: '!', and_symbol: '&&', or_symbol: '||').to_dnf).to eq('!a && b || !a && c')
+  end
+  
+  describe 'validation' do
+    it 'raises an exception when the expression is empty' do
+      expect {
+        Dnf::BooleanExpression.new(' ').to_dnf
+      }.to raise_error(Dnf::ExpressionSyntaxError, 'Expression cannot be empty')
+    end
+    
+    it 'raises an exception when a token is invalid' do
+      expect {
+        Dnf::BooleanExpression.new('a & ### b').to_dnf
+      }.to raise_error(Dnf::ExpressionSyntaxError, 'Invalid token: ###')
+    end
+    
+    it 'raises an exception when the syntax is invalid (unexpected token)' do
+      expect {
+        Dnf::BooleanExpression.new('a & | b').to_dnf
+      }.to raise_error(Dnf::ExpressionSyntaxError, 'Unexpected token: & |')
+    end
+    
+    it 'raises an exception when the syntax is invalid (unexpected end)' do
+      expect {
+        Dnf::BooleanExpression.new('a &').to_dnf
+      }.to raise_error(Dnf::ExpressionSyntaxError, 'Unexpected end: &')
+    end
+    
+    it 'raises an exception when the parentheses are mismatched' do
+      expect {
+        Dnf::BooleanExpression.new('a & ((b | c)').to_dnf
+      }.to raise_error(Dnf::ExpressionSyntaxError, 'Mismatched parentheses')
+    end
+  end
+  
   describe '#to_dnf' do
     it 'converts simple variable' do
       expect(Dnf::BooleanExpression.new('a').to_dnf).to eq('a')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dnf
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Marco Colli
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-11 00:00:00.000000000 Z
+date: 2024-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,12 +24,13 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
-email: 
+description:
+email:
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - Gemfile
@@ -38,6 +39,7 @@ files:
 - dnf.gemspec
 - lib/dnf.rb
 - lib/dnf/boolean_expression.rb
+- lib/dnf/errors.rb
 - lib/dnf/version.rb
 - spec/dnf/boolean_expression_spec.rb
 - spec/spec_helper.rb
@@ -45,7 +47,7 @@ homepage: https://github.com/collimarco/dnf-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -60,8 +62,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: Convert any boolean expression to disjunctive normal form (DNF).
 test_files: []