elasticsearch-git 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6dfec96f6e2fbded64a0429c7b083aadf96234b
-  data.tar.gz: 8eb678cf43ecbb8aeabc1016e00f3b721010f269
+  metadata.gz: d48d7fd7bd1dc6d71ce6c24024a746cb75d0b60e
+  data.tar.gz: e4297f9c88cecef626495998bbb3838ee8829f61
 SHA512:
-  metadata.gz: b88db3a9d3647bcd9c3eae1039e7b2380e51fcbf4b02b242e2bda5acc2cff8c58b8d2a1ad2941fedb586f3cfd318f9c9b386fa9bcdfeaeabdaef616c3c891f38
-  data.tar.gz: 5b2fa5f90008f048b33627724847ca317e36e766fdbc4e9e185e8ba26c7edc16a4d3981a5e6577c4943cfad45fe3825694728ca9eef8a3927414ef8466f9ca55
+  metadata.gz: 0260393250e6bb3fdb4a757b363b5b48d5bd3851bbb923b53170ca88a8b40b7f6c7319a4f0ff6c4b14e4fa8ede81c70b3b6eb343617c624f8a9e961e366d039e
+  data.tar.gz: be0c4572531338cd2cfa595ce523b9bd16d65bc4139942319862f77fb00215bd85c63bdda4261f6da2b0142a373b7fb862a8f9426f47cff7a5b91481f29670ce

data/README.md

@@ -316,6 +316,10 @@ Project.last.repository.as_indexed_json
     :message=>"first commit\n"}]}
 ```
 
+## TODO
+
+    * Add Exceptions handlers for indexing (Error connections and timeouts)
+
 ## Contributing
 
 1. Fork it ( http://github.com/[my-github-username]/elasticsearch-git/fork )

data/elasticsearch-git.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Andrey Kumanyaev"]
   spec.email         = ["me@zzet.org"]
   spec.summary       = %q{Elasticsearch integrations for git repositories.}
-  spec.description   = %q{Elasticsearch integrations for git repositories.}
+  spec.description   = %q{Elasticsearch integrations for indexing git repositories.}
   spec.homepage      = "https://github.com/zzet/elasticsearch-git"
   spec.license       = "MIT"
 
@@ -19,10 +19,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency 'elasticsearch-model'
-  spec.add_runtime_dependency 'elasticsearch-api'
-  spec.add_runtime_dependency 'rugged'
-  spec.add_runtime_dependency 'charlock_holmes'
-  spec.add_runtime_dependency 'gitlab-linguist'
-  spec.add_runtime_dependency 'activemodel'
-  spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'elasticsearch-api', '> 0.4.0'
+  spec.add_runtime_dependency 'rugged', '~> 0.19.0'
+  spec.add_runtime_dependency 'charlock_holmes', '~> 0.6.9'
+  spec.add_runtime_dependency 'gitlab-linguist', '> 2.9.0'
+  spec.add_runtime_dependency 'activemodel', '~> 4.0.0'
+  spec.add_runtime_dependency 'activesupport', '~> 4.0.0'
 end

data/lib/elasticsearch/git/encoder_helper.rb

@@ -0,0 +1,43 @@
+require 'active_support/concern'
+require 'charlock_holmes'
+
+module Elasticsearch
+  module Git
+    module EncoderHelper
+      extend ActiveSupport::Concern
+
+      included do
+        def encode!(message)
+          return nil unless message.respond_to? :force_encoding
+
+          # if message is utf-8 encoding, just return it
+          message.force_encoding("UTF-8")
+          return message if message.valid_encoding?
+
+          # return message if message type is binary
+          detect = CharlockHolmes::EncodingDetector.detect(message)
+          return message.force_encoding("BINARY") if detect && detect[:type] == :binary
+
+          # encoding message to detect encoding
+          if detect && detect[:encoding]
+            message.force_encoding(detect[:encoding])
+          end
+
+          # encode and clean the bad chars
+          message.replace clean(message)
+        rescue
+          encoding = detect ? detect[:encoding] : "unknown"
+          "--broken encoding: #{encoding}"
+        end
+
+        private
+
+        def clean(message)
+          message.encode("UTF-16BE", undef: :replace, invalid: :replace, replace: "")
+          .encode("UTF-8")
+          .gsub("\0".encode("UTF-8"), "")
+        end
+      end
+    end
+  end
+end

data/lib/elasticsearch/git/lite_blob.rb

@@ -0,0 +1,25 @@
+require 'linguist'
+require 'elasticsearch/git/encoder_helper'
+
+module Elasticsearch
+  module Git
+    class LiteBlob
+      include Linguist::BlobHelper
+      include Elasticsearch::Git::EncoderHelper
+
+      attr_accessor :id, :name, :path, :data, :size, :mode, :commit_id
+
+      def initialize(repo, raw_blob_hash)
+        @id   = raw_blob_hash[:oid]
+
+        blob  = repo.lookup(@id)
+
+        @mode = '%06o' % raw_blob_hash[:filemode]
+        @size = blob.size
+        @path = encode!(raw_blob_hash[:path])
+        @name = @path.split('/').last
+        @data = encode!(blob.content)
+      end
+    end
+  end
+end

data/lib/elasticsearch/git/model.rb

@@ -42,7 +42,7 @@ module Elasticsearch
             },
             tokenizer: {
               sha_tokenizer: {
-                type: "NGram",
+                type: "edgeNGram",
                 min_gram: 8,
                 max_gram: 40,
                 token_chars: %w(letter digit)
@@ -61,7 +61,7 @@ module Elasticsearch
                 max_gram: 20
               },
               sha_ngrams: {
-                type: "NGram",
+                type: "edgeNGram",
                 min_gram: 8,
                 max_gram: 40
               }

data/lib/elasticsearch/git/repository.rb

@@ -1,9 +1,10 @@
 require 'active_support/concern'
 require 'active_model'
 require 'elasticsearch'
-require 'elasticsearch/model'
+require 'elasticsearch/git/model'
+require 'elasticsearch/git/encoder_helper'
+require 'elasticsearch/git/lite_blob'
 require 'rugged'
-require 'linguist'
 
 module Elasticsearch
   module Git
@@ -12,30 +13,37 @@ module Elasticsearch
 
       included do
         include Elasticsearch::Git::Model
+        include Elasticsearch::Git::EncoderHelper
 
-        mapping do
+        mapping _timestamp: { enabled: true } do
           indexes :blob do
             indexes :id,          type: :string, index_options: 'offsets', search_analyzer: :human_analyzer,  index_analyzer: :human_analyzer
             indexes :rid,         type: :string, index: :not_analyzed
-            indexes :oid,         type: :string, index_options: 'offsets', search_analyzer: :sha_analyzer,    index_analyzer: :sha_analyzer
-            indexes :commit_sha,  type: :string, index_options: 'offsets', search_analyzer: :sha_analyzer,    index_analyzer: :sha_analyzer
-            indexes :content,     type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,   index_analyzer: :human_analyzer
+            indexes :oid,         type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,   index_analyzer: :code_analyzer
+            indexes :commit_sha,  type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,   index_analyzer: :code_analyzer
+            indexes :path,        type: :string, index_options: 'offsets', search_analyzer: :human_analyzer,  index_analyzer: :human_analyzer
+            indexes :content,     type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,   index_analyzer: :code_analyzer
+            indexes :language,    type: :string, index: :not_analyzed
           end
+
           indexes :commit do
             indexes :id,          type: :string, index_options: 'offsets', search_analyzer: :human_analyzer,  index_analyzer: :human_analyzer
             indexes :rid,         type: :string, index: :not_analyzed
-            indexes :sha,         type: :string, index_options: 'offsets', search_analyzer: :sha_analyzer,    index_analyzer: :sha_analyzer
+            indexes :sha,         type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :code_analyzer
+
             indexes :author do
-              indexes :name,      type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :human_analyzer
-              indexes :email,     type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :human_analyzer
+              indexes :name,      type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :code_analyzer
+              indexes :email,     type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :code_analyzer
               indexes :time,      type: :date
             end
+
             indexes :commiter do
-              indexes :name,      type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :human_analyzer
-              indexes :email,     type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :human_analyzer
+              indexes :name,      type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :code_analyzer
+              indexes :email,     type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :code_analyzer
               indexes :time,      type: :date
             end
-            indexes :message,    type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,     index_analyzer: :human_analyzer
+
+            indexes :message,     type: :string, index_options: 'offsets', search_analyzer: :code_analyzer,    index_analyzer: :code_analyzer
           end
         end
 
@@ -79,7 +87,8 @@ module Elasticsearch
             end
 
             diff = repository_for_indexing.diff(from_rev, to_rev)
-            diff.deltas.reverse.each do |delta|
+
+            diff.deltas.reverse.each_with_index do |delta, step|
               if delta.status == :deleted
                 b = LiteBlob.new(repository_for_indexing, delta.old_file)
                 delete_from_index_blob(b)
@@ -87,14 +96,20 @@ module Elasticsearch
                 b = LiteBlob.new(repository_for_indexing, delta.new_file)
                 index_blob(b, target_sha)
               end
+
+              # Run GC every 100 blobs
+              ObjectSpace.garbage_collect if step % 100 == 0
             end
           else
             if repository_for_indexing.bare?
               recurse_blobs_index(repository_for_indexing.lookup(target_sha).tree, target_sha)
             else
-              repository_for_indexing.index.each do |blob|
+              repository_for_indexing.index.each_with_index do |blob, step|
                 b = LiteBlob.new(repository_for_indexing, blob)
                 index_blob(b, target_sha)
+
+                # Run GC every 100 blobs
+                ObjectSpace.garbage_collect if step % 100 == 0
               end
             end
           end
@@ -108,29 +123,51 @@ module Elasticsearch
             index_blob(b, target_sha)
           end
 
+          # Run GC every recurse step
+          ObjectSpace.garbage_collect
+
           tree.each_tree do |nested_tree|
             recurse_blobs_index(repository_for_indexing.lookup(nested_tree[:oid]), target_sha, "#{path}#{nested_tree[:name]}/")
           end
         end
 
         def index_blob(blob, target_sha)
-          if blob.text?
-            client_for_indexing.index \
-              index: "#{self.class.index_name}",
-              type: "repository",
-              id: "#{repository_id}_#{blob.path}",
-              body: {
-                blob: {
-                  type: "blob",
-                  oid: blob.id,
-                  rid: repository_id,
-                  content: blob.data,
-                  commit_sha: target_sha
+          if can_index_blob?(blob)
+            tries = 0
+            begin
+              client_for_indexing.index \
+                index: "#{self.class.index_name}",
+                type: "repository",
+                id: "#{repository_id}_#{blob.path}",
+                body: {
+                  blob: {
+                    type: "blob",
+                    oid: blob.id,
+                    rid: repository_id,
+                    content: blob.data,
+                    commit_sha: target_sha,
+                    path: blob.path,
+                    language: blob.language ? blob.language.name : "Text"
+                  }
                 }
-              }
+            rescue Exception => ex
+              # Retry 10 times send request
+              if tries < 10
+                tries += 1
+                sleep tries * 10 * rand(10)
+                retry
+              else
+                logger.warn "Can't index #{repository_id}_#{blob.path}. Reason: #{ex.message}"
+              end
+            end
           end
         end
 
+        # Index text-like files which size less 1.mb
+        def can_index_blob?(blob)
+          blob.text? && (blob.size && blob.size.to_i < 1048576)
+        end
+
         def delete_from_index_blob(blob)
           if blob.text?
             begin
@@ -140,6 +177,8 @@ module Elasticsearch
                 id: "#{repository_id}_#{blob.path}"
             rescue Elasticsearch::Transport::Transport::Errors::NotFound
               return true
+            rescue Exception => ex
+              logger.warn "Error with remove file from index #{repository_id}_#{blob.path}. Reason: #{ex.message}"
             end
           end
         end
@@ -167,52 +206,74 @@ module Elasticsearch
         #
         # For search from commits use type 'commit'
         def index_commits(from_rev: nil, to_rev: nil)
-          if to_rev.present?
+          to_rev = repository_for_indexing.head.target unless to_rev.present?
+
+          if to_rev != "0000000000000000000000000000000000000000"
+            # If to_rev correct
+            begin
+              raise unless repository_for_indexing.lookup(to_rev).type == :commit
+            rescue
+              raise ArgumentError, "'to_rev': '#{to_rev}' is a incorrect commit sha."
+            end
+
             begin
               if from_rev.present? && from_rev != "0000000000000000000000000000000000000000"
                 raise unless repository_for_indexing.lookup(from_rev).type == :commit
               end
-              if to_rev != "0000000000000000000000000000000000000000"
-                raise unless repository_for_indexing.lookup(to_rev).type == :commit
-              end
             rescue
               raise ArgumentError, "'from_rev': '#{from_rev}' is a incorrect commit sha."
             end
 
-            walker = if from_rev == "0000000000000000000000000000000000000000" || from_rev.nil?
-                       repository_for_indexing.walk(to_rev)
-                     else
-                       repository_for_indexing.walk(from_rev, to_rev)
-                     end
+            # If pushed new branch no need reindex all repository
+            # Find merge_base and reindex diff
+            if from_rev == "0000000000000000000000000000000000000000" && to_rev != repository_for_indexing.head.target
+              from_rev = repository_for_indexing.merge_base(to_rev, repository_for_indexing.head.target)
+            end
 
-            walker.each do |commit|
-              index_commit(commit)
+            walker = Rugged::Walker.new(repository_for_indexing)
+            walker.push(to_rev)
+
+            if from_rev.present? && from_rev != "0000000000000000000000000000000000000000"
+              walker.hide(from_rev)
             end
-          else
-            repository_for_indexing.each_id do |oid|
-              obj = repository_for_indexing.lookup(oid)
-              if obj.type == :commit
-                index_commit(obj)
-              end
+
+            commits = walker.map { |c| c.oid }
+            walker.reset
+
+            commits.each_with_index do |commit, step|
+              index_commit(repository_for_indexing.lookup(commit))
+              ObjectSpace.garbage_collect if step % 100 == 0
             end
           end
         end
 
         def index_commit(commit)
-          client_for_indexing.index \
-            index: "#{self.class.index_name}",
-            type: "repository",
-            id: "#{repository_id}_#{commit.oid}",
-            body: {
-              commit: {
-                type: "commit",
-                rid: repository_id,
-                sha: commit.oid,
-                author: commit.author,
-                committer: commit.committer,
-                message: commit.message
+          tries = 0
+          begin
+            client_for_indexing.index \
+              index: "#{self.class.index_name}",
+              type: "repository",
+              id: "#{repository_id}_#{commit.oid}",
+              body: {
+                commit: {
+                  type: "commit",
+                  rid: repository_id,
+                  sha: commit.oid,
+                  author: commit.author,
+                  committer: commit.committer,
+                  message: encode!(commit.message)
+                }
               }
-            }
+          rescue Exception => ex
+            # Retry 10 times send request
+            if tries < 10
+              tries += 1
+              sleep tries * 10 * rand(10)
+              retry
+            else
+              logger.warn "Can't index #{repository_id}_#{commit.oid}. Reason: #{ex.message}"
+            end
+          end
         end
 
         # Representation of repository as indexed json
@@ -235,7 +296,7 @@ module Elasticsearch
             result.push(recurse_blobs_index_hash(tree))
           else
             repository_for_indexing.index.each do |blob|
-              b = EasyBlob.new(repository_for_indexing, blob)
+              b = LiteBlob.new(repository_for_indexing, blob)
               result.push(
                 {
                   type: 'blob',
@@ -290,7 +351,7 @@ module Elasticsearch
                   sha: obj.oid,
                   author: obj.author,
                   committer: obj.committer,
-                  message: obj.message
+                  message: encode!(obj.message)
                 }
               )
             end
@@ -326,18 +387,18 @@ module Elasticsearch
         end
 
         def repository_for_indexing(repo_path = "")
+          return @rugged_repo_indexer if defined? @rugged_repo_indexer
+
           @path_to_repo ||= repo_path
           set_repository_id
-          Rugged::Repository.new(@path_to_repo)
+          @rugged_repo_indexer = Rugged::Repository.new(@path_to_repo)
         end
 
         def client_for_indexing
           @client_for_indexing ||= Elasticsearch::Client.new log: true
         end
-      end
 
-      module ClassMethods
-        def search(query, type: :all, page: 1, per: 20, options: {})
+        def self.search(query, type: :all, page: 1, per: 20, options: {})
           results = { blobs: [], commits: []}
           case type.to_sym
           when :all
@@ -352,6 +413,12 @@ module Elasticsearch
           results
         end
 
+        def logger
+          @logger ||= Logger.new(STDOUT)
+        end
+      end
+
+      module ClassMethods
         def search_commit(query, page: 1, per: 20, options: {})
           page ||= 1
 
@@ -364,11 +431,19 @@ module Elasticsearch
                   multi_match: {
                     fields: fields,
                     query: "#{query}",
-                    operator: :and
+                    operator: :or
                   }
                 },
               },
             },
+            facets: {
+              commitRepositoryFaset: {
+                terms: {
+                  field: "commit.rid",
+                  all_term: true
+                }
+              }
+            },
             size: per,
             from: per * (page - 1)
           }
@@ -387,11 +462,28 @@ module Elasticsearch
             }
           end
 
+          options[:order] = :default if options[:order].blank?
+          order = case options[:order].to_sym
+                  when :recently_indexed
+                    { _timestamp: { order: :desc, mode: :min } }
+                  when :last_indexed
+                    { _timestamp: { order: :asc,  mode: :min } }
+                  else
+                    {}
+                  end
+
+          query_hash[:sort] = order.blank? ? [:_score] : [order, :_score]
+
           if options[:highlight]
-            query_hash[:highlight] = { fields: options[:in].inject({}) { |a, o| a[o.to_sym] = {} } }
+            #query_hash[:highlight] = { fields: options[:in].inject({}) { |a, o| a[o.to_sym] = {} } }
           end
 
-          self.__elasticsearch__.search(query_hash).results
+          res = self.__elasticsearch__.search(query_hash)
+          {
+            results: res.results,
+            total_count: res.total_count,
+            repositories: res.response["facets"]["commitRepositoryFaset"]["terms"]
+          }
         end
 
         def search_blob(query, type: :all, page: 1, per: 20, options: {})
@@ -404,12 +496,26 @@ module Elasticsearch
                   match: {
                     'blob.content' => {
                       query: "#{query}",
-                      operator: :and
+                      operator: :or
                     }
                   }
                 }
               }
             },
+            facets: {
+              languageFacet: {
+                terms: {
+                  field: :language,
+                  all_term: true
+                }
+              },
+              blobRepositoryFaset: {
+                terms: {
+                  field: :rid,
+                  all_term: true
+                }
+              }
+            },
             size: per,
             from: per * (page - 1)
           }
@@ -423,56 +529,48 @@ module Elasticsearch
             }
           end
 
-          if options[:highlight]
-            query_hash[:highlight] = { fields: options[:in].inject({}) { |a, o| a[o.to_sym] = {} } }
+          if options[:language]
+            query_hash[:query][:filtered][:filter] ||= { and: [] }
+            query_hash[:query][:filtered][:filter][:and] << {
+              terms: {
+                "blob.language" => [options[:language]].flatten
+              }
+            }
           end
 
-          self.__elasticsearch__.search(query_hash).results
-        end
-      end
-    end
-
-    class LiteBlob
-      include Linguist::BlobHelper
+          options[:order] = :default if options[:order].blank?
+          order = case options[:order].to_sym
+                  when :recently_indexed
+                    { _timestamp: { order: :desc, mode: :min } }
+                  when :last_indexed
+                    { _timestamp: { order: :asc, mode: :min } }
+                  else
+                    {}
+                  end
 
-      attr_accessor :id, :name, :path, :data, :commit_id
+          query_hash[:sort] = order.blank? ? [:_score] : [order, :_score]
 
-      def initialize(repo, raw_blob_hash)
-        @id = raw_blob_hash[:oid]
-        @path = raw_blob_hash[:path]
-        @name = @path.split("/").last
-        @data = encode!(repo.lookup(@id).content)
-      end
-
-      def encode!(message)
-        return nil unless message.respond_to? :force_encoding
-
-        # if message is utf-8 encoding, just return it
-        message.force_encoding("UTF-8")
-        return message if message.valid_encoding?
+          if options[:highlight]
+            query_hash[:highlight] = {
+              pre_tags: [""],
+              post_tags: [""],
+              fields: {
+                "blob.content" => {},
+                "type" => "fvh",
+                "boundary_chars" => "\n"
+              }
+            }
+          end
 
-        # return message if message type is binary
-        detect = CharlockHolmes::EncodingDetector.detect(message)
-        return message.force_encoding("BINARY") if detect && detect[:type] == :binary
+          res = self.__elasticsearch__.search(query_hash)
 
-        # encoding message to detect encoding
-        if detect && detect[:encoding]
-          message.force_encoding(detect[:encoding])
+          {
+            results: res.results,
+            total_count: res.total_count,
+            languages: res.response["facets"]["languageFacet"]["terms"],
+            repositories: res.response["facets"]["blobRepositoryFaset"]["terms"]
+          }
         end
-
-        # encode and clean the bad chars
-        message.replace clean(message)
-      rescue
-        encoding = detect ? detect[:encoding] : "unknown"
-        "--broken encoding: #{encoding}"
-      end
-
-      private
-
-      def clean(message)
-        message.encode("UTF-16BE", undef: :replace, invalid: :replace, replace: "")
-        .encode("UTF-8")
-        .gsub("\0".encode("UTF-8"), "")
       end
     end
   end

data/lib/elasticsearch/git/version.rb

@@ -1,5 +1,5 @@
 module Elasticsearch
   module Git
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: elasticsearch-git
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Andrey Kumanyaev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-19 00:00:00.000000000 Z
+date: 2014-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: elasticsearch-model
@@ -28,87 +28,87 @@ dependencies:
   name: elasticsearch-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '>'
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '>'
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: rugged
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.19.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.19.0
 - !ruby/object:Gem::Dependency
   name: charlock_holmes
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.9
 - !ruby/object:Gem::Dependency
   name: gitlab-linguist
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '>'
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - '>'
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 2.9.0
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-description: Elasticsearch integrations for git repositories.
+        version: 4.0.0
+description: Elasticsearch integrations for indexing git repositories.
 email:
 - me@zzet.org
 executables: []
@@ -122,10 +122,12 @@ files:
 - Rakefile
 - elasticsearch-git.gemspec
 - lib/elasticsearch/git.rb
+- lib/elasticsearch/git/encoder_helper.rb
+- lib/elasticsearch/git/lite_blob.rb
 - lib/elasticsearch/git/model.rb
 - lib/elasticsearch/git/repository.rb
 - lib/elasticsearch/git/version.rb
-- lib/test/test_helper.rb
+- test/test_helper.rb
 homepage: https://github.com/zzet/elasticsearch-git
 licenses:
 - MIT
@@ -150,4 +152,5 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Elasticsearch integrations for git repositories.
-test_files: []
+test_files:
+- test/test_helper.rb