slingshot-rb 0.0.8 → 0.0.9

data/lib/slingshot.rb

@@ -1,7 +1,9 @@
 require 'rest_client'
 require 'yajl/json_gem'
+require 'active_model'
 
 require 'slingshot/rubyext/hash'
+require 'slingshot/rubyext/symbol'
 require 'slingshot/logger'
 require 'slingshot/configuration'
 require 'slingshot/client'
@@ -12,10 +14,21 @@ require 'slingshot/search/sort'
 require 'slingshot/search/facet'
 require 'slingshot/search/filter'
 require 'slingshot/search/highlight'
+require 'slingshot/results/pagination'
 require 'slingshot/results/collection'
 require 'slingshot/results/item'
 require 'slingshot/index'
 require 'slingshot/dsl'
+require 'slingshot/model/naming'
+require 'slingshot/model/callbacks'
+require 'slingshot/model/search'
+require 'slingshot/model/indexing'
+require 'slingshot/model/import'
+require 'slingshot/model/persistence/finders'
+require 'slingshot/model/persistence/attributes'
+require 'slingshot/model/persistence/storage'
+require 'slingshot/model/persistence'
+require 'slingshot/tasks'
 
 module Slingshot
   extend DSL

data/lib/slingshot/client.rb

@@ -4,12 +4,18 @@ module Slingshot
 
     class Base
       def get(url)
-        raise NoMethodError, "Implement this method in your client class"
+        raise_no_method_error
       end
       def post(url, data)
+        raise_no_method_error
+      end
+      def put(url, data)
         raise NoMethodError, "Implement this method in your client class"
       end
       def delete(url)
+        raise_no_method_error
+      end
+      def raise_no_method_error
         raise NoMethodError, "Implement this method in your client class"
       end
     end
@@ -21,6 +27,9 @@ module Slingshot
       def self.post(url, data)
         ::RestClient.post url, data
       end
+      def self.put(url, data)
+        ::RestClient.put url, data
+      end
       def self.delete(url)
         ::RestClient.delete url rescue nil
       end

data/lib/slingshot/dsl.rb

@@ -6,7 +6,23 @@ module Slingshot
     end
 
     def search(indices, options={}, &block)
-      Search::Search.new(indices, options, &block).perform
+      if block_given?
+        Search::Search.new(indices, options, &block).perform
+      else
+        payload = case options
+          when Hash    then options.to_json
+          when String  then options
+          else raise ArgumentError, "Please pass a Ruby Hash or String with JSON"
+        end
+
+        response = Configuration.client.post( "#{Configuration.url}/#{indices}/_search", payload)
+        json     = Yajl::Parser.parse(response.body)
+        results  = Results::Collection.new(json, options)
+      end
+    rescue Exception => error
+      STDERR.puts "[REQUEST FAILED] #{error.class} #{error.http_body rescue nil}\n"
+      raise
+    ensure
     end
 
     def index(name, &block)

data/lib/slingshot/index.rb

@@ -1,15 +1,23 @@
 module Slingshot
   class Index
 
+    attr_reader :name
+
     def initialize(name, &block)
       @name = name
       instance_eval(&block) if block_given?
     end
 
+    def exists?
+      !!Configuration.client.get("#{Configuration.url}/#{@name}/_status")
+    rescue Exception => error
+      false
+    end
+
     def delete
       # FIXME: RestClient does not return response for DELETE requests?
       @response = Configuration.client.delete "#{Configuration.url}/#{@name}"
-      return @response =~ /error/ ? false : true
+      return @response.body =~ /error/ ? false : true
     rescue Exception => error
       false
     ensure
@@ -28,7 +36,8 @@ module Slingshot
     end
 
     def mapping
-      JSON.parse( Configuration.client.get("#{Configuration.url}/#{@name}/_mapping") )[@name]
+      @response = Configuration.client.get("#{Configuration.url}/#{@name}/_mapping")
+      JSON.parse(@response.body)[@name]
     end
 
     def store(*args)
@@ -56,7 +65,7 @@ module Slingshot
       url = id ? "#{Configuration.url}/#{@name}/#{type}/#{id}" : "#{Configuration.url}/#{@name}/#{type}/"
 
       @response = Configuration.client.post url, document
-      JSON.parse(@response)
+      JSON.parse(@response.body)
 
     rescue Exception => error
       raise
@@ -65,14 +74,107 @@ module Slingshot
       logged(error, "/#{@name}/#{type}/", curl)
     end
 
+    def bulk_store documents
+      create unless exists?
+
+      payload = documents.map do |document|
+        old_verbose, $VERBOSE = $VERBOSE, nil # Silence Object#id deprecation warnings
+        id = case
+          when document.is_a?(Hash)                                           then document[:id] || document['id']
+          when document.respond_to?(:id) && document.id != document.object_id then document.id
+          # TODO: Raise error when no id present
+        end
+        $VERBOSE = old_verbose
+
+        type = case
+          when document.is_a?(Hash)                 then document[:type] || document['type']
+          when document.respond_to?(:document_type) then document.document_type
+        end || 'document'
+
+        output = []
+        output << %Q|{"index":{"_index":"#{@name}","_type":"#{type}","_id":"#{id}"}}|
+        output << document.to_indexed_json
+        output.join("\n")
+      end
+      payload << ""
+
+      tries = 5
+      count = 0
+
+      begin
+        # STDERR.puts "Posting payload..."
+        # STDERR.puts payload.join("\n")
+        Configuration.client.post("#{Configuration.url}/_bulk", payload.join("\n"))
+      rescue Exception => error
+        if count < tries
+          count += 1
+          STDERR.puts "[ERROR] #{error.message}:#{error.http_body rescue nil}, retrying (#{count})..."
+          retry
+        else
+          STDERR.puts "[ERROR] Too many exceptions occured, giving up..."
+          STDERR.puts "Response: #{error.http_body rescue nil}"
+          raise
+        end
+      ensure
+        curl = %Q|curl -X POST "#{Configuration.url}/_bulk" -d '{... data omitted ...}'|
+        logged(error, 'BULK', curl)
+      end
+    end
+
+    def import(klass_or_collection, method=nil, options={})
+      # p [klass_or_collection, method, options]
+
+      case
+
+        when method
+          options = {:page => 1, :per_page => 1000}.merge options
+          while documents = klass_or_collection.send(method.to_sym, options.merge(:page => options[:page])) \
+                            and not documents.empty?
+            documents = yield documents if block_given?
+
+            bulk_store documents
+            options[:page] += 1
+          end
+
+        when klass_or_collection.respond_to?(:map)
+          documents = block_given? ? yield(klass_or_collection) : klass_or_collection
+          bulk_store documents
+        else
+          raise ArgumentError, "Please pass either a collection of objects, "+
+                               "or method for fetching records, or Enumerable compatible class"
+      end
+    end
+
+    def remove(*args)
+      # TODO: Infer type from the document (hash property, method)
+
+      if args.size > 1
+        (type, document = args)
+      else
+        (document = args.pop; type = :document)
+      end
+
+      old_verbose, $VERBOSE = $VERBOSE, nil # Silence Object#id deprecation warnings
+      id = case true
+        when document.is_a?(Hash)                                           then document[:id] || document['id']
+        when document.respond_to?(:id) && document.id != document.object_id then document.id
+        else document
+      end
+      $VERBOSE = old_verbose
+
+      result = Configuration.client.delete "#{Configuration.url}/#{@name}/#{type}/#{id}"
+      JSON.parse(result) if result
+    end
+
     def retrieve(type, id)
       @response = Configuration.client.get "#{Configuration.url}/#{@name}/#{type}/#{id}"
-      h = JSON.parse(@response)
+      h = JSON.parse(@response.body)
       if Configuration.wrapper == Hash then h
       else
-        document = h['_source'] ? h['_source'] : h['fields']
-        h.update document if document
-        Configuration.wrapper.new(h)
+        document = {}
+        document = h['_source'] ? document.update( h['_source'] ) : document.update( h['fields'] )
+        document.update('id' => h['_id'], '_version' => h['_version'])
+        Configuration.wrapper.new(document)
       end
     end
 

data/lib/slingshot/model/callbacks.rb

@@ -0,0 +1,23 @@
+module Slingshot
+  module Model
+
+    module Callbacks
+
+      def self.included(base)
+        if base.respond_to?(:after_save) && base.respond_to?(:after_destroy)
+          base.send :after_save,    :update_elastic_search_index
+          base.send :after_destroy, :update_elastic_search_index
+        end
+
+        if base.respond_to?(:before_destroy) && !base.respond_to?(:destroyed?)
+          base.class_eval do
+            before_destroy  { @destroyed = true }
+            def destroyed?; !!@destroyed; end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/slingshot/model/import.rb

@@ -0,0 +1,18 @@
+module Slingshot
+  module Model
+
+    module Import
+
+      module ClassMethods
+
+        def import options={}, &block
+          method = options.delete(:method) || 'paginate'
+          self.index.import self, method, options, &block
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/slingshot/model/indexing.rb

@@ -0,0 +1,50 @@
+module Slingshot
+  module Model
+
+    module Indexing
+
+      module ClassMethods
+
+        def mapping
+          if block_given?
+            @store_mapping = true
+            yield
+            @store_mapping = false
+            create_index_or_update_mapping
+          else
+            @mapping ||= {}
+          end
+        end
+
+        def indexes(name, options = {})
+          # p "#{self}, SEARCH PROPERTY, #{name}"
+          mapping[name] = options
+        end
+
+        def store_mapping?
+          @store_mapping || false
+        end
+
+        def create_index_or_update_mapping
+          # STDERR.puts "Creating index with mapping", mapping_to_hash.inspect
+          # STDERR.puts "Index exists?, #{index.exists?}"
+          unless index.exists?
+            index.create :mappings => mapping_to_hash
+          else
+            # TODO: Update mapping
+          end
+        rescue Exception => e
+          # TODO: STDERR + logger
+          raise
+        end
+
+        def mapping_to_hash
+          { document_type.to_sym => { :properties => mapping } }
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/slingshot/model/naming.rb

@@ -0,0 +1,30 @@
+module Slingshot
+  module Model
+
+    module Naming
+
+      module ClassMethods
+        def index_name name=nil
+          @index_name = name if name
+          @index_name || model_name.plural
+        end
+
+        def document_type
+          model_name.singular
+        end
+      end
+
+      module InstanceMethods
+        def index_name
+          self.class.index_name
+        end
+
+        def document_type
+          self.class.document_type
+        end
+      end
+
+    end
+
+  end
+end

data/lib/slingshot/model/persistence.rb

@@ -0,0 +1,34 @@
+module Slingshot
+  module Model
+
+    module Persistence
+
+      def self.included(base)
+
+        base.class_eval do
+          include ActiveModel::AttributeMethods
+          include ActiveModel::Validations
+          include ActiveModel::Serialization
+          include ActiveModel::Serializers::JSON
+          include ActiveModel::Naming
+          include ActiveModel::Conversion
+
+          extend  ActiveModel::Callbacks
+          define_model_callbacks :save, :destroy
+
+          include Slingshot::Model::Search
+          include Slingshot::Model::Callbacks
+
+          extend  Persistence::Finders::ClassMethods
+          extend  Persistence::Attributes::ClassMethods
+          include Persistence::Attributes::InstanceMethods
+
+          include Persistence::Storage
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/slingshot/model/persistence/attributes.rb

@@ -0,0 +1,60 @@
+module Slingshot
+  module Model
+
+    module Persistence
+
+      module Attributes
+
+        module ClassMethods
+
+          def property(name, options = {})
+            # p "#{self}, PERSISTENCE PROPERTY, #{name}"
+            attr_accessor name.to_sym
+            properties << name.to_s unless properties.include?(name.to_s)
+            define_query_method      name.to_sym
+            define_attribute_methods [name.to_sym]
+            mapping[name] = options if store_mapping?
+            self
+          end
+
+          def properties
+            @properties ||= []
+          end
+
+          private
+
+          def define_query_method name
+            define_method("#{name}?")  { !! send(name) }
+          end
+
+        end
+
+        module InstanceMethods
+
+          attr_accessor :id
+
+          def initialize(attributes={})
+            attributes.each { |name, value| send("#{name}=", value) }
+          end
+
+          def attributes
+            self.class.properties.
+              inject( self.id ? {'id' => self.id} : {} ) {|attributes, key| attributes[key] = send(key); attributes}
+          end
+
+          def attribute_names
+            self.class.properties.sort
+          end
+
+          def has_attribute?(name)
+            properties.include?(name.to_s)
+          end
+          alias :has_property? :has_attribute?
+
+        end
+
+      end
+
+    end
+  end
+end