ssickles-tire 0.4.2 → 0.4.2.7

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

@@ -1,143 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

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

@@ -1,71 +0,0 @@
-module Tire
-  module Model
-
-    module Persistence
-
-      # Provides infrastructure for storing records in _ElasticSearch_.
-      #
-      module Storage
-
-        def self.included(base)
-
-          base.class_eval do
-            extend  ClassMethods
-            include InstanceMethods            
-          end
-
-        end
-
-        module ClassMethods
-
-          def create(args={})
-            document    = new(args)
-            return false unless document.valid?
-            document.save
-            document
-          end
-
-        end
-
-        module InstanceMethods
-
-          def update_attribute(name, value)
-            __update_attributes name => value
-            save
-          end
-
-          def update_attributes(attributes={})
-            __update_attributes attributes
-            save
-          end
-
-          def save
-            return false unless valid?
-            run_callbacks :save do
-              # Document#id is set in the +update_elasticsearch_index+ method,
-              # where we have access to the JSON response
-            end
-            self
-          end
-
-          def destroy
-            run_callbacks :destroy do
-              @destroyed = true
-            end
-            self.freeze
-          end
-
-          # TODO: Implement `new_record?` and clean up
-
-          def destroyed?; !!@destroyed; end
-
-          def persisted?; !!id;           end
-
-        end
-
-      end
-
-    end
-
-  end
-end

data/lib/tire/model/search.rb

@@ -1,305 +0,0 @@
-module Tire
-  module Model
-
-    # Main module containing the search infrastructure for ActiveModel classes.
-    #
-    # By including this module, you'll provide the model with facilities to
-    # perform searches against index, define index settings and mappings,
-    # access the index object, etc.
-    #
-    # All the _Tire_ methods are accessible via the "proxy" class and instance
-    # methods of the model, named `tire`, eg. `Article.tire.search 'foo'`.
-    #
-    # When there's no clash with a method in the class (your own, defined by another gem, etc)
-    # _Tire_ will bring these methods to the top-level namespace of the class,
-    # eg. `Article.search 'foo'`.
-    #
-    # You'll find the relevant methods in the ClassMethods and InstanceMethods module.
-    #
-    #
-    module Search
-
-      # Alias for Tire::Model::Naming::ClassMethods.index_prefix
-      #
-      def self.index_prefix(*args)
-        Naming::ClassMethods.index_prefix(*args)
-      end
-
-      module ClassMethods
-
-        # Returns search results for a given query.
-        #
-        # Query can be passed simply as a String:
-        #
-        #     Article.search 'love'
-        #
-        # Any options, such as pagination or sorting, can be passed as a second argument:
-        #
-        #     Article.search 'love', :per_page => 25, :page => 2
-        #     Article.search 'love', :sort => 'title'
-        #
-        # For more powerful query definition, use the query DSL passed as a block:
-        #
-        #     Article.search do
-        #       query { terms :tags, ['ruby', 'python'] }
-        #       facet 'tags' { terms :tags }
-        #     end
-        #
-        # You can pass options as the first argument, in this case:
-        #
-        #     Article.search :per_page => 25, :page => 2 do
-        #       query { string 'love' }
-        #     end
-        #
-        # This methods returns a Tire::Results::Collection instance, containing instances
-        # of Tire::Results::Item, populated by the data available in _ElasticSearch, by default.
-        #
-        # If you'd like to load the "real" models from the database, you may use the `:load` option:
-        #
-        #     Article.search 'love', :load => true
-        #
-        # You can pass options as a Hash to the model's `find` method:
-        #
-        #     Article.search :load => { :include => 'comments' } do ... end
-        #
-        def search(*args, &block)
-          default_options = {:type => document_type, :index => index.name}
-
-          if block_given?
-            options = args.shift || {}
-          else
-            query, options = args
-            options ||= {}
-          end
-
-          sort      = Array( options[:order] || options[:sort] )
-          options   = default_options.update(options)
-
-          s = Tire::Search::Search.new(options.delete(:index), options)
-          s.size( options[:per_page].to_i ) if options[:per_page]
-          s.from( options[:page].to_i <= 1 ? 0 : (options[:per_page].to_i * (options[:page].to_i-1)) ) if options[:page] && options[:per_page]
-          s.sort do
-            sort.each do |t|
-              field_name, direction = t.split(' ')
-              by field_name, direction
-            end
-          end unless sort.empty?
-
-          if block_given?
-            block.arity < 1 ? s.instance_eval(&block) : block.call(s)
-          else
-            s.query { string query }
-            # TODO: Actualy, allow passing all the valid options from
-            # <http://www.elasticsearch.org/guide/reference/api/search/uri-request.html>
-            s.fields Array(options[:fields]) if options[:fields]
-          end
-
-          s.results
-        end
-
-        # Returns a Tire::Index instance for this model.
-        #
-        # Example usage: `Article.index.refresh`.
-        #
-        def index
-          name = index_name.respond_to?(:to_proc) ? klass.instance_eval(&index_name) : index_name
-          @index = Index.new(name)
-        end
-
-      end
-
-      module InstanceMethods
-
-        # Returns a Tire::Index instance for this instance of the model.
-        #
-        # Example usage: `@article.index.refresh`.
-        #
-        def index
-          instance.class.tire.index
-        end
-
-        # Updates the index in _ElasticSearch_.
-        #
-        # On model instance create or update, it will store its serialized representation in the index.
-        #
-        # On model destroy, it will remove the corresponding document from the index.
-        #
-        # It will also execute any `<after|before>_update_elasticsearch_index` callback hooks.
-        #
-        def update_index
-          #instance.send :_run_update_elasticsearch_index_callbacks do
-            if instance.destroyed?
-              index.remove instance
-            else
-              response  = index.store( instance, {:percolate => percolator} )
-              instance.id     ||= response['_id']      if instance.respond_to?(:id=)
-              instance._index   = response['_index']   if instance.respond_to?(:_index=)
-              instance._type    = response['_type']    if instance.respond_to?(:_type=)
-              instance._version = response['_version'] if instance.respond_to?(:_version=)
-              instance.matches  = response['matches']  if instance.respond_to?(:matches=)
-              self
-            end
-          #end
-        end
-        alias :update_elasticsearch_index  :update_index
-        alias :update_elastic_search_index :update_index
-
-        # The default JSON serialization of the model, based on its `#to_hash` representation.
-        #
-        # If you don't define any mapping, the model is serialized as-is.
-        #
-        # If you do define the mapping for _ElasticSearch_, only attributes
-        # declared in the mapping are serialized.
-        #
-        # For properties declared with the `:as` option, the passed String or Proc
-        # is evaluated in the instance context.
-        #
-        def to_indexed_json
-          if instance.class.tire.mapping.empty?
-            # Reject the id and type keys
-            instance.to_hash.reject {|key,_| key.to_s == 'id' || key.to_s == 'type' }.to_json
-          else
-            mapping = instance.class.tire.mapping
-            # Reject keys not declared in mapping
-            hash = instance.to_hash.reject { |key, value| ! mapping.keys.map(&:to_s).include?(key.to_s) }
-
-            # Evalute the `:as` options
-            mapping.each do |key, options|
-              case options[:as]
-                when String
-                  hash[key] = instance.instance_eval(options[:as])
-                when Proc
-                  hash[key] = instance.instance_eval(&options[:as])
-              end
-            end
-
-            hash.to_json
-          end
-        end
-
-        def matches
-          @attributes['matches']
-        end
-
-        def matches=(value)
-          @attributes ||= {}; @attributes['matches'] = value
-        end
-
-      end
-
-      module Loader
-
-        # Load the "real" model from the database via the corresponding model's `find` method.
-        #
-        # Notice that there's an option to eagerly load models with the `:load` option
-        # for the search method.
-        #
-        def load(options=nil)
-          options ? self.class.find(self.id, options) : self.class.find(self.id)
-        end
-
-      end
-
-      # An object containing _Tire's_ model class methods, accessed as `Article.tire`.
-      #
-      class ClassMethodsProxy
-        include Tire::Model::Naming::ClassMethods
-        include Tire::Model::Import::ClassMethods
-        include Tire::Model::Indexing::ClassMethods
-        include Tire::Model::Percolate::ClassMethods
-        include ClassMethods
-
-        INTERFACE = public_instance_methods.map(&:to_sym) - Object.public_instance_methods.map(&:to_sym)
-
-        attr_reader :klass
-        def initialize(klass)
-          @klass = klass
-        end
-
-      end
-
-      # An object containing _Tire's_ model instance methods, accessed as `@article.tire`.
-      #
-      class InstanceMethodsProxy
-        include Tire::Model::Naming::InstanceMethods
-        include Tire::Model::Percolate::InstanceMethods
-        include InstanceMethods
-
-        INTERFACE = public_instance_methods.map(&:to_sym) - Object.public_instance_methods.map(&:to_sym)
-
-        attr_reader :instance
-        def initialize(instance)
-          @instance = instance
-        end
-      end
-
-      # A hook triggered by the `include Tire::Model::Search` statement in the model.
-      #
-      def self.included(base)
-        base.class_eval do
-
-          # Returns proxy to the _Tire's_ class methods.
-          #
-          def self.tire &block
-            @__tire__ ||= ClassMethodsProxy.new(self)
-
-            @__tire__.instance_eval(&block) if block_given?
-            @__tire__
-          end
-
-          # Returns proxy to the _Tire's_ instance methods.
-          #
-          def tire &block
-            @__tire__ ||= InstanceMethodsProxy.new(self)
-
-            @__tire__.instance_eval(&block) if block_given?
-            @__tire__
-          end
-
-          # Define _Tire's_ callbacks (<after|before>_update_elasticsearch_index).
-          #
-          #define_model_callbacks(:update_elasticsearch_index, :only => [:after, :before]) if \
-          #  respond_to?(:define_model_callbacks)
-
-          # Serialize the model as a Hash.
-          #
-          # Uses `serializable_hash` representation of the model,
-          # unless implemented in the model already.
-          #
-          def to_hash
-            self.serializable_hash
-          end unless instance_methods.map(&:to_sym).include?(:to_hash)
-
-        end
-
-        # Alias _Tire's_ class methods in the top-level namespace of the model,
-        # unless there's a conflict with existing method.
-        #
-        ClassMethodsProxy::INTERFACE.each do |method|
-          base.class_eval <<-"end;", __FILE__, __LINE__ unless base.public_methods.map(&:to_sym).include?(method.to_sym)
-            def self.#{method}(*args, &block)                     # def search(*args, &block)
-              tire.__send__(#{method.inspect}, *args, &block)     #   tire.__send__(:search, *args, &block)
-            end                                                   # end
-          end;
-        end
-
-        # Alias _Tire's_ instance methods in the top-level namespace of the model,
-        # unless there's a conflict with existing method
-        InstanceMethodsProxy::INTERFACE.each do |method|
-          base.class_eval <<-"end;", __FILE__, __LINE__ unless base.instance_methods.map(&:to_sym).include?(method.to_sym)
-            def #{method}(*args, &block)                          # def to_indexed_json(*args, &block)
-              tire.__send__(#{method.inspect}, *args, &block)     #   tire.__send__(:to_indexed_json, *args, &block)
-            end                                                   # end
-          end;
-        end
-
-        # Include the `load` functionality in Results::Item
-        #
-        Results::Item.send :include, Loader
-      end
-
-      
-    end
-
-  end
-end