expressionist 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f849377088fcff72b0ccd7d6b8c82e4f4465b2ad142e5fce4bd11080389bdb09
-  data.tar.gz: c7cc2728aa2d5b0e5dbcff4350f819a9cebf3f19785a86b6b0196e491828264b
+  metadata.gz: 1da1a2ceee72ee773a38c0473c4b204274369bcaeb9ee5b80de93b6d8fcc84e2
+  data.tar.gz: c657865ed1042f95856f2acfb1beec2adb0667469e3c3eb23cc93b672296bfd4
 SHA512:
-  metadata.gz: e6d1de63704129958bf171aa089a8139ad0cfeac68ae736ee40f6104b4bc3a5c6796614c0f702e644ba63dba3796c80ef2bdb8d279d8feb11eae5329637ff1e8
-  data.tar.gz: cb512ff6dff6b079bd59fdaa1cce4291b7797c631c65848fdb2fa00501c2146714e3a0c519596be79256371e5c78af13703518ad3c799e00343595efc3e4d60e
+  metadata.gz: adcea62b1ca67c192f7ad89e1b3a1516b5074d8e42215934dfa33885767465fe2a36d5ea52b704babaf63a2685a75afbd15e8ab8db76a5392f315994976e7c7d
+  data.tar.gz: 97788da9e6736afa85d186ecb835083f4be7de33168a1fea4d364ac52c5320edda58cf0f60dc7b495fe7b9fa2ef8f954ba584ab22906d854e368898ee5724e9b

data/.gitignore

@@ -7,4 +7,5 @@
 /spec/reports/
 /tmp/
 /.idea
-*.iml
+*.iml
+/*.gem

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    expressionist (0.0.1)
+    expressionist (0.0.2)
       parslet (~> 1.8)
 
 GEM

data/README.md

@@ -1,8 +1,6 @@
 # Expressionist
 
-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/expressionist`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Simple query language for tree structured data
 
 ## Installation
 
@@ -22,18 +20,63 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+```ruby
+require 'expressionist'
+
+context = Expressionist::Context.new
+
+context['some.key'] = 'value'
+
+expression = Expressionist.compile('some.key == "value" AND count(some.*) == 1')
+
+expression.call(context) # => true
+
+context['some.key2'] = 'value'
+
+expression.call(context) # => false
+
+context.export # => {"some"=>{"key"=>{"."=>"value"}, "key2"=>{"."=>"value"}}}
+
+tmp = expression.executable # => Array
+
+another = Expressionist.compile(tmp)
+
+another.call(context) # => false
+```
+
+## Contexts
+
+Context defines tree data structure that can be queried. Data can be importad
+from an existing `Hash` and can be exported using `context.export`. 
+
+The `.` is used to separate the path. There can never be two `.` next to each
+other and path can not start with a `.`. The `.` character can not be escaped.
+
+Paths can only contain these `/[A-Za-z0-9.\-_]/` characters.
+
+## Query language (expressions)
+
+ToDo: update the section, ATM check the `lib/expressionist/grammar.rb` and
+`lib/expressionist/functions/*.rb` files. 
 
 ## 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.
+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).
+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/[USERNAME]/expressionist.
+Bug reports and pull requests are welcome on GitHub at 
+[marekjelen/expressionist](https://github.com/marekjelen/expressionist).
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the 
+[MIT License](https://opensource.org/licenses/MIT).

data/expressionist.gemspec

@@ -11,8 +11,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Marek Jelen']
   spec.email         = ['marek@jelen.biz']
 
-  spec.summary       = 'Simple query language for querying tree data structure'
-  spec.description   = 'Simple query language for querying tree data structure'
+  spec.summary       = 'Simple query language for tree structured data'
+  spec.description   = 'Safely make queries against tree data structure with ' \
+                       'ability to serialize queries for later usage'
   spec.homepage      = 'https://www.github.com/marekjelen/expressionist'
   spec.license       = 'MIT'
 

data/lib/expressionist.rb

@@ -1,6 +1,16 @@
 # frozen_string_literal: true
 
+require 'parslet'
+
 require 'expressionist/version'
+require 'expressionist/context'
+require 'expressionist/expression'
+require 'expressionist/parser'
 
 module Expressionist
-end
+
+  def self.compile(expression)
+    Expression.new(Parser.new(expression))
+  end
+
+end

data/lib/expressionist/context.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Expressionist
+
+  class Context
+
+    def initialize(data = {})
+      @data = data
+    end
+
+    def []=(key, value)
+      segments = key.split('.')
+      len = segments.length
+      data = @data
+      (0...len).each do |i|
+        key = segments[i]
+        data = (data[key] ||= {})
+      end
+      data['.'] = value
+    end
+
+    def delete(key)
+      segments = key.split('.')
+      len = segments.length
+      data = @data
+      (0...len).each do |i|
+        break unless data
+        data = data[segments[i]]
+      end
+      data.delete('.') if data
+    end
+
+    def [](key)
+      find(key.split('.'), @data)
+    end
+
+    def find(segments = [], data = nil)
+      data ||= @data
+      segment = segments[0]
+      subsegments = segments[1..-1]
+
+      case
+      when data == nil
+        [nil]
+      when segments.length == 0
+        [cast(data['.'])]
+      when segment == '?'
+        (data.keys - ['.']).map do |k|
+          find(subsegments, data[k])
+        end
+      when segment == '*' && subsegments.length > 0 && data[subsegments[0]]
+        find(subsegments[1..-1], data[subsegments[0]])
+      when segment == '*'
+        (subsegments.length == 0 ? [data['.']] : []) + (data.keys - ['.']).map do |k|
+          find(segments, data[k])
+        end
+      else
+        find(subsegments, data[segment])
+      end.flatten.compact
+    end
+
+    def export
+      @data
+    end
+
+    def cast(value)
+      case value
+      when 'true'
+        true
+      when 'false'
+        false
+      when /[0-9]+[.,][0-9]+/
+        Float(value)
+      when /[0-9]+/
+        Integer(value)
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/lib/expressionist/expression.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'expressionist/function'
+require 'expressionist/functions'
+
+module Expressionist
+
+  class Expression
+
+    def initialize(value)
+      if value.kind_of?(Parser)
+        @parser = value
+      else
+        @executable = value
+      end
+    end
+
+    def executable
+      @executable ||= @parser.executable
+    end
+
+    def call(context = {}, executable = nil)
+      executable ||= self.executable
+
+      args = executable[1..-1].map do |exp|
+        if exp.kind_of?(Array)
+          call(context, exp)
+        else
+          exp
+        end
+      end
+
+      function = Functions.get(executable[0])
+      unless function
+        raise ArgumentError, "Function #{executable[0].inspect} is missing"
+      end
+
+      function.call(context, *args)
+    end
+
+  end
+
+end

data/lib/expressionist/function.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Expressionist
+
+  class Function
+
+    attr_reader :name, :args
+
+    def initialize(name, *args)
+      if name.kind_of?(Array) && args.length == 0
+        @name = name[0]
+        @args = name[1..-1].map do |arg|
+          arg.kind_of?(Array) ? Function.new(arg) : arg
+        end
+      else
+        @name = name
+        @args = args
+      end
+    end
+
+    def to_a
+      [name] + args.map { |arg| arg.kind_of?(Function) ? arg.to_a : arg }
+    end
+
+    def to_s
+      "#{name}(#{args.map(&to_s).join(', ')})"
+    end
+
+    def ==(other)
+      self.class == other.class && other.name == self.name && other.args == self.args
+    end
+
+  end
+
+end

data/lib/expressionist/functions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Expressionist
+
+  module Functions
+
+    class << self
+
+      def functions
+        @functions ||= {}
+      end
+
+      def add(name, &block)
+        functions[name] = block
+      end
+
+      def get(name)
+        functions[name]
+      end
+
+    end
+
+  end
+
+end
+
+require 'expressionist/functions/core'
+require 'expressionist/functions/operators'
+require 'expressionist/functions/boolean'
+require 'expressionist/functions/math'

data/lib/expressionist/functions/boolean.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Expressionist
+  module Functions
+
+    add('and') do |context, *items|
+      items.inject(true) {|c, i| c && i}
+    end
+
+    add('or') do |context, *items|
+      items.inject(false) {|c, i| c || i}
+    end
+
+  end
+end

data/lib/expressionist/functions/core.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Expressionist
+  module Functions
+
+    add('get') do |context, *segments|
+      context.find(segments).first
+    end
+
+  end
+end

data/lib/expressionist/functions/math.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Expressionist
+  module Functions
+
+    add('max') do |context, *segments|
+      context.find(segments).max
+    end
+
+    add('count') do |context, *segments|
+      context.find(segments).length
+    end
+
+  end
+end

data/lib/expressionist/functions/operators.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Expressionist
+
+  module Functions
+
+    add('>') do |context, left, right|
+      left > right
+    end
+
+    add('>=') do |context, left, right|
+      left >= right
+    end
+
+    add('=') do |context, left, right|
+      left == right
+    end
+
+    add('==') do |context, left, right|
+      left == right
+    end
+
+    add('!=') do |context, left, right|
+      left != right
+    end
+
+    add('<=') do |context, left, right|
+      left <= right
+    end
+
+    add('<') do |context, left, right|
+      left < right
+    end
+
+  end
+
+end

data/lib/expressionist/grammar.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Expressionist
+
+  class Grammar < Parslet::Parser
+
+    rule(:space) {match('\s').repeat(1)}
+    rule(:space?) {space.maybe}
+
+    rule(:lparen) {space? >> str('(') >> space?}
+    rule(:rparen) {space? >> str(')') >> space?}
+
+    rule(:comma) {space? >> str(',') >> space?}
+    rule(:dot) {space? >> str('.') >> space?}
+
+    rule(:lquote) {space? >> str('"')}
+    rule(:rquote) {str('"') >> space?}
+
+    rule(:ande) {space? >> str('AND').as(:boolean_operator) >> space?}
+    rule(:ore) {space? >> str('OR').as(:boolean_operator) >> space?}
+
+    rule(:anum) {match('[0-9a-zA-Z]')}
+    rule(:anums) {match('[.-_]') >> anum}
+    rule(:sanums) {match('[-_]') >> anum}
+
+    rule(:quoted) {(str('\"').as(:char) | (str('"').absent? >> any).as(:char)).repeat}
+    rule(:string) {lquote >> quoted.as(:string) >> rquote}
+    rule(:integer) {match('[0-9]').repeat(1).as(:integer)}
+    rule(:float) {(match('[0-9a-zA-Z]').repeat(1) >> str('.') >> match('[0-9a-zA-Z]').repeat(1)).as(:float)}
+    rule(:bool) {(str('true') | str('false')).as(:bool)}
+
+    rule(:keyword) {anum >> (anum | sanums).repeat}
+
+    rule(:segment) { str('*').as(:segment) | str('?').as(:segment) | ((anum >> (anum | sanums).repeat).as(:segment)) }
+    rule(:path) {(segment >> (dot >> segment).repeat).as(:path)}
+
+    rule(:func) {keyword.as(:function) >> lparen >> path >> rparen}
+
+    rule(:operator) {str('>=') | str('<=') | str('!=') | str('==') | str('=') | str('<') | str('>')}
+
+    rule(:value) {string | bool | float | integer}
+
+    rule(:expression) do
+      space? >>
+        (func.as(:func) | path) >>
+        space? >>
+        operator.as(:operator) >>
+        space? >>
+        value.as(:value) >>
+        space?
+    end
+
+    rule(:primary) { lparen >> or_expression >> rparen | expression }
+
+    rule(:and_expression) { (primary.as(:left) >> ande >> and_expression.as(:right)).as(:and) | primary }
+
+    rule(:or_expression) { (and_expression.as(:left) >> ore >> or_expression.as(:right)).as(:or) | and_expression }
+
+    rule(:base) { or_expression }
+    # https://github.com/kschiess/parslet/blob/master/example/boolean_algebra.rb
+
+    root(:base)
+
+  end
+
+end

data/lib/expressionist/parser.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'expressionist/grammar'
+require 'expressionist/transformer'
+
+module Expressionist
+
+  class Parser
+
+    def initialize(expression)
+      @parsed = nil
+      @compiled = nil
+      @executable = nil
+
+      case expression
+      when String
+        @expression = expression
+      when Function
+        @compiled   = expression
+      when Array
+        @executable = expression
+      else
+        raise ArgumentError, "Unknown expression type: #{expression}"
+      end
+    end
+
+    def parsed
+      raise RuntimeError, 'Expression was not passed' unless @expression
+      @parsed ||= Grammar.new.parse(@expression)
+    rescue Parslet::ParseFailed => e
+      # puts expression
+      # puts e.parse_failure_cause.ascii_tree
+      raise ArgumentError, "Invalid expression: #{@expression}"
+    end
+
+    def compiled
+      raise RuntimeError, 'Raw nor compiled form was passed' unless @compiled || parsed
+      @compiled ||= Transformer.new.apply(parsed)
+    end
+
+    def executable
+      raise RuntimeError, 'Compiled nor executable form was passed' unless @executable || compiled
+      @executable ||= compiled.to_a
+    end
+
+  end
+
+end

data/lib/expressionist/transformer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Expressionist
+
+  class Transformer < Parslet::Transform
+
+    rule(integer: simple(:value)) { Integer(value) }
+    rule(float: simple(:value)) { Float(value) }
+    rule(integer: simple(:value)) { Integer(value) }
+    rule(bool: simple(:value)) { ['false'].include?(value) ? false : true }
+
+    rule(char: simple(:value)) { value == '\\"' ? '"' : value }
+    rule(string: sequence(:value)) { value.join }
+
+    rule(segment: simple(:value)) { value.str }
+
+    rule(path: sequence(:value)) { value }
+    rule(path: simple(:value)) { value }
+
+    rule(function: simple(:name), path: simple(:path)) do
+      Function.new(name.str, path)
+    end
+
+    rule(function: simple(:name), path: sequence(:path)) do
+      Function.new(name.str, *path)
+    end
+
+    rule(operator: simple(:op), value: simple(:value), func: simple(:func)) do
+      Function.new(op.str, func, value)
+    end
+
+    rule(operator: simple(:op), value: simple(:value), path: simple(:path)) do
+      Function.new(op.str, Function.new('get', path), value)
+    end
+
+    rule(operator: simple(:op), value: simple(:value), path: sequence(:path)) do
+      Function.new(op.str, Function.new('get', *path), value)
+    end
+
+    rule(expression: simple(:value)) { value }
+
+    rule(boolean_operator: simple(:value), left: simple(:left), right: simple(:right)) do
+      Function.new(value.str.strip.downcase, left, right)
+    end
+
+    rule(and: simple(:value)) { value }
+    rule(or: simple(:value)) { value }
+
+  end
+
+end

data/lib/expressionist/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 #
 module Expressionist
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressionist
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Marek Jelen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-24 00:00:00.000000000 Z
+date: 2018-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -80,7 +80,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: Simple query language for querying tree data structure
+description: Safely make queries against tree data structure with ability to serialize
+  queries for later usage
 email:
 - marek@jelen.biz
 executables: []
@@ -98,6 +99,17 @@ files:
 - bin/setup
 - expressionist.gemspec
 - lib/expressionist.rb
+- lib/expressionist/context.rb
+- lib/expressionist/expression.rb
+- lib/expressionist/function.rb
+- lib/expressionist/functions.rb
+- lib/expressionist/functions/boolean.rb
+- lib/expressionist/functions/core.rb
+- lib/expressionist/functions/math.rb
+- lib/expressionist/functions/operators.rb
+- lib/expressionist/grammar.rb
+- lib/expressionist/parser.rb
+- lib/expressionist/transformer.rb
 - lib/expressionist/version.rb
 homepage: https://www.github.com/marekjelen/expressionist
 licenses:
@@ -122,5 +134,5 @@ rubyforge_project:
 rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
-summary: Simple query language for querying tree data structure
+summary: Simple query language for tree structured data
 test_files: []