gummi 0.1.2 → 0.2.0

data/lib/gummi/document/attributes.rb

@@ -1,28 +0,0 @@
-module Gummi
-  module Document
-    module Attributes
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-
-        def mapping_for_attribute(attribute)
-          if attribute.is_a? Virtus::Attribute::EmbeddedValue
-            {properties: attribute.primitive.mapping}
-          elsif attribute.is_a? Virtus::Attribute::Collection
-            mapping_for_attribute(attribute.member_type)
-          else
-            attribute.mapping
-          end
-        end
-
-        def mapping
-          result = {}
-          attribute_set.each do |attribute|
-            result.merge!({ attribute.name => mapping_for_attribute(attribute)})
-          end
-          result
-        end
-      end
-    end
-  end
-end

data/lib/gummi/document/object.rb

@@ -1,12 +0,0 @@
-module Gummi
-  module Document
-    module Object
-      extend ActiveSupport::Concern
-
-      included do
-        include Virtus.model
-        include Gummi::Document::Attributes
-      end
-    end
-  end
-end

data/lib/gummi/document/search/filtered.rb

@@ -1,39 +0,0 @@
-module Gummi
-  module Document
-    module Search
-      class Filtered
-        include Gummi::Document::Search::Searching
-
-        attribute :query_string,  Gummi::Fields::SanitizedString
-        attribute :query_filters, Array[Hash],                    default: []
-        attribute :facets,        Hash,                           default: {}
-
-        def to_client_args
-          args = super
-          args[:body]  = {query: filtered, facets: facets }
-          args
-        end
-
-        def query
-          if query_string.present?
-            {query_string: { query: query_string}}
-          else
-            {match_all: {}}
-          end
-        end
-
-        def filtered
-          { 'filtered' => { 'query' => query, 'filter' => process_query_filters }}
-        end
-
-        def process_query_filters
-          if query_filters.length > 1
-            {and: query_filters}
-          else
-            query_filters.first
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gummi/document/search/raw.rb

@@ -1,9 +0,0 @@
-module Gummi
-  module Document
-    module Search
-      class Raw
-        include Gummi::Document::Search::Searching
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-module Gummi
-  module Document
-    module Search
-      class Result
-
-        attr_reader :took, :total, :hits, :facets
-
-        def initialize(result)
-          @took = result["took"]
-          @total = result["hits"]["total"]
-          @hits = result["hits"]["hits"]
-          @facets = result["facets"]
-        end
-
-        def records
-          hits.map do |hit|
-            model = "DB::#{hit["_type"].humanize}".constantize
-            doc_hash = {id: hit["_id"]}.merge(hit["_source"])
-            model.new(doc_hash)
-          end
-        end
-      end
-    end
-  end
-end

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

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

data/lib/gummi/entity.rb

@@ -1,20 +0,0 @@
-module Gummi
-  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

data/lib/gummi/fields/boolean.rb

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

data/lib/gummi/fields/integer.rb

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

data/lib/gummi/fields/keyword.rb

@@ -1,13 +0,0 @@
-module Gummi
-  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

data/lib/gummi/fields/ngram_and_plain.rb

@@ -1,18 +0,0 @@
-module Gummi
-  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

data/lib/gummi/fields/path_hierarchy.rb

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

data/lib/gummi/fields/positive_integer.rb

@@ -1,19 +0,0 @@
-module Gummi
-  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

data/lib/gummi/fields/sanitized_string.rb

@@ -1,28 +0,0 @@
-module Gummi
-  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

data/lib/gummi/fields/string.rb

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

data/lib/gummi/fields/time.rb

@@ -1,15 +0,0 @@
-module Gummi
-  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

data/lib/gummi/index.rb

@@ -1,146 +0,0 @@
-module Gummi
-  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