active_orm 3.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da03a7da4c7e4a6842338e0e31ea791a561f0b7e
-  data.tar.gz: ef6069ee665ae797c4dc77ae8b1886df4fd3ffb1
+  metadata.gz: f553533ee1d9e00017974e9be0f066242baaf401
+  data.tar.gz: 8dc77ee230e832e299ef3bf08dba9c8cea08be5b
 SHA512:
-  metadata.gz: f8dd836ccfbfdcf2aeffd8016b721a3ad31e4d7471d1bafffede3d945012b258292c4f8754d6568fdd0bc7b0fdd1cab6efcb474a2084dd3212a04700191a8797
-  data.tar.gz: 8dda4a7f1b7d7160016874389b08709a9f6f3295df2d16dbc81aceefaf5f0263a7040e6decb3b53d0a2a9ee12b2a288a899473d91a569dfae7bfaac088ed6721
+  metadata.gz: 060aeaf9aa0a1bc68ab5646e39379aaa06a838c6b18b855471e958fa01b04bf1c551583c4e3d94c68c0aaa5336d79d058ecfb3f1771551d358168098f53186f3
+  data.tar.gz: be4c7ba86630e1c45d9cff37d83d10561cd59beae5745419f2d4661eb43bf287d07590c774e85b84d89ad75dfa41127ba4828b89b67f75aef531e7f652f78d62

data/.fasterer.yml

@@ -0,0 +1,19 @@
+speedups:
+  rescue_vs_respond_to: true
+  module_eval: true
+  shuffle_first_vs_sample: true
+  for_loop_vs_each: true
+  each_with_index_vs_while: false
+  map_flatten_vs_flat_map: true
+  reverse_each_vs_reverse_each: true
+  select_first_vs_detect: true
+  sort_vs_sort_by: true
+  fetch_with_argument_vs_block: true
+  keys_each_vs_each_key: true
+  hash_merge_bang_vs_hash_brackets: true
+  block_vs_symbol_to_proc: true
+  proc_call_vs_yield: true
+  gsub_vs_tr: true
+  select_last_vs_reverse_detect: true
+  getter_vs_attr_reader: true
+  setter_vs_attr_writer: true

data/.reek

@@ -0,0 +1,34 @@
+---
+Attribute:
+  enabled: false
+BooleanParameter:
+  enabled: false
+ClassVariable:
+  enabled: false
+ControlParameter:
+  enabled: false
+DuplicateMethodCall:
+  exclude:
+    - 'Base#metamorph'
+FeatureEnvy:
+  enabled: false
+IrresponsibleModule:
+  enabled: false
+LongParameterList:
+  enabled: false
+ManualDispatch:
+  enabled: false
+NestedIterators:
+  max_allowed_nesting: 2
+NilCheck:
+  enabled: false
+PrimaDonnaMethod:
+  enabled: false
+RepeatedConditional:
+  enabled: false
+TooManyStatements:
+  max_statements: 10
+  exclude:
+    - 'Base#metamorph'
+UtilityFunction:
+  enabled: false

data/.rubocop.yml

@@ -0,0 +1,42 @@
+AllCops:
+  DisplayCopNames: true
+  DisplayStyleGuide: true
+  TargetRubyVersion: 2.3
+  Exclude:
+    - 'spec/**/**/*'
+LineLength:
+  Max: 100
+Metrics/ClassLength:
+  Enabled: false
+Metrics/ModuleLength:
+  Enabled: false
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+Style/BracesAroundHashParameters:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+Style/ClassVars:
+  Enabled: false
+Style/ClosingParenthesisIndentation:
+  Enabled: false
+Style/Documentation:
+  Enabled: false
+Style/EmptyLinesAroundBlockBody:
+  Enabled: false
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+Style/HashSyntax:
+  Enabled: false
+Style/FirstParameterIndentation:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/MultilineMethodCallIndentation:
+  EnforcedStyle: aligned
+Style/NumericLiterals:
+  Enabled: false
+Style/RescueModifier:
+  Enabled: false

data/Gemfile

@@ -1,4 +1,4 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 # Specify your gem's dependencies in active_orm.gemspec
 gemspec

data/README.md

@@ -18,7 +18,7 @@ ActiveOrm is a library for object ruby mapping of different databases.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "active_orm"
+gem 'active_orm'
 ```
 
 And then execute:
@@ -40,14 +40,13 @@ Or install it yourself as:
 **Options:**
  * client: add a custom Redis client
 
-`rails generate active_orm:install` will generate the following `active_orm.rb` file:
+`rails generate active_orm:install` will generate the following file:
+`../config/initalizers/active_orm.rb`
 
 ```ruby
-# config/initalizers/active_orm.rb
-
 if defined?(Redis)
   ActiveOrm::Redis.configure do |config|
-    config.client = Redis.new(:host => "10.0.1.1", :port => 6380, :db => 15)
+    config.client = Redis.new(host: '10.0.1.1', port: 6380, db: 15)
   end
 end
 ```
@@ -68,13 +67,13 @@ end
  * Transaction
 
 ```ruby
-ActiveOrm::Redis::String.create(:month, "01")
-ActiveOrm::Redis::String.find(:month) #=> "01"
-ActiveOrm::Redis::String.evaluate.find(:month) #=> 1
+ActiveOrm::Redis::String.create(:month, '01')
+ActiveOrm::Redis::String.find(:month)           #=> '01'
+ActiveOrm::Redis::String.evaluate.find(:month)  #=> 1
 
-ActiveOrm::Redis::List.create(:user_1, { id: 32123, name: "James Dean", username: "alpha123" })
-ActiveOrm::Redis::List.find(:user_1) #=> { id: "32123", name: "James Dean", username: "alpha123" }
-ActiveOrm::Redis::List.evaluate.find(:user_1) #=> { id: 32123, name: "James Dean", username: "alpha123" }
+ActiveOrm::Redis::List.create(:user_1, { id: 32123, name: 'James Dean', username: 'alpha123' })
+ActiveOrm::Redis::List.find(:user_1)            #=> { id: '32123', name: 'James Dean', username: 'alpha123' }
+ActiveOrm::Redis::List.evaluate.find(:user_1)   #=> { id: 32123, name: 'James Dean', username: 'alpha123' }
 ```
 
 **Rake:**

data/Rakefile

@@ -1,5 +1,5 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 
 task default: :spec
 
-import "lib/tasks/redis.rake"
+import 'lib/tasks/redis.rake'

data/active_orm.gemspec

@@ -1,29 +1,33 @@
 # coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "active_orm/version"
+require 'active_orm/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "active_orm"
+  spec.name = 'active_orm'
   spec.version = ActiveOrm::VERSION
-  spec.authors = ["Juan Gomez"]
-  spec.email = ["j.gomez@drexed.com"]
+  spec.authors = ['Juan Gomez']
+  spec.email = ['j.gomez@drexed.com']
 
-  spec.summary = %q{Gem for commonly used database ORM.}
-  spec.description = %q{ORM for non-supported databases.}
-  spec.homepage = "http://drexed.github.io/active_orm"
-  spec.license = "MIT"
+  spec.summary = 'Gem for commonly used database ORM.'
+  spec.description = 'ORM for non-supported databases.'
+  spec.homepage = 'http://drexed.github.io/active_orm'
+  spec.license = 'MIT'
 
   spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir = "exe"
+  spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency "rails"
+  spec.add_runtime_dependency 'rails'
+  spec.add_runtime_dependency 'dry-configurable'
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "coveralls"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "generator_spec"
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'generator_spec'
+  spec.add_development_dependency 'fasterer'
+  spec.add_development_dependency 'reek'
+  spec.add_development_dependency 'rubocop'
 end

data/bin/console

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "active_orm"
+require 'bundler/setup'
+require 'active_orm'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
+# require 'pry'
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start

data/bin/rake

@@ -2,15 +2,14 @@
 #
 # This file was generated by Bundler.
 #
-# The application "rake" is installed as part of a gem, and
+# The application 'rake' is installed as part of a gem, and
 # this file is here to facilitate running it.
 #
 
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', Pathname.new(__FILE__).realpath)
 
-require "rubygems"
-require "bundler/setup"
+require 'rubygems'
+require 'bundler/setup'
 
-load Gem.bin_path("rake", "rake")
+load Gem.bin_path('rake', 'rake')

data/lib/active_orm.rb

@@ -1,30 +1,12 @@
-require "rails/railtie"
+require 'rails/railtie'
 
-require "active_orm/version"
-require "active_orm/base"
-
-require "active_orm/redis"
-require "active_orm/redis/connection"
-require "active_orm/redis/geo"
-require "active_orm/redis/hash"
-require "active_orm/redis/hyper_log_log"
-require "active_orm/redis/key"
-require "active_orm/redis/list"
-require "active_orm/redis/pub_sub"
-require "active_orm/redis/script"
-require "active_orm/redis/set"
-require "active_orm/redis/sorted_set"
-require "active_orm/redis/string"
-require "active_orm/redis/transaction"
-
-require "generators/active_orm/install_generator"
-
-module ActiveOrm
-  class Railtie < Rails::Railtie
-
-    rake_tasks do
-      Dir[File.expand_path("tasks/*.rake", File.dirname(__FILE__))].each { |ext| load(ext) }
-    end
+%w(version railtie base redis).each do |file_name|
+  require "active_orm/#{file_name}"
+end
 
+%w(connection geo hash hyper_log_log key list pub_sub script set sorted_set string transaction)
+  .each do |file_name|
+    require "active_orm/redis/#{file_name}"
   end
-end
+
+require 'generators/active_orm/install_generator'

data/lib/active_orm/base.rb

@@ -6,10 +6,6 @@ class ActiveOrm::Base
     @configuration ||= Configuration.new
   end
 
-  def self.configuration=(config)
-    @configuration = config
-  end
-
   def self.configure
     yield(configuration)
   end

data/lib/active_orm/railtie.rb

@@ -0,0 +1,7 @@
+class ActiveOrm::Railtie < Rails::Railtie
+
+  rake_tasks do
+    Dir[File.expand_path('tasks/*.rake', File.dirname(__FILE__))].each { |ext| load(ext) }
+  end
+
+end

data/lib/active_orm/redis.rb

@@ -1,22 +1,22 @@
 begin
-  require "fakeredis"
+  require 'fakeredis'
 rescue LoadError
-  require "redis"
+  require 'redis'
 end
 
-require "active_orm/redis/base"
-require "active_orm/redis/configuration"
-class ActiveOrm::Redis < ActiveOrm::Base
+require 'active_orm/redis/base'
+require 'active_orm/redis/configuration'
 
+class ActiveOrm::Redis < ActiveOrm::Base
   extend Base
 
   attr_accessor :client
 
-  def initialize(client=nil)
+  def initialize(client = nil)
     @client ||= (client.nil? ? ActiveOrm::Redis.configuration.client : client)
   end
 
-  def self.client(client=nil)
+  def self.client(client = nil)
     client.nil? ? new.client : new(client).client
   end
 

data/lib/active_orm/redis/base.rb

@@ -2,7 +2,7 @@ module Base
 
   @@evaluate = false
 
-  def evaluate(value=true)
+  def evaluate(value = true)
     @@evaluate = value
     self
   end
@@ -10,44 +10,51 @@ module Base
   private
 
   def evaluate?
-    value      = @@evaluate
+    value = @@evaluate
     @@evaluate = false
     value
   end
 
   def append?(order)
-    "append" == order.to_s
+    'append' == order.to_s
   end
 
+  # rubocop:disable Lint/Eval, Lint/RescueException
   def metaform(value)
     value.nil? ? value : eval(value)
-  rescue Exception => e
+  rescue Exception
     value
   end
+  # rubocop:enable Lint/Eval, Lint/RescueException
 
+  # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
   def metamorph(datum)
     case datum.class.name
-    when "Array"
-      if datum.first.is_a?(Array)
-        datum.map { |array| array.map { |value| metaform(value) } }
-      elsif datum.first.is_a?(Hash)
-        datum.map { |hash| hash.each { |key, value| hash.store(key, metaform(value)) } }
+    when 'Array'
+      data = datum.first
+
+      if data.is_a?(Array)
+        datum.map { |arr| arr.map { |val| metaform(val) } }
+      elsif data.is_a?(Hash)
+        datum.map { |hsh| hsh.each { |key, val| hash.store(key, metaform(val)) } }
       else
-        datum.map { |value| metaform(value) }
+        datum.map { |val| metaform(val) }
       end
-    when "Hash"
-      datum.each { |key, value| datum.store(key, metaform(value)) }
+    when 'Hash'
+      datum.each { |key, val| datum.store(key, metaform(val)) }
     else
       metaform(datum)
     end
   end
+  # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
   def metatransform(datum)
-    datum.empty? ? nil : (evaluate? ? metamorph(datum) : datum)
+    return(nil) if datum.empty?
+    evaluate? ? metamorph(datum) : datum
   end
 
   def milliseconds?(format)
-    "milliseconds" == format.to_s
+    'milliseconds' == format.to_s
   end
 
   def normalize_key(key)
@@ -55,15 +62,15 @@ module Base
   end
 
   def prepend?(order)
-    "prepend" == order.to_s
+    'prepend' == order.to_s
   end
 
   def seconds?(format)
-    "seconds" == format.to_s
+    'seconds' == format.to_s
   end
 
   def stringify_keys(value)
-    value.map { |k, v| k.to_s }
+    value.map { |key, _| key.to_s }
   end
 
 end

data/lib/active_orm/redis/connection.rb

@@ -72,15 +72,11 @@ class ActiveOrm::Redis::Connection < ActiveOrm::Redis
     client.shutdown
   end
 
-  def self.shutdown
-    client.shutdown
-  end
-
   def self.slave_of(host, port)
     client.slaveof(host, port)
   end
 
-  def self.slowlog(command, length=nil)
+  def self.slowlog(command, length = nil)
     client.slowlog(command, length)
   end
 
@@ -92,7 +88,7 @@ class ActiveOrm::Redis::Connection < ActiveOrm::Redis
     client.time
   end
 
-  def self.with_reconnect(val=true, &block)
+  def self.with_reconnect(val = true, &block)
     client.with_reconnect(val, &block)
   end
 

data/lib/active_orm/redis/hash.rb

@@ -55,14 +55,20 @@ class ActiveOrm::Redis::Hash < ActiveOrm::Redis
   end
 
   def self.increment(key, field, value)
-    value.is_a?(Float) ? client.hincrbyfloat(normalize_key(key), field, value) : client.hincrby(normalize_key(key), field, value)
+    normalized_key = normalize_key(key)
+
+    if value.is_a?(Float)
+      client.hincrbyfloat(normalized_key, field, value)
+    else
+      client.hincrby(normalized_key, field, value)
+    end
   end
 
   def self.destroy(key, *args)
     client.hdel(normalize_key(key), *args)
   end
 
-  def self.scan(key, cursor, opts={})
+  def self.scan(key, cursor, opts = {})
     client.hdel(normalize_key(key), cursor, opts)
   end
 

data/lib/active_orm/redis/key.rb

@@ -8,11 +8,13 @@ class ActiveOrm::Redis::Key < ActiveOrm::Redis
     client.type(normalize_key(key))
   end
 
-  def self.ttl?(key, format=:seconds)
-    seconds?(format) ? client.ttl(normalize_key(key)) : client.pttl(normalize_key(key))
+  def self.ttl?(key, format = :seconds)
+    normalized_key = normalize_key(key)
+
+    seconds?(format) ? client.ttl(normalized_key) : client.pttl(normalized_key)
   end
 
-  def self.sort(key, opts={})
+  def self.sort(key, opts = {})
     client.sort(normalize_key(key), opts)
   end
 
@@ -36,19 +38,31 @@ class ActiveOrm::Redis::Key < ActiveOrm::Redis
     client.persist(normalize_key(key))
   end
 
-  def self.expire(key, seconds, format=:seconds)
-    seconds?(format) ? client.expire(normalize_key(key), seconds) : client.pexpire(normalize_key(key), seconds)
+  def self.expire(key, seconds, format = :seconds)
+    normalized_key = normalize_key(key)
+
+    if seconds?(format)
+      client.expire(normalized_key, seconds)
+    else
+      client.pexpire(normalized_key, seconds)
+    end
   end
 
-  def self.expire_at(key, seconds, format=:seconds)
-    seconds?(format) ? client.expireat(normalize_key(key), seconds) : client.pexpireat(normalize_key(key), seconds)
+  def self.expire_at(key, seconds, format = :seconds)
+    normalized_key = normalize_key(key)
+
+    if seconds?(format)
+      client.expireat(normalized_key, seconds)
+    else
+      client.pexpireat(normalized_key, seconds)
+    end
   end
 
   def self.dump(key)
     client.dump(normalize_key(key))
   end
 
-  def self.match(pattern='*')
+  def self.match(pattern = '*')
     value = client.keys(normalize_key(pattern))
     value = nil if value.empty?
     value
@@ -70,11 +84,7 @@ class ActiveOrm::Redis::Key < ActiveOrm::Redis
     client.restore(normalize_key(key), milliseconds, value)
   end
 
-  def self.sort(key, opts={})
-    client.sort(normalize_key(key), opts)
-  end
-
-  def self.scan(cursor, opts={})
+  def self.scan(cursor, opts = {})
     client.scan(cursor, opts)
   end
 

data/lib/active_orm/redis/list.rb

@@ -1,26 +1,26 @@
 class ActiveOrm::Redis::List < ActiveOrm::Redis
 
-  def self.find(key, position=1)
+  def self.find(key, position = 1)
     value = client.lindex(normalize_key(key), (position - 1))
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.first(key, limit=1)
+  def self.first(key, limit = 1)
     value = client.lrange(normalize_key(key), 0, -1)
-    value = ((limit == 1) ? value.first : value.first(limit))
+    value = (limit == 1 ? value.first : value.first(limit))
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.last(key, limit=1)
+  def self.last(key, limit = 1)
     value = client.lrange(normalize_key(key), 0, -1)
-    value = ((limit == 1) ? value.last : value.last(limit))
+    value = (limit == 1 ? value.last : value.last(limit))
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.between(key, start=1, finish=0)
+  def self.between(key, start = 1, finish = 0)
     value = client.lrange(normalize_key(key), (start - 1), (finish - 1))
     value = metatransform(value)
     value
@@ -36,22 +36,30 @@ class ActiveOrm::Redis::List < ActiveOrm::Redis
     client.llen(normalize_key(key))
   end
 
-  def self.create(key, value, order=:prepend)
-    append?(order) ? client.rpush(normalize_key(key), value) : client.lpush(normalize_key(key), value)
+  def self.create(key, value, order = :prepend)
+    normalized_key = normalize_key(key)
+
+    append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
   end
 
-  def self.create!(key, value, order=:prepend)
-    append?(order) ? client.rpushx(normalize_key(key), value) : client.lpushx(normalize_key(key), value)
+  def self.create!(key, value, order = :prepend)
+    normalized_key = normalize_key(key)
+
+    append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
   end
 
-  def self.create_limit(key, value, limit, order=:prepend)
-    append?(order) ? client.rpush(normalize_key(key), value) : client.lpush(normalize_key(key), value)
-    client.ltrim(normalize_key(key), 0, (limit - 1))
+  def self.create_limit(key, value, limit, order = :prepend)
+    normalized_key = normalize_key(key)
+
+    append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
+    client.ltrim(normalized_key, 0, (limit - 1))
   end
 
-  def self.create_limit!(key, value, limit, order=:prepend)
-    append?(order) ? client.rpushx(normalize_key(key), value) : client.lpushx(normalize_key(key), value)
-    client.ltrim(normalize_key(key), 0, (limit - 1))
+  def self.create_limit!(key, value, limit, order = :prepend)
+    normalized_key = normalize_key(key)
+
+    append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
+    client.ltrim(normalized_key, 0, (limit - 1))
   end
 
   def self.create_before(key, pivot, value)
@@ -72,7 +80,7 @@ class ActiveOrm::Redis::List < ActiveOrm::Redis
     value
   end
 
-  def self.move_blocking(key, desination, opts={})
+  def self.move_blocking(key, desination)
     value = brpoplpush(normalize_key(key), normalize_key(desination))
     value = metamorph(value) if evaluate?
     value
@@ -82,11 +90,11 @@ class ActiveOrm::Redis::List < ActiveOrm::Redis
     client.lrem(normalize_key(key), count, value)
   end
 
-  def self.destroy_first(key, limit=1)
+  def self.destroy_first(key, limit = 1)
     client.ltrim(normalize_key(key), limit, -1)
   end
 
-  def self.destroy_last(key, limit=1)
+  def self.destroy_last(key, limit = 1)
     client.ltrim(normalize_key(key), 0, -(limit + 1))
   end
 
@@ -98,14 +106,20 @@ class ActiveOrm::Redis::List < ActiveOrm::Redis
     client.ltrim(normalize_key(key), -1, 0)
   end
 
-  def self.pop(key, order=:prepend)
+  def self.pop(key, order = :prepend)
     value = append?(order) ? client.rpop(key) : client.lpop(key)
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.pop_blocking(keys, opts={})
-    value = append?(opts.fetch(:order, :prepend)) ? client.brpop(keys, opts.fetch(:timeout, 0)) : client.blpop(keys, opts.fetch(:timeout, 0))
+  def self.pop_blocking(keys, opts = {})
+    timeout = opts[:timeout] || 0
+    value = if append?(opts[:order] || :prepend)
+              client.brpop(keys, timeout)
+            else
+              client.blpop(keys, timeout)
+            end
+
     value = metamorph(value) if evaluate?
     value
   end

data/lib/active_orm/redis/set.rb

@@ -24,7 +24,7 @@ class ActiveOrm::Redis::Set < ActiveOrm::Redis
     value
   end
 
-  def self.sample(key, value=1)
+  def self.sample(key, value = 1)
     value = client.srandmember(normalize_key(key), value)
     value = metatransform(value)
     value
@@ -66,7 +66,7 @@ class ActiveOrm::Redis::Set < ActiveOrm::Redis
     client.spop(normalize_key(key))
   end
 
-  def self.scan(key, cursor, opts={})
+  def self.scan(key, cursor, opts = {})
     client.sscan(normalize_key(key), cursor, opts)
   end
 

data/lib/active_orm/redis/sorted_set.rb

@@ -1,84 +1,86 @@
 class ActiveOrm::Redis::SortedSet < ActiveOrm::Redis
 
-  def self.find(key, position, opts={})
-    value = client.zrange(normalize_key(key), (position - 1), (position - 1), opts)
+  def self.find(key, position, opts = {})
+    position -= 1
+
+    value = client.zrange(normalize_key(key), position, position, opts)
     value = value.first
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.find_score(key, position, opts={})
+  def self.find_score(key, position, opts = {})
     value = client.zrangebyscore(normalize_key(key), position, position, opts)
     value = value.first
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.first(key, opts={})
+  def self.first(key, opts = {})
     value = client.zrange(normalize_key(key), 0, 0, opts)
     value = value.first
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.first_score(key, opts={})
+  def self.first_score(key, opts = {})
     value = client.zrangebyscore(normalize_key(key), 1, 1, opts)
     value = value.first
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.last(key, opts={})
+  def self.last(key, opts = {})
     value = client.zrevrange(normalize_key(key), 0, 0, opts)
     value = value.first
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.last_score(key, opts={})
+  def self.last_score(key, opts = {})
     value = client.zrevrangebyscore(normalize_key(key), 1, 1, opts)
     value = value.first
     value = metamorph(value) if evaluate?
     value
   end
 
-  def self.between(key, start, finish, opts={})
+  def self.between(key, start, finish, opts = {})
     value = client.zrange(normalize_key(key), (start - 1), (finish - 1), opts)
     value = metatransform(value)
     value
   end
 
-  def self.between_reverse(key, start, finish, opts={})
+  def self.between_reverse(key, start, finish, opts = {})
     value = client.zrevrange(normalize_key(key), (start - 1), (finish - 1), opts)
     value = metatransform(value)
     value
   end
 
-  def self.between_scores(key, min, max, opts={})
+  def self.between_scores(key, min, max, opts = {})
     value = client.zrangebyscore(normalize_key(key), min, max, opts)
     value = metatransform(value)
     value
   end
 
-  def self.between_scores_reverse(key, min, max, opts={})
+  def self.between_scores_reverse(key, min, max, opts = {})
     value = client.zrevrangebyscore(normalize_key(key), min, max, opts)
     value = metatransform(value)
     value
   end
 
-  def self.between_lex(key, min, max, opts={})
+  def self.between_lex(key, min, max, opts = {})
     value = client.zrangebylex(normalize_key(key), min, max, opts)
     value = metatransform(value)
     value
   end
 
-  def self.between_lex_reverse(key, min, max, opts={})
+  def self.between_lex_reverse(key, min, max, opts = {})
     value = client.zrevrangebylex(normalize_key(key), min, max, opts)
     value = metatransform(value)
     value
   end
 
-  def self.all(key, opts={})
+  def self.all(key, opts = {})
     value = client.zrange(normalize_key(key), '-inf', '+inf', opts)
     value = metatransform(value)
     value
@@ -86,13 +88,13 @@ class ActiveOrm::Redis::SortedSet < ActiveOrm::Redis
 
   def self.position(key, value)
     value = client.zrank(normalize_key(key), value)
-    value = value + 1 unless value.nil?
+    value += 1 unless value.nil?
     value
   end
 
   def self.position_reverse(key, value)
     value = client.zrevrank(normalize_key(key), value)
-    value = value + 1 unless value.nil?
+    value += 1 unless value.nil?
     value
   end
 
@@ -112,11 +114,11 @@ class ActiveOrm::Redis::SortedSet < ActiveOrm::Redis
     client.zadd(normalize_key(key), args)
   end
 
-  def self.create_intersection(key, keys, opts={})
+  def self.create_intersection(key, keys, opts = {})
     client.zinterstore(normalize_key(key), keys, opts)
   end
 
-  def self.create_combination(key, keys, opts={})
+  def self.create_combination(key, keys, opts = {})
     client.zunionstore(normalize_key(key), keys, opts)
   end
 
@@ -136,11 +138,11 @@ class ActiveOrm::Redis::SortedSet < ActiveOrm::Redis
     client.zremrangebyscore(normalize_key(key), min, max)
   end
 
-  def self.destroy_lex(key, min, max, opts={})
+  def self.destroy_lex(key, min, max, opts = {})
     client.zrevrangebylex(normalize_key(key), max, min, opts)
   end
 
-  def self.scan(key, cursor, opts={})
+  def self.scan(key, cursor, opts = {})
     client.zscan(normalize_key(key), cursor, opts)
   end
 

data/lib/active_orm/redis/string.rb

@@ -21,7 +21,7 @@ class ActiveOrm::Redis::String < ActiveOrm::Redis
     client.getrange(normalize_key(key), start, finish)
   end
 
-  def self.create(key, value, opts={})
+  def self.create(key, value, opts = {})
     client.set(normalize_key(key), value, opts)
   end
 
@@ -39,8 +39,14 @@ class ActiveOrm::Redis::String < ActiveOrm::Redis
     client.msetnx(args)
   end
 
-  def self.create_until(key, value, seconds, format=:seconds)
-    seconds?(format) ? client.setex(normalize_key(key), seconds, value) : client.psetex(normalize_key(key), seconds, value)
+  def self.create_until(key, value, seconds, format = :seconds)
+    normalized_key = normalize_key(key)
+
+    if seconds?(format)
+      client.setex(normalized_key, seconds, value)
+    else
+      client.psetex(normalized_key, seconds, value)
+    end
   end
 
   def self.append(key, value)
@@ -51,23 +57,27 @@ class ActiveOrm::Redis::String < ActiveOrm::Redis
     client.setrange(normalize_key(key), offset, value)
   end
 
-  def self.decrement(key, value=1)
-    (value == 1) ? client.decr(normalize_key(key)) : client.decrby(normalize_key(key), value)
+  def self.decrement(key, value = 1)
+    normalized_key = normalize_key(key)
+
+    value == 1 ? client.decr(normalized_key) : client.decrby(normalized_key, value)
   end
 
-  def self.increment(key, value=1)
+  def self.increment(key, value = 1)
+    normalized_key = normalize_key(key)
+
     if value.is_a?(Float)
-      client.incrbyfloat(normalize_key(key), value)
+      client.incrbyfloat(normalized_key, value)
     else
-      (value == 1) ? client.incr(normalize_key(key)) : client.incrby(normalize_key(key), value)
+      value == 1 ? client.incr(normalized_key) : client.incrby(normalized_key, value)
     end
   end
 
-  def self.reset(key, value=0)
+  def self.reset(key, value = 0)
     client.getset(normalize_key(key), value)
   end
 
-  def self.bit_count(key, start=0, finish=-1)
+  def self.bit_count(key, start = 0, finish = -1)
     client.bitcount(normalize_key(key), start, finish)
   end
 

data/lib/active_orm/version.rb

@@ -1,3 +1,3 @@
 module ActiveOrm
-  VERSION = "3.0.0"
+  VERSION = '4.0.0'.freeze
 end

data/lib/generators/active_orm/install_generator.rb

@@ -1,12 +1,10 @@
-require "rails/generators"
+require 'rails/generators'
 
-module ActiveOrm
-  class InstallGenerator < Rails::Generators::Base
-    source_root File.expand_path("../templates", __FILE__)
-
-    def copy_initializer_file
-      copy_file("install.rb", "config/initializers/active_orm.rb")
-    end
+class ActiveOrm::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
 
+  def copy_initializer_file
+    copy_file('install.rb', 'config/initializers/active_orm.rb')
   end
+
 end

data/lib/tasks/redis.rake

@@ -1,30 +1,30 @@
 namespace :db do
   namespace :redis do
 
-    desc "Reset Redis database"
+    desc 'Reset Redis database'
     task reset: :environment do
-      puts "== Reset: reseting Redis ".ljust(80, "=")
+      puts '== Reset: reseting Redis '.ljust(80, '=')
       total_task_start_time = Time.current
 
-      puts "  -> Resetting"
+      puts '  -> Resetting'
       ActiveOrm::Redis::Connection.flush
 
       total_task_elapsed_time = (Time.current - total_task_start_time).round(5)
-      puts "== Reset: reset Redis (#{total_task_elapsed_time}s) ".ljust(80, "=")
-      puts ""
+      puts "== Reset: reset Redis (#{total_task_elapsed_time}s) ".ljust(80, '=')
+      puts ''
     end
 
-    desc "Reset all Redis databases"
+    desc 'Reset all Redis databases'
     task reset_all: :environment do
-      puts "== Reset: reseting all Redis ".ljust(80, "=")
+      puts '== Reset: reseting all Redis '.ljust(80, '=')
       total_task_start_time = Time.current
 
-      puts "  -> Resetting"
+      puts '  -> Resetting'
       ActiveOrm::Redis::Connection.flush_all
 
       total_task_elapsed_time = (Time.current - total_task_start_time).round(5)
-      puts "== Reset: reset all Redis (#{total_task_elapsed_time}s) ".ljust(80, "=")
-      puts ""
+      puts "== Reset: reset all Redis (#{total_task_elapsed_time}s) ".ljust(80, '=')
+      puts ''
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_orm
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Juan Gomez
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-03 00:00:00.000000000 Z
+date: 2016-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: fasterer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ORM for non-supported databases.
 email:
 - j.gomez@drexed.com
@@ -101,9 +157,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".DS_Store"
 - ".coveralls.yml"
+- ".fasterer.yml"
 - ".gitignore"
+- ".reek"
 - ".rspec"
+- ".rubocop.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -113,9 +173,13 @@ files:
 - bin/console
 - bin/rake
 - bin/setup
+- lib/.DS_Store
 - lib/active_orm.rb
+- lib/active_orm/.DS_Store
 - lib/active_orm/base.rb
+- lib/active_orm/railtie.rb
 - lib/active_orm/redis.rb
+- lib/active_orm/redis/.DS_Store
 - lib/active_orm/redis/base.rb
 - lib/active_orm/redis/configuration.rb
 - lib/active_orm/redis/connection.rb