namarara 0.9.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a3e1538437882fe2870b7954c6d9d956c3aa99c79f62eca39c625688b76a2056
+  data.tar.gz: 3729dba6c1adb99865d166a7690ab7d21fad7be57aae710f6150dc792a6d6e1c
+SHA512:
+  metadata.gz: 2e81025ef3050f8a27d87029ff3db0238f08fc081d9d4b8b3510dd09a7a2f26d6fd07a89676addf89f135890eb1991802c0185ae5eeede61db991921f957ff09
+  data.tar.gz: 25b30ba9b15aab14afd9c127333134860f428da6778e4aa271649ff46dbefa9f825e2e20cb87fc20bacb6ba2de129b099155ed453ed410213608a3e8483e8ea3

data/.github/workflows/gempush.yml

@@ -0,0 +1,33 @@
+---
+name: Ruby Gem
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Build + Publish
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@master
+      - name: Set up Ruby 2.6
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version: 2.6.x
+
+      - name: Publish to RubyGems
+        run: |
+          mkdir -p $HOME/.gem
+          touch $HOME/.gem/credentials
+          chmod 0600 $HOME/.gem/credentials
+          printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+          gem build *.gemspec
+          gem push *.gem
+        env:
+          GEM_HOST_API_KEY: ${{secrets.RUBYGEMS_AUTH_TOKEN}}

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,58 @@
+require: rubocop-rspec
+
+##
+## TEMPORARILY disabled 
+##
+
+AllCops:
+  TargetRubyVersion: 2.5
+
+##
+## LOCAL PREFERENCES
+##
+# Allow bigger test cases ('examples')
+RSpec/ExampleLength:
+  Enabled: true
+  Max: 10
+
+Metrics/MethodLength:
+  Enabled: true
+  Max: 10
+
+Metrics/BlockLength:
+  Enabled: false
+  Exclude:
+    - spec/**/*
+
+Metrics/AbcSize:
+  Enabled: false
+
+# Disable errors due to rspec-specific patterns
+RSpec/DescribedClass:
+  Enabled: false
+
+##
+## DISABLE all layout/whitespace-related errors 
+## 
+
+RSpec/FilePath:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/MultilineIfThen:
+  Enabled: false
+
+# Style/FileName:
+# Enabled: false
+
+# Style/StringLiterals:
+# Enabled: false
+
+Style/FormatString:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+

data/.ruby-version

@@ -0,0 +1 @@
+2.2.7

data/.tool-versions

@@ -0,0 +1 @@
+ruby 2.6.1

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.3

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in namarara.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Roguelearg
+
+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,124 @@
+# Namarara
+
+Namarara is a library that can parses boolean expressions, builds an [binary
+expression tree](https://en.wikipedia.org/wiki/Binary_expression_tree) and
+evalutes a result given a set of values associated to the variables used within
+the boolean expression.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'namarara'
+```
+
+And then execute:
+
+```shell-session
+$ bundle
+```
+
+Or install it yourself as:
+
+```shell-session
+$ gem install namarara
+```
+
+## Usage
+
+### Evaluate a single expression
+
+```ruby
+require 'namarara'
+
+# Initialize Namarara
+namarara = Namarara::Parser.new(Namarara::Lexer.new)
+
+# Prepare variables 
+namarara.names = {
+  this: 'true',
+  that: 'false',
+  other: 'false',
+  something_else: 'true'
+}
+
+# Build a binary expression tree (aka BET) from string
+# and inject values
+exp_tree = namarara.parse('this AND (that OR other) AND something_else')
+
+# Compute tree with variables
+result = exp_tree.compute
+puts result # = false
+```
+
+### Evaluating a set of rules
+
+```ruby
+require 'namarara'
+
+# Initialize Namarara
+namarara = Namarara::Parser.new(Namarara::Lexer.new)
+
+# A set of rules i want to check 
+# (in this example we are looking for sensitive personnal data)
+rules = {
+    vulnerable_person: 'is_adult AND is_subordinate',
+    has_constraints: 'is_adult AND has_children',
+    is_child: 'NOT is_adult'
+    # ...
+}
+
+# A set of values i want to inject (values must be expressed as strings)
+namarara.names = {
+    "is_adult" => 'false', 
+    "is_subordinate" => 'true',
+    "has_children" => 'true'
+}
+
+results = rules.map { |rule, expr| [rule, namarara.parse(expr).compute] }
+
+if results.select{ |rule, value| value }.empty?
+    puts "Perfect! Nothing to say ;-)"
+else
+    puts "Warning: you are collectif sensitive personnal data !"
+    results.each do |rule, value|
+      puts "#{value ? '>>':'  '} #{rule}: #{value}" 
+    end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 
+
+Then, run `rake test` to run the tests. 
+
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. 
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/glenux/namarara
+
+
+## License and copyright
+
+[Namarara](https://github.com/glenux/namarara) is an open source project under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+Original author : [Brendon Torre](https://www.linkedin.com/in/brendon-torre-b128a0168)
+
+Current developer & maintainer : Glenn Y. Rolland ([@glenux](https://twitter.com/glenux))
+
+
+## Sponsors and funding
+
+[Namarara](https://github.com/glenux/namarara) is an independent project whose development and maintenance is made possible thanks to the support of its patrons.
+
+If you wish to join them and support the work of its author, just participate with this link :
+
+__>>> [Become a patron or sponsor on Patreon](https://www.patreon.com/glenux) <<<__
+

data/Rakefile

@@ -0,0 +1,28 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require 'rubocop/rake_task'
+
+# Add additional test suite definitions to the default test task here
+namespace :spec do
+  desc 'Runs RuboCop on specified directories'
+  RuboCop::RakeTask.new(:rubocop) do |task|
+    # Dirs: app, lib, test
+    task.patterns = ['exe/**/*.rb', 'lib/**/*.rb', 'spec/**/*_spec.rb']
+
+    # Make it easier to disable cops.
+    task.options << "--display-cop-names"
+
+    # Abort on failures (fix your code first)
+    task.fail_on_error = true
+  end
+end
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << "spec"
+  t.libs << "lib"
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+Rake::Task[:spec].enhance ['spec:rubocop']
+
+task :default => :spec

data/TODO.md

@@ -0,0 +1,13 @@
+# TODO
+
+* prefixer les spec/files par success ou error
+* factoriser parser dans tous les tests unitaires (le mettre en let(:parser)
+* dans les tests, verifier quelle variables ont été reportées comme non définies
+  (si possible)
+* pour priority parser, comparer le to_s de l'expression
+  avec celui d'un arbre correct plutot que le résultat
+
+* tester une expression pour chaque type possible dans la grammaire de EXPR 
+* tester ensuite quelques combinaisons simples 
+* tester enfin les cas foireux (ceux des priorités à gauche/droite sur les NOT, etc.)
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "namarara"
+
+# 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

@@ -0,0 +1,8 @@
+#!/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/demo.rb

@@ -0,0 +1,46 @@
+  
+$:.insert(0, 'lib')
+require 'namarara'
+
+def verify_input
+  parser = Namarara::Parser.new(Namarara::Lexer.new)
+
+  # on démarre avec zéro alertes
+  warnings = []
+
+  # ma liste de regles pour lesquelles je veux des alertes
+  rules = [
+    'est_adulte AND est_subordone',
+    'est_adulte AND a_des_enfants',
+    'NOT est_adulte'
+    # ...
+  ]
+
+  # contexte récupéré en HTTP ou en base de données
+  context = {
+    "est_adulte" => 'false', 
+    "est_subordone" => 'true',
+    "a_des_enfants" => 'true'
+    # 80 valeurs de plus si on veut
+  }
+
+  rules.each do |rule|
+    parser.names = context
+    token = parser.parse(rule)
+    res = token.compute
+    if res then
+      warnings << "La règle #{rule} n'est pas respectée"
+    end
+  end
+
+  if not warnings.empty?
+    puts "Attention: vous collectez des DCP de personnes vulnerables"
+    puts warnings.join("\n")
+  else
+    puts "Rien à dire :-)"
+  end
+
+end
+
+verify_input()
+

data/exe/namarara-api

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+$:.insert(0, 'lib')
+
+require 'namarara'
+require 'json'
+require 'sinatra'
+
+get '/' do
+  <<-EOF
+Bonjour le monde !
+  EOF
+end
+
+post '/single' do
+  json = JSON.parse(request.body.read)
+  expr = json['expr'] || ''
+  vars = json['vars'] || ''
+  puts json.inspect
+  result = Namarara.parse_string(expr, vars, true)
+  JSON.generate(result)
+end
+

data/exe/namarara-cli

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+$:.insert(0, 'lib')
+
+require 'thor'
+require 'rly'
+require 'namarara'
+require 'json'
+
+module Namarara
+  class ParseCli < Thor
+    class_option :debug, 
+      type: :boolean, 
+      aliases: '-d', 
+      default: false, 
+      desc: "Enable debugging output"
+    class_option :format, 
+      type: :string, 
+      aliases: '-f', 
+      default: 'text', 
+      enum: ['text','json'],
+      desc: "Output format"
+
+    desc 'file FILE VARS', 
+      'Parse FILE into tokens then compute with VARS'
+    def file(infile, *vars)
+      line = File.read(infile).gsub(/\n/,'')
+      vars_hash = get_vars_hash(vars)
+      res = parse_string(line, vars_hash, options[:debug])
+      puts format(res, options[:format])
+    end
+
+    desc 'string STRING VARS', 
+      'Parse STRING into tokens then compute with VARS'
+    def string(line, *vars)
+      vars_hash = get_vars_hash(vars)
+      res = parse_string(line, vars_hash, options[:debug])
+      puts format(res, options[:format])
+    end
+
+    private
+
+    # Convert VAR=value list into hash
+    def get_vars_hash(vars)
+      tab_vars = {}
+      vars.each do |var|
+        tab_vars[var.split('=')[0]] = var.split('=')[1]
+      end
+      tab_vars
+    end
+
+    def format(result, format)
+      case format 
+      when 'text' then
+        txt = []
+        txt << "EXPR: #{result[:expr]}"
+        txt << "TREE: #{result[:tree]}"
+        result[:errors].each do |error|
+          txt << "ERROR: #{error}"
+        end
+        txt << "RESULT: #{result[:result]}"
+        txt.join("\n")
+      when 'json'
+        JSON.generate(result)
+      else
+        raise 'Unknown output format'
+      end
+    end
+  end
+end
+
+Namarara::ParseCli.start(ARGV)

data/lib/namarara/errors/invalid_grammar.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Namarara
+  module Errors
+    class InvalidGrammar < EvalError
+    end
+  end
+end

data/lib/namarara/errors/var_not_defined.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Namarara
+  module Errors
+    class VarNotDefined < EvalError
+    end
+  end
+end

data/lib/namarara/eval_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Namarara
+  class EvalError
+    attr_accessor :var
+    attr_accessor :message
+
+    def initialize(hash)
+      # validate input
+      raise ArgumentError unless hash[:message]
+
+      # load input
+      @message = hash[:message]
+      @var = hash[:var]
+    end
+  end
+end

data/lib/namarara/lexer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Namarara
+  class Lexer < Rly::Lex
+    attr_reader :logger
+
+    ignore "\t\n "
+
+    # token :SPACE, /\s+/
+    token :L_PAR, /\(/
+    token :R_PAR, /\)/
+    token :NUMBER, /[0-9]+(\.[0-9]+)?/
+    token :STRING, /"([^"]*)"/ do |s|
+      s.value.gsub!(/"(.*)"/, '\1')
+      s
+    end
+
+    token :EQ_OP, /\=/
+    token :T_BOOL, /true/i
+    token :F_BOOL, /false/i
+    token :VAR, /[a-z][a-zA-Z0-9_]+/
+    token :AND_OP, /AND/
+    token :OR_OP, /OR/
+    token :NOT_OP, /NOT/
+
+    def initialize(logger = nil)
+      @logger = logger
+      super()
+    end
+
+    on_error do |t|
+      t.lexer.logger&.error "Illegal character #{t.value}"
+      t.lexer.pos += 1
+      nil
+    end
+  end
+end

data/lib/namarara/parser.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module Namarara
+  class TreeExpr
+    def compute
+      raise NotImplementedError
+    end
+  end
+
+  class TreeValue
+    attr_reader :value
+
+    def to_s
+      raise NotImplementedError
+    end
+  end
+
+  class VarValue < TreeValue
+    attr_reader :errors
+
+    def initialize(str, value)
+      @errors = []
+      @name = str
+      @value = value
+      @value = true if value =~ /^true$/i
+      @value = false if value =~ /^false$/i
+      return unless @value.nil?
+
+      @errors << Errors::VarNotDefined.new(
+        message: "No value for #{@name}",
+        var: @name
+      )
+    end
+
+    def compute
+      @value
+    end
+
+    def to_s
+      "var:#{@name}<-(#{@value})"
+    end
+  end
+
+  class NumberValue < TreeValue
+    attr_reader :errors
+
+    def initialize(str)
+      @errors = []
+      @value = str
+    end
+
+    def compute
+      @value
+    end
+
+    def to_s
+      "number:#{@value}"
+    end
+  end
+
+  class StringValue < TreeValue
+    attr_reader :errors
+
+    def initialize(str)
+      @errors = []
+      @value = str
+    end
+
+    def compute
+      @value
+    end
+
+    def to_s
+      "string:\"#{@value}\""
+    end
+  end
+
+  class BoolValue < TreeValue
+    attr_reader :errors
+
+    def initialize(str)
+      @errors = []
+      @value = case str
+               when /true/i then true
+               when /false/i then false
+               end
+    end
+
+    def compute
+      @value
+    end
+
+    def to_s
+      "bool:#{@value}"
+    end
+  end
+
+  class AndOp < TreeExpr
+    attr_reader :errors
+
+    def initialize(lval, rval)
+      @errors = []
+      @errors.concat lval.errors
+      @errors.concat rval.errors
+      @lval = lval
+      @rval = rval
+    end
+
+    def compute
+      # rubocop:disable Style/DoubleNegation
+      !!@lval.compute && !!@rval.compute
+      # rubocop:enable Style/DoubleNegation
+    end
+
+    def to_s
+      "( #{@lval} ) AND ( #{@rval} )"
+    end
+  end
+
+  class OrOp
+    attr_reader :errors
+
+    def initialize(lval, rval)
+      @errors = []
+      @errors.concat lval.errors
+      @errors.concat rval.errors
+      @lval = lval
+      @rval = rval
+    end
+
+    def compute
+      # rubocop:disable Style/DoubleNegation
+      !!@lval.compute || !!@rval.compute
+      # rubocop:enable Style/DoubleNegation
+    end
+
+    def to_s
+      "( #{@lval} ) OR ( #{@rval} )"
+    end
+  end
+
+  class NotOp
+    attr_reader :errors
+
+    def initialize(expr)
+      @errors = []
+      @errors.concat expr.errors
+      @expr = expr
+    end
+
+    def compute
+      !@expr.compute
+    end
+
+    def to_s
+      "NOT ( #{@expr} )"
+    end
+  end
+
+  class EqOp
+    attr_reader :errors
+
+    def initialize(lval, rval)
+      @errors = []
+      @errors.concat lval.errors
+      @errors.concat rval.errors
+      @lval = lval
+      @rval = rval
+    end
+
+    def compute
+      @lval.value == @rval.value
+    end
+
+    def to_s
+      "#{@lval} = #{@rval}"
+    end
+  end
+
+  # Cut HERE
+  # 8< ---- 8< ---- ...
+
+  class Parser < Rly::Yacc
+    class MissingNamesError < RuntimeError; end
+    attr_writer :names
+
+    # Initialize names hash
+    def initialize(*args)
+      @names = nil
+      super(*args)
+    end
+
+    # Make sure names are filled in
+    def parse(str)
+      raise MissingNamesError if @names.nil?
+
+      super(str)
+    end
+
+    # Check if grammar is valid
+    def check_grammar(line, tokens)
+      grammar = tokens.to_s.split(/=|AND|OR/)
+      expr = line.split(/=|AND|OR/)
+      return if grammar.size == expr.size
+      return if grammar.empty?
+
+      tokens.errors << Errors::InvalidGrammar.new(
+        message: 'Invalid Grammar'
+      )
+    end
+
+    precedence :left, :VAR
+    precedence :left, :OR_OP
+    precedence :left, :AND_OP
+    precedence :left, :EQ_OP
+    precedence :right, :L_PAR, :R_PAR
+    precedence :right, :UMINUS
+
+    rule 'statement : expr' do |st, e|
+      st.value = e.value
+    end
+
+    rule 'bool_expr : F_BOOL' do |ex, l|
+      ex.value = l.value
+    end
+
+    rule 'bool_expr : T_BOOL' do |ex, l|
+      ex.value = l.value
+    end
+
+    rule 'expr : VAR' do |ex, l|
+      ex.value = VarValue.new(l.value.to_s, @names[l.value.to_s])
+    end
+
+    rule 'expr : bool_expr' do |ex, l|
+      ex.value = BoolValue.new(l.value)
+    end
+
+    rule 'expr : STRING' do |ex, l|
+      ex.value = StringValue.new(l.value)
+    end
+
+    rule 'expr : NUMBER' do |ex, l|
+      ex.value = NumberValue.new(l.value)
+    end
+
+    rule 'expr : expr OR_OP expr' do |ex, l, _e, r|
+      ex.value = OrOp.new(
+        l.value,
+        r.value
+      )
+    end
+
+    rule 'expr : expr AND_OP expr' do |ex, l, _e, r|
+      ex.value = AndOp.new(
+        l.value,
+        r.value
+      )
+    end
+
+    rule 'expr : expr EQ_OP expr' do |ex, v, _eq, n|
+      ex.value = EqOp.new(
+        v.value,
+        n.value
+      )
+    end
+
+    rule 'expr : L_PAR expr R_PAR' do |ex, _l, e, _r|
+      ex.value = e.value
+    end
+
+    rule 'expr : NOT_OP expr %prec UMINUS' do |ex, _l, e|
+      ex.value = NotOp.new(e.value)
+    end
+
+    # rule 'expr : VAR EQ_OP bool_expr' do |ex, v, _eq, n|
+    #   ex.value = EqOp.new(
+    #     VarValue.new(v.value.to_s, @names[v.value.to_s]),
+    #     BoolValue.new(n.value)
+    #   )
+    # end
+
+    # rule 'expr : VAR EQ_OP STRING' do |ex, v, _eq, n|
+    #   ex.value = EqOp.new(
+    #     VarValue.new(v.value.to_s, @names[v.value.to_s]),
+    #     StringValue.new(n.value)
+    #   )
+    # end
+
+    # rule 'expr : VAR EQ_OP NUMBER' do |ex, v, _eq, n|
+    #   ex.value = EqOp.new(
+    #     VarValue.new(v.value.to_s, @names[v.value.to_s]),
+    #     NumberValue.new(n.value)
+    #   )
+    # end
+  end
+end

data/lib/namarara/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Namarara
+  VERSION = '0.9.4'
+end

data/lib/namarara.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'namarara/version'
+
+module Namarara; end
+
+require 'rly'
+
+require 'namarara/lexer'
+require 'namarara/parser'
+require 'namarara/eval_error'
+require 'namarara/errors/var_not_defined'
+require 'namarara/errors/invalid_grammar'
+
+module Namarara
+  def self.parse_string(line, vars, debug = false)
+    parser = Parser.new(Lexer.new)
+    parser.names = vars
+    parser_bet = parser.parse(line.chomp, debug)
+    parser.check_grammar line, parser_bet
+
+    {
+      expr: line,
+      tree: parser_bet.to_s,
+      errors: parser_bet&.errors&.map { |e| e.message },
+      result: parser_bet&.compute
+    }
+  end
+end

data/namarara.gemspec

@@ -0,0 +1,44 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'namarara/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'namarara'
+  spec.version       = Namarara::VERSION
+  spec.authors       = ['Brendon Torre', 'Glenn Y. Rolland']
+  spec.email         = ['glenux@glenux.net']
+
+  spec.summary       = %q{A library and tools for parsing boolean expressions}
+  spec.description   = %q{A library and tools for parsing boolean expressions}
+  spec.homepage      = 'https://github.com/glenux/namarara/'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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 'thor'
+  spec.add_development_dependency 'rly'
+  spec.add_development_dependency 'sinatra'
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  # spec.add_development_dependency "opal"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop-rspec"
+
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: namarara
+version: !ruby/object:Gem::Version
+  version: 0.9.4
+platform: ruby
+authors:
+- Brendon Torre
+- Glenn Y. Rolland
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  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'
+- !ruby/object:Gem::Dependency
+  name: rly
+  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'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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'
+- !ruby/object:Gem::Dependency
+  name: rubocop-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: A library and tools for parsing boolean expressions
+email:
+- glenux@glenux.net
+executables:
+- namarara-api
+- namarara-cli
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/gempush.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".tool-versions"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- bin/console
+- bin/setup
+- demo.rb
+- exe/namarara-api
+- exe/namarara-cli
+- lib/namarara.rb
+- lib/namarara/errors/invalid_grammar.rb
+- lib/namarara/errors/var_not_defined.rb
+- lib/namarara/eval_error.rb
+- lib/namarara/lexer.rb
+- lib/namarara/parser.rb
+- lib/namarara/version.rb
+- namarara.gemspec
+homepage: https://github.com/glenux/namarara/
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A library and tools for parsing boolean expressions
+test_files: []