solrb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e90b9041817aa81077a2d05c9be0105682dedac1bb681d7cdd0802e2dd82e829
+  data.tar.gz: ac2d9553669c73c72e57bbba5636cd325c31141c859463dbf88908e0e0f070c6
+SHA512:
+  metadata.gz: 154b62204ff427c13b7eedf8cf0dbe18d18d73093402f6a74a0f292e4f226929bce30a874d7586e50beff08b1b74c792f2702f9f277351e825a80d9367c1af18
+  data.tar.gz: 1bfd971cb1973195288dec35d37911fceb98fc4ef4a76123a9e09261b97d7e8c9ead7ec851074ce3df9698421423298ea00aed3d38bee0b3eb78e6ae575b34e9

data/.circleci/config.yml

@@ -0,0 +1,69 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      # primary image where all specs are run
+      - image: circleci/ruby:2.5.1-node-browsers
+        environment:
+          SOLR_URL: http://localhost:8983/solr/test-core
+      # service images that primary image will use
+      - image: solr:7.4.0
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      # Download and cache dependencies
+      - restore_cache:
+          keys:
+          - v1-dependencies-{{ checksum "Gemfile.lock" }}
+          # fallback to using the latest cache if no exact match is found
+          - v1-dependencies-
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+      - run:
+          name: Wait for Solr
+          command: dockerize -wait tcp://localhost:8983 -timeout 1m
+
+      - run:
+          name: Create a test core
+          command: curl 'http://localhost:8983/solr/admin/cores?action=CREATE&name=test-core&configSet=_default'
+
+      - run:
+          name: Disable field type guessing
+          command: |
+            curl http://localhost:8983/solr/test-core/config -d '{"set-user-property": {"update.autoCreateFields":"false"}}'
+
+
+      - run:
+          name: run tests
+          command: |
+            mkdir /tmp/test-results
+            TEST_FILES="$(circleci tests glob "spec/**/*_spec.rb" | circleci tests split --split-by=timings)"
+
+            bundle exec rspec --format progress \
+                            --format RspecJunitFormatter \
+                            --out /tmp/test-results/rspec.xml \
+                            --format progress \
+                            $TEST_FILES
+
+      # collect reports
+      - store_test_results:
+          path: /tmp/test-results
+      - store_artifacts:
+          path: /tmp/test-results
+          destination: test-results

data/.circleci/run-with-local-config.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+curl --user ${CIRCLE_TOKEN}: \
+    --request POST \
+    --form revision=67d7c5937163 \
+    --form config=@config.yml \
+    --form notify=false \
+        https://circleci.com/api/v1.1/project/github/machinio/solrb/tree/master

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,30 @@
+AllCops:
+  Exclude:
+    - db/schema.rb
+    - node_modules/**/*
+    - bin/*
+  TargetRubyVersion: '2.5'
+Metrics/LineLength:
+  Max: 120
+Documentation:
+  Enabled: false
+FrozenStringLiteralComment:
+  Enabled: false
+Metrics/MethodLength:
+  Max: 20
+Metrics/AbcSize:
+  Max: 20
+ # Removing Blocks Cop for RSpec
+Style/BlockDelimiters:
+  Exclude:
+    - 'spec/**/*'
+ # Removing Indentation Cop for RSpec
+Layout/MultilineMethodCallIndentation:
+  Exclude:
+    - 'spec/**/*'
+Metrics/BlockLength:
+  Exclude:
+    - 'Rakefile'
+    - '**/*.rake'
+    - 'spec/**/*'
+    - 'config/environments/**/*'

data/.ruby-version

@@ -0,0 +1 @@
+2.5.1

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 solr.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,83 @@
+PATH
+  remote: .
+  specs:
+    solrb (0.1.0)
+      addressable
+      faraday
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
+    ast (2.4.0)
+    byebug (10.0.2)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    docile (1.3.1)
+    faraday (0.15.2)
+      multipart-post (>= 1.2, < 3)
+    jaro_winkler (1.5.1)
+    json (2.1.0)
+    method_source (0.9.0)
+    multipart-post (2.0.0)
+    parallel (1.12.1)
+    parser (2.5.1.2)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
+    public_suffix (3.0.2)
+    rainbow (3.0.0)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rspec_junit_formatter (0.4.1)
+      rspec-core (>= 2, < 4, != 2.12.0)
+    rubocop (0.58.2)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.10.0)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    unicode-display_width (1.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  pry
+  pry-byebug
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  rspec_junit_formatter
+  rubocop
+  simplecov
+  solrb!
+
+BUNDLED WITH
+   1.16.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Adriano Luz, Valentin Vasilyev
+
+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,259 @@
+[![CircleCI](https://circleci.com/gh/machinio/solrb/tree/master.svg?style=svg)](https://circleci.com/gh/machinio/solrb/tree/master)
+[![Maintainability](https://api.codeclimate.com/v1/badges/81e84c1c42f10f9da801/maintainability)](https://codeclimate.com/github/machinio/solrb/maintainability)
+
+# Solrb [WIP]
+
+Object-Oriented approach to Solr in Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'solrb', require: 'solr'
+```
+
+## Configuration
+
+The simplest way to use Solrb is `SORL_URL` environment variable (that has a core name in it):
+
+```bash
+  ENV['SOLR_URL'] = 'http://localhost:8983/solr/demo'
+```
+
+or through `Solr.configure` to specify the solr URL:
+
+```ruby
+# Single core configuration
+Solr.configure do |config|
+  config.url = 'http://localhost:8983/solr/demo'
+end
+```
+
+Use `Solr.configure` for an additional configuration:
+
+```ruby
+# Single core configuration
+Solr.configure do |config|
+  config.url = 'http://localhost:8983/solr/demo'
+
+  # This gem uses faraday to make requests to Solr. You can specify additional faraday
+  # options here.
+  config.faraday_options = {}
+
+  # Core's URL is 'http://localhost:8983/solr/demo'
+  # Adding fields to work with
+  config.define_core do |f|
+    f.field :title, dynamic_field: :text
+    f.dynamic_field :text, solr_name: '*_text'
+  end
+end
+```
+
+```ruby
+# Multiple core configuration
+Solr.configure do |config|
+  config.url = 'http://localhost:8983/solr'
+
+  # Define a core with fields that will be used with Solr.
+  # Core URL is 'http://localhost:8983/solr/listings'
+  config.define_core(name: :listings) do |f|
+    # When a dynamic_field is present, the field name will be mapped to match the dynamic field.
+    # Here, "title" will be mapped to "title_text"
+    # You must define a dynamic field to be able to use the dynamic_field option
+    f.field :title, dynamic_field: :text
+
+    # When solr_name is present, the field name will be mapped to the solr_name at runtime
+    f.field :tags, solr_name: :tags_array
+
+    # define a dynamic field
+    f.dynamic_field :text, solr_name: '*_text'
+  end
+
+  # Pass `default: true` to use one core as a default.
+  # Core's URL is 'http://localhost:8983/solr/cars'
+  config.define_core(name: :cars, default: true) do |f|
+    f.field :manufacturer, solr_name: :manuf_s
+    f.field :model, solr_name: :model_s
+  end
+end
+```
+
+It's important to note that those fields that are not configured, will be passed as-is to solr.
+*So you only need to specify fields in configuration if you want Solrb to modify them at runtime*.
+
+
+Warning: Solrb doesn't support fields with the same name. If you have two fields with the same name mapping
+to a single solr field,  you'll have to rename one of the fields.
+
+```ruby
+...
+config.define_core do |f|
+  ...
+  # Not allowed: Two fields with same name 'title'
+  f.field :title, solr_name: :article_title
+  f.field :title, solr_name: :page_title
+end
+...
+```
+
+## Usage
+
+### Indexing
+
+```ruby
+# creates a single document and commits it to index
+doc = Solr::Indexing::Document.new
+doc.add_field(:id, 1)
+doc.add_field(:name, 'Solrb!!!')
+
+request = Solr::Indexing::Request.new(documents: [doc])
+request.run(commit: true)
+```
+
+You can also create indexing document directly from attributes:
+
+```ruby
+doc = Solr::Indexing::Document.new(id: 5, name: 'John')
+```
+
+### Querying
+
+#### Simple Query
+
+```ruby
+  field = Solr::Query::Request::FieldWithBoost.new(field: :name)
+
+  request = Solr::Query::Request.new(search_term: 'term', fields: [field])
+  request.run(page: 1, page_size: 10)
+```
+
+#### Query with field boost
+
+```ruby
+  fields = [
+    # Use boost_magnitude argument to apply boost to a specific field that you query
+    Solr::Query::Request::FieldWithBoost.new(field: :name, boost_magnitude: 16),
+    Solr::Query::Request::FieldWithBoost.new(field: :title)
+  ]
+  request = Solr::Query::Request.new(search_term: 'term', fields: fields)
+  request.run(page: 1, page_size: 10)
+```
+
+#### Query with filters
+
+```ruby
+  fields = [
+    Solr::Query::Request::FieldWithBoost.new(field: :name),
+    Solr::Query::Request::FieldWithBoost.new(field: :title)
+  ]
+  filters = [Solr::Query::Request::Filter.new(type: :equal, field: :title, value: 'A title')]
+  request = Solr::Query::Request.new(search_term: 'term', fields: fields, filters: filters)
+  request.run(page: 1, page_size: 10)
+```
+
+
+#### Query with sorting
+
+```ruby
+  fields = [
+    Solr::Query::Request::FieldWithBoost.new(field: :name),
+    Solr::Query::Request::FieldWithBoost.new(field: :title)
+  ]
+  sort_fields = [Solr::Query::Request::Sorting::Field.new(name: :name, direction: :asc)]
+  request = Solr::Query::Request.new(search_term: 'term', fields: fields)
+  request.sorting = Solr::Query::Request::Sorting.new(fields: sort_fields)
+  request.run(page: 1, page_size: 10)
+```
+
+#### Query with grouping
+
+```ruby
+  fields = [
+    Solr::Query::Request::FieldWithBoost.new(field: :name),
+    Solr::Query::Request::FieldWithBoost.new(field: :category)
+  ]
+  request = Solr::Query::Request.new(search_term: 'term', fields: fields)
+  request.grouping = Solr::Query::Request::Grouping.new(field: :category, limit: 10)
+  request.run(page: 1, page_size: 10)
+```
+
+#### Query with facets
+
+```ruby
+  fields = [
+    Solr::Query::Request::FieldWithBoost.new(field: :name),
+    Solr::Query::Request::FieldWithBoost.new(field: :category)
+  ]
+  request = Solr::Query::Request.new(search_term: 'term', fields: fields)
+  request.facets = [Solr::Query::Request::Facet.new(type: :terms, field: :category, options: { limit: 10 })]
+  request.run(page: 1, page_size: 10)
+```
+
+#### Query with boosting functions
+
+```ruby
+  fields = [
+    Solr::Query::Request::FieldWithBoost.new(field: :name),
+    Solr::Query::Request::FieldWithBoost.new(field: :category)
+  ]
+  request = Solr::Query::Request.new(search_term: 'term', fields: fields)
+  request.boosting = Solr::Query::Request::Boosting.new(
+    multiplicative_boost_functions: [Solr::Query::Request::Boosting::RankingFieldBoostFunction.new(field: :name)],
+    phrase_boosts: [Solr::Query::Request::Boosting::PhraseProximityBoost.new(field: :category, boost_magnitude: 4)]
+  )
+  request.run(page: 1, page_size: 10)
+```
+
+#### Field list
+
+
+```ruby
+  fields = [
+    Solr::Query::Request::FieldWithBoost.new(field: :name),
+    Solr::Query::Request::FieldWithBoost.new(field: :category)
+  ]
+  request = Solr::Query::Request.new(search_term: 'term', fields: fields)
+  # Solr::Query::Request will return only :id field by default.
+  # Specify additional return fields (fl param) by setting the request response_fields
+  request.response_fields = [:name, :category]
+  request.run(page: 1, page_size: 10)
+```
+
+### Deleting documents
+
+```ruby
+Solr.delete_by_id(3242343)
+Solr.delete_by_id(3242343, commit: true)
+Solr.delete_by_query('*:*')
+Solr.delete_by_query('*:*', commit: true)
+```
+
+### Using multi-core configuration
+
+For multi-core configuration use `Solr.with_core` block:
+
+```ruby
+Solr.with_core(:models) do
+  Solr.delete_by_id(3242343)
+  Solr::Query::Request.new(search_term: 'term', fields: fields)
+  Solr::Indexing::Request.new(documents: [doc])
+end
+```
+
+## Running specs
+
+This project is setup to use CI to run all specs agains a real solr.
+
+If you want to run it locally, you can either use  [CircleCI CLI](https://circleci.com/docs/2.0/local-cli/)
+or do a completely manual setup (for up-to-date steps see circleci config)
+
+```sh
+docker pull solr:7.4.0
+docker run -it --name test-solr -p 8983:8983/tcp -t solr:7.4.0
+# create a core
+curl 'http://localhost:8983/solr/admin/cores?action=CREATE&name=test-core&configSet=_default'
+# disable field guessing
+curl http://localhost:8983/solr/test-core/config -d '{"set-user-property": {"update.autoCreateFields":"false"}}'
+SOLR_URL=http://localhost:8983/solr/test-core rspec
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "solr"
+
+# 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/lib/solr/commit/request.rb

@@ -0,0 +1,15 @@
+module Solr
+  module Commit
+    class Request
+      include Solr::Support::ConnectionHelper
+      PATH = '/update'.freeze
+
+      def run
+        # the way to do commit message in SOLR is to send an empty 
+        # request with ?commit=true in the URL.
+        raw_response = connection(PATH, commit: true).post
+        Solr::Response.from_raw_response(raw_response)
+      end
+    end
+  end
+end

data/lib/solr/configuration.rb

@@ -0,0 +1,66 @@
+require 'solr/core_configuration/dynamic_field'
+require 'solr/core_configuration/field'
+require 'solr/core_configuration/core_config'
+require 'solr/core_configuration/core_config_builder'
+require 'solr/errors/solr_url_not_defined_error'
+require 'solr/errors/ambiguous_core_error'
+
+module Solr
+  class Configuration
+    attr_accessor :faraday_options, :cores, :test_connection
+    attr_reader :url
+
+    def initialize
+      @faraday_options = {
+        request: { timeout: 2, open_timeout: 8 },
+        headers: { user_agent: "Solrb v#{Solr::VERSION}" }
+      }
+      @cores = {}
+    end
+
+    def url=(value)
+      if value.nil?
+        raise ArgumentError, "Solr's URL can't be nil"
+      else
+        @url = value
+      end
+    end
+
+    def core_config_by_name(core)
+      cores[core.to_sym] || build_env_url_core_config(name: core)
+    end
+
+    def default_core_config
+      defined_default_core_config = cores.values.detect(&:default?)
+      return defined_default_core_config if defined_default_core_config
+      raise Errors::AmbiguousCoreError if cores.count > 1
+      cores.values.first || build_env_url_core_config
+    end
+
+    def define_core(name: nil, default: false)
+      validate_default_core_config!(default: default)
+      builder = Solr::CoreConfiguration::CoreConfigBuilder.new(
+        name: name,
+        default: default
+      )
+      yield builder
+      core = builder.build
+      if cores.has_key?(core.name)
+        raise "A core with name '#{core.name}' has been already defined"
+      else
+        cores[core.name] = core
+      end
+    end
+
+    def build_env_url_core_config(name: nil)
+      Solr::CoreConfiguration::EnvUrlCoreConfig.new(name: name)
+    end
+
+    def validate_default_core_config!(default:)
+      return unless default
+      if cores.any? { |name, core_config| core_config.default? }
+        raise ArgumentError, 'Only one default core can be specified'
+      end
+    end
+  end
+end

data/lib/solr/connection.rb

@@ -0,0 +1,33 @@
+module Solr
+  # low-level connection that can do network requests to Solr
+  class Connection
+    INSTRUMENT_KEY = 'solrb.request'.freeze
+
+    def initialize(url, faraday_options: Solr.configuration.faraday_options)
+      # Allow mock the connection for testing
+      @raw_connection = Solr.configuration.test_connection || Faraday.new(url, faraday_options)
+      freeze
+    end
+
+    def get 
+      Solr.instrument(name: INSTRUMENT_KEY) { @raw_connection.get }
+    end
+
+    def post(data = {})
+      Solr.instrument(name: INSTRUMENT_KEY) do 
+        @raw_connection.post do |req|
+          req.body = data
+        end
+      end
+    end
+
+    def post_as_json(data)
+      Solr.instrument(name: INSTRUMENT_KEY, data: data) do
+        @raw_connection.post do |req|
+          req.headers['Content-Type'] = 'application/json'.freeze
+          req.body = JSON.generate(data)
+        end
+      end
+    end
+  end
+end