ssickles-tire 0.4.2.7 → 0.4.3

data/lib/tire/model/naming.rb

@@ -0,0 +1,100 @@
+module Tire
+  module Model
+
+    # Contains logic for getting and setting the index name and document type for this model.
+    #
+    module Naming
+
+      module ClassMethods
+
+        # Get or set the index name for this model, based on arguments.
+        #
+        # By default, uses ActiveSupport inflection, so a class named `Article`
+        # will be stored in the `articles` index.
+        #
+        # To get the index name:
+        #
+        #     Article.index_name
+        #
+        # To set the index name:
+        #
+        #     Article.index_name 'my-custom-name'
+        #
+        # You can also use a block for defining the index name,
+        # which is evaluated in the class context:
+        #
+        #     Article.index_name { "articles-#{Time.now.year}" }
+        #
+        #     Article.index_name { "articles-#{Rails.env}" }
+        #
+        def index_name name=nil, &block
+          @index_name = name if name
+          @index_name = block if block_given?
+          # TODO: Try to get index_name from ancestor classes
+          @index_name || [index_prefix, klass.model_name.plural].compact.join('_')
+        end
+
+        # Set or get index prefix for all models or for a specific model.
+        #
+        # To set the prefix for all models (preferably in an initializer inside Rails):
+        #
+        #     Tire::Model::Search.index_prefix Rails.env
+        #
+        # To set the prefix for specific model:
+        #
+        #     class Article
+        #       # ...
+        #       index_prefix 'my_prefix'
+        #     end
+        #
+        # TODO: Maybe this would be more sane with ActiveSupport extensions such as `class_attribute`?
+        #
+        @@__index_prefix__ = nil
+        def index_prefix(*args)
+          # Uses class or instance variable depending on the context
+          if args.size > 0
+            value = args.pop
+            self.is_a?(Module) ? ( @@__index_prefix__ = value ) : ( @__index_prefix__ = value )
+          end
+          self.is_a?(Module) ? ( @@__index_prefix__ || nil ) : ( @__index_prefix__ || @@__index_prefix__ || nil )
+        end
+        extend self
+
+        # Get or set the document type for this model, based on arguments.
+        #
+        # By default, uses ActiveSupport inflection, so a class named `Article`
+        # will be stored as the `article` type.
+        #
+        # To get the document type:
+        #
+        #     Article.document_type
+        #
+        # To set the document type:
+        #
+        #     Article.document_type 'my-custom-type'
+        #
+        def document_type name=nil
+          @document_type = name if name
+          @document_type || klass.model_name.underscore
+        end
+      end
+
+      module InstanceMethods
+
+        # Proxy to class method `index_name`.
+        #
+        def index_name
+          instance.class.tire.index_name
+        end
+
+        # Proxy to instance method `document_type`.
+        #
+        def document_type
+          instance.class.tire.document_type
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/percolate.rb

@@ -0,0 +1,99 @@
+module Tire
+  module Model
+
+    # Contains support for the [percolation](http://www.elasticsearch.org/guide/reference/api/percolate.html)
+    # feature of _ElasticSearch_.
+    #
+    module Percolate
+
+      module ClassMethods
+
+        # Set up the percolation when documents are being added to the index.
+        #
+        # Usage:
+        #
+        #     class Article
+        #       # ...
+        #       percolate!
+        #     end
+        #
+        # First, you have to register a percolator query:
+        #
+        #     Article.index.register_percolator_query('fail')    { |query| query.string 'fail' }
+        #
+        # Then, when you update the index, matching queries are returned in the `matches` property:
+        #
+        #     p Article.create(:title => 'This is a FAIL!').matches
+        #
+        #
+        # You may pass a pattern to filter which percolator queries will be executed.
+        #
+        # See <http://www.elasticsearch.org/guide/reference/api/index_.html> for more information.
+        #
+        def percolate!(pattern=true)
+          @@_percolator = pattern
+          self
+        end
+
+        # A callback method for intercepting percolator matches.
+        #
+        # Usage:
+        #
+        #     class Article
+        #       # ...
+        #       on_percolate do
+        #         puts "Article title “#{title}” matches queries: #{matches.inspect}" unless matches.empty?
+        #       end
+        #     end
+        #
+        # Based on the response received in `matches`, you may choose to fire notifications,
+        # increment counters, send out e-mail alerts, etc.
+        #
+        def on_percolate(pattern=true,&block)
+          percolate!(pattern)
+          klass.after_update_elasticsearch_index(block)
+        end
+
+        # Returns the status or pattern of percolator for this class.
+        #
+        def percolator
+          defined?(@@_percolator) ? @@_percolator : nil
+        end
+      end
+
+      module InstanceMethods
+
+        # Run this document against registered percolator queries, without indexing it.
+        #
+        # First, register a percolator query:
+        #
+        #     Article.index.register_percolator_query('fail')    { |query| query.string 'fail' }
+        #
+        # Then, you may query the percolator endpoint with:
+        #
+        #     p Article.new(:title => 'This is a FAIL!').percolate
+        #
+        # Optionally, you may pass a block to filter which percolator queries will be executed.
+        #
+        # See <http://www.elasticsearch.org/guide/reference/api/percolate.html> for more information.
+        def percolate(&block)
+          index.percolate instance, block
+        end
+
+        # Mark this instance for percolation when adding it to the index.
+        #
+        def percolate=(pattern)
+          @_percolator = pattern
+        end
+
+        # Returns the status or pattern of percolator for this instance.
+        #
+        def percolator
+          @_percolator || instance.class.tire.percolator || nil
+        end
+      end
+
+    end
+
+  end
+end

data/lib/tire/model/persistence.rb

@@ -0,0 +1,72 @@
+module Tire
+  module Model
+
+    # Allows to use _ElasticSearch_ as a primary database (storage).
+    #
+    # Contains all the `Tire::Model::Search` features and provides
+    # an [_ActiveModel_](http://rubygems.org/gems/activemodel)-compatible
+    # interface for persistance.
+    #
+    # Usage:
+    #
+    #     class Article
+    #       include Tire::Model::Persistence
+    #     
+    #       property :title
+    #     end
+    #
+    #     Article.create :id => 1, :title => 'One'
+    #
+    #     article = Article.find
+    #
+    #     article.destroy
+    #
+    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 Tire::Model::Search
+          include Tire::Model::Callbacks
+
+          extend  Persistence::Finders::ClassMethods
+          extend  Persistence::Attributes::ClassMethods
+          include Persistence::Attributes::InstanceMethods
+
+          include Persistence::Storage
+
+          ['_score', '_type', '_index', '_version', 'sort', 'highlight', 'matches', '_explanation'].each do |attr|
+            define_method("#{attr}=") { |value| @attributes ||= {}; @attributes[attr] = value }
+            define_method("#{attr}")  { @attributes[attr] }
+          end
+
+          def self.search(*args, &block)
+            # Update options Hash with the wrapper definition
+            args.last.update(:wrapper => self) if args.last.is_a? Hash
+            args << { :wrapper => self }       unless args.any? { |a| a.is_a? Hash }
+
+            self.__search_without_persistence(*args, &block)
+          end
+
+          def self.__search_without_persistence(*args, &block)
+            self.tire.search(*args, &block)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,143 @@
+module Tire
+  module Model
+
+    module Persistence
+
+      # Provides infrastructure for declaring the model properties and accessing them.
+      #
+      module Attributes
+
+        module ClassMethods
+
+          # Define property of the model:
+          #
+          #    class Article
+          #      include Tire::Model::Persistence
+          #
+          #      property :title,     :analyzer => 'snowball'
+          #      property :published, :type => 'date'
+          #      property :tags,      :analyzer => 'keywords', :default => []
+          #    end
+          #
+          # You can pass mapping definition for ElasticSearch in the options Hash.
+          #
+          # You can define default property values.
+          #
+          def property(name, options = {})
+
+            # Define attribute reader:
+            define_method("#{name}") do
+              instance_variable_get(:"@#{name}")
+            end
+
+            # Define attribute writer:
+            define_method("#{name}=") do |value|
+              instance_variable_set(:"@#{name}", value)
+            end
+
+            # Save the property in properties array:
+            properties << name.to_s unless properties.include?(name.to_s)
+
+            # Define convenience <NAME>? method:
+            define_query_method      name.to_sym
+
+            # ActiveModel compatibility. NEEDED?
+            define_attribute_methods [name.to_sym]
+
+            # Save property default value (when relevant):
+            unless (default_value = options.delete(:default)).nil?
+              property_defaults[name.to_sym] = default_value
+            end
+
+            # Save property casting (when relevant):
+            property_types[name.to_sym] = options[:class] if options[:class]
+
+            # Store mapping for the property:
+            mapping[name] = options
+            self
+          end
+
+          def properties
+            @properties ||= []
+          end
+
+          def property_defaults
+            @property_defaults ||= {}
+          end
+
+          def property_types
+            @property_types ||= {}
+          end
+
+          private
+
+          def define_query_method name
+            define_method("#{name}?")  { !! send(name) }
+          end
+
+        end
+
+        module InstanceMethods
+
+          attr_accessor :id
+
+          def initialize(attributes={})
+            # Make a copy of objects in the property defaults hash, so default values such as `[]` or `{ foo: [] }` are left intact
+            property_defaults = self.class.property_defaults.inject({}) do |hash, item|
+              key, value = item
+              hash[key.to_s] = value.class.respond_to?(:new) ? value.clone : value
+              hash
+            end
+
+            __update_attributes(property_defaults.merge(attributes))
+          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?
+
+          def __update_attributes(attributes)
+            attributes.each { |name, value| send "#{name}=", __cast_value(name, value) }
+          end
+
+          # Casts the values according to the <tt>:class</tt> option set when
+          # defining the property, cast Hashes as Hashr[http://rubygems.org/gems/hashr]
+          # instances and automatically convert UTC formatted strings to Time.
+          #
+          def __cast_value(name, value)
+            case
+
+              when klass = self.class.property_types[name.to_sym]
+                if klass.is_a?(Array) && value.is_a?(Array)
+                  value.map { |v| klass.first.new(v) }
+                else
+                  klass.new(value)
+                end
+
+              when value.is_a?(Hash)
+                Hashr.new(value)
+
+              else
+                # Strings formatted as <http://en.wikipedia.org/wiki/ISO8601> are automatically converted to Time
+                value = Time.parse(value) if value.is_a?(String) && value =~ /^\d{4}[\/\-]\d{2}[\/\-]\d{2}T\d{2}\:\d{2}\:\d{2}Z$/
+                value
+            end
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/tire/model/persistence/finders.rb

@@ -0,0 +1,66 @@
+module Tire
+  module Model
+
+    module Persistence
+
+      # Provides infrastructure for an _ActiveRecord_-like interface for finding records.
+      #
+      module Finders
+
+        module ClassMethods
+
+          def find *args
+            # TODO: Options like `sort`
+            old_wrapper = Tire::Configuration.wrapper
+            Tire::Configuration.wrapper self
+            options = args.pop if args.last.is_a?(Hash)
+            args.flatten!
+            if args.size > 1
+              Tire::Search::Search.new(index.name) do |search|
+                search.query do |query|
+                  query.ids(args, document_type)
+                end
+                search.size args.size
+              end.results
+            else
+              case args = args.pop
+                when Fixnum, String
+                  index.retrieve document_type, args
+                when :all, :first
+                  send(args)
+                else
+                  raise ArgumentError, "Please pass either ID as Fixnum or String, or :all, :first as an argument"
+              end
+            end
+          ensure
+            Tire::Configuration.wrapper old_wrapper
+          end
+
+          def all
+            # TODO: Options like `sort`; Possibly `filters`
+            old_wrapper = Tire::Configuration.wrapper
+            Tire::Configuration.wrapper self
+            s = Tire::Search::Search.new(index.name).query { all }
+            s.results
+          ensure
+            Tire::Configuration.wrapper old_wrapper
+          end
+
+          def first
+            # TODO: Options like `sort`; Possibly `filters`
+            old_wrapper = Tire::Configuration.wrapper
+            Tire::Configuration.wrapper self
+            s = Tire::Search::Search.new(index.name).query { all }.size(1)
+            s.results.first
+          ensure
+            Tire::Configuration.wrapper old_wrapper
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end