yuri-ita 0.2.1

data/lib/yuriita/query.rb

@@ -0,0 +1,57 @@
+module Yuriita
+  class Query
+    include Enumerable
+
+    attr_reader :inputs
+
+    def initialize(inputs: [])
+      @inputs = inputs
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.inputs == inputs
+    end
+
+    def keywords
+      inputs.select{ |input| input.is_a?(Yuriita::Inputs::Keyword) }
+    end
+
+    def each(&block)
+      block or return enum_for(__method__) { size }
+      inputs.each(&block)
+      self
+    end
+
+    def add_input(input)
+      inputs << input
+      self
+    end
+    alias << add_input
+
+    def delete(input)
+      inputs.delete(input)
+      self
+    end
+
+    def delete_if
+      block_given? or return enum_for(__method__) { size }
+      select { |input| yield input }.each { |input| inputs.delete(input) }
+      self
+    end
+
+    def size
+      inputs.size
+    end
+    alias length size
+
+    def initialize_dup(original)
+      super
+      @inputs = original.instance_variable_get(:@inputs).dup
+    end
+
+    def initialize_clone(original)
+      super
+      @inputs = original.instance_variable_get(:@inputs).clone
+    end
+  end
+end

data/lib/yuriita/query_builder.rb

@@ -0,0 +1,23 @@
+module Yuriita
+  class QueryBuilder
+    def self.build(input)
+      new.build(input)
+    end
+
+    def initialize(lexer: Lexer, parser: Parser)
+      @lexer = Lexer
+      @parser = Parser
+    end
+
+    def build(input)
+      tokens = lexer.lex(input)
+      parser.parse(tokens)
+    rescue RLTK::LexingError, RLTK::NotInLanguage, RLTK::BadToken, EOFError
+      raise ParseError
+    end
+
+    private
+
+    attr_reader :lexer, :parser
+  end
+end

data/lib/yuriita/result.rb

@@ -0,0 +1,26 @@
+module Yuriita
+  class Result
+    def self.error(exception)
+      new(exception: exception)
+    end
+
+    def self.success(relation)
+      new(relation: relation)
+    end
+
+    attr_reader :relation, :exception
+
+    def initialize(relation: nil, exception: nil)
+      @relation = relation
+      @exception = exception
+
+      if @relation.nil? && @exception.nil?
+        raise ArgumentError, "Must provide a relation or an exception"
+      end
+    end
+
+    def successful?
+      exception.nil?
+    end
+  end
+end

data/lib/yuriita/route.rb

@@ -0,0 +1,37 @@
+module Yuriita
+  class Route
+    attr_reader :collection
+
+    def initialize(collection, matcher, to)
+      @collection = collection
+      @matcher = matcher
+      @to = to
+    end
+
+    def match?(input)
+      case matcher
+      when String
+        # TODO better matching
+        # This won't work for string matching becuase to_s will use quotes
+        # Could we parse it and compare the queries? This would maybe let us
+        # catch parse exceptions
+        #
+        # If we do parse the matcher we could warn if it resulted in more than
+        # two inputs.
+        input.to_s == matcher
+      when Proc
+        matcher.call(input)
+      else
+        matcher.match?(input)
+      end
+    end
+
+    def action
+      to
+    end
+
+    private
+
+    attr_reader :matcher, :to
+  end
+end

data/lib/yuriita/router.rb

@@ -0,0 +1,26 @@
+module Yuriita
+  class Router
+    def initialize
+      @routes = []
+    end
+
+    def append_route(collection, matcher, to:)
+      routes.append Route.new(collection, matcher, to)
+    end
+
+    def route(input, relation)
+      if route = match_for(input)
+        collection = route.collection
+        collection.dispatch(route.action, input, relation)
+      end
+    end
+
+    def match_for(input)
+      routes.detect { |route| route.match?(input) }
+    end
+
+    private
+
+    attr_reader :routes
+  end
+end

data/lib/yuriita/routing.rb

@@ -0,0 +1,19 @@
+module Yuriita
+  module Routing
+    extend ::ActiveSupport::Concern
+
+    included do
+      cattr_accessor :router, default: Yuriita::Router.new
+    end
+
+    class_methods do
+      def routing(matcher, to:)
+        router.append_route(self, matcher, to: to)
+      end
+
+      def route(input, relation)
+        router.route(input, relation)
+      end
+    end
+  end
+end

data/lib/yuriita/runner.rb

@@ -0,0 +1,19 @@
+module Yuriita
+  class Runner
+    def initialize(relation:, configuration:, **options)
+      @relation = relation
+      @configuration = configuration
+      @executor = options.fetch(:executor, Executor)
+      @assembler = options.fetch(:assembler, Assembler)
+    end
+
+    def run(query)
+      clauses = assembler.new(configuration).build(query)
+      executor.new(clauses).run(relation)
+    end
+
+    private
+
+    attr_reader :relation, :configuration, :executor, :assembler
+  end
+end

data/lib/yuriita/search.rb

@@ -0,0 +1,13 @@
+require "active_model"
+
+module Yuriita
+  class Search
+    include ActiveModel::Model
+
+    def initialize(table, param_key)
+      define_singleton_method(param_key) do
+        table.q
+      end
+    end
+  end
+end

data/lib/yuriita/search_filter.rb

@@ -0,0 +1,26 @@
+module Yuriita
+  class SearchFilter
+    attr_reader :input
+
+    def initialize(input:, combination:, &block)
+      @input = input
+      @combination = combination
+      @block = block
+    end
+
+    def apply(relation, keywords)
+      relations = keywords.map do |keyword|
+        block.call(relation, keyword.to_s)
+      end
+
+      combination.new(
+        base_relation: relation,
+        relations: relations,
+      ).combine
+    end
+
+    private
+
+    attr_reader :combination, :block
+  end
+end

data/lib/yuriita/selects/all_or_explicit.rb

@@ -0,0 +1,28 @@
+module Yuriita
+  module Selects
+    class AllOrExplicit
+      def initialize(options:, query:)
+        @options = options
+        @query = query
+      end
+
+      def filters
+        active_options.map(&:filter)
+      end
+
+      private
+
+      attr_reader :options, :query
+
+      def active_options
+        explicit_options.presence || options
+      end
+
+      def explicit_options
+        options.select do |option|
+          query.include?(option.input)
+        end
+      end
+    end
+  end
+end

data/lib/yuriita/selects/exclusive.rb

@@ -0,0 +1,48 @@
+module Yuriita
+  module Selects
+    class Exclusive
+      def initialize(options:, default:, query:)
+        @options = options
+        @default = default
+        @query = query
+      end
+
+      def filter
+        active_option.filter
+      end
+
+      def selected?(option)
+        active_option == option
+      end
+
+      private
+
+      attr_reader :options, :default, :query
+
+      def active_option
+        chosen_option || default
+      end
+
+      def chosen_option
+        input = last_matching_input
+        if input.present?
+          option_for(input)
+        end
+      end
+
+      def last_matching_input
+        matching_inputs.last
+      end
+
+      def matching_inputs
+        query.select do |input|
+          options.any? { |option| option.input == input }
+        end
+      end
+
+      def option_for(input)
+        options.detect { |option| option.input == input }
+      end
+    end
+  end
+end

data/lib/yuriita/selects/multiple.rb

@@ -0,0 +1,28 @@
+module Yuriita
+  module Selects
+    class Multiple
+      def initialize(options:, query:)
+        @options = options
+        @query = query
+      end
+
+      def filters
+        active_options.map(&:filter)
+      end
+
+      def selected?(option)
+        active_options.include?(option)
+      end
+
+      private
+
+      attr_reader :options, :query
+
+      def active_options
+        options.select do |option|
+          query.include?(option.input)
+        end
+      end
+    end
+  end
+end

data/lib/yuriita/selects/single.rb

@@ -0,0 +1,49 @@
+module Yuriita
+  module Selects
+    class Single
+      def initialize(options:, query:)
+        @options = options
+        @query = query
+      end
+
+      def filter
+        if active_option.present?
+          active_option.filter
+        end
+      end
+
+      def selected?(option)
+        if active_option.present?
+          active_option == option
+        else
+          false
+        end
+      end
+
+      private
+
+      attr_reader :options, :query
+
+      def active_option
+        input = last_matching_input
+        if input.present?
+          option_for(input)
+        end
+      end
+
+      def last_matching_input
+        matching_inputs.last
+      end
+
+      def matching_inputs
+        query.select do |input|
+          options.any? { |option| option.input == input }
+        end
+      end
+
+      def option_for(input)
+        options.detect { |option| option.input == input }
+      end
+    end
+  end
+end

data/lib/yuriita/table.rb

@@ -0,0 +1,84 @@
+require "active_support"
+require "active_model"
+require "yuriita/runner"
+
+module Yuriita
+  class Table
+    include ActiveModel::Model
+
+    SPACE = " ".freeze
+    EMPTY_STRING = "".freeze
+
+    def initialize(
+      relation:,
+      params:,
+      configuration:,
+      param_key: :q
+    )
+      @relation = relation
+      @params = params
+      @configuration = configuration
+      @param_key = param_key
+      @search = Yuriita::Search.new(self, @param_key)
+    end
+
+    attr_reader :search
+
+    def q
+      output =
+        if user_input?
+          user_input
+        else
+          default_input
+        end
+
+      if output.blank?
+        EMPTY_STRING
+      else
+        output + SPACE
+      end
+    end
+
+    def items
+      Runner.new(relation: relation, configuration: configuration).run(query)
+    end
+
+    def filtered?
+      user_input? && user_query != default_query
+    end
+
+    def default_input
+      configuration.default_input
+    end
+
+    private
+
+    attr_reader :relation, :params, :configuration, :param_key
+
+    def query
+      if user_input?
+        user_query
+      else
+        default_query
+      end
+    end
+
+    def user_input
+      params.fetch(param_key, EMPTY_STRING)
+    end
+
+    def user_input?
+      params.key?(param_key)
+    end
+
+    def default_query
+      QueryBuilder.build(default_input)
+    end
+
+    def user_query
+      QueryBuilder.build(user_input)
+    rescue ParseError
+      Query.new
+    end
+  end
+end

data/lib/yuriita/version.rb

@@ -0,0 +1,3 @@
+module Yuriita
+  VERSION = "0.2.1"
+end

data/lib/yuriita.rb

@@ -0,0 +1,19 @@
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/yuri-ita.rb")
+loader.collapse("#{__dir__}/yuriita/errors")
+loader.setup
+
+module Yuriita
+  def self.filter(relation, input, configuration)
+    query = build_query(input)
+    relation = Runner.new(relation: relation, configuration: configuration).run(query)
+    Result.success(relation)
+  rescue ParseError => exception
+    Result.error(exception)
+  end
+
+  def self.build_query(input)
+    QueryBuilder.build(input)
+  end
+end