active_redis 0.0.5 → 0.0.7

data/lib/active_redis/constants.rb

@@ -7,5 +7,7 @@ module ActiveRedis
 
     DEFAULT_ATTRIBUTES = {id: :integer, created_at: :time, updated_at: :time}
 
+    ASSOCIATIONS = [:has_one, :has_many, :belongs_to]
+
   end
 end

data/lib/active_redis/errors.rb

@@ -3,10 +3,16 @@ module ActiveRedis
   class NoConnectionError < ::StandardError
   end
 
+  class NoLogError < ::StandardError
+  end
+
   class NotSpecifiedIdError < ::StandardError
   end
 
   class InvalidArgumentError < ::StandardError
   end
 
+  class UnregisteredAssociationError < ::StandardError
+  end
+
 end

data/lib/active_redis/helpers/lua_scripts.rb

@@ -20,6 +20,13 @@ module ActiveRedis
         LUA
       end
 
+      def query_analyzer_script
+        <<-LUA
+          #{LuaLoader.get_main}
+          return query_analyzer(KEYS, ARGV)
+        LUA
+      end
+
       class LuaLoader
 
         def self.get_main

data/lib/active_redis/inspector.rb

@@ -3,7 +3,7 @@ module ActiveRedis
 
     def inspect
       string = "#<#{self.class.name}:#{self.object_id} "
-      fields = self.class.attributes_list.map{|field| "#{field}: #{self.send(field)}"}
+      fields = self.class.attributes_list.map{|field| val = self.send(field); "#{field}: #{val ? val : 'nil'}"}
       string << fields.join(", ") << ">"
     end
 

data/lib/active_redis/logs/basic_log.rb

@@ -0,0 +1,11 @@
+module ActiveRedis
+  module Logs
+    class BasicLog
+
+      def write(message)
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/active_redis/logs/console_log.rb

@@ -0,0 +1,14 @@
+require_relative './basic_log'
+require 'colorize'
+
+module ActiveRedis
+  module Logs
+    class ConsoleLog < BasicLog
+
+      def write(message)
+        puts message.green
+      end
+
+    end
+  end
+end

data/lib/active_redis/logs/query_logger.rb

@@ -0,0 +1,29 @@
+require 'benchmark'
+
+module ActiveRedis
+  module Logs
+    module QueryLogger
+
+      def loggable(*methods)
+        str_eval = ""
+        methods.each do |method|
+          str_eval += <<-CODE
+
+            def #{method}_with_loggable(*args)
+              res = nil
+              time = Benchmark.realtime do
+                res = #{method}_without_loggable(*args)
+              end
+              ActiveRedis.log.write "  Redis Query (\#{(time*1000).round(2)}ms) => #{method}(\#{args})"
+              res
+            end
+
+            alias_method_chain :#{method}, :loggable
+          CODE
+        end
+        class_eval(str_eval)
+      end
+
+    end
+  end
+end

data/lib/active_redis/lua_scripts/main.lua

@@ -1,72 +1,149 @@
+-- Split string by pattern
+--
+-- pString  - input string
+-- pPattern - pattern for splitting
+--
+-- returns: array of string's parts
+local split = function (pString, pPattern)
+   local Table = {}  -- NOTE: use {n = 0} in Lua-5.0
+   local fpat = "(.-)" .. pPattern
+   local last_end = 1
+   local s, e, cap = pString:find(fpat, 1)
+   while s do
+      if s ~= 1 or cap ~= "" then
+        table.insert(Table,cap)
+      end
+      last_end = e+1
+      s, e, cap = pString:find(fpat, last_end)
+   end
+   if last_end <= #pString then
+      cap = pString:sub(last_end)
+      table.insert(Table, cap)
+   end
+   return Table
+end
+
+-- Fetching keys by pattern
+--
+-- k - pattern for searching
+--
+-- return: list of keys by pattern
 local keys = function (k)
   return redis.call("KEYS", k)
 end
 
-local cond_tonum = function (value, tonum)
-  if tonum == true then
-    return tonumber(value)
-  else
-    return value
+-- Specify is record match conditions or not
+--
+-- key  - record key
+-- argv - array with conditions
+--
+-- return: true if matched or false otherwise
+local is_match_record = function (key, argv)
+  for i = 1, #argv, 2 do
+    local k = argv[i]
+    local value = argv[i+1]
+    if (redis.call("HGET", key, k) ~= value) then
+      return false
+    end
   end
+  return true
 end
 
-local getHashValues = function (k, attr, tonum)
-  local result = {}
-  local ks = keys(k)
-  for index, key in pairs(ks) do
-    local cell = redis.call("HGET", key, attr)
-    table.insert(result, cond_tonum(cell, tonum))
+-- Splitting input string with key=value to array
+--
+-- str - string like "attr1=value1, attr2=value2"
+--
+-- return: array
+local fetch_conditions = function(str)
+  local t = {}
+  for i, value in pairs(split(str, ",")) do
+    local res = split(value, "=")
+    table.insert(t, res[1])
+    table.insert(t, res[2])
   end
-  return result
+  return t
 end
 
-local calculate_count = function (key)
-  return #keys(key)
-end
-
-local calculate_pluck = function (key, attr)
-  return getHashValues(key, attr, false)
-end
-
-local calculate_max = function (key, attr)
-  local res = getHashValues(key, attr, true)
-  table.sort(res)
-  return res[#res]
+-- Applying where conditions for table set
+--
+-- key      - table name
+-- cond_str - conditions represented as string
+--
+-- return: key of result id list
+local apply_where = function(key, cond_str, seed)
+  math.randomseed(seed)
+  local cond_array = fetch_conditions(cond_str)
+  local ks = keys(key)
+  local list_name = "templist:"..math.random()
+  for index, k in pairs(ks) do
+    if is_match_record(k, cond_array) == true then
+      redis.call("RPUSH", list_name, redis.call("HGET", k, "id"))
+    end
+  end
+  return list_name
 end
 
-local calculate_min = function (key, attr)
-  local res = getHashValues(key, attr, true)
-  table.sort(res)
-  return res[1]
+-- Applying order conditions to command string
+--
+-- key      - table name
+-- command  - current query to redis
+-- cond_str - conditions represented as string
+--
+-- returns: changed command string with sorting by
+local apply_order = function(key, command, cond_str)
+  table.insert(command, 'BY')
+  if string.len(cond_str) == 0 then
+    table.insert(command, 'nosort')
+  else
+    local cond_array = fetch_conditions(cond_str)
+    table.insert(command, key.."->"..cond_array[1])
+    table.insert(command, "ALPHA")
+    table.insert(command, cond_array[2])
+  end
+  return command
 end
 
-local calculate_sum = function (key, attr)
-  local res = getHashValues(key, attr, true)
-  local sum = 0
-  for index, s in pairs(res) do
-    sum = sum + s
+-- Applying limit conditions to command string
+--
+-- command  - current query to redis
+-- cond_str - conditions represented as string
+--
+-- returns: changed command string with limit
+local apply_limit = function(command, cond_str)
+  if string.len(cond_str) ~= 0 then
+    local cond_array = fetch_conditions(cond_str)
+    table.insert(command, "LIMIT")
+    table.insert(command, cond_array[1])
+    table.insert(command, cond_array[2])
   end
-  return sum
+  return command
 end
 
-local is_match_record = function (key, argv)
-  for i = 1, #argv, 2 do
-    local k = argv[i]
-    local value = argv[i+1]
-    if (redis.call("HGET", key, k) ~= value) then
-      return false
-    end
-  end
-  return true
+-- Fetching record by table name and id
+--
+-- key - table name
+-- id  - record id
+--
+-- returns: record hash
+local fetch_row = function(key, id)
+  local name = string.sub(key, 1, -2)
+  name = name..id
+  return redis.call("HGETALL", name)
 end
 
-local where_finder = function (key, argv)
+-- Query analyzer for searching
+--
+-- key  - table name
+-- argv - array with query parameters WHERE, ORDER, LIMIT
+local query_analyzer = function (keys, argv)
+  local temp_list = apply_where(keys[1], argv[1], tonumber(keys[2]))
+  local sort_command = {"SORT", temp_list}
+  sort_command = apply_order(keys[1], sort_command, argv[2])
+  sort_command = apply_limit(sort_command, argv[3])
+  local ids = redis.call(unpack(sort_command))
   local result = {}
-  local ks = keys(key)
-  for index, k in pairs(ks) do
-    if is_match_record(k, argv) == true then
-      table.insert(result, redis.call("HGETALL", k))
-    end
+  for index, id in pairs(ids) do
+    table.insert(result, fetch_row(keys[1], id))
   end
   return result
-end
+end

data/lib/active_redis/naming.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/string'
+
 module ActiveRedis
 
   module Naming

data/lib/active_redis/persistence.rb

@@ -22,6 +22,17 @@ module ActiveRedis
       self.save
     end
 
+    def reload
+      if self.class.respond_to? :associations
+        self.class.associations.each { |key, assoc| assoc.reload(self) }
+      end
+      true
+    end
+
+    def touch
+      save
+    end
+
     private
 
       def fill_attributes
@@ -33,7 +44,7 @@ module ActiveRedis
       def prepare_hash
         fill_attributes
         self.class.attributes_list.inject({}) do |hash, attribute|
-          hash[attribute.to_sym] = self.send("#{attribute}"); hash
+          hash[attribute.to_sym] = self.instance_variable_get("@#{attribute}"); hash
         end
       end
 

data/lib/active_redis/query_chainer.rb

@@ -0,0 +1,61 @@
+require 'active_redis/relation'
+require 'active_redis/query_iterator'
+
+module ActiveRedis
+  autoload :QueryExecutor, 'active_redis/query_executor'
+
+  class QueryChainer
+    include Relation
+    include QueryIterator
+
+    def initialize(target)
+      @where_options = {}
+      @order_options = {id: :asc}
+      @limit_options = {per_page: 10, page: 0}
+      @target = target
+    end
+
+    def apply_where(options)
+      @where_options.merge!(options)
+      self
+    end
+
+    def apply_order(options)
+      @order_options = options if options.any?
+      self
+    end
+
+    def apply_limit(options)
+      @limit_options = options if options.any?
+      self
+    end
+
+    def apply_top(options)
+      apply_limit per_page: 1, page: 0
+    end
+
+    def reload
+      @collection = nil
+    end
+
+    def linked_objects
+      @collection ||= objects_by_query
+    end
+
+    private
+
+    def execute_query
+      QueryExecutor.execute(@target, @where_options, @order_options, @limit_options)
+    end
+
+    def objects_by_query
+      res = execute_query.inject([]) { |arr, attrs| arr << @target.new(attrs) if attrs && attrs.any?; arr }
+      top_limit? ? res.first : res
+    end
+
+    def top_limit?
+      @limit_options[:per_page] == 1 && @limit_options[:page] == 0
+    end
+
+  end
+end

data/lib/active_redis/query_executor.rb

@@ -0,0 +1,24 @@
+module ActiveRedis
+  class QueryExecutor
+
+    def self.execute(target, where, order, limit)
+      ActiveRedis.connection.run_query_analyzer target, [prepare_where(where), prepare_order(order), prepare_limit(limit)]
+    end
+
+    private
+
+    def self.prepare_where(where)
+      where.keys.map{|key| "#{key}=#{where[key]}" }.join(",")
+    end
+
+    def self.prepare_order(order)
+      field = order.keys.first
+      "#{field}=#{order[field]}"
+    end
+
+    def self.prepare_limit(limit)
+      limit.any? ? "#{limit[:page]}=#{limit[:per_page]}" : ""
+    end
+
+  end
+end

data/lib/active_redis/query_iterator.rb

@@ -0,0 +1,27 @@
+module ActiveRedis
+  module QueryIterator
+    include Enumerable
+
+    def method_missing(method, *args)
+      unless linked_objects.is_a? Array
+        linked_objects.send method, *args
+      else
+        super
+      end
+    end
+
+    def inspect
+      if linked_objects.is_a? Array
+        "[#{linked_objects.map{|e| e.inspect}.join(', ')}]"
+      else
+        linked_objects.inspect
+      end
+    end
+
+    def each(&block)
+      raise "Exception occured when trying call #each on #{@target}" unless linked_objects.is_a? Array
+      linked_objects.each(&block)
+    end
+
+  end
+end