rika 1.6.0-java → 2.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 077d41fc4797ad2074f4acdd6df554cb7221ef01
-  data.tar.gz: 7f1a591fe8bad0e68ca8173e1d8d7690b16341db
+SHA256:
+  metadata.gz: 70dc9cbc6d2da17d3bcff5cdeb3a905fdbcf2e2b9d24c131558566cbfc19eada
+  data.tar.gz: fb81f98476322d2291488b2bd2cb9c89a1544b4ee1f85ce22ab773c30ac4765c
 SHA512:
-  metadata.gz: 07346daa2e40986329f5b19e85d12e02b9a6cb802249d9a303aa86022e6b7515f309c3b411338bfe1d82e5bb27e2c4e5de0a6cdb18221e80b8c414c5bb5deaa2
-  data.tar.gz: c26125c52c0c0411aa8c5dff2f7f0f81e28d0d63f4b241ca6ef47d5ea841c50576c5c40ce47a072c31ec7f16a6312510ab194c6f47499847b323f4bd80c29c68
+  metadata.gz: 780650b18df09662b8b67e7321641c2cf36d78335c5cf1f59f5d81a23cf262dc478958ad7aab306f80deb235e9c9910332086b3ea5231888ea96c26abd2d2505
+  data.tar.gz: afa841ebfe9ebb1bee5ccb0550fedde43edab6e1d6b86eed671537604d64b318c0abc7e41ffee054443f6bfd4a7b3c9423926e137fba4fdd95da66775e35d695

data/.gitignore

@@ -1,7 +1,10 @@
 *.gem
 *.rbc
+.DS_Store
 .bundle
 .config
+coverage/
+.idea/
 .yardoc
 Gemfile.lock
 InstalledFiles
@@ -10,12 +13,11 @@ coverage
 doc/
 lib/bundler/man
 pkg
+projectFilesBackup/
 rdoc
 spec/reports
+spec/rspec-failed-tests-control-file.txt
+target/
 test/tmp
 test/version_tmp
 tmp
-
-.DS_Store
-projectFilesBackup/
-.idea/

data/.rubocop.yml

@@ -0,0 +1,49 @@
+require: rubocop-rspec
+AllCops:
+  NewCops: enable
+  Include:
+    - '**/*.rb'
+    - '*.gemspec'
+    - '**/Rakefile'
+    - '**/Gemfile'
+    - 'bin/rika'
+Gemspec/RequiredRubyVersion:
+  Enabled: false
+Layout/HashAlignment:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/BlockLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+RSpec/ExampleLength:
+  Enabled: false
+RSpec/ExpectOutput:
+  Enabled: false
+RSpec/InstanceVariable:
+  Enabled: false
+RSpec/MultipleExpectations:
+  Enabled: false
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
+Style/AccessModifierDeclarations:
+  Enabled: false
+Style/FetchEnvVar:
+  Enabled: false
+Style/GuardClause:
+  Enabled: false
+Style/IfUnlessModifier:
+  Enabled: false
+Style/Lambda:
+  Enabled: false
+Style/LambdaCall:
+  Enabled: false
+Style/NumericLiterals:
+  Enabled: false
+Style/PercentLiteralDelimiters:
+  Enabled: false
+Style/StderrPuts:
+  Enabled: false
+Style/TrailingUnderscoreVariable:
+  Enabled: false

data/Gemfile

@@ -1,4 +1,16 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rika.gemspec
 gemspec
+
+group :development do
+  gem 'pry'
+  gem 'rake', '~> 13.0'
+  gem 'rspec', '~> 3.9'
+  gem 'rubocop'
+  gem 'rubocop-rspec'
+  gem 'simplecov', require: false
+  gem 'webrick', '~> 1.6'
+end

data/README.md

@@ -1,83 +1,262 @@
 # Rika
 
-A JRuby wrapper for Apache Tika to extract text and metadata from various file formats.
+[Rika](https://github.com/keithrbennett/rika) is a [JRuby](https://www.jruby.org) wrapper for
+the [Apache Tika](http://tika.apache.org/) Java library, which extracts text and metadata from files and resources
+of [many different formats](https://tika.apache.org/1.24.1/formats.html).
 
-More information about Apache Tika can be found here: http://tika.apache.org/
+Rika can be used as a library in your Ruby code, or on the command line.
 
-[![Code Climate](https://codeclimate.com/github/ricn/rika.png)](https://codeclimate.com/github/ricn/rika)
-[![Build Status](https://travis-ci.org/ricn/rika.png?branch=master)](https://travis-ci.org/ricn/rika)
+For class and method level documentation, please use [YARD](https://rubydoc.info/gems/yard).
+You can `gem install yard`, then run `yard doc` from the project root, 
+and then open the `doc/index.html` file in a browser.
 
-## Installation
 
-Add this line to your application's Gemfile:
+### Requirements
+
+* This gem only works with [JRuby](https://www.jruby.org).
+* The [Apache Tika](http://tika.apache.org/) jar file must be installed on your system.
+  See the [Installation](#installation) section below for more information.
+
+Rika currently supports some basic and commonly used functions of Tika.
+Since it runs on JRuby, the Tika library's Java methods can be called directly from Ruby code
+for more advanced needs.
+See the [Other Tika Resources](#other-tika-resources) section of this document for alternatives to
+Rika that may suit more demanding needs.
 
-    gem 'rika'
+Rika can be used either as a gem in your own Ruby project, or on the command line using the provided executable.
 
-Remember that this gem only works on JRuby.
+## Usage in Your Ruby Code
 
-And then execute:
+> [!IMPORTANT]  
+> **It is necessary to call `Rika.init` before using Rika.**  This is because the loading of the Tika library
+has been put in an init method, rather than at load time, so that 'jar file not found or specified' errors 
+do not prevent your application from loading. If you forget to call `Rika.init`, you may see seemingly unrelated
+error messages.
 
-    $ bundle
+As a convenience, the `Rika.init` method is called automatically when you call the Rika module methods. However,
+if you access other Rika classes and methods, `init` may not have been called yet, so you should call it yourself.
 
-Or install it yourself as:
+----
 
-    $ gem install rika
+The Rika `parse` method returns a `Rika::ParseResult` object that contains the parsed text and
+various pieces of metadata.  The `ParseResult` class' main methods are:
 
-## Usage
+* `content` - the parsed text
+* `metadata` - a hash of metadata key/value pairs
+* `content_type` - the content type of the parsed data, e.g. "text/plain; charset=UTF-8"
+* `language` - the language of the parsed data, e.g. "en"
+* `data_source` - the data source, either a filespec or a URL
 
-For a quick start with the simplest use cases, the following functions
-are provided to get what you need in a single function call, for your convenience:
+For example:
 
 ```ruby
 require 'rika'
 
-content           = Rika.parse_content('document.pdf')    # string containing all content text
-metadata          = Rika.parse_metadata('document.pdf')   # hash containing the document metadata
-content, metadata = Rika.parse_content_and_metadata('document.pdf')   # both of the above
+parse_result = Rika.parse('x.pdf') # returns a Rika::ParseResult object
+parse_result.content               # string containing all content text
+parse_result.text                  # 'text' is an alias for 'content'
+parse_result.metadata              # hash containing the document metadata
+parse_result.content_type          # e.g. "application/pdf"
+parse_result.language              # e.g. "en"
+parse_result.data_source           # e.g. "x.pdf"
 ```
 
-For other use cases and finer control, you can work directly with the Rika::Parser object:
+A URL can be used instead of a filespec wherever a data source is specified:
 
 ```ruby
-require 'rika'
+parse_result = Rika.parse('https://github.com/keithrbennett/rika')
+```
+
+The Rika module also has the following methods:
+
+```ruby
+Rika.language("magnifique") # => "fr"
+Rika.tika_version           # => "2.9.0"
+```
+
+## Command Line Executable Usage
+  
+Rika can also be used on the command line using the `rika` executable.  For example, the simplest form is to simply
+specify one or more filespecs or URL's as arguments:
+
+```bash
+rika x.pdf https://github.com/keithrbennett/rika
+```
+Here is the help text:
+
+```
+Rika v2.0.0 (Tika v2.9.0) - https://github.com/keithrbennett/rika
+
+Usage: rika [options] <file or url> [...file or url...]
+Output formats are: [a]wesome_print, [t]o_s, [i]nspect, [j]son), [J] for pretty json, and [y]aml.
+If a format contains two letters, the first will be used for metadata, the second for text.
+Values for the text, metadata, and as_array boolean options may be specified as follows:
+  Enable:  +, true,  yes, [empty]
+  Disable: -, false, no, [long form option with no- prefix, e.g. --no-metadata]
+
+    -f, --format FORMAT              Output format (default: at)
+    -m, --[no-]metadata [FLAG]       Output metadata (default: true)
+    -t, --[no-]text [FLAG]           Output text (default: true)
+    -k, --[no-]key-sort [FLAG]       Sort metadata keys case insensitively (default: true)
+    -s, --[no-]source [FLAG]         Document source file or URL
+    -a, --[no-]as-array [FLAG]       Output all parsed results as an array (default: false)
+    -v, --version                    Output version
+    -h, --help                       Output help
+```    
+
+### Outputting Only Metadata or Only Parsed Text
+
+The default setting is to output both metadata and text. To disable either, use the `-m` or `-t` options 
+with a disabling flag, e.g. `-m-`, `-m false`, `-m no`, or `--no-metadata` to disable metadata.
+
+### Outputting the Document Source Identifier (Filespec or URL)
+
+There are many times when it is useful to know the source of the document.  For example, if you are processing
+a large number of documents, you may want to know which document a particular piece of output came from.
+
+The document source identifier is output by default.  To disable it, use the `-s` option with a disabling flag, e.g. `-s-`,
+`-s false`, `-s no`, or `--no-source`.
+
+### Output Formats
 
-parser = Rika::Parser.new('document.pdf')
+The `-f` option can be used to specify the output format.  The default is `at`, which means that the metadata will be
+output in awesome_print format, and the text will be output using `to_s` 
+(i.e. without any changes to the parsed string).
 
-# Return the content of the document:
-parser.content 
+If a single argument to `-f` is specified, it will be used for both metadata and text.  If two arguments are specified,
+the first will be used for metadata and the second for the parsed text.
 
-# Return the media type for the document:
-parser.media_type 
-=> "application/pdf"
+### Sorting of Metadata Keys
 
-# Return the metadata field title if it exists:
-parser.metadata["title"] if parser.metadata_exists?("title") 
+By default, metadata keys will be sorted case insensitively.  To disable this, use the `-k` option 
+with a disabling flag, i.e. `-k-`, `-k false`, `-k no`, or `--no-key-sort`.
 
-# Return all the available metadata keys that can be read from the document
-parser.available_metadata
+The case insensitivity is implemented by using `String#downcase`.
+This may not sort correctly on some non-English systems.
 
-# Return only the first 10000 chars of the content:
-parser = Rika::Parser.new('document.pdf', 10000)
-parser.content # 10000 first chars returned
+### Specifying Command Line Options in the RIKA_OPTIONS Environment Variable
 
-# Return content from URL
-parser = Rika::Parser.new('http://riakhandbook.com/sample.pdf', 200)
-parser.content
+If you find yourself using the same options over and over again, you can put them in the `RIKA_OPTIONS` environment 
+variable. For example, if the default behavior of sorting keys does not work for your language, you can disable it
+for all invocations of the `rika` command by specifying `-k-` in the RIKA_OPTIONS environment variable.
 
-# Return the language for the content
-parser = parser = Rika::Parser.new('german document.pdf')
-parser.language
-=> "de"
+### Machine Readable Data Support
 
-# Check whether the langugage identification is certain enough to be trusted
-parser.language_is_reasonably_certain?
-	
+If both metadata and text are output, and the same output format is used for both, and that format is JSON
+(plain or "pretty") or YAML, then the output per document will be a single JSON or YAML hash representation
+containing both the metadata and the text (whose keys are "metadata" and "text"). This enables piping
+the results of multiple documents to a file or to another program that can use it as a data source. 
+In addition, when processing multiple files, this streaming approach will be more efficient 
+than calling Rika separately for each file, since each invocation of the rika command requires starting up
+a Java Virtual Machine.
+
+If the `-a` (`--as-array`) option is specified, then the output will be an array of such hashes, one for each file.
+This enables the output to be used as a data source for programs that can process an array of hashes, e.g. for analysis.
+
+For example, here is an example of how to use Rika and [rexe](https://github.com/keithrbennett/rexe]) to get a tally 
+of content types for a set of documents, sorted by content type:
+
+```bash
+$ rika -t- -s- -fy -a spec/fixtures/* | \
+  rexe -iy -oa -mb "map { |r| r['metadata']['Content-Type'] }.tally.sort.to_h"
+{
+                                                         "application/msword" => 1,
+                                                   "application/octet-stream" => 1,
+                                                            "application/pdf" => 1,
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document" => 1,
+                                                                 "image/jpeg" => 2,
+                                             "text/plain; charset=ISO-8859-1" => 1,
+                                                  "text/plain; charset=UTF-8" => 6,
+                                          "text/x-matlab; charset=ISO-8859-1" => 1
+}
 ```
+Here is a breakdown of the above command:
+
+* `rika`
+  * `-t-` suppresses the output of text
+  * `-s-` suppresses the output of the source identifier
+  * `-fy` outputs the data in YAML format.
+  * `-a` option causes the output to be an array of hashes, one for each file
+* `rexe` 
+  * `-iy` indicates that the input is YAML
+  * `-oa` indicates that the output should be done using awesome_print/amazing_print
+  * `-mb` indicates that all input should be ingested as a single string ("b" for "big string", as opposed to streamed)
+
+* Ruby code passed to `rexe`
+  * `map` is called on the array to extract the content type from each parsed document hash
+  * `tally` is called on the resulting array to get the count of each content type
+  * `sort` is called on the hash to sort it by key (content type) and return an array of 2-element arrays
+  * `to_h` is called on the array of 2-element arrays to convert it back to a hash
+  
+Here is another example that prints out the 5 most common words in all the parsed text, and their counts,
+as "pretty" JSON:
+
+```bash
+$ rika -m- spec/fixtures/* | \
+rexe -in -oJ -mb 'downcase \
+  .split \
+  .tally \
+  .sort_by { |word, count| [-count, word] }
+  .first(5) \
+  .to_h'
+
+{
+  "the": 35,
+  "to": 30,
+  "woods": 25,
+  "i": 25,
+  "and": 25
+}
+```
+
+## Installation
+
+* Install [JRuby](https://www.jruby.org) if you don't already have it. Ruby version managers such as
+[rvm](https://rvm.io/) and [rbenv](https://github.com/rbenv) can simplify this process.
+* Download the [Apache Tika](http://tika.apache.org/) jar file from
+  http://tika.apache.org/download.html (look for the "tika-app" jar file).
+  Put it in a place that makes sense for your system, such as `/usr/local/lib`.
+* Configure the `TIKA_JAR_FILESPEC` environment variable to point to the Tika jar file.
+  For example, if you are using tika-app-2.9.0.jar, and put the jar file in `/opt/jars',
+  then the setting of the environment variable should look like this:
+
+  ```bash
+  export TIKA_JAR_FILESPEC=/opt/jars/tika-app-2.9.0.jar
+  ```
+
+  You can put this in your `.bashrc` or `.zshrc` file to make it persistent.
+
+* Install the gem:
+
+  ```bash
+  gem install rika
+  ```
+
+  or, if you're using [bundler](https://bundler.io/), add this to your Gemfile:
+
+  ```ruby
+  gem 'rika'
+  ```
+
+  and then run `bundle install`.
+* Verify that it works by running (as an example) `rika -m https://www.github.com`.
+  You should see key/value pairs representing the metadata of the Github home page.
+
+This gem has been tested with JRuby managed by rvm.  It should work with other Ruby version managers and
+without any version manager at all, but those configurations have not been tested.
+
+## Other Tika Resources
+
+* The Apache Tika wiki is at https://cwiki.apache.org/confluence/display/tika.
+
+* Tika also provides another jar file containing a RESTful server that you can run on the command line.
+  You can download this server jar from http://tika.apache.org/download.html (look for the "tika-server-standard" jar
+  file).
+  See the "Running the Tika Server as a Jar file" section of https://cwiki.apache.org/confluence/display/TIKA/TikaServer
+  for more information.
 
-## Credits
-The following people have contributed ideas, documentation, or code to Rika:
-* Keith Bennett
-* Richard Nyström
+* @chrismattman and others have provided a ["tika_python" Python library and CLI](https://github.com/chrismattmann/tika-python)
+  that interfaces with the Tika server.
 
 ## Contributing
 

data/RELEASE_NOTES.md

@@ -0,0 +1,43 @@
+## Release Notes
+
+#### v2.0.0
+
+* Add features:
+  * command line interface
+  * support for JSON, Pretty JSON, YAML, AwesomePrint, to_s, and inspect output formats
+  * optional array mode (previously only nonarray streaming mode).
+  * more persistent options can be specified in an environment variable, `RIKA_OPTIONS`.
+  * metadata keys can optionally be sorted alphabetically (not all languages though).
+  * properties added by Rika to the metadata: data-source, language
+  * Filespec or URL data source identifier can optionally be output with metadata and text.
+* Add support for Tika 2.8.0, breaks compatibility with Tika 1.x.
+* Remove tika-app-1.24.1.jar from code base and gem (but it is still in git history).
+* Tika jar file is now downloaded by the user and found via environment variable `TIKA_JAR_FILESPEC`.
+* New class ParseResult created to simplify result access and Parser class.
+* Add `Rika.tika_version`.
+* Add `webrick` dependency, needed for current versions of Ruby.
+* Remove deprecated methods `Parser#available_metadata` and `Parser#metadata_exists?`.
+* Move `Parser#language` to `Rika.language`.
+* Remove `Parser#language_is_reasonably_certain?`, no longer supported by Tika.
+* Remove obsolete `LanguageIdentifier` import. Otherwise updated language detection.
+* Various refactorings and improvements.
+* Add SimpleCov test coverage and Rubocop linting tools to project.
+* Set up RSpec configuration to enable --only-failures and --next-failure options.
+
+
+
+#### v1.11.1
+
+* Add Apache-2.0 license to gemspec.
+
+
+#### v1.11.0
+
+* Replace 2015 Tika jar files w/2020 tika-app-1.24.1.jar.
+* Handover of maintainer status from @ricn to @keithrbennett.
+* Add rika_helper.rb to provide abbreviated method names for interactive use w/pry, etc.
+* Extract parser class to its own file.
+* Various cleanup and refactoring.
+* Improve README.md documentation.
+* Tested successfully on Java 14.
+* Move Tika jar file from /target/dependency to /java-lib.

data/Rakefile

@@ -1,11 +1,8 @@
-require "bundler/gem_tasks"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
-
-desc 'Download jars'
-task :download_jars do
-	system "mvn dependency:copy-dependencies"
-end
+task default: :spec

data/bin/rika

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rika/cli/rika_command'
+
+begin
+  Rika.init
+rescue Rika::TikaLoadError => e
+  $stderr.puts e.message
+  exit 1
+end
+
+RikaCommand.new.call

data/lib/rika/cli/args_parser.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# Processes the array of arguments (ARGV by default) and returns the options, targets, and help string.
+class ArgsParser
+  attr_reader :args, :options, :option_parser
+  private     :args, :options, :option_parser
+
+  DEFAULT_OPTIONS =
+    {
+      as_array: false,
+      format: 'at', # AwesomePrint for metadata, to_s for text content
+      metadata: true,
+      text: true,
+      source: true,
+      key_sort: true
+    }.freeze
+
+  # Parses the command line arguments.
+  # Shorthand for ArgsParser.new.call. This call is recommended to pro tect the caller in case
+  # this functionality is repackaged as a Module or otherwise modified.
+  # @param [Array] args the command line arguments (overridable for testing, etc.)
+  # @return [Array<Hash,String>] [options, targets, help_string],
+  #   or exits if help or version requested or no targets specified.
+  def self.call(args = ARGV)
+    new.call(args)
+  end
+
+  # Parses the command line arguments.
+  # @param [Array] args the command line arguments (overridable for testing, etc.)
+  # @return [Array<Hash,String>] [options, targets, help_string],
+  #   or exits if help or version requested or no targets specified.
+  def call(args = ARGV)
+    @args = args
+    @options = DEFAULT_OPTIONS.dup
+    prepend_environment_args
+    @option_parser = create_option_parser
+    option_parser.parse!(args)
+    postprocess_format_options
+    targets = create_target_array
+    [options, targets, option_parser.help]
+  end
+
+  # @return [OptionParser]
+  private def create_option_parser
+    OptionParser.new do |opts|
+      opts.banner =  <<~BANNER
+        Rika v#{Rika::VERSION} (Tika v#{Rika.tika_version}) - #{Rika::PROJECT_URL}
+
+        Usage: rika [options] <file or url> [...file or url...]
+        Output formats are: [a]wesome_print, [t]o_s, [i]nspect, [j]son), [J] for pretty json, and [y]aml.
+        If a format contains two letters, the first will be used for metadata, the second for text.
+        Values for the text, metadata, and as_array boolean options may be specified as follows:
+          Enable:  +, true,  yes, [empty]
+          Disable: -, false, no, [long form option with no- prefix, e.g. --no-metadata]
+
+      BANNER
+
+      format_message = 'Output format (default: at)'
+      opts.on('-f', '--format FORMAT', format_message) do |format|
+        options[:format] = format
+      end
+
+      opts.on('-m', '--[no-]metadata [FLAG]', TrueClass, 'Output metadata (default: true)') do |v|
+        options[:metadata] = (v.nil? ? true : v)
+      end
+
+      opts.on('-t', '--[no-]text [FLAG]', TrueClass, 'Output text (default: true)') do |v|
+        options[:text] = (v.nil? ? true : v)
+      end
+
+      opts.on('-k', '--[no-]key-sort [FLAG]', TrueClass, 'Sort metadata keys case insensitively (default: true)') do |v|
+        options[:key_sort] = (v.nil? ? true : v)
+      end
+
+      opts.on('-s', '--[no-]source [FLAG]', TrueClass, 'Document source file or URL') do |v|
+        options[:source] = (v.nil? ? true : v)
+      end
+
+      opts.on('-a', '--[no-]as-array [FLAG]', TrueClass,
+              'Output all parsed results as an array (default: false)') do |v|
+        options[:as_array] = (v.nil? ? true : v)
+      end
+
+      opts.on('-v', '--version', 'Output version') do
+        puts versions_string
+        exit
+      end
+
+      opts.on('-h', '--help', 'Output help') do
+        puts opts
+        exit
+      end
+    end
+  end
+
+  # @return [Array] the targets specified on the command line, possibly expanded by the shell,
+  #   and with any directories removed.
+  private def create_target_array
+    targets = args.dup.reject { |arg| File.directory?(arg) }.freeze # reject dirs to handle **/* globbing
+    targets.map(&:freeze)
+  end
+
+  # Fills in the second format option character if absent, and removes any excess characters
+  # @return [String] format options 2-character value, e.g. 'at'
+  private def postprocess_format_options
+    # If only one format letter is specified, use it for both metadata and text.
+    options[:format] *= 2 if options[:format].length == 1
+
+    # Ignore and remove extra characters after the first two format characters.
+    options[:format] = options[:format][0..1]
+  end
+
+  # If the user wants to specify options in an environment variable ("RIKA_OPTIONS"),
+  # then this method will insert those options at the beginning of the `args` array,
+  # where they can be overridden by command line arguments.
+  private def prepend_environment_args
+    env_opt_string = environment_options
+    args_to_prepend = Shellwords.shellsplit(env_opt_string)
+    args.unshift(args_to_prepend).flatten!
+  end
+
+  # @return [String] the value of the RIKA_OPTIONS environment variable if present, else ''.
+  private def environment_options
+    ENV['RIKA_OPTIONS'] || ''
+  end
+
+  # @return [String] string containing versions of Rika and Tika, with labels
+  private def versions_string
+    "Versions: Rika: #{Rika::VERSION}, Tika: #{Rika.tika_version}"
+  end
+end