gummi 0.1.2 → 0.2.0

data/lib/gummi/db_layer/document/search/result.rb

@@ -0,0 +1,34 @@
+module Gummi
+  module DbLayer
+    module Document
+      module Search
+        class Result
+
+          attr_reader :took, :total, :hits
+
+          def initialize(response, converter, per_page, page)
+            @response  = Hashie::Mash.new response
+            @took      = @response.hits.took
+            @total     = @response.hits.total
+            @hits      = @response.hits.hits
+            @converter = converter
+            @per_page  = per_page
+            @page      = page
+          end
+
+          def documents
+            @documents ||= begin
+              documents = Array(converter.hits_to_documents(hits)) if hits
+              Leaflet::Collection.new documents, total: total, page: page, per_page: per_page
+            end
+          end
+
+          private
+
+          attr_reader :response, :converter, :per_page, :page, :hits
+
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/document/search/searching.rb

@@ -0,0 +1,51 @@
+module Gummi
+  module DbLayer
+    module Document
+      module Search
+        module Searching
+          extend ActiveSupport::Concern
+
+          included do
+            include Virtus.model
+
+            attribute :document_class, Class
+            attribute :index,          String,                         default: lambda { |search, attr| Gummi::DbLayer::DefaultIndex.name }
+            attribute :type,           String
+            attribute :page,           Gummi::DbLayer::Fields::PositiveInteger, default: 1
+            attribute :per_page,       Gummi::DbLayer::Fields::PositiveInteger, default: 300
+            attribute :options,        Hash,                           default: {}
+          end
+
+          def to_client_args
+            args = {
+              index: index,
+              from:  from,
+              size:  size,
+            }
+            args[:type]  = type if type
+            args.merge options
+          end
+
+          def execute
+            Gummi::DbLayer::Document::Search::Result.new client.search(to_client_args), document_class, per_page, page
+          end
+
+          private
+
+          def size
+            per_page
+          end
+
+          def from
+            per_page * (page - 1)
+          end
+
+          def client
+            Gummi::API.client
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/boolean.rb

@@ -0,0 +1,13 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class Boolean < Virtus::Attribute::Boolean
+
+        def mapping
+          { type: 'boolean' }
+        end
+
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/integer.rb

@@ -0,0 +1,16 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class Integer < Virtus::Attribute
+
+        def coerce(value)
+          value.to_i if value.present?
+        end
+
+        def mapping
+          { type: 'integer' }
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/keyword.rb

@@ -0,0 +1,15 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class Keyword < Virtus::Attribute
+        def coerce(value)
+          value
+        end
+
+        def mapping
+          { type: 'string', index_analyzer: 'keyword_index_analyzer', search_analyzer: 'keyword_search_analyzer' }
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/ngram_and_plain.rb

@@ -0,0 +1,20 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class NgramAndPlain < Virtus::Attribute
+        def coerce(value)
+          value
+        end
+
+        def mapping
+          { type: 'multi_field',
+                      fields: {
+                                name      => { type: 'string', index_analyzer: 'text_index_analyzer',   search_analyzer: 'text_search_analyzer' },
+                                :plain    => { type: 'string', index_analyzer: 'string_index_analyzer', search_analyzer: 'text_search_analyzer' },
+                              }
+                    }
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/path_hierarchy.rb

@@ -0,0 +1,15 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class PathHierarchy < Virtus::Attribute
+        def coerce(value)
+          value
+        end
+
+        def mapping
+          {type: 'string', index_analyzer: 'path_hierarchy_analyzer' }
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/positive_integer.rb

@@ -0,0 +1,21 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class PositiveInteger < Virtus::Attribute
+
+        def coerce(value)
+          coerced = value.to_i
+          if coerced > 0
+            coerced
+          else
+            default_value.value
+          end
+        end
+
+        def mapping
+          { type: 'integer' }
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/sanitized_string.rb

@@ -0,0 +1,30 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class SanitizedString < Virtus::Attribute
+
+        def coerce(value)
+          return nil if value.blank?
+          sanitize_string_for_query(value.to_s)
+        end
+
+        def mapping
+          { type: 'string' }
+        end
+
+        def sanitize_string_for_query(str)
+          # Escape special characters
+          escaped_characters = Regexp.escape('\/\\+-&|!(){}[]^~*?:')
+          str = str.gsub(/([#{escaped_characters}])/) do |match|
+            '\\'+match
+          end
+
+          # Escape odd quotes
+          quote_count = str.count '"'
+          str = str.gsub(/(.*)"(.*)/, '\1\"\3') if quote_count % 2 == 1
+          str
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/string.rb

@@ -0,0 +1,17 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class String < Virtus::Attribute
+
+
+        def coerce(value)
+          value
+        end
+
+        def mapping
+          { type: 'string' }
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/fields/time.rb

@@ -0,0 +1,17 @@
+module Gummi
+  module DbLayer
+    module Fields
+      class Time < Virtus::Attribute
+
+        def coerce(value)
+          return nil unless value.respond_to? :in_time_zone
+          value.in_time_zone 'UTC'
+        end
+
+        def mapping
+          {type: "date"}
+        end
+      end
+    end
+  end
+end

data/lib/gummi/db_layer/index.rb

@@ -0,0 +1,150 @@
+module Gummi
+  module DbLayer
+    module Index
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Return true if created or false if already created.
+        #
+        def setup
+          created_settings = client.indices.create index: name, body: { settings: settings }
+          created_settings.present?
+          refresh
+        rescue ::Elasticsearch::Transport::Transport::Errors::BadRequest => exception
+          false
+        end
+
+        # Return true if successful or already teared down.
+        #
+        # Raises NotImplementedError in production.
+        #
+        def teardown
+          raise NotImplementedError if Gummi.env == 'production'
+          response = client.indices.delete index: name
+          response.present?
+        rescue ::Elasticsearch::Transport::Transport::Errors::NotFound
+          true
+        end
+
+        def name
+          raise "Implement me"
+        end
+
+        def refresh
+          client.indices.refresh
+          client.cluster.health wait_for_status: :yellow
+        end
+
+        def settings
+          default_settings
+        end
+
+        def default_settings
+          {
+            index: {
+              # Main Settings
+              number_of_shards: '3',
+              number_of_replicas: (Gummi.env == 'production' ? '2' : '0'),
+              refresh_interval: '1s',
+              store: { type: (Gummi.env == 'test' ? :memory : :niofs) },
+              mapper: { dynamic: false },
+
+              analysis: {
+
+                # Tokenizers are just some sort of "tool" or "module"  that can be applied to analyzers.
+                tokenizer: {
+                  # This one is a little bit more general and is able to chop any word into all of its components.
+                  ngram_tokenizer: {
+                    type: 'nGram',
+                    min_gram: 1,
+                    max_gram: 7,
+                    token_chars: [ 'letter', 'digit' ],
+                  }
+
+                },
+
+                # Now we are ready to use our tokenizers.
+                # Let's create the most important thing: Analyzers.
+                analyzer: {
+
+                  path_hierarchy_analyzer: {
+                    type: 'custom',
+                    tokenizer: 'path_hierarchy',
+                  },
+                  # When adding long text to Elastic, we most likely are going to use this
+                  # analyzer. This is commonly used for titles and descriptions.
+                  text_index_analyzer: {
+                    type: 'custom',
+                    tokenizer: 'ngram_tokenizer',  # Chopping every word up into tokens
+                    filter: {
+                      0 => 'standard',       # Some default transformations
+                      1 => 'lowercase',      # Make everything lowercase
+                      2 => 'word_delimiter', # E.g. "O'Neil" -> "O Neil", "Victoria's" -> "Victoria"
+                      2 => 'asciifolding',   # Transform everything into ASCII
+                    },
+                  },
+
+                  # For smaller texts, such as the city "stockholm", we don't want any
+                  # tokenizing. It's enough to explicitly save the word as it is.
+                  # As a matter of fact, if we would tokenize the city, then the facets
+                  # would report that we have Transports in "st" "sto" "stoc" etc.
+                  string_index_analyzer: {
+                    type: 'custom',
+                    tokenizer: 'standard',
+                    filter: {
+                      # The filters, however, are identical to the other analyzer.
+                      0 => 'standard',
+                      1 => 'lowercase',
+                      2 => 'word_delimiter',
+                      3 => 'asciifolding',
+                    },
+                  },
+
+                  # For finding Slugs
+                  keyword_index_analyzer: {
+                    type: 'custom',
+                    tokenizer: 'keyword',
+                    filter: {
+                      0 => 'lowercase',
+                      1 => 'asciifolding',
+                    },
+                  },
+
+                  # This is an analyzer that we apply to the search query itself.
+                  text_search_analyzer: {
+                    type: 'custom',
+                    tokenizer: 'standard',
+                    filter: {
+                      0 => 'standard',
+                      1 => 'lowercase',
+                      2 => 'word_delimiter',
+                      3 => 'asciifolding',
+                    },
+                  },
+
+                  # This is an analyzer that we apply to the search query itself.
+                  keyword_search_analyzer: {
+                    type: 'custom',
+                    tokenizer: 'keyword',
+                    filter: {
+                      0 => 'lowercase',
+                      1 => 'asciifolding',
+                    },
+                  },
+
+                }
+              }
+            }
+          }
+        end
+
+        def client
+          Gummi::API.client
+        end
+
+      end
+
+    end
+  end
+end

data/lib/gummi/entity_layer/entity.rb

@@ -0,0 +1,22 @@
+module Gummi
+  module EntityLayer
+    module Entity
+      extend ActiveSupport::Concern
+
+      included do
+        include Repobahn::Entity
+      end
+
+      attr_accessor :id
+      attr_accessor :version
+
+      def ==(other)
+        other &&
+        self.id == other.id &&
+        self.version == other.version &&
+        self.attributes == other.attributes
+      end
+
+    end
+  end
+end

data/lib/gummi/errors.rb

@@ -0,0 +1,7 @@
+module Gummi
+  module Errors
+
+    ImplicitMappingForbidden = Class.new(ArgumentError)
+
+  end
+end