logicality 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0356f85f51e792d67aaadf12bb510c5c9e798870
+  data.tar.gz: 17d3463798a0c252bb4161853254280bbb2f9ccd
+SHA512:
+  metadata.gz: '044761792866c934fb3f2827b36a7f1c1d94351ea82dfc85cb79611e7f2f13fa25a906428c1d006ca96c7333bc02455e0e55573503fc8ccb28c0315c2eefd17d'
+  data.tar.gz: ab723be91f1b30bf0b1fe5c14e46dec6bdf907729fe8ae9dfbe55d75a24b733c0d2ea98a8aadb21c0ea9d0f4631217a79d20bb71f88ec5b7f4c0bfe42b7f9eed

data/.editorconfig

@@ -0,0 +1,8 @@
+# See http://editorconfig.org/
+
+[*]
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+end_of_line = lf

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

data/.ruby-version

@@ -0,0 +1 @@
+2.3.7

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.3.7
+cache: bundler
+script:
+  - bundle exec rspec

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    logicality (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  logicality!
+  rspec
+
+BUNDLED WITH
+   1.16.3

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2018 Blue Marble Payroll, LLC
+
+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

@@ -0,0 +1,93 @@
+*Note: This is a ruby implementation of [Logicality](https://github.com/bluemarblepayroll/logicality).*
+
+# Logicality
+
+[![Build Status](https://travis-ci.org/bluemarblepayroll/logicality-rb.svg?branch=master)](https://travis-ci.org/bluemarblepayroll/logicality-rb)
+
+A common problem that many frameworks have is the ability to give developers an expressive
+intermediary scripting language or DSL. Logicality helps solve this problem by providing a simple
+boolean expression evaluator.  That way, your developers can create simple scripts for dynamically
+resolving boolean values such as:
+
+* a
+* b
+* a && b
+* a || b
+* a && b || c
+* (a && b) || (c && d)
+* (a && b) || (c && (d || e && f))
+
+## Credit
+
+Deep inspiration was taken from [this set of articles](https://ruslanspivak.com/lsbasi-part7/).  
+Here, the author gives details around the theory and practical implementation of creating a basic
+language processor and compiler.
+
+## Installation
+
+To install through Rubygems:
+
+````
+gem install install logicality
+````
+
+You can also add this to your Gemfile:
+
+````
+bundle add logicality
+````
+
+## Examples
+
+### A simple object-based example.
+
+Consider a case where some content should be displayed if it is marked as visible or if the user is an administrator. You can express this as:
+
+````
+visible || admin
+````
+
+Now you can bind and evaluate this expression against passed in objects:
+
+````
+record = { 'visible' => false, 'admin' => true }
+visible = Logicality::Logic.evaluate('visible || admin', record) # resolves to true.
+````
+
+### Plugging in a Custom Resolver
+
+Notice that the above example uses the default value resolver, which either wants an object that has values as attributes, or an object with a brackets method (i.e. Hash).  In the brackets method approach, keys will be accessed using strings (as opposed to symbols.).  If we wanted to use a custom resolver, for example to use symbols as keys, we could do this:
+
+````
+resolver = lambda do |value, input|
+  symbolized_hash = (input || {}).map { |k,v| [ k.to_s.to_sym, v] }.to_h
+  !!symbolized_hash[value]
+end
+
+record = { visible: false, admin: true }
+visible = Logicality::Logic.evaluate('visible || admin', record) # resolves to true.
+````
+
+## Contributing
+
+### Development Environment Configuration
+
+Basic steps to take to get this repository compiling:
+
+1. Install [Ruby](https://www.ruby-lang.org/en/documentation/installation/) (check logicality.gemspec for versions supported)
+2. Install bundler (gem install bundler)
+3. Clone the repository (git clone git@github.com:bluemarblepayroll/logicality-rb.git)
+4. Navigate to the root folder (cd logicality)
+5. Install dependencies (bundle)
+
+### Running Tests
+
+To execute the test suite run:
+
+````
+rspec
+````
+
+## License
+
+This project is MIT Licensed.

data/lib/logicality/interpreter/interpreter.rb

@@ -0,0 +1,9 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './lib/logicality/interpreter/node_visitor'
+require './lib/logicality/interpreter/simple_interpreter'

data/lib/logicality/interpreter/node_visitor.rb

@@ -0,0 +1,36 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Interpreter
+    class NodeVisitor
+
+      def visit(node)
+        return nil unless node
+
+        visitor_name = method_name(node)
+
+        if respond_to?(visitor_name)
+          send(visitor_name, node)
+        else
+          generic_visit(node)
+        end
+      end
+
+      private
+
+      def generic_visit(node)
+        raise ArgumentError, "No visitor method: #{method_name(node)}"
+      end
+
+      def method_name(node)
+        "visit_#{node.name}"
+      end
+
+    end
+  end
+end

data/lib/logicality/interpreter/simple_interpreter.rb

@@ -0,0 +1,64 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Interpreter
+    class SimpleInterpreter < NodeVisitor
+
+      attr_reader :resolver
+
+      def initialize(resolver)
+        raise ArgumentError, "Resolver is required" unless resolver
+
+        @resolver = resolver
+      end
+
+      def error(node)
+        raise ArgumentError, "Visitor cant process node token type: #{node.token.type}"
+      end
+
+      def visit_binary_operator_node(node)
+        if node.token.type == Lexer::Token::Type::AND_OP
+          visit(node.left) && visit(node.right)
+        elsif node.token.type == Lexer::Token::Type::OR_OP
+          visit(node.left) || visit(node.right)
+        else
+          error(node)
+        end
+      end
+
+      def visit_unary_operator_node(node)
+        if node.token.type == Lexer::Token::Type::NOT_OP
+          !visit(node.child)
+        else
+          error(node)
+        end
+      end
+
+      def visit_value_operand_node(node)
+        if node.value == 'true'
+          true
+        elsif node.value == 'false' || node.value == 'null'
+          false
+        else
+          resolve_value(node.value)
+        end
+      end
+
+      private
+
+      def resolve_value(value)
+        if resolver.nil?
+          raise ArgumentError, "No resolver function but trying to resolve: #{value}"
+        end
+
+        !!resolver.call(value)
+      end
+
+    end
+  end
+end

data/lib/logicality/lexer/grammar.rb

@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Lexer
+    module Grammar
+      VALUE       = /([a-zA-Z0-9_$@?\.]+)/
+      AND_OP      = /(&&)/
+      OR_OP       = /(\|\|)/
+      NOT_OP      = /(\!)/
+      LEFT_PAREN  = /(\()/
+      RIGHT_PAREN = /(\))/
+    end
+  end
+end

data/lib/logicality/lexer/lexer.rb

@@ -0,0 +1,10 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './lib/logicality/lexer/grammar'
+require './lib/logicality/lexer/token'
+require './lib/logicality/lexer/regexp_lexer'

data/lib/logicality/lexer/regexp_lexer.rb

@@ -0,0 +1,97 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Lexer
+    class RegexpLexer
+      include Grammar
+
+      class << self
+
+        def invalid_pattern
+          "#{pattern}|(\\s*)"
+        end
+
+        def invalid_regexp
+          Regexp.new(invalid_pattern)
+        end
+
+        def pattern
+          Grammar.constants.map { |c| Grammar.const_get(c).source }
+                           .join('|')
+        end
+
+        def regexp
+          Regexp.new(pattern)
+        end
+
+      end
+
+      attr_reader :expression
+
+      def initialize(expression)
+        raise ArgumentError, 'Expression is required' unless expression && expression.to_s.length > 0
+
+        @expression = expression.to_s
+
+        if invalid_matches.length > 0
+          raise ArgumentError, "Invalid syntax: #{invalid_matches}"
+        end
+
+        reset
+      end
+
+      def next_token
+        return nil if index > matches.length - 1
+
+        increment
+
+        scan_array = matches[index]
+
+        return nil unless scan_array
+
+        tokens = scan_array.map.with_index do |value, index|
+          const = Grammar.constants[index]
+          value ? Token.new(const, value) : nil
+        end.compact
+
+        if tokens.length > 1
+          raise ArgumentError, "Too many tokens found for: #{scan_array}"
+        elsif tokens.length == 0
+          raise ArgumentError, "Cannot tokenize: #{scan_array}"
+        end
+
+        tokens.first
+      end
+
+      def reset
+        @index = -1
+
+        self
+      end
+
+      private
+
+      attr_reader :index
+
+      def increment
+        @index += 1
+
+        nil
+      end
+
+      def invalid_matches
+        @invalid_matches ||= expression.gsub(self.class.invalid_regexp, '')
+      end
+
+      def matches
+        @matches ||= expression.scan(self.class.regexp)
+      end
+
+    end
+  end
+end

data/lib/logicality/lexer/token.rb

@@ -0,0 +1,37 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Lexer
+    class Token
+
+      module Type
+        VALUE       = :value
+        AND_OP      = :and_op
+        OR_OP       = :or_op
+        NOT_OP      = :not_op
+        LEFT_PAREN  = :left_paren
+        RIGHT_PAREN = :right_paren
+      end
+
+      attr_reader :type, :value
+
+      def initialize(type, value)
+        raise ArgumentError, 'type is required'   unless type   && type.to_s.length > 0
+        raise ArgumentError, 'value is required'  unless value  && value.to_s.length > 0
+
+        @type   = Type.const_get(type.to_s.upcase.to_sym)
+        @value  = value.to_s
+      end
+
+      def to_s
+        "#{type}::#{value}"
+      end
+
+    end
+  end
+end

data/lib/logicality/logic.rb

@@ -0,0 +1,65 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  class Logic
+    class << self
+
+      def evaluate(expression, input, resolver = nil)
+        node        = get(expression)
+        wrapper     = resolver_wrapper(input, resolver)
+        interpreter = Interpreter::SimpleInterpreter.new(wrapper)
+
+        interpreter.visit(node)
+      end
+
+      private
+
+      def resolver_wrapper(input, resolver)
+        if resolver
+          lambda { |value| resolver.call(value, input) }
+        else
+          lambda { |value| object_resolver.call(value, input) }
+        end
+      end
+
+      def object_resolver
+        lambda do |value, input|
+          return false unless input
+
+          if input.respond_to?(value)
+            !!input.send(value)
+          elsif input.respond_to?(:[])
+            !!input[value]
+          else
+            false
+          end
+        end
+      end
+
+      def cache
+        @cache || {}
+      end
+
+      def set(expression, node)
+        @cache = {} unless @cache
+
+        @cache[expression] = node
+      end
+
+      def get(expression)
+        return cache[expression] if cache[expression]
+
+        lexer   = Lexer::RegexpLexer.new(expression)
+        parser  = Parser::SimpleParser.new(lexer)
+
+        set(expression, parser.parse)
+      end
+
+    end
+  end
+end

data/lib/logicality/logicality.rb

@@ -0,0 +1,11 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './lib/logicality/lexer/lexer'
+require './lib/logicality/parser/parser'
+require './lib/logicality/interpreter/interpreter'
+require './lib/logicality/logic'

data/lib/logicality/parser/ast/ast.rb

@@ -0,0 +1,11 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './lib/logicality/parser/ast/node'
+require './lib/logicality/parser/ast/binary_operator_node'
+require './lib/logicality/parser/ast/unary_operator_node'
+require './lib/logicality/parser/ast/value_operand_node'

data/lib/logicality/parser/ast/binary_operator_node.rb

@@ -0,0 +1,26 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Parser
+    module Ast
+      class BinaryOperatorNode < Node
+
+        attr_reader :left, :right
+
+        def initialize(left, token, right)
+          super(token)
+
+          @name  = 'binary_operator_node'
+          @left  = left
+          @right = right
+        end
+
+      end
+    end
+  end
+end

data/lib/logicality/parser/ast/node.rb

@@ -0,0 +1,27 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Parser
+    module Ast
+      class Node
+
+        attr_reader :token, :name
+
+        def initialize(token)
+          @token = token
+          @name  = ''
+        end
+
+        def to_s
+          "AstNode: #{self.class.name}::#{token}"
+        end
+
+      end
+    end
+  end
+end

data/lib/logicality/parser/ast/unary_operator_node.rb

@@ -0,0 +1,25 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Parser
+    module Ast
+      class UnaryOperatorNode < Node
+
+        attr_reader :child
+
+        def initialize(child, token)
+          super(token)
+
+          @name   = 'unary_operator_node'
+          @child  = child
+        end
+
+      end
+    end
+  end
+end

data/lib/logicality/parser/ast/value_operand_node.rb

@@ -0,0 +1,25 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Parser
+    module Ast
+      class ValueOperandNode < Node
+
+        attr_reader :value
+
+        def initialize(token)
+          super(token)
+
+          @name  = 'value_operand_node'
+          @value = token.value
+        end
+
+      end
+    end
+  end
+end

data/lib/logicality/parser/parser.rb

@@ -0,0 +1,9 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './lib/logicality/parser/ast/ast'
+require './lib/logicality/parser/simple_parser'

data/lib/logicality/parser/simple_parser.rb

@@ -0,0 +1,97 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  module Parser
+    class SimpleParser
+
+      attr_reader :lexer
+
+      def initialize(lexer)
+        @lexer = lexer
+
+        @current_token = lexer.next_token
+
+        if @current_token.nil?
+          raise ArgumentError, 'Lexer must contain at least one token'
+        end
+
+      end
+
+      def parse
+        expr
+      end
+
+      private
+
+      BINARY_TYPES = [
+        Lexer::Token::Type::AND_OP,
+        Lexer::Token::Type::OR_OP,
+      ].freeze
+
+      attr_reader :current_token
+
+      def error
+        raise ArgumentError, 'Invalid parser syntax'
+      end
+
+      def eat(token_type)
+        if current_token.type == token_type
+          @current_token = lexer.next_token
+        else
+          error
+        end
+
+        nil
+      end
+
+      def factor
+        token = current_token
+
+        if current_token.type == Lexer::Token::Type::VALUE
+          eat(Lexer::Token::Type::VALUE)
+
+          Ast::ValueOperandNode.new(token)
+        elsif current_token.type == Lexer::Token::Type::LEFT_PAREN
+          eat(Lexer::Token::Type::LEFT_PAREN)
+          node = expr
+          eat(Lexer::Token::Type::RIGHT_PAREN)
+
+          node
+        elsif current_token.type == Lexer::Token::Type::NOT_OP
+          eat(Lexer::Token::Type::NOT_OP)
+          node = factor
+
+          Ast::UnaryOperatorNode.new(node, token)
+        else
+          raise ArgumentError, "Factor cannot determine what to do with: #{token}"
+        end
+      end
+
+      def expr
+        node = factor
+
+        loop do
+          break unless current_token && BINARY_TYPES.include?(current_token.type)
+
+          token = current_token
+
+          if token.type == Lexer::Token::Type::AND_OP
+            eat(Lexer::Token::Type::AND_OP)
+          elsif token.type == Lexer::Token::Type::OR_OP
+            eat(Lexer::Token::Type::OR_OP)
+          end
+
+          node = Ast::BinaryOperatorNode.new(node, token, factor)
+        end
+
+        node
+      end
+
+    end
+  end
+end

data/lib/logicality/version.rb

@@ -0,0 +1,10 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Logicality
+  VERSION = "0.0.1"
+end

data/logicality.gemspec

@@ -0,0 +1,28 @@
+require "./lib/logicality/version"
+
+Gem::Specification.new do |s|
+
+  s.name        = 'logicality'
+  s.version     = Logicality::VERSION
+  s.summary     = "String-based boolean expression evaluator"
+
+  s.description = <<-EOS
+    A common problem that many frameworks have is the ability to give developers
+    an expressive intermediary scripting language or DSL.
+    Logicality helps solve this problem by providing a simple boolean
+    expression evaluator.
+  EOS
+
+  s.authors     = [ 'Matthew Ruggio' ]
+  s.email       = [ 'mruggio@bluemarblepayroll.com' ]
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.homepage    = 'https://github.com/bluemarblepayroll/logicality-rb'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 2.3.7'
+
+  s.add_development_dependency('rspec')
+
+end

data/spec/logic_spec.rb

@@ -0,0 +1,87 @@
+#
+# Copyright (c) 2018-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require './lib/logicality/logicality'
+
+def run(tests)
+  tests.each do |x|
+    input = x[1] ? x[1].map { |k,v| [ k.to_s, v] }.to_h : nil
+
+    result = Logicality::Logic.evaluate(x[0], input)
+
+    expect(result).to eq(x[2]), "Failed on #{x[0]} (input: #{input}): expected #{x[2]} but got: #{result}"
+  end
+
+  nil
+end
+
+describe Logicality::Logic do
+
+  context 'when evaluating' do
+
+    it 'should evaluate boolean-only expressions' do
+      tests = [
+        [ 'true',           nil, true ],
+        [ 'false',          nil, false ],
+        [ 'true && false',  nil, false ],
+        [ 'true && true',   nil, true ]
+      ]
+
+      run(tests)
+    end
+
+    it 'should evaluate and expressions' do
+      tests = [
+        [ 'a && b', nil,                    false ],
+        [ 'a && b', {},                     false ],
+        [ 'a && b', { a: true },            false ],
+        [ 'a && b', { a: true, b: false },  false ],
+        [ 'a && b', { a: false, b: false }, false ],
+        [ 'a && b', { a: true, b: true },   true ]
+      ]
+
+      run(tests)
+    end
+
+    it 'should evaluate and-or expressions' do
+      tests = [
+        [ 'a && b || c',    { a: false, b: false, c: true },  true ],
+        [ '(a && b) || c',  { a: false, b: false, c: true },  true ],
+        [ 'a || b && c',    { a: false, b: false, c: true },  false ],
+        [ 'a || (b && c)',  { a: false, b: false, c: true },  false ],
+        [ '(a || b) && c',  { a: false, b: false, c: true },  false ]
+      ]
+
+      run(tests)
+    end
+
+    it 'should evaluate not expressions' do
+      tests = [
+        [ '!a',         { a: false },            true ],
+        [ '!a && !b',   { a: false, b: false },  true ],
+        [ '!a && b',    { a: false, b: false },  false ],
+        [ 'a && !b',    { a: false, b: false },  false ],
+        [ '!(a && b)',  { a: false, b: false },  true ]
+      ]
+
+      run(tests)
+    end
+
+    it 'should treat question marks as a valid part of a value token' do
+      tests = [
+        [ 'a?',       { 'a?': true },             true ],
+        [ '!a?',      { 'a?': true },             false ],
+        [ 'a? && b?', { 'a?': true, 'b?': true }, true ],
+        [ 'a && b?',  { a: true, 'b?': true },    true ]
+      ]
+
+      run(tests)
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: logicality
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Matthew Ruggio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: |2
+      A common problem that many frameworks have is the ability to give developers
+      an expressive intermediary scripting language or DSL.
+      Logicality helps solve this problem by providing a simple boolean
+      expression evaluator.
+email:
+- mruggio@bluemarblepayroll.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/logicality/interpreter/interpreter.rb
+- lib/logicality/interpreter/node_visitor.rb
+- lib/logicality/interpreter/simple_interpreter.rb
+- lib/logicality/lexer/grammar.rb
+- lib/logicality/lexer/lexer.rb
+- lib/logicality/lexer/regexp_lexer.rb
+- lib/logicality/lexer/token.rb
+- lib/logicality/logic.rb
+- lib/logicality/logicality.rb
+- lib/logicality/parser/ast/ast.rb
+- lib/logicality/parser/ast/binary_operator_node.rb
+- lib/logicality/parser/ast/node.rb
+- lib/logicality/parser/ast/unary_operator_node.rb
+- lib/logicality/parser/ast/value_operand_node.rb
+- lib/logicality/parser/parser.rb
+- lib/logicality/parser/simple_parser.rb
+- lib/logicality/version.rb
+- logicality.gemspec
+- spec/logic_spec.rb
+homepage: https://github.com/bluemarblepayroll/logicality-rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: String-based boolean expression evaluator
+test_files:
+- spec/logic_spec.rb