lucid_works 0.7.18 → 0.9.4

data/lib/lucid_works/elevation.rb

@@ -0,0 +1,93 @@
+class Array
+  def move(from, to)
+    insert(to, delete_at(from))
+  end
+end
+
+module LucidWorks
+  class Elevation
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+    extend SimpleNaming
+
+    attr_reader :id, :collection, :query, :doc_id, :excluded
+    alias :excluded? :excluded
+
+    def initialize(attributes = {})
+      @doc_id = attributes[:doc_id]
+      @collection = attributes[:collection]
+      @query = attributes[:query]
+      @excluded = [true, "true"].include? attributes[:excluded]
+      @persisted = [true, "true"].include? attributes[:persisted]
+      @id = "#{CGI.escape query}~~#{doc_id}"
+    end
+    
+    def save
+      settings.elevations[query] ||= []
+      settings.elevations[query] << {'doc' => doc_id, 'exclude' => excluded?}
+      settings.save
+      @persisted = true
+    rescue
+      false
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def destroy
+      return unless settings.elevations.include?(query)
+      settings.elevations[query].delete_if {|elevation| "#{CGI.escape query}~~#{elevation['doc']}" == id }
+      settings.elevations.delete(query) if settings.elevations[query].empty?
+      settings.save
+    end
+
+    def first?
+      index_of_in_elevations(doc_id) == 0
+    end
+    
+    def last?
+      index_of_in_elevations(doc_id) == elevations.size - 1
+    end
+    
+    def move_up
+      return if first?
+      current_index = index_of_in_settings(doc_id)
+      new_index = elevation_indexes[elevation_indexes.index(current_index) - 1]
+      settings.elevations[query].move(current_index, new_index)
+      settings.save
+    end
+    
+    def move_down
+      return if last?
+      current_index = index_of_in_settings(doc_id)
+      new_index = elevation_indexes[elevation_indexes.index(current_index) + 1]
+      settings.elevations[query].move(current_index, new_index)
+      settings.save
+    end
+    
+    private
+    
+      def settings
+        collection.build_settings(:elevations => collection.settings.elevations)
+      end
+
+      def index_of_in_settings(doc_id)
+        settings.elevations[query].index {|elevation| elevation['doc'] == doc_id }      
+      end
+
+      def elevations
+        settings.elevations[query].index.select {|elevation| !elevation['exclude'] }
+      end
+
+      def index_of_in_elevations(doc_id)
+        elevations.index {|elevation| elevation['doc'] == doc_id }
+      end
+
+      def elevation_indexes
+        indexes = []
+        settings.elevations[query].each_with_index {|elevation, index| indexes << index if !elevation['exclude'] }
+        indexes
+      end
+  end
+end

data/lib/lucid_works/exceptions.rb

@@ -4,8 +4,4 @@ module LucidWorks
 
   class ResourceNotFound < Exception ; end
   class RecordInvalid < Exception ; end
-  class AclConfigInvalid < Exception
-    attr_accessor :messages;
-    def initialize(messages); @messages = messages; end
-  end
 end

data/lib/lucid_works/field.rb

@@ -1,39 +1,38 @@
+require 'lucid_works/field_commons'
+
 module LucidWorks
 
   class Field < Base
-    belongs_to :collection
-
-    INDEXING_OPTIONS = [
-      'document_only',
-      'document_termfreq',
-      'document_termfreq_termpos'
-    ]
+    include LucidWorks::FieldCommons
+    
+    class << self
+      attr_accessor :include_dynamic
+      
+      def collection_url(parent)
+        include_dynamic ? "#{super}?include_dynamic=true" : super
+      end
 
-    BOOST_VALUES = [
-      'none',
-      'moderate',
-      'high'
-    ]
+      def member_url(parent, id = nil)
+        include_dynamic ? "#{super}?include_dynamic=true" : super
+      end
+    end
 
     schema do
-      attribute :name, :string, :primary_key => true, :omit_during_update => true
-      attribute :editable, :boolean, :omit_during_update => true
-      attribute :dynamic_base, :string, :omit_during_update => true
-      attributes :indexed, :stored, :facet, :include_in_results,
-                 :search_by_default, :highlight, :multi_valued,
-                 :term_vectors, :omit_tf, :omit_positions,
-                 :use_for_deduplication, :synonym_expansion,
-                 :index_for_spellcheck, :index_for_autocomplete,
-                 :query_time_stopword_handling,
-                 :use_in_find_similar,
-                 :type => :boolean
       attribute :default_boost, :integer
-      attributes :field_type, :short_field_boost, :term_vectors, :default_value, :type => :string
-      attribute :copy_fields, :list
-      attribute :indexing_options, :custom, :values => INDEXING_OPTIONS
-    end
-
-    validates_presence_of :name
+      attribute :default_value, :string
+      attribute :dynamic_base, :string, :omit_during_update => true
+      attribute :facet, :boolean
+      attribute :highlight, :boolean
+      attribute :include_in_results, :boolean
+      attribute :num_facets, :integer
+      attribute :query_time_stopword_handling, :boolean
+      attribute :search_by_default, :boolean
+      attribute :short_field_boost, :string
+      attribute :synonym_expansion, :boolean
+      attribute :use_for_deduplication, :boolean
+      attribute :use_in_find_similar, :boolean
+    end
+    
     validates_each :name, :unless => :persisted?, :allow_blank => true do |model, attr, value|
       model.errors.add(attr, 'must be unique') if model.collection.fields.any? {|f| f.name == value }
     end
@@ -52,92 +51,15 @@ module LucidWorks
     validates_each :use_in_find_similar do |model, attr, value|
       model.errors.add(attr, 'a field must be indexed for it to be used for find-similar') if value == true && !model.indexed?
     end
-    validates_each :indexing_options do |model, attr, value|
-      if model.persisted?
-        if value
-          if model.indexed?
-            model.errors.add(attr, "must be one of #{INDEXING_OPTIONS.join(', ')}") unless INDEXING_OPTIONS.include?(value.to_s)
-          end
-        else
-          # If the model is already persisted, but the user has not manually set indexing_options,
-          # just go with the omit_tf/omit_positions we have now.
-        end
-      else # new model
-        if model.indexed?
-          # If this is a new model, and the user set 'indexed' they MUST also set indexing_options
-          model.errors.add(attr, "must be one of #{INDEXING_OPTIONS.join(', ')}") unless INDEXING_OPTIONS.include?(value.to_s)
-        end
-      end
-    end
-
-    before_save :convert_indexing_options_to_term_freq_and_pos
 
     def initialize(options)
-      super(options.reverse_merge(:omit_tf => false, :short_field_boost => 'high'))
+      super(options.reverse_merge(:short_field_boost => 'high'))
     end
 
-    def dynamically_generated?
+    def dynamically_generated
       !dynamic_base.blank?
     end
-
-    def t_field_type
-      self.class.t_field_type(self.field_type)
-    end
-
-    def self.t_field_type(type)
-      I18n.translate(type, :scope => 'activemodel.models.lucid_works.collection.field.field_type')
-    end
-
-    # Indexing_options is a fake attribute that wraps the omit_tf and omit_positions combinations.
-    # Translations are:
-    #
-    #   INDEXED?     indexing_options                    omit_tf         omit_positions
-    #
-    #   false           -                                 true              true
-    #   true            :document_only                    true              true
-    #   true            :document_termfreq                false             true
-    #   true            :documents_termfreq_termpos       false             false
-    #
-    def indexing_options
-      @attributes[:indexing_options] ||=
-        if !indexed? || omit_tf?
-          :document_only
-        else
-          omit_positions? ? :document_termfreq : :document_termfreq_termpos
-        end
-    end
-
-    # We have to remember the caller's choice of indexing_options, as we can't determine the correct
-    # omit_tf/omit_positions settins until we also know whether 'indexed' is set or not.
-    # So we keep it as an attribute for now, and remove it in a before_save.
-    def indexing_options=(new_value)
-      @attributes[:indexing_options] = new_value
-    end
-
-    # Convert indexing_options to the correct values for omit_tf and omit_positions.
-    # Delete indexing_options from attributes so it is not saved.
-    def convert_indexing_options_to_term_freq_and_pos
-      i_opt = @attributes.delete(:indexing_options)
-      if indexed? && i_opt
-        case i_opt.to_sym
-        when :document_only
-          self.omit_tf = true
-          self.omit_positions = true
-        when :document_termfreq
-          self.omit_tf = false
-          self.omit_positions = true
-        when :document_termfreq_termpos
-          self.omit_tf = false
-          self.omit_positions = false
-        else
-          raise "Unknown indexing option: '#{i_opt}'. Allowed values are: #{INDEXING_OPTIONS.join(', ')}"
-        end
-      else # !indexed?
-        self.omit_tf = true
-        self.omit_positions = true
-      end
-      true
-    end
+    alias :dynamically_generated? :dynamically_generated
 
     def update_attributes(attrs)
       attrs = attrs.with_indifferent_access
@@ -148,8 +70,6 @@ module LucidWorks
       if [false, '0'].include?(attrs[:indexed])
         attrs[:facet] ||= false
         attrs[:synonym_expansion] ||= false
-        attrs[:omit_tf] ||= false 
-        attrs[:omit_positions] ||= false
         attrs[:short_field_boost] ||= 'high'
         attrs[:search_by_default] ||= false
         attrs[:use_in_find_similar] ||= false

data/lib/lucid_works/field_commons.rb

@@ -0,0 +1,133 @@
+module LucidWorks
+
+  module FieldCommons
+    extend ActiveSupport::Concern
+    
+    included do
+      belongs_to :collection
+      
+      INDEXING_OPTIONS = [
+        'document_only',
+        'document_termfreq',
+        'document_termfreq_termpos'
+      ] unless defined?(INDEXING_OPTIONS)
+
+      BOOST_VALUES = [
+        'none',
+        'moderate',
+        'high'
+      ] unless defined?(BOOST_VALUES)
+      
+      schema do
+        attribute :name, :string, :primary_key => true, :omit_during_update => true
+        attribute :copy_fields, :list
+        attribute :editable, :boolean, :omit_during_update => true
+        attribute :field_type, :string
+        attribute :index_for_autocomplete, :boolean
+        attribute :index_for_spellcheck, :boolean
+        attribute :indexed, :boolean
+        attribute :indexing_options, :custom, :values => INDEXING_OPTIONS
+        attribute :multi_valued, :boolean
+        attribute :omit_positions, :boolean
+        attribute :omit_tf, :boolean
+        attribute :stored, :boolean
+        attribute :term_vectors, :boolean
+      end
+      
+      validates_presence_of :name, :field_type
+      validates_each :indexing_options do |model, attr, value|
+        if model.persisted?
+          if value
+            if model.indexed?
+              model.errors.add(attr, "must be one of #{INDEXING_OPTIONS.join(', ')}") unless INDEXING_OPTIONS.include?(value.to_s)
+            end
+          else
+            # If the model is already persisted, but the user has not manually set indexing_options,
+            # just go with the omit_tf/omit_positions we have now.
+          end
+        else # new model
+          if model.indexed?
+            # If this is a new model, and the user set 'indexed' they MUST also set indexing_options
+            model.errors.add(attr, "must be one of #{INDEXING_OPTIONS.join(', ')}") unless INDEXING_OPTIONS.include?(value.to_s)
+          end
+        end
+      end
+      
+      before_save :convert_indexing_options_to_term_freq_and_pos
+    end
+
+    module ClassMethods
+      def t_field_type(type)
+        I18n.translate(type, :scope => 'activemodel.models.collection.field.field_type')
+      end
+    end
+    
+    def initialize(options)
+      super(options.reverse_merge(:omit_tf => false))
+    end
+
+    def t_field_type
+      self.class.t_field_type(self.field_type)
+    end
+    
+    # Indexing_options is a fake attribute that wraps the omit_tf and omit_positions combinations.
+    # Translations are:
+    #
+    #   INDEXED?     indexing_options                    omit_tf         omit_positions
+    #
+    #   false           -                                 true              true
+    #   true            :document_only                    true              true
+    #   true            :document_termfreq                false             true
+    #   true            :documents_termfreq_termpos       false             false
+    #
+    def indexing_options
+      @attributes[:indexing_options] ||=
+        if !indexed? || omit_tf?
+          :document_only
+        else
+          omit_positions? ? :document_termfreq : :document_termfreq_termpos
+        end
+    end
+
+    # We have to remember the caller's choice of indexing_options, as we can't determine the correct
+    # omit_tf/omit_positions settins until we also know whether 'indexed' is set or not.
+    # So we keep it as an attribute for now, and remove it in a before_save.
+    def indexing_options=(new_value)
+      @attributes[:indexing_options] = new_value
+    end
+
+    # Convert indexing_options to the correct values for omit_tf and omit_positions.
+    # Delete indexing_options from attributes so it is not saved.
+    def convert_indexing_options_to_term_freq_and_pos
+      i_opt = @attributes.delete(:indexing_options)
+      if indexed? && i_opt
+        case i_opt.to_sym
+        when :document_only
+          self.omit_tf = true
+          self.omit_positions = true
+        when :document_termfreq
+          self.omit_tf = false
+          self.omit_positions = true
+        when :document_termfreq_termpos
+          self.omit_tf = false
+          self.omit_positions = false
+        else
+          raise "Unknown indexing option: '#{i_opt}'. Allowed values are: #{INDEXING_OPTIONS.join(', ')}"
+        end
+      else # !indexed?
+        self.omit_tf = true
+        self.omit_positions = true
+      end
+      true
+    end
+
+    def update_attributes(attrs)
+      attrs = attrs.with_indifferent_access
+      if [false, '0'].include?(attrs[:indexed])
+        attrs[:omit_positions] ||= false
+        attrs[:omit_tf] ||= false 
+      end
+      super(attrs)
+    end
+  end
+end

data/lib/lucid_works/gem_version.rb

@@ -1,3 +1,3 @@
 module LucidWorks
-  VERSION = "0.7.18"
+  VERSION = "0.9.4"
 end

data/lib/lucid_works/inflections.rb

@@ -0,0 +1,3 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.singular /^(cache)s/i, '\1'
+end

data/lib/lucid_works/patch_time.rb

@@ -21,6 +21,10 @@ class Time #:nodoc:
   end
 
   alias_method_chain :iso8601, :support_for_timezones_without_colons
+
+  def ceil(seconds = 60)
+    Time.at((self.to_f / seconds).ceil * seconds)
+  end
 end
 
 class Fixnum

data/lib/lucid_works/request_handler.rb

@@ -0,0 +1,16 @@
+module LucidWorks
+  
+  class RequestHandler
+    
+    attr_reader :name
+
+    def initialize(collection, name)
+      @collection = collection
+      @name = name
+    end
+
+    def default_params
+      @collection.search(:qt => '/lucid', :echoParams => 'all')['responseHeader']['params'].symbolize_keys
+    end
+  end
+end

data/lib/lucid_works/role.rb

@@ -18,10 +18,17 @@ module LucidWorks
     end
     
     def filters
-      # require 'ruby-debug'; debugger
       @attributes[:filters]
     end
     
+    def users_for_text_field
+      @attributes[:users].to_a.join(", ")
+    end
+
+    def groups_for_text_field
+      @attributes[:groups].to_a.join(", ")
+    end
+
     def filters_for_text_area
       @attributes[:filters].to_a.join("\n")
     end
@@ -30,24 +37,27 @@ module LucidWorks
     # Accept a comma or space separated list of users, convert to array
     #
     def users=(val)
-      @attributes[:users] = string_or_array(val, /[\s,]+/) rescue "Can't interpret #{val.class} as list of users"
+      @attributes[:users] = string_or_array(val, :space_or_comma) rescue "Can't interpret #{val.class} as list of users"
     end
     
     def groups=(val)
-      @attributes[:groups] = string_or_array(val, /[\s,]+/) rescue "Can't interpret #{val.class} as list of groups"
+      @attributes[:groups] = string_or_array(val, :space_or_comma) rescue "Can't interpret #{val.class} as list of groups"
     end
     
     def filters=(val)
-      @attributes[:filters] = string_or_array(val, /\r+/) rescue "Can't interpret #{val.class} as list of groups"
-      # require 'ruby-debug'; debugger
-      # @attributes[:filters]
+      @attributes[:filters] = string_or_array(val, :newline) rescue "Can't interpret #{val.class} as list of groups"
     end
       
     private
     
-    def string_or_array(val, pattern)
+    def string_or_array(val, method)
       if val.is_a?(String)
-        val.split(pattern)
+        pattern = case method
+        when :space_or_comma ;  then (val =~ /,/) ? /[,]+/ : /\s+/
+        when :newline ;         then  /\r+/
+        else raise "Unrecognized split method #{method}, can't convert #{val} to an Array"
+        end
+        val.split(pattern).map{|item| remove_leading_and_trailing_spaces(item)}
       elsif val.is_a?(Array)
         val
       else
@@ -55,5 +65,10 @@ module LucidWorks
       end
       
     end
+    
+    def remove_leading_and_trailing_spaces(string)
+      string.sub(/^\s*(.*?)\s*$/,'\1') # remember everything in the middle, but non-greedy
+    end
+    
   end
 end

data/lib/lucid_works/schema/attribute.rb

@@ -60,7 +60,7 @@ module LucidWorks
         if values
           # If this attribute was defined with a set of :values,
           # assume we can get translations for those valuesfrom the L10n database.
-          l10n_scope = %w{activemodel models} + schema.model.name.underscore.split('/') + [name]
+          l10n_scope = %w{activemodel models} + schema.model.name.underscore.split('/').drop(1) + [name]
           return I18n.t(value, :scope => l10n_scope, :default => value)
         end
         value.to_s

data/lib/lucid_works/schema/boolean_attribute.rb

@@ -27,7 +27,7 @@ module LucidWorks
       end
 
       def human_value(value)
-        value.to_yesno
+        (!!value).to_yesno
       end
     end
   end

data/lib/lucid_works/schema/integer_attribute.rb

@@ -13,11 +13,10 @@ module LucidWorks
 
         klass.class_eval <<-EOF, __FILE__, __LINE__+1
           def #{name}=(new_value)
-            if new_value.blank? && (self.class.schema[:#{name}].nil_when_blank? ||
-                                    self.class.schema[:#{name}].omit_when_blank?)
-              new_value = nil
+            new_value = if new_value.blank? && (self.class.schema[:#{name}].nil_when_blank? || self.class.schema[:#{name}].omit_when_blank?)
+              nil
             else
-              new_value = new_value.to_i
+              Integer(new_value.to_s) rescue new_value
             end
             @attributes[:#{name}] = new_value
           end

data/lib/lucid_works/server/crawlers_status.rb

@@ -0,0 +1,15 @@
+module LucidWorks
+  class Server
+    class CrawlersStatus < Base
+      self.singleton = true
+
+      def self.member_url(parent, id = nil) # :nodoc:
+        "#{parent.uri}/crawlers/status"
+      end
+
+      def ok?
+        self.status == 'OK' rescue false
+      end
+    end
+  end
+end

data/lib/lucid_works/server.rb

@@ -8,32 +8,53 @@ module LucidWorks
     has_many :collections, :crawlers
     has_one :logs, :has_content => false
     has_one :version
+    has_one :crawlers_status
 
-    DEFAULT_REST_API_PATH = "/api"
+    attr_accessor :server_uri, :path, :protocol, :host, :port, :user, :password
 
-    attr_accessor :host, :path
+    def initialize(server_uri)
+      @server_uri = server_uri
+      uri = URI.parse(@server_uri)
+      @protocol, @host, @port, @user, @password = "#{uri.scheme}://", uri.host, uri.port, uri.user, uri.password
+    end
 
-    def initialize(server_uri, options = {})
-      @host = server_uri
-      @path = options.delete(:path) || DEFAULT_REST_API_PATH
+    def api_uri
+      "#{server_uri}/api"
     end
+    alias :uri :api_uri # used by associations
 
-    def uri
-      @host + @path
+    def solr_uri
+      "#{server_uri}/solr"
+    end
+
+    # Location where raw log files may be retrieved
+    def logs_uri
+      "#{server_uri}/logs"
     end
-    alias :rest_api_uri :uri
 
     def crawler(name)
-      crawlers.detect { |c| c.name == name }
+      crawlers.detect {|c| c.name == name }
     end
 
-    def solr_uri
-      "#{host}/solr/"
+    def datasource_type(type_name, crawler_name)
+      crawler(crawler_name).datasource_type(type_name)
     end
 
-    # Location where raw log files may be retrieved
-    def logs_url
-      "#{host}/logs/"
+    def clustered?
+      begin
+        RestClient.get(solr_uri + "/zookeeper")
+        true
+      rescue RestClient::ResourceNotFound
+        false
+      end
+    end
+    
+    def cluster
+      Cluster.new(solr_uri)
+    end
+    
+    def datasource_types
+      crawlers.collect(&:datasource_types).flatten
     end
   end
 end

data/lib/lucid_works/simple_naming.rb

@@ -1,13 +1,7 @@
 module LucidWorks
   module SimpleNaming
     def model_name
-      super.tap do |name|
-        name.instance_eval do
-          def singular; ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).tr('/', '_').freeze; end
-          def plural; singular.pluralize.freeze; end
-          def collection; ActiveSupport::Inflector.tableize(ActiveSupport::Inflector.demodulize(self)).freeze; end
-        end
-      end
+      ActiveModel::Name.new(self, nil, self.name.sub(/^LucidWorks::/, ''))
     end
   end
 end

data/lib/lucid_works/synonym.rb

@@ -6,7 +6,7 @@ module LucidWorks
     extend ActiveModel::Naming
     extend SimpleNaming
     
-    attr_reader :id, :collection, :persisted
+    attr_reader :id, :collection
     attr_accessor :mapping
     
     validates_presence_of :mapping

data/lib/lucid_works/version.rb

@@ -1,4 +1,5 @@
 module LucidWorks
   class Version < Base
+    self.singleton = true
   end
 end