yuri-ita 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 413f3447fff9ac44f83651cf97d96ce1ec2a80b850b9e88ef142e1afd2bc3519
+  data.tar.gz: 0d85e9307246eeca631a8ea73b252ddb545912b9c0acb8972d25970046074087
+SHA512:
+  metadata.gz: 7d1ba86975041460af1ace033804af6a3f9b0d592a300a69ebf3028a33e16f748cab9ef7302bb6931b8fdfa71b142481d05097f62505af2b42ef0a1b7c61b57a
+  data.tar.gz: b320a83a41391c6fa86972ddec4e2d730de2c27e1028cae68227cf41f8b08fd072054ae828d5949ba3e14f9ef61698fee93cb126f3a3709d37281dab7976a479

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 Ebrahim Kobeissi and thoughtbot, inc.
+
+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/lib/yuri-ita.rb

@@ -0,0 +1 @@
+require "yuriita"

data/lib/yuriita/and_combination.rb

@@ -0,0 +1,22 @@
+module Yuriita
+  class AndCombination
+    def initialize(base_relation:, relations:)
+      @base_relation = base_relation
+      @relations = relations
+    end
+
+    def combine
+      base_relation.merge(combined_relations)
+    end
+
+    private
+
+    attr_reader :base_relation, :relations
+
+    def combined_relations
+      relations.reduce do |chain, relation|
+        chain.merge(relation)
+      end
+    end
+  end
+end

data/lib/yuriita/assembler.rb

@@ -0,0 +1,15 @@
+module Yuriita
+  class Assembler
+    attr_reader :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def build(query)
+      configuration.map do |definition|
+        definition.apply(query: query)
+      end
+    end
+  end
+end

data/lib/yuriita/clauses/dynamic.rb

@@ -0,0 +1,18 @@
+module Yuriita
+  module Clauses
+    class Dynamic
+      def initialize(filter:, input:)
+        @filter = filter
+        @input = input
+      end
+
+      def apply(relation)
+        filter.apply(relation, input)
+      end
+
+      private
+
+      attr_reader :filter, :input
+    end
+  end
+end

data/lib/yuriita/clauses/filter.rb

@@ -0,0 +1,19 @@
+module Yuriita
+  module Clauses
+    class Filter
+      def initialize(filters:, combination:)
+        @filters = filters
+        @combination = combination
+      end
+
+      def apply(relation)
+        relations = filters.map { |filter| filter.apply(relation) }
+        combination.new(base_relation: relation, relations: relations).combine
+      end
+
+      private
+
+      attr_reader :filters, :combination
+    end
+  end
+end

data/lib/yuriita/clauses/identity.rb

@@ -0,0 +1,9 @@
+module Yuriita
+  module Clauses
+    class Identity
+      def apply(relation)
+        relation
+      end
+    end
+  end
+end

data/lib/yuriita/clauses/search.rb

@@ -0,0 +1,20 @@
+module Yuriita
+  module Clauses
+    class Search
+      def initialize(filters:, keywords:, combination:)
+        @filters = filters
+        @keywords = keywords
+        @combination = combination
+      end
+
+      def apply(relation)
+        relations = filters.map { |filter| filter.apply(relation, keywords) }
+        combination.new(base_relation: relation, relations: relations).combine
+      end
+
+      private
+
+      attr_reader :filters, :keywords, :combination
+    end
+  end
+end

data/lib/yuriita/collection.rb

@@ -0,0 +1,60 @@
+module Yuriita
+  class Collection
+    include Yuriita::Routing
+
+    attr_reader :input
+
+    class << self
+      def dispatch(name, input, relation)
+        new(input).dispatch(name, relation)
+      end
+
+      def action_methods
+        @action_methods ||= begin
+          internal_methods = superclass.public_instance_methods(true)
+          methods = (public_instance_methods(true) - internal_methods)
+
+          methods.map!(&:to_s)
+
+          methods.to_set
+        end
+      end
+    end
+
+    def initialize(input)
+      @input = input
+    end
+
+    def dispatch(name, relation)
+      process(name, relation)
+    end
+
+    private
+
+    def process(action, *args)
+      action = action.to_s
+
+      unless method_name = find_method_name(action)
+        raise ActionNotFound.new("The action '#{action}' could not be found for #{self.class.name}", self, action)
+      end
+
+      process_action(method_name, *args)
+    end
+
+    def process_action(method_name, *args)
+      send_action(method_name, *args)
+    end
+    alias send_action send
+
+
+    def find_method_name(action)
+      if action_method?(action)
+        action
+      end
+    end
+
+    def action_method?(name)
+      self.class.action_methods.include?(name)
+    end
+  end
+end

data/lib/yuriita/configuration.rb

@@ -0,0 +1,31 @@
+module Yuriita
+  class Configuration
+    include Enumerable
+    EMPTY_STRING = "".freeze
+
+    attr_reader :default_input
+
+    def initialize(definitions, default_input: EMPTY_STRING)
+      @definitions = definitions
+      @default_input = default_input
+    end
+
+    def find_definition(key)
+      definitions.fetch(key)
+    end
+
+    def each(&block)
+      block or return enum_for(__method__) { size }
+      definitions.each_value(&block)
+      self
+    end
+
+    def size
+      definitions.size
+    end
+
+    private
+
+    attr_reader :definitions
+  end
+end

data/lib/yuriita/definitions/dynamic.rb

@@ -0,0 +1,38 @@
+module Yuriita
+  module Definitions
+    class Dynamic
+      def initialize(filter:)
+        @filter = filter
+      end
+
+      def apply(query:)
+        input = select_input(query)
+
+        if input.present?
+          Clauses::Dynamic.new(filter: filter, input: input)
+        else
+          Clauses::Identity.new
+        end
+      end
+
+      private
+
+      attr_reader :filter
+
+      def select_input(query)
+        matching_inputs(query).last
+      end
+
+      def matching_inputs(query)
+        query.select do |input|
+          case input
+          when Inputs::Expression
+            input.qualifier == filter.qualifier
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yuriita/definitions/exclusive.rb

@@ -0,0 +1,32 @@
+module Yuriita
+  module Definitions
+    class Exclusive
+      attr_reader :options, :default
+
+      def initialize(options:, default:)
+        @options = options
+        @default = default
+      end
+
+      def apply(query:)
+        filter = selected_filter(query)
+
+        Clauses::Filter.new(filters: [filter], combination: combination)
+      end
+
+      private
+
+      def combination
+        AndCombination
+      end
+
+      def selected_filter(query)
+        Selects::Exclusive.new(
+          options: options,
+          default: default,
+          query: query,
+        ).filter
+      end
+    end
+  end
+end

data/lib/yuriita/definitions/multiple.rb

@@ -0,0 +1,28 @@
+module Yuriita
+  module Definitions
+    class Multiple
+      attr_reader :options, :combination
+
+      def initialize(options:, combination:)
+        @options = options
+        @combination = combination
+      end
+
+      def apply(query:)
+        filters = selected_filters(query)
+
+        if filters.present?
+          Clauses::Filter.new(filters: filters, combination: combination)
+        else
+          Clauses::Identity.new
+        end
+      end
+
+      private
+
+      def selected_filters(query)
+        Selects::Multiple.new(options: options, query: query).filters
+      end
+    end
+  end
+end

data/lib/yuriita/definitions/scope.rb

@@ -0,0 +1,33 @@
+module Yuriita
+  module Definitions
+    class Scope
+      attr_reader :options, :combination
+
+      def initialize(options:, combination:)
+        @options = options
+        @combination = combination
+      end
+
+      def apply(query:)
+        filters = selected_filters(query)
+        keywords = query.keywords
+
+        if keywords.present?
+          Clauses::Search.new(
+            filters: filters,
+            keywords: keywords,
+            combination: combination,
+          )
+        else
+          Clauses::Identity.new
+        end
+      end
+
+      private
+
+      def selected_filters(query)
+        Selects::AllOrExplicit.new(options: options, query: query).filters
+      end
+    end
+  end
+end

data/lib/yuriita/definitions/single.rb

@@ -0,0 +1,31 @@
+module Yuriita
+  module Definitions
+    class Single
+      attr_reader :options
+
+      def initialize(options:)
+        @options = options
+      end
+
+      def apply(query:)
+        filter = selected_filter(query)
+
+        if filter.present?
+          Clauses::Filter.new(filters: [filter], combination: combination)
+        else
+          Clauses::Identity.new
+        end
+      end
+
+      private
+
+      def combination
+        AndCombination
+      end
+
+      def selected_filter(query)
+        Selects::Single.new(options: options, query: query).filter
+      end
+    end
+  end
+end

data/lib/yuriita/dynamic_filter.rb

@@ -0,0 +1,18 @@
+module Yuriita
+  class DynamicFilter
+    attr_reader :qualifier
+
+    def initialize(qualifier:, &block)
+      @qualifier = qualifier
+      @block = block
+    end
+
+    def apply(relation, input)
+      block.call(relation, input)
+    end
+
+    private
+
+    attr_reader :block
+  end
+end

data/lib/yuriita/errors/collection/action_not_found.rb

@@ -0,0 +1,14 @@
+module Yuriita
+  class Collection
+    class ActionNotFound < Yuriita::Error
+      attr_reader :collection, :action
+
+      def initialize(message = nil, collection = nil, action = nil)
+        @collection = collection
+        @action = action
+        super(message)
+      end
+
+    end
+  end
+end

data/lib/yuriita/errors/error.rb

@@ -0,0 +1,4 @@
+module Yuriita
+  class Error < StandardError
+  end
+end

data/lib/yuriita/errors/parse_error.rb

@@ -0,0 +1,4 @@
+module Yuriita
+  class ParseError < Yuriita::Error
+  end
+end

data/lib/yuriita/executor.rb

@@ -0,0 +1,17 @@
+module Yuriita
+  class Executor
+    def initialize(clauses)
+      @clauses = clauses
+    end
+
+    def run(relation)
+      clauses.reduce(relation) do |chain, clause|
+        chain.merge(clause.apply(relation))
+      end
+    end
+
+    private
+
+    attr_reader :clauses
+  end
+end

data/lib/yuriita/expression_filter.rb

@@ -0,0 +1,18 @@
+module Yuriita
+  class ExpressionFilter
+    attr_reader :input
+
+    def initialize(input:, &block)
+      @input = input
+      @block = block
+    end
+
+    def apply(relation)
+      block.call(relation)
+    end
+
+    private
+
+    attr_reader :block
+  end
+end

data/lib/yuriita/inputs/expression.rb

@@ -0,0 +1,13 @@
+module Yuriita
+  module Inputs
+    Expression = Struct.new(:qualifier, :term) do
+      def to_s
+        if term.match?(" ")
+          "#{qualifier}:\"#{term}\""
+        else
+          "#{qualifier}:#{term}"
+        end
+      end
+    end
+  end
+end

data/lib/yuriita/inputs/keyword.rb

@@ -0,0 +1,9 @@
+module Yuriita
+  module Inputs
+    Keyword = Struct.new(:value) do
+      def to_s
+        value
+      end
+    end
+  end
+end

data/lib/yuriita/lexer.rb

@@ -0,0 +1,21 @@
+require "rltk/lexer"
+
+module Yuriita
+  class Lexer < RLTK::Lexer
+    DATETIME_REGEX = %r{
+      ([0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])
+      (
+        T
+        ((2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9]))
+        (Z|[+-](2[0-3]|[01][0-9])(:[0-5][0-9])?)
+      )?
+    }x
+
+    rule(/[ \t\f]+/) { :SPACE }
+    rule(/:/) { :COLON }
+    rule(/>/) { :GT }
+    rule(DATETIME_REGEX) { |d| [:DATETIME, DateTime.parse(d)] }
+    rule(/[^ >\t\f:"]+/) { |t| [:WORD, t] }
+    rule(/"/) { :QUOTE }
+  end
+end

data/lib/yuriita/option.rb

@@ -0,0 +1,19 @@
+module Yuriita
+  class Option
+    attr_reader :name, :filter
+
+    def initialize(name:, filter:)
+      @name = name
+      @filter = filter
+    end
+
+    def input
+      filter.input
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.name == name
+    end
+    alias_method :eql?, :==
+  end
+end

data/lib/yuriita/or_combination.rb

@@ -0,0 +1,23 @@
+module Yuriita
+  class OrCombination
+    def initialize(base_relation:, relations:)
+      @base_relation = base_relation
+      @relations = relations
+    end
+
+    def combine
+      base_relation.merge(combined_relations)
+    end
+
+    private
+
+    attr_reader :base_relation, :relations
+
+    def combined_relations
+      relations.reduce do |chain, relation|
+        chain.or(relation)
+      end
+    end
+  end
+end
+

data/lib/yuriita/parser.rb

@@ -0,0 +1,61 @@
+require "rltk/parser"
+
+module Yuriita
+  class Parser < RLTK::Parser
+    left :SPACE
+
+    production(:query) do
+      clause("SPACE? .input_list SPACE?") do |inputs|
+        Query.new(inputs: inputs)
+      end
+      clause("SPACE?") { |_| Query.new }
+    end
+
+    production(:input_list) do
+      clause(".input") { |input| [input] }
+      clause(".input_list SPACE .input") { |head, tail| head + [tail] }
+    end
+
+    production(:input) do
+      clause(".keyword") { |keyword| keyword }
+      clause(".expression") { |expression| expression }
+    end
+
+    production(:keyword) do
+      clause(:WORD) { |word| Inputs::Keyword.new(word) }
+      clause("QUOTE SPACE? .phrase SPACE? QUOTE") do |phrase|
+        Inputs::Keyword.new(phrase)
+      end
+    end
+
+    production(:expression) do
+      clause(".qualifier COLON .term") do |qualifier, term|
+        Inputs::Expression.new(qualifier, term)
+      end
+    end
+
+    production(:scope_field) do
+      clause(:WORD) { |word| word }
+    end
+
+    production(:qualifier) do
+      clause(:WORD) { |word| word }
+    end
+
+    production(:order) do
+      clause(:WORD) { |word| word }
+    end
+
+    production(:term) do
+      clause(:WORD) { |word| word }
+      clause("QUOTE SPACE? .phrase SPACE? QUOTE") { |phrase| phrase }
+    end
+
+    production(:phrase) do
+      clause(:WORD) { |word| word }
+      clause(".phrase SPACE .WORD") { |phrase, word| phrase + " " + word }
+    end
+
+    finalize
+  end
+end