tire 0.1.0

data/lib/tire/model/indexing.rb

@@ -0,0 +1,50 @@
+module Tire
+  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/tire/model/naming.rb

@@ -0,0 +1,30 @@
+module Tire
+  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/tire/model/persistence.rb

@@ -0,0 +1,34 @@
+module Tire
+  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 Tire::Model::Search
+          include Tire::Model::Callbacks
+
+          extend  Persistence::Finders::ClassMethods
+          extend  Persistence::Attributes::ClassMethods
+          include Persistence::Attributes::InstanceMethods
+
+          include Persistence::Storage
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,60 @@
+module Tire
+  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

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

@@ -0,0 +1,61 @@
+module Tire
+  module Model
+
+    module Persistence
+
+      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).query do |query|
+                query.ids(args, document_type)
+              end.perform.results
+            else
+              case args = args.pop
+                when Fixnum, String
+                  Index.new(index_name).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.perform.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.perform.results.first
+          ensure
+            Tire::Configuration.wrapper old_wrapper
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,75 @@
+module Tire
+  module Model
+
+    module Persistence
+
+      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
+
+          def index
+            @index = Index.new(index_name)
+          end
+
+        end
+
+        module InstanceMethods
+
+          def update_attribute(name, value)
+            send("#{name}=", value)
+            save
+          end
+
+          def update_attributes(attributes={})
+            attributes.each do |name, value|
+              send("#{name}=", value)
+            end
+            save
+          end
+
+          def save
+            return false unless valid?
+            run_callbacks :save do
+              # Document#id is set in the +update_elastic_search_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

@@ -0,0 +1,97 @@
+module Tire
+  module Model
+
+    module Search
+
+      def self.included(base)
+        base.class_eval do
+          extend  Tire::Model::Naming::ClassMethods
+          include Tire::Model::Naming::InstanceMethods
+
+          extend  Tire::Model::Indexing::ClassMethods
+          extend  Tire::Model::Import::ClassMethods
+
+          extend  ClassMethods
+          include InstanceMethods
+
+          ['_score', '_type', '_index', '_version', 'sort', 'highlight'].each do |attr|
+            # TODO: Find a sane way to add attributes like _score for ActiveRecord -
+            #       `define_attribute_methods [attr]` does not work in AR.
+            define_method("#{attr}=") { |value| @attributes ||= {}; @attributes[attr] = value }
+            define_method("#{attr}")  { @attributes[attr] }
+          end
+        end
+      end
+
+      module ClassMethods
+
+        def search(query=nil, options={}, &block)
+          old_wrapper = Tire::Configuration.wrapper
+          Tire::Configuration.wrapper self
+          sort  = options[:order] || options[:sort]
+          sort  = Array(sort)
+          unless block_given?
+            s = Tire::Search::Search.new(index.name, options)
+            s.query { string query }
+            s.sort do
+              sort.each do |t|
+                field_name, direction = t.split(' ')
+                field_name.include?('.') ? field(field_name, direction) : send(field_name, direction)
+              end
+            end unless sort.empty?
+            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.perform.results
+          else
+            s = Tire::Search::Search.new(index.name, options)
+            block.arity < 1 ? s.instance_eval(&block) : block.call(s)
+            s.perform.results
+          end
+        ensure
+          Tire::Configuration.wrapper old_wrapper
+        end
+
+        def index
+          @index = Index.new(index_name)
+        end
+
+      end
+
+      module InstanceMethods
+
+        def score
+          attributes['_score']
+        end
+
+        def index
+          self.class.index
+        end
+
+        def update_elastic_search_index
+          if destroyed?
+            self.class.index.remove document_type, self
+          else
+            response  = self.class.index.store  document_type, self
+            self.id ||= response['_id'] if self.respond_to?(:id=)
+            self
+          end
+        end
+
+        def to_indexed_json
+          if self.class.mapping.empty?
+            self.serializable_hash.
+              to_json
+          else
+            self.serializable_hash.
+              reject { |key, value| ! self.class.mapping.keys.map(&:to_s).include?(key.to_s) }.
+              to_json
+          end
+        end
+
+      end
+
+      extend ClassMethods
+    end
+
+  end
+end

data/lib/tire/results/collection.rb

@@ -0,0 +1,56 @@
+module Tire
+  module Results
+
+    class Collection
+      include Enumerable
+      include Pagination
+
+      attr_reader :time, :total, :options, :results, :facets
+
+      def initialize(response, options={})
+        @options = options
+        @time    = response['took'].to_i
+        @total   = response['hits']['total'].to_i
+        @results = response['hits']['hits'].map do |h|
+                     if Configuration.wrapper == Hash then h
+                     else
+                       document = {}
+
+                       # Update the document with content and ID
+                       document = h['_source'] ? document.update( h['_source'] || {} ) : document.update( h['fields'] || {} )
+                       document.update( {'id' => h['_id']} )
+
+                       # Update the document with meta information
+                       ['_score', '_version', 'sort', 'highlight'].each { |key| document.update( {key => h[key]} || {} ) }
+
+                       object = Configuration.wrapper.new(document)
+                       # TODO: Figure out how to circumvent mass assignment protection for id in ActiveRecord
+                       object.id = h['_id'] if object.respond_to?(:id=)
+                       # TODO: Figure out how mark record as "not new record" in ActiveRecord
+                       object.instance_variable_set(:@new_record, false) if object.respond_to?(:new_record?)
+                       object
+                     end
+                   end
+        @facets  = response['facets']
+      end
+
+      def each(&block)
+        @results.each(&block)
+      end
+
+      def empty?
+        @results.empty?
+      end
+
+      def size
+        @results.size
+      end
+
+      def to_ary
+        self
+      end
+
+    end
+
+  end
+end