flare 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+flare-solr.pid

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Michael Dwan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,18 @@
+= flare
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Michael Dwan. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "flare"
+    gem.executables= 'flare-solr'
+    gem.summary = 'This needs to get updated'
+    gem.description = 'This needs to get updated'
+    gem.email = "mpdwan@gmail.com"
+    gem.homepage = "http://github.com/michaeldwan/flare"
+    gem.authors = ["Michael Dwan"]
+    gem.add_dependency('rsolr', '>= 0.9.6')
+    gem.add_dependency('escape', '>= 0.0.4')
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "flare #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/flare-solr

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+using_gems = false
+begin
+  require 'fileutils'
+  require 'tempfile'
+  require 'tmpdir'
+  require 'optparse'
+  require 'daemons'
+rescue LoadError => e
+  if using_gems
+    raise(e)
+  else
+    using_gems = true
+    require 'rubygems'
+    retry
+  end
+end
+
+working_directory = FileUtils.pwd
+solr_install = File.expand_path(File.join(File.dirname(__FILE__), '..', 'solr'))
+
+port      = '8983'
+data_dir  = File.expand_path(File.join(Dir.tmpdir, 'solr_data'))
+solr_home = File.join(solr_install, 'solr')
+pid_dir   = working_directory
+log_file  = nil
+log_level = 'OFF'
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: flare-solr start [options]"
+
+  opts.on '-p', '--port=PORT', 'Port on which to run Solr (default 8983)' do |p|
+    port = p
+  end
+
+  opts.on '-d', '--data-directory=DIRECTORY', 'Solr data directory' do |d|
+    data_dir = File.expand_path(d)
+  end
+
+  opts.on '-s', '--solr-home=HOME', 'Solr home directory (should contain conf/ directory)' do |s|
+    solr_home = File.expand_path(s)
+  end
+
+  opts.on '--pid-dir=PID_DIR', 'Directory for pid files' do |pd|
+    pid_dir = File.expand_path(pd)
+  end
+
+  opts.on '-l', '--log-level=LOG_LEVEL', 'Solr logging level' do |l|
+    log_level = l
+  end
+
+  opts.on '--log-file=LOG_FILE', 'Path to Solr log file' do |lf|
+    log_file = File.expand_path(lf)
+  end
+end.parse!
+
+options = { :dir_mode => :normal, :dir => pid_dir }
+
+def logging_properties( log_file, log_level )
+  temp_file = Tempfile.new 'logging.properties'
+  temp_file << <<PROPERTIES
+.level = #{log_level}
+handlers = java.util.logging.FileHandler
+java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
+java.util.logging.FileHandler.pattern   = #{log_file}
+PROPERTIES
+  temp_file.flush
+  temp_file.close
+  temp_file.path
+end
+
+Daemons.run_proc('flare-solr', options) do
+  FileUtils.cd(solr_install) do
+    args = ['java']
+    args << "-Djetty.port=#{port}" if port
+    args << "-Dsolr.data.dir=#{data_dir}" if data_dir
+    args << "-Dsolr.solr.home=#{solr_home}" if solr_home
+    args << "-Djava.util.logging.config.file=#{logging_properties(log_file, log_level)}" if log_file and log_level != 'OFF'
+    args << '-jar' << File.join(solr_install, 'start.jar')
+    STDERR.puts(args * ' ')
+    Kernel.exec(*args)
+  end
+end

data/flare.gemspec

@@ -0,0 +1,91 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{flare}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Dwan"]
+  s.date = %q{2009-11-03}
+  s.default_executable = %q{flare-solr}
+  s.description = %q{This needs to get updated}
+  s.email = %q{mpdwan@gmail.com}
+  s.executables = ["flare-solr"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "bin/flare-solr",
+     "flare.gemspec",
+     "lib/flare.rb",
+     "lib/flare/active_record.rb",
+     "lib/flare/collection.rb",
+     "lib/flare/configuration.rb",
+     "lib/flare/index_builder.rb",
+     "lib/flare/session.rb",
+     "lib/flare/tasks.rb",
+     "solr/etc/jetty.xml",
+     "solr/etc/webdefault.xml",
+     "solr/lib/jetty-6.1.3.jar",
+     "solr/lib/jetty-util-6.1.3.jar",
+     "solr/lib/jsp-2.1/ant-1.6.5.jar",
+     "solr/lib/jsp-2.1/core-3.1.1.jar",
+     "solr/lib/jsp-2.1/jsp-2.1.jar",
+     "solr/lib/jsp-2.1/jsp-api-2.1.jar",
+     "solr/lib/servlet-api-2.5-6.1.3.jar",
+     "solr/solr/conf/elevate.xml",
+     "solr/solr/conf/protwords.txt",
+     "solr/solr/conf/schema.xml",
+     "solr/solr/conf/solrconfig.xml",
+     "solr/solr/conf/stopwords.txt",
+     "solr/solr/conf/synonyms.txt",
+     "solr/solr/lib/geoapi-nogenerics-2.1-M2.jar",
+     "solr/solr/lib/gt2-referencing-2.3.1.jar",
+     "solr/solr/lib/jsr108-0.01.jar",
+     "solr/solr/lib/locallucene.jar",
+     "solr/solr/lib/localsolr.jar",
+     "solr/start.jar",
+     "solr/webapps/solr.war",
+     "test/helper.rb",
+     "test/test_flare.rb"
+  ]
+  s.homepage = %q{http://github.com/michaeldwan/flare}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{This needs to get updated}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_flare.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rsolr>, [">= 0.9.6"])
+      s.add_runtime_dependency(%q<escape>, [">= 0.0.4"])
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    else
+      s.add_dependency(%q<rsolr>, [">= 0.9.6"])
+      s.add_dependency(%q<escape>, [">= 0.0.4"])
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rsolr>, [">= 0.9.6"])
+    s.add_dependency(%q<escape>, [">= 0.0.4"])
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+  end
+end
+

data/lib/flare/active_record.rb

@@ -0,0 +1,102 @@
+module Flare
+  module ActiveRecord
+    def self.included(base)
+      base.extend Hook
+    end
+
+    module Hook
+      def searchable(&block)
+        Flare.indexed_models << self unless Flare.indexed_models.include?(self)
+        
+        builder = IndexBuilder.new(&block)
+        solr_index = builder.index
+        
+        write_inheritable_attribute :solr_index, solr_index
+        class_inheritable_reader :solr_index
+        
+        after_save :solr_save
+        after_destroy :solr_destroy
+        
+        include InstanceMethods
+        extend ClassMethods
+      end
+      
+      def searchable?
+        false
+      end
+    end
+    
+    module ClassMethods
+      def search_for_ids(*args)
+        options = args.extract_options!
+        options[:types] ||= []
+        options[:types] << self
+        Flare.session.search_for_ids(*[args, options].flatten)
+      end
+
+      def search(*args)
+        options = args.extract_options!
+        options[:types] ||= []
+        options[:types] << self
+        Flare.session.search(*[args, options].flatten)
+      end
+
+      def search_count(*args)
+        options = args.extract_options!
+        options[:types] ||= []
+        options[:types] << self
+        Flare.session.count(*[args, options].flatten)
+      end
+      
+      def searchable?
+        true
+      end
+      
+      def rebuild_solr_index
+        total = self.count
+        count = 0
+        self.find_in_batches(:batch_size => 100) do |batch|
+          Flare.session.index(batch)
+          count += batch.length
+          printf "\r#{count}/#{total} complete"
+          STDOUT.flush
+        end
+        puts
+        Flare.session.commit
+        Flare.session.optimize
+      end
+      
+      def clear_solr_index
+        Flare.session.remove_all!(self)
+      end
+    end
+    
+    module InstanceMethods
+      def to_solr_doc
+        doc = { :id => solr_document_id, :type => self.class.name }
+        solr_index[:fields].each do |field|
+          value = send(field[:source])
+          # Need to convert dates to utc xmlschema.
+          #TODO: move this translation to rsolr gem
+          if value.respond_to?(:utc)
+            value = value.utc.xmlschema
+          end
+          doc[field[:name]] = value
+        end
+        doc
+      end
+      
+      def solr_document_id
+        "#{self.class.name}:#{self.id}"
+      end
+      
+      def solr_save
+        Flare.session.index!(self)
+      end
+      
+      def solr_destroy
+        Flare.session.remove!(self)
+      end
+    end
+  end
+end

data/lib/flare/collection.rb

@@ -0,0 +1,47 @@
+module Flare
+  class Collection < ::Array
+    attr_reader :total_entries, :total_pages, :current_page, :per_page
+    attr_accessor :response
+
+    def initialize(page, per_page, total)
+      @current_page, @per_page, @total_entries = page, per_page, total
+      
+      @total_pages = (@total_entries / @per_page.to_f).ceil
+    end
+    
+    def self.ids_from_response(response, page, per_page, options)
+      collection = self.new(page, per_page, response['response']['numFound'] || 0)
+      collection.response = response
+      collection.replace(response['response']['docs'].map {|doc| doc['id']})
+      return collection
+    end
+    
+    def self.create_from_response(response, page, per_page, options)
+      # raise response.inspect
+      collection = self.new(page, per_page, response['response']['numFound'] || 0)
+      collection.response = response      
+      collection.replace(instantiate_objects(response))
+      return collection
+    end
+    
+    def previous_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+    
+    def next_page
+      current_page < total_pages ? (current_page + 1): nil
+    end
+    
+    def offset
+      (current_page - 1) * @per_page
+    end
+    
+    private
+      def self.instantiate_objects(response)
+        response['response']['docs'].map do |doc|
+          type, id = doc['id'].split(':')
+          type.constantize.find(id)
+        end
+      end
+  end
+end

data/lib/flare/configuration.rb

@@ -0,0 +1,76 @@
+require 'yaml'
+
+module Flare
+  class Configuration
+    class << self
+      attr_reader :client, :server
+      
+      def server(reload = false)
+        @server = nil if reload
+        @server ||= Server.new
+      end
+
+      def client(reload = false)
+        @client = nil if reload
+        @client = Client.new
+      end
+    end
+
+    private
+      class Server
+        def initialize
+          @config = YAML::load_file(File.join(Rails.root, 'config', 'solr.yml'))[Rails.env]
+        end
+
+        def port
+          @port ||= (@config['port'] || 8983).to_i
+        end
+
+        def log_dir
+          @log_dir ||= File.expand_path(@config['log_dir'] || 'log')
+        end
+
+        def log_level
+          @log_level ||= @config['log_level'] || 'INFO'
+        end
+
+        def data_dir
+          @data_dir ||= File.expand_path(@config['data_dir'] || File.join('solr', 'data', Rails.env))
+        end
+
+        def solr_home
+          @solr_home ||= File.expand_path(@config['solr_home'] || File.join(File.dirname(__FILE__), '..', '..', 'solr', 'solr'))
+        end
+
+        def pid_dir
+          @pid_dir ||= File.expand_path(@config['pid_dir'] || 'tmp/pids')
+        end
+
+        def jvm_options
+          @jvm_options ||= @config['jvm_options']
+        end        
+      end
+
+      class Client
+        def initialize
+          @config = YAML::load_file(File.join(Rails.root, 'config', 'flare.yml'))[Rails.env]
+        end
+
+        def port
+          @port ||= (@config['port'] || 8983).to_i
+        end
+
+        def host
+          @host ||= @config['host'] || '127.0.0.1'
+        end
+
+        def path
+          @path ||= @config['path'] || 'solr'
+        end
+        
+        def url
+          @url ||= "http://#{host}:#{port}/#{path}"
+        end
+      end
+  end
+end

data/lib/flare/index_builder.rb

@@ -0,0 +1,24 @@
+module Flare
+  class IndexBuilder
+    attr_reader :fields
+
+    def initialize(&block)
+      @fields = []
+      self.instance_eval(&block) if block_given?
+    end
+
+    def index
+      { :fields => @fields }
+    end
+
+    protected
+      def field(*args)
+        field, options = args.first, args.extract_options!
+        @fields << {
+          :source => field, 
+          :name => options[:as] || field, 
+          :boost => options[:boost] || nil
+          }
+      end
+  end
+end

data/lib/flare/session.rb

@@ -0,0 +1,142 @@
+module Flare
+  class Session
+    RESULT_LIMIT = 1000
+    PER_PAGE = 16
+    
+    def connection
+      @connection ||= RSolr.connect(:url => Flare::Configuration.client.url)
+    end
+
+    delegate :commit, :optimize, :to => :connection
+
+    def search_for_ids(*args)
+      response = execute(*args)
+      Flare::Collection.ids_from_response(response, response[:request][:page], response[:request][:per_page], response[:request])
+    end
+
+    def search(*args)
+      response = execute(*args)
+      Flare::Collection.create_from_response(response, response[:request][:page], response[:request][:per_page], response[:request])
+    end
+
+    def count(*args)
+      execute(*args)[:response][:numFound]
+    end
+    
+    def index(*objects)
+      objects = ensure_searchable(objects)
+      connection.add(objects.collect(&:to_solr_doc))
+    end
+    
+    def index!(*objects)
+      index(objects)
+      commit
+    end
+    
+    def remove(*objects)
+      objects = ensure_searchable(objects)
+      connection.delete_by_id(objects.collect(&:solr_document_id))
+    end
+    
+    def remove!(*objects)
+      remove(objects)
+      commit
+    end
+    
+    def remove_all(*types)
+      types = Array(types).flatten.select { |type| type.searchable? }
+      connection.delete_by_query(types.map { |type| "type:#{type.name}" }.join(' OR '))
+    end
+    
+    def remove_all!(*types)
+      remove_all(types)
+      commit
+      optimize
+    end
+    
+    private
+      def execute(*args)
+        options = args.extract_options!
+        
+        options.reverse_merge!({
+          :page => 1,
+          :per_page => PER_PAGE,
+          :limit => RESULT_LIMIT,
+          :fields => '* score',
+        })
+
+        options.assert_valid_keys(:filter, :types, :page, :per_page, :limit, :fields, :order, :facet)
+        
+        query = {
+          :q => args,
+          :fq => Array(options[:filter]).flatten,
+          :fl => options[:fields],
+          :start => start = (options[:page] -1) * options[:per_page],
+          :rows => options[:per_page]
+        }
+        
+        if options[:facets]
+          query[:facets] = true
+          query['facet.field'] = options[:facets][:fields]
+          query['facet.query'] = options[:facets][:queries]
+          query['facet.mincount'] = options[:facets][:mincount] || 1
+          query["facet.limit"] = options[:facets][:limit]
+          
+          query["facet.missing"] = @params[:facets][:missing]
+          query["facet.mincount"] = @params[:facets][:mincount]
+          query["facet.prefix"] = @params[:facets][:prefix]
+          query["facet.offset"] = @params[:facets][:offset]
+        end        
+        
+        
+        if options[:types]
+          query[:fq] << Array(options[:types]).map {|type| "type:#{type}"}.join(" OR ")
+        end
+        
+        query[:q] = query.delete(:fq) if query[:q].blank?
+        
+        ::ActiveRecord::Base.logger.debug(<<-SOLR.squish)
+          \e[4;32mSolr Query:\e[0;1m 
+          #{query[:q].join(', ')} 
+          #{"(#{query[:fq].join(' AND ')})," if query[:fq] } 
+          sort: #{query[:order]} 
+          start: #{query[:start]}, 
+          rows: #{query[:rows]}
+        SOLR
+
+        response = connection.select(query)
+        response[:request] = query
+        response[:request][:page] = options[:page]
+        response[:request][:per_page] = options[:per_page]
+        response.with_indifferent_access
+      end
+      
+      def ensure_searchable(*objects)
+        Array(objects).flatten.select { |object| object.class.searchable? }
+      end
+      
+      def prepare_query(query)
+        query[:page] ||= query[:page] ? query[:page].to_i : 1
+        query[:per_page] ||= PER_PAGE
+        query[:limit] ||= RESULT_LIMIT
+        query[:fields] ||= '* score'
+        query
+      end
+      
+      # I dont like this... Can we move it to hash if a library like ActiveSupport doesn't already have it?
+      def symbolize_keys(hash)
+        hash.inject({}){|result, (key, value)|  
+          new_key = case key  
+                    when String then key.to_sym  
+                    else key  
+                    end  
+          new_value = case value  
+                      when Hash then symbolize_keys(value)  
+                      else value  
+                      end  
+          result[new_key] = new_value  
+          result  
+        }  
+      end
+  end
+end