human_query_parser 1.0.0

data/test/phrase_test.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class HumanQueryParser::PhraseTest < Minitest::Spec
+  it 'generates a non-fuzzy query fragment correctly' do
+    HumanQueryParser::Phrase.new('bloo blah').query_fragments(['field1', 'field2'], false).must_equal([
+      {
+        multi_match: {
+          fields: ['field1', 'field2'],
+          query: 'bloo blah',
+          type: 'phrase',
+        },
+      },
+    ],)
+  end
+
+  it 'generates a fuzzy query fragment correctly' do
+    HumanQueryParser::Phrase.new('bloo blah').query_fragments(['field1', 'field2'], true).must_equal([
+      {
+        function_score: {
+          query: {
+            multi_match: {
+              fields: ['field1', 'field2'],
+              query: 'bloo blah',
+              type: 'phrase',
+              max_expansions: 50,
+            },
+          },
+          boost: 8.0,
+        },
+      },
+    ],)
+  end
+end

data/test/query_test.rb

@@ -0,0 +1,159 @@
+require 'test_helper'
+
+class HumanQueryParser::QueryTest < Minitest::Spec
+  describe '#combine_barewords' do
+    it 'combines two bareword terms' do
+      query = HumanQueryParser::Query.new([
+        HumanQueryParser::Term.new(
+          nil,
+          HumanQueryParser::Bareword.new('word'),
+        ),
+        HumanQueryParser::Term.new(
+          nil,
+          HumanQueryParser::Bareword.new('up'),
+        ),
+      ],)
+
+      query.terms_by_operator.size.must_equal 1
+      query.terms_for_operator(nil).size.must_equal 1
+
+      combined_term = query.terms_for_operator(nil).first
+      combined_term.must_be :bareword?
+      combined_term.content.content.must_equal 'word up'
+    end
+
+    it 'does not combine phrases' do
+      query = HumanQueryParser::Query.new([
+        HumanQueryParser::Term.new(
+          nil,
+          HumanQueryParser::Bareword.new('word'),
+        ),
+        HumanQueryParser::Term.new(
+          nil,
+          HumanQueryParser::Bareword.new('up'),
+        ),
+        HumanQueryParser::Term.new(
+          nil,
+          HumanQueryParser::Phrase.new('a phrase'),
+        ),
+        HumanQueryParser::Term.new(
+          nil,
+          HumanQueryParser::Phrase.new('another phrase'),
+        ),
+      ],)
+
+      query.terms_by_operator.size.must_equal 1
+      query.terms_for_operator(nil).size.must_equal 3
+
+      bareword_term = query.terms_for_operator(nil).first
+      bareword_term.must_be :bareword?
+      bareword_term.content.content.must_equal 'word up'
+
+      phrase_term_1 = query.terms_for_operator(nil)[1]
+      phrase_term_1.wont_be :bareword?
+      phrase_term_1.content.content.must_equal 'a phrase'
+
+      phrase_term_1 = query.terms_for_operator(nil)[2]
+      phrase_term_1.wont_be :bareword?
+      phrase_term_1.content.content.must_equal 'another phrase'
+    end
+
+    it 'does not combine barewords with different operators' do
+      query = HumanQueryParser::Query.new([
+        HumanQueryParser::Term.new(
+          nil,
+          HumanQueryParser::Bareword.new('word'),
+        ),
+        HumanQueryParser::Term.new(
+          '+',
+          HumanQueryParser::Bareword.new('up'),
+        ),
+      ],)
+
+      query.terms_by_operator.size.must_equal 2
+      query.terms_for_operator(nil).size.must_equal 1
+      query.terms_for_operator('+').size.must_equal 1
+
+      word_term = query.terms_for_operator(nil).first
+      word_term.must_be :bareword?
+      word_term.content.content.must_equal 'word'
+
+      word_term = query.terms_for_operator('+').first
+      word_term.must_be :bareword?
+      word_term.content.content.must_equal 'up'
+    end
+  end
+
+  describe '#es_query' do
+    it 'generates a basic query' do
+      bareword = HumanQueryParser::Bareword.new('word')
+
+      query = HumanQueryParser::Query.new([
+        HumanQueryParser::Term.new(
+          '+',
+          bareword,
+        ),
+      ],)
+
+      query.es_query(['body', 'tags']).must_equal({
+        bool: {
+          must: bareword.query_fragments(['body', 'tags'], false),
+        },
+      },)
+    end
+
+    it 'combines terms of the same operator' do
+      bareword = HumanQueryParser::Bareword.new('word')
+      phrase = HumanQueryParser::Phrase.new('phrase-ology')
+
+      query = HumanQueryParser::Query.new([
+        HumanQueryParser::Term.new(
+          '+',
+          bareword,
+        ),
+        HumanQueryParser::Term.new(
+          '+',
+          phrase,
+        ),
+      ],)
+
+      query.es_query(['body', 'tags']).must_equal({
+        bool: {
+          must: (
+            bareword.query_fragments(['body', 'tags'], false) +
+            phrase.query_fragments(['body', 'tags'], false)
+          ),
+        },
+      },)
+    end
+
+    it 'generates separate sections for different operators' do
+      must_word = HumanQueryParser::Bareword.new('word1')
+      should_word = HumanQueryParser::Bareword.new('word2')
+      must_not_word = HumanQueryParser::Bareword.new('word3')
+
+      query = HumanQueryParser::Query.new([
+        HumanQueryParser::Term.new(
+          '+',
+          must_word,
+        ),
+        HumanQueryParser::Term.new(
+          nil,
+          should_word,
+        ),
+        HumanQueryParser::Term.new(
+          '-',
+          must_not_word,
+        ),
+      ],)
+
+      query.es_query(['body', 'tags']).must_equal({
+        bool: {
+          must: must_word.query_fragments(['body', 'tags'], false),
+          should: should_word.query_fragments(['body', 'tags'], true),
+          must_not: must_not_word.query_fragments(['body', 'tags'], false),
+        },
+      },)
+    end
+  end
+end

data/test/term_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class HumanQueryParser::TermTest < Minitest::Spec
+  it 'correctly identifies fuzzy vs non-fuzzy terms' do
+    content = HumanQueryParser::Bareword.new('word')
+
+    HumanQueryParser::Term.new(nil, content).must_be :fuzzy?
+    HumanQueryParser::Term.new('+', content).wont_be :fuzzy?
+    HumanQueryParser::Term.new('-', content).wont_be :fuzzy?
+  end
+
+  it 'correctly identifies barewords vs non-barewords' do
+    HumanQueryParser::Term.new(nil, HumanQueryParser::Bareword.new('word')).must_be :bareword?
+    HumanQueryParser::Term.new(nil, HumanQueryParser::Phrase.new('word')).wont_be :bareword?
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/reporters'
+require 'pry'
+
+require 'human_query_parser'
+
+if ENV['BUILD_NUMBER']
+  Minitest::Reporters.use!(
+    [MiniTest::Reporters::DefaultReporter.new, MiniTest::Reporters::JUnitReporter.new('test/reports')],
+    ENV,
+    Minitest.backtrace_filter,
+  )
+else
+  Minitest::Reporters.use!(Minitest::Reporters::SpecReporter.new, ENV, Minitest.backtrace_filter)
+end

data/test/transform_test.rb

@@ -0,0 +1,185 @@
+require 'test_helper'
+
+class HumanQueryParser::TransformTest < Minitest::Spec
+  subject { HumanQueryParser::Transform.new }
+
+  it 'transforms a single term correctly' do
+    query = subject.apply({
+      query: [
+        {
+          operator: nil,
+          term: {
+            bareword: 'word',
+          },
+        },
+      ],
+    },)
+
+    word_term = query.terms_for_operator(nil).first
+    word_term.must_be :bareword?
+    word_term.content.content.must_equal 'word'
+  end
+
+  it 'combines two bareword terms' do
+    query = subject.apply({
+      query: [
+        {
+          operator: nil,
+          term: {
+            bareword: 'word',
+          },
+        },
+        {
+          operator: nil,
+          term: {
+            bareword: 'up',
+          },
+        },
+      ],
+    },)
+
+    query.terms_by_operator.size.must_equal 1
+    query.terms_for_operator(nil).size.must_equal 1
+
+    combined_term = query.terms_for_operator(nil).first
+    combined_term.must_be :bareword?
+    combined_term.content.content.must_equal 'word up'
+  end
+
+  it 'handles operators correctly' do
+    plus_query = subject.apply({
+      query: [
+        {
+          operator: '+',
+          term: {
+            bareword: 'word',
+          },
+        },
+      ],
+    },)
+
+    plus_query.terms_by_operator.size.must_equal 1
+    plus_query.terms_for_operator('+').size.must_equal 1
+
+    minus_query = subject.apply({
+      query: [
+        {
+          operator: '-',
+          term: {
+            bareword: 'word',
+          },
+        },
+      ],
+    },)
+
+    minus_query.terms_by_operator.size.must_equal 1
+    minus_query.terms_for_operator('-').size.must_equal 1
+  end
+
+  it 'transforms phrases correctly' do
+    query = subject.apply({
+      query: [
+        {
+          operator: nil,
+          term: {
+            bareword: 'word',
+          },
+        },
+        {
+          operator: nil,
+          term: {
+            phrase: 'a phrase',
+          },
+        },
+      ],
+    },)
+
+    query.terms_by_operator.size.must_equal 1
+    query.terms_for_operator(nil).size.must_equal 2
+
+    bareword_term = query.terms_for_operator(nil).first
+    bareword_term.must_be :bareword?
+    bareword_term.content.content.must_equal 'word'
+
+    phrase_term = query.terms_for_operator(nil)[1]
+    phrase_term.wont_be :bareword?
+    phrase_term.content.content.must_equal 'a phrase'
+  end
+
+  it 'does not combine phrases' do
+    query = subject.apply({
+      query: [
+        {
+          operator: nil,
+          term: {
+            bareword: 'word',
+          },
+        },
+        {
+          operator: nil,
+          term: {
+            bareword: 'up',
+          },
+        },
+        {
+          operator: nil,
+          term: {
+            phrase: 'a phrase',
+          },
+        },
+        {
+          operator: nil,
+          term: {
+            phrase: 'another phrase',
+          },
+        },
+      ],
+    },)
+
+    query.terms_by_operator.size.must_equal 1
+    query.terms_for_operator(nil).size.must_equal 3
+
+    bareword_term = query.terms_for_operator(nil).first
+    bareword_term.must_be :bareword?
+    bareword_term.content.content.must_equal 'word up'
+
+    phrase_term_1 = query.terms_for_operator(nil)[1]
+    phrase_term_1.wont_be :bareword?
+    phrase_term_1.content.content.must_equal 'a phrase'
+
+    phrase_term_1 = query.terms_for_operator(nil)[2]
+    phrase_term_1.wont_be :bareword?
+    phrase_term_1.content.content.must_equal 'another phrase'
+  end
+
+  it 'does not combine barewords with different operators' do
+    query = subject.apply({
+      query: [
+        {
+          operator: nil,
+          term: {
+            bareword: 'word',
+          },
+        },
+        {
+          operator: '+',
+          term: {
+            bareword: 'up',
+          },
+        },
+      ],
+    },)
+
+    query.terms_by_operator.size.must_equal 2
+    query.terms_for_operator(nil).size.must_equal 1
+    query.terms_for_operator('+').size.must_equal 1
+
+    word_term = query.terms_for_operator(nil).first
+    word_term.must_be :bareword?
+    word_term.content.content.must_equal 'word'
+
+    word_term = query.terms_for_operator('+').first
+    word_term.must_be :bareword?
+    word_term.content.content.must_equal 'up'
+  end
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: human_query_parser
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- PatientsLikeMe
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  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: 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'
+description: A tool for taking search queries of the form most users will expect,
+  and producing ElasticSearch queries that do what most users would expect.
+email:
+- engineers@patientslikeme.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Guardfile
+- Jenkinsfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/_guard-core
+- bin/guard
+- bin/rake
+- human_query_parser.gemspec
+- lib/human_query_parser.rb
+- lib/human_query_parser/bareword.rb
+- lib/human_query_parser/parser.rb
+- lib/human_query_parser/phrase.rb
+- lib/human_query_parser/query.rb
+- lib/human_query_parser/term.rb
+- lib/human_query_parser/transform.rb
+- lib/human_query_parser/version.rb
+- test/bareword_test.rb
+- test/human_query_parser_test.rb
+- test/parser_test.rb
+- test/phrase_test.rb
+- test/query_test.rb
+- test/term_test.rb
+- test/test_helper.rb
+- test/transform_test.rb
+homepage: https://www.patientslikeme.com
+licenses: []
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A tool for taking search queries of the form most users will expect, and
+  producing ElasticSearch queries that do what most users would expect.
+test_files:
+- test/bareword_test.rb
+- test/human_query_parser_test.rb
+- test/parser_test.rb
+- test/phrase_test.rb
+- test/query_test.rb
+- test/term_test.rb
+- test/test_helper.rb
+- test/transform_test.rb