isomorfeus-ferret 0.12.0

data/lib/isomorfeus/ferret/monitor.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: false
+# = monitor.rb
+#
+# Copyright (C) 2001  Shugo Maeda <shugo@ruby-lang.org>
+#
+# This library is distributed under the terms of the Ruby license.
+# You can freely distribute/modify this library.
+#
+
+#
+# In concurrent programming, a monitor is an object or module intended to be
+# used safely by more than one thread.  The defining characteristic of a
+# monitor is that its methods are executed with mutual exclusion.  That is, at
+# each point in time, at most one thread may be executing any of its methods.
+# This mutual exclusion greatly simplifies reasoning about the implementation
+# of monitors compared to reasoning about parallel code that updates a data
+# structure.
+#
+# You can read more about the general principles on the Wikipedia page for
+# Monitors[http://en.wikipedia.org/wiki/Monitor_%28synchronization%29]
+#
+# == Examples
+#
+# === Simple object.extend
+#
+#   require 'monitor.rb'
+#
+#   buf = []
+#   buf.extend(MonitorMixin)
+#   empty_cond = buf.new_cond
+#
+#   # consumer
+#   Thread.start do
+#     loop do
+#       buf.synchronize do
+#         empty_cond.wait_while { buf.empty? }
+#         print buf.shift
+#       end
+#     end
+#   end
+#
+#   # producer
+#   while line = ARGF.gets
+#     buf.synchronize do
+#       buf.push(line)
+#       empty_cond.signal
+#     end
+#   end
+#
+# The consumer thread waits for the producer thread to push a line to buf
+# while <tt>buf.empty?</tt>.  The producer thread (main thread) reads a
+# line from ARGF and pushes it into buf then calls <tt>empty_cond.signal</tt>
+# to notify the consumer thread of new data.
+#
+# === Simple Class include
+#
+#   require 'monitor'
+#
+#   class SynchronizedArray < Array
+#
+#     include MonitorMixin
+#
+#     def initialize(*args)
+#       super(*args)
+#     end
+#
+#     alias :old_shift :shift
+#     alias :old_unshift :unshift
+#
+#     def shift(n=1)
+#       self.synchronize do
+#         self.old_shift(n)
+#       end
+#     end
+#
+#     def unshift(item)
+#       self.synchronize do
+#         self.old_unshift(item)
+#       end
+#     end
+#
+#     # other methods ...
+#   end
+#
+# +SynchronizedArray+ implements an Array with synchronized access to items.
+# This Class is implemented as subclass of Array which includes the
+# MonitorMixin module.
+#
+module Isomorfeus
+  module Ferret
+    module MonitorMixin
+      #
+      # FIXME: This isn't documented in Nutshell.
+      #
+      # Since MonitorMixin.new_cond returns a ConditionVariable, and the example
+      # above calls while_wait and signal, this class should be documented.
+      #
+      class ConditionVariable
+        class Timeout < Exception; end
+
+        #
+        # Releases the lock held in the associated monitor and waits; reacquires the lock on wakeup.
+        #
+        # If +timeout+ is given, this method returns after +timeout+ seconds passed,
+        # even if no other thread doesn't signal.
+        #
+        def wait(timeout = nil)
+          Thread.handle_interrupt(Exception => :never) do
+            @monitor.__send__(:mon_check_owner)
+            count = @monitor.__send__(:mon_exit_for_cond)
+            begin
+              Thread.handle_interrupt(Exception => :immediate) do
+                @cond.wait(@monitor.instance_variable_get(:@mon_mutex), timeout)
+              end
+              return true
+            ensure
+              @monitor.__send__(:mon_enter_for_cond, count)
+            end
+          end
+        end
+
+        #
+        # Calls wait repeatedly while the given block yields a truthy value.
+        #
+        def wait_while
+          while yield
+            wait
+          end
+        end
+
+        #
+        # Calls wait repeatedly until the given block yields a truthy value.
+        #
+        def wait_until
+          until yield
+            wait
+          end
+        end
+
+        #
+        # Wakes up the first thread in line waiting for this lock.
+        #
+        def signal
+          @monitor.__send__(:mon_check_owner)
+          @cond.signal
+        end
+
+        #
+        # Wakes up all threads waiting for this lock.
+        #
+        def broadcast
+          @monitor.__send__(:mon_check_owner)
+          @cond.broadcast
+        end
+
+        private
+
+        def initialize(monitor)
+          @monitor = monitor
+          @cond = Thread::ConditionVariable.new
+        end
+      end
+
+      def self.extend_object(obj)
+        super(obj)
+        obj.__send__(:mon_initialize)
+      end
+
+      #
+      # Attempts to enter exclusive section.  Returns +false+ if lock fails.
+      #
+      def mon_try_enter
+        if @mon_owner != Thread.current
+          unless @mon_mutex.try_lock
+            return false
+          end
+          @mon_owner = Thread.current
+          @mon_count = 0
+        end
+        @mon_count += 1
+        return true
+      end
+      # For backward compatibility
+      alias try_mon_enter mon_try_enter
+
+      #
+      # Enters exclusive section.
+      #
+      def mon_enter
+        if @mon_owner != Thread.current
+          @mon_mutex.lock
+          @mon_owner = Thread.current
+          @mon_count = 0
+        end
+        @mon_count += 1
+      end
+
+      #
+      # Leaves exclusive section.
+      #
+      def mon_exit
+        mon_check_owner
+        @mon_count -=1
+        if @mon_count == 0
+          @mon_owner = nil
+          @mon_mutex.unlock
+        end
+      end
+
+      #
+      # Returns true if this monitor is locked by any thread
+      #
+      def mon_locked?
+        @mon_mutex.locked?
+      end
+
+      #
+      # Returns true if this monitor is locked by current thread.
+      #
+      def mon_owned?
+        @mon_mutex.locked? && @mon_owner == Thread.current
+      end
+
+      #
+      # Enters exclusive section and executes the block.  Leaves the exclusive
+      # section automatically when the block exits.  See example under
+      # +MonitorMixin+.
+      #
+      def mon_synchronize
+        # Prevent interrupt on handling interrupts; for example timeout errors
+        # it may break locking state.
+        Thread.handle_interrupt(Exception => :never){ mon_enter }
+        begin
+          yield
+        ensure
+          Thread.handle_interrupt(Exception => :never){ mon_exit }
+        end
+      end
+      alias synchronize mon_synchronize
+
+      #
+      # Creates a new MonitorMixin::ConditionVariable associated with the
+      # receiver.
+      #
+      def new_cond
+        return ConditionVariable.new(self)
+      end
+
+      private
+
+      # Use <tt>extend MonitorMixin</tt> or <tt>include MonitorMixin</tt> instead
+      # of this constructor.  Have look at the examples above to understand how to
+      # use this module.
+      def initialize(*args)
+        super
+        mon_initialize
+      end
+
+      # Initializes the MonitorMixin after being included in a class or when an
+      # object has been extended with the MonitorMixin
+      def mon_initialize
+        if defined?(@mon_mutex) && @mon_mutex_owner_object_id == object_id
+          raise ThreadError, "already initialized"
+        end
+        @mon_mutex = Thread::Mutex.new
+        @mon_mutex_owner_object_id = object_id
+        @mon_owner = nil
+        @mon_count = 0
+      end
+
+      def mon_check_owner
+        if @mon_owner != Thread.current
+          raise ThreadError, "current thread not owner"
+        end
+      end
+
+      def mon_enter_for_cond(count)
+        @mon_owner = Thread.current
+        @mon_count = count
+      end
+
+      def mon_exit_for_cond
+        count = @mon_count
+        @mon_owner = nil
+        @mon_count = 0
+        return count
+      end
+    end
+
+    # Use the Monitor class when you want to have a lock object for blocks with
+    # mutual exclusion.
+    #
+    #   require 'monitor'
+    #
+    #   lock = Monitor.new
+    #   lock.synchronize do
+    #     # exclusive access
+    #   end
+    #
+    class Monitor
+      include MonitorMixin
+      alias try_enter try_mon_enter
+      alias enter mon_enter
+      alias exit mon_exit
+    end
+  end
+end
+
+# Documentation comments:
+#  - All documentation comes from Nutshell.
+#  - MonitorMixin.new_cond appears in the example, but is not documented in
+#    Nutshell.
+#  - All the internals (internal modules Accessible and Initializable, class
+#    ConditionVariable) appear in RDoc.  It might be good to hide them, by
+#    making them private, or marking them :nodoc:, etc.
+#  - RDoc doesn't recognise aliases, so we have mon_synchronize documented, but
+#    not synchronize.
+#  - mon_owner is in Nutshell, but appears as an accessor in a separate module
+#    here, so is hard/impossible to RDoc.  Some other useful accessors
+#    (mon_count and some queue stuff) are also in this module, and don't appear
+#    directly in the RDoc output.
+#  - in short, it may be worth changing the code layout in this file to make the
+#    documentation easier

data/lib/isomorfeus/ferret/stdlib_patches.rb

@@ -0,0 +1,151 @@
+require 'date'
+require 'time'
+
+# Provides support for converting integers to Strings, and back again. The
+# strings are structured so that lexicographic sorting order is preserved.
+# 
+# That is, if integer1 is less than integer2 for any two integers integer1 and
+# integer2, then integer1.to_s_lex is lexicographically less than
+# integer2.to_s_lex. (Similarly for "greater than" and "equals".)
+#
+# This class handles numbers between - 10 ** 10,000 and 10 ** 10,000
+# which should cover all practical numbers. If you need bigger numbers,
+# increase Integer::LEN_STR_SIZE.
+class Integer
+  # LEN_SIZE of 4 should handle most numbers that can practically be held in
+  # memory.
+  LEN_STR_SIZE = 4
+  NEG_LEN_MASK = 10 ** LEN_STR_SIZE
+  LEN_STR_TEMPLATE = "%0#{LEN_STR_SIZE}d"
+
+  # Convert the number to a lexicographically sortable string. This string will
+  # use printable characters only but will not be human readable.
+  def to_s_lex
+    if (self >= 0)
+      num_str = self.to_s
+      len_str = LEN_STR_TEMPLATE % num_str.size
+      return len_str + num_str
+    else
+      num = self * -1
+      num_str = num.to_s
+      num_len = num_str.size
+      len_str = LEN_STR_TEMPLATE % (NEG_LEN_MASK - num_len)
+      num = (10 ** num_str.size) - num
+      return "-#{len_str}%0#{num_len}d" % num
+    end
+  end
+
+  # Convert the number to a lexicographically sortable string by padding with
+  # 0s. You should make sure that you set the width to a number large enough to
+  # accommodate all possible values. Also note that this method will not work
+  # with negative numbers. That is negative numbers will sort in the opposite
+  # direction as positive numbers. If you have very large numbers or a mix of
+  # positive and negative numbers you should use the Integer#to_s_lex method
+  #
+  # width::  number of characters in the string returned. Default is 10. So
+  #          123.to_s_pad(5) => 00123 and -123.to_s_pad(5) => -0123
+  # return:: padding string representation of the number.
+  def to_s_pad(width = 10)
+    "%#{width}d" % self
+  end
+end
+
+class Date
+  # Convert the Date to a lexicographically sortable string with the required
+  # precision. The format used is %Y%m%d
+  #
+  # precision:: the precision required in the string version of the date. The
+  #             options are :year, :month and :day
+  # return::    a lexicographically sortable string representing the date
+  def to_s_lex(precision = :day)
+    self.strftime(Time::LEX_FORMAT[precision])
+  end
+end
+
+class DateTime
+  # Convert the DateTime to a lexicographically sortable string with the
+  # required precision. The format used is %Y%m%d %H:%M:%S.
+  #
+  # precision:: the precision required in the string version of the date. The
+  #             options are :year, :month, :day, :hour, :minute and :second
+  # return::    a lexicographically sortable string representing the date
+  def to_s_lex(precision = :day)
+    self.strftime(Time::LEX_FORMAT[precision])
+  end
+end
+
+class Time
+  LEX_FORMAT = {
+      :year        => "%Y",
+      :month       => "%Y-%m",
+      :day         => "%Y-%m-%d",
+      :hour        => "%Y-%m-%d %H",
+      :minute      => "%Y-%m-%d %H:%M",
+      :second      => "%Y-%m-%d %H:%M:%S",
+      :millisecond => "%Y-%m-%d %H:%M:%S"
+  }
+
+  # Convert the Time to a lexicographically sortable string with the required
+  # precision. The format used is %Y%m%d %H:%M:%S.
+  #
+  # precision:: the precision required in the string version of the time. The
+  #             options are :year, :month, :day, :hour, :minute and :second
+  # return::    a lexicographically sortable string representing the date
+  def to_s_lex(precision = :day)
+    self.strftime(LEX_FORMAT[precision])
+  end
+end
+
+class String
+  # Convert a string to an integer. This method will only work on strings that
+  # were previously created with Integer#to_s_lex, otherwise the result will be
+  # unpredictable.
+  def to_i_lex
+    if (self[0] == ?-)
+      return self[(Integer::LEN_STR_SIZE + 1)..-1].to_i -
+        10 ** (self.size - Integer::LEN_STR_SIZE - 1)
+    else
+      return self[Integer::LEN_STR_SIZE..-1].to_i
+    end
+  end
+
+  # Convert a string to a Time. This method will only work on strings that
+  # match the format %Y%m%d %H%M%S, otherwise the result will be unpredictable.
+  def to_time_lex
+    vals = []
+    self.gsub(/(?:^|[- :])(\d+)/) {vals << $1.to_i; $&}
+    Time.mktime(*vals)
+  end
+
+  # Convert a string to a Date. This method will only work on strings that
+  # match the format %Y%m%d %H%M%S, otherwise the result will be unpredictable.
+  def to_date_lex
+    return Date.strptime(self + "-02-01", "%Y-%m-%d")
+  end
+
+  # Convert a string to a DateTime. This method will only work on strings that
+  # match the format %Y%m%d %H%M%S, otherwise the result will be unpredictable.
+  def to_date_time_lex
+    return DateTime.strptime(self + "-01-01", "%Y-%m-%d %H:%M:%S")
+  end
+
+  private
+  
+  def get_lex_format(len)
+    case len
+    when  0.. 3 then ""
+    when  4.. 5 then "%Y"
+    when  6.. 7 then "%Y%m"
+    when  8.. 9 then "%Y%m%d"
+    when 10..11 then "%Y%m%d%H"
+    when 12..13 then "%Y%m%d%H%M"
+    else "%Y%m%d%H%M%S"
+    end
+  end
+end
+
+# See FieldSymbolMethods
+class Symbol
+  include Isomorfeus::Ferret::FieldSymbolMethods
+end
+

data/lib/isomorfeus/ferret/version.rb

@@ -0,0 +1,5 @@
+module Isomorfeus
+  module Ferret
+    VERSION = '0.12.0'
+  end
+end

data/lib/isomorfeus-ferret.rb

@@ -0,0 +1,8 @@
+require 'isomorfeus_ferret_ext'
+require 'isomorfeus/ferret/version'
+require 'isomorfeus/ferret/field_symbol'
+require 'isomorfeus/ferret/stdlib_patches'
+require 'isomorfeus/ferret/monitor'
+require 'isomorfeus/ferret/index/field_infos'
+require 'isomorfeus/ferret/index/index'
+require 'isomorfeus/ferret/document'