active_kv 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d2f673f0b0a6150b3b57d6d983dea905450e2bb4
+  data.tar.gz: 36710d432228d89aa41bfabd972756ff1d5f4abf
+SHA512:
+  metadata.gz: 0895e2ac0c2ad161c42ab2ae7711a14de238dfcd43f66cbcdba43ee9e5dd59429cee9b798f4d33a2e09125bd8d8a4046e33330b4e5331273b1159ab337f3ce5e
+  data.tar.gz: 8a524df8b4d89067c02e7215ff55c3430b9ff5d16e02c83cac92e14d4a7858a5226d5c2a065479d2a1839f29d66ed1f7a66a090e6e5971b02fae9fde8a47c675

data/README.md

@@ -0,0 +1,39 @@
+# ActiveRedis
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/active_redis`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_redis'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_redis
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/active_redis/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/active_redis.rb

@@ -0,0 +1,40 @@
+require "active_model"
+require "redis"
+
+require "active_redis/version"
+require "active_redis/attributes"
+require "active_redis/relation"
+require "active_redis/boolean"
+
+module ActiveRedis
+
+  @redis ||= Redis.new
+
+  attr_reader :redis
+
+  class Base
+
+    include ActiveModel::Validations
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include ActiveRedis::Attributes::InstanceMethods
+    include ActiveRedis::Relation::InstanceMethods
+    extend ActiveRedis::Attributes::ClassMethods
+    extend ActiveRedis::Relation::ClassMethods
+
+    def initialize args={}, settings={reload: false}
+      raise TypeError, 'Hash expected.' unless args.is_a? Hash
+      keys.merge!({id: Integer, updated_at: Time})
+      args = Hash[args.map{|(k,v)| [k.to_sym,v]}]
+      @h = args
+      create_relation_methods
+      create_attribute_methods
+      get_attributes reload: settings[:reload]
+    end
+
+  end
+
+  extend self
+
+end

data/lib/active_redis/attributes.rb

@@ -0,0 +1,297 @@
+module ActiveRedis
+  module Attributes
+
+    module InstanceMethods
+
+      ##
+      # Save the current record to redis store.
+      #
+      # @return [true,false]
+      #
+      def save
+        valid? ? (set_attributes(attributes) && true) : false
+      end
+
+      ##
+      # Reformat object.
+      #
+      # @return [String]
+      #
+      def inspect
+        a = keys.reject{|k,v| k == :id }.map do |attribute,type|
+          %Q{#{attribute}=#{send(attribute).inspect}}
+        end
+        %Q{#<#{self.class.name} id=#{self.id} #{a.join(' ')}>}
+      end
+
+      ##
+      # Remove the instance from redis store.
+      # Remove all relations to another objects.
+      #
+      # @return [void]
+      #
+      def remove
+        blto = self.class.instance_variable_get(:@belongs_to)
+        (blto || []).each do |rel|
+          handle_relation relation_key: "#{rel.to_s.singularize}_id",
+            action: :del
+        end
+        connection.del *attribute_paths
+      end
+
+      alias :delete :remove
+      alias :destroy :remove
+
+      ##
+      # Get the current attributes.
+      #
+      # @return [Hash]
+      #
+      def attributes
+        get_attributes
+      end
+
+      ##
+      # @see ActiveRedis#keys
+      #
+      def keys
+        self.class.keys
+      end
+
+      ##
+      # @see ActiveRedis#connection
+      #
+      def connection
+        self.class.connection
+      end
+
+      ##
+      # Implement ActiveModel validation support.
+      #
+      def read_attribute_for_validation key 
+        attributes[key]
+      end
+
+
+      module_function
+
+      ##
+      # Create getter/setter/bool methods by attributes.
+      # This method should be called in a constructor.
+      #
+      # @return [void]
+      #
+      def create_attribute_methods
+        self.class.instance_eval do
+          keys.each do |attribute,type|
+            define_method(attribute) do
+              attributes[attribute]
+            end 
+
+            define_method("#{attribute}=") do |arg|
+              attributes[attribute] = format_attribute(attribute,arg.to_s)
+            end 
+
+            define_method("#{attribute}?") do
+              !attributes[attribute].to_s.empty?
+            end 
+          end 
+        end 
+      end
+
+      ##
+      # Get attributes from redis store.
+      #
+      # @param reload [true,false] Force reload from redis.
+      #
+      # @return [Hash]
+      #
+      def get_attributes reload: false
+        if reload or not @h
+          h = (@h and @h[:id]) ? connection.hgetall(basename) : {}
+          attribute_hash = {}
+          unless h.empty?
+            keys.each do |k,v|
+              attribute_hash[k.to_sym] = format_attribute(k.to_sym, h[k.to_s])
+            end
+          end
+          @h = attribute_hash
+        end
+        @h
+      end
+
+      ##
+      # Casting objects into original values.
+      # The type whould be defined at class method "keys"
+      #
+      # @see ActiveRedis.keys
+      #
+      # @param key [String,Symbol]
+      # @param value [Object]
+      #
+      # @return [Object] Casted value.
+      #
+      def format_attribute key, value
+        case keys[key.to_sym].to_s
+        when /Integer/
+          value.to_i
+        when /Array/
+          connection.lrange("#{basename}:#{key}",0,-1)
+        when /Hash/
+          connection.hgetall("#{basename}:#{key}")
+        when /Time/
+          Time.parse(value) rescue nil
+        else value
+        end
+      end
+
+      ##
+      # Save given hash to redis server.
+      # Refresh updated_at timestamp.
+      # Unless id isn't set, get the next primary key.
+      #
+      # @param arg [Hash]
+      #
+      # @return [void]
+      #
+      def set_attributes arg
+        remove
+        arg[:updated_at] = Time.now.to_s
+        arg[:id] ||= connection.incr("#{self.class.name}_id")
+        arg.each do |k,v|
+          case v
+          when Array
+            v.each do |v|
+              connection.lpush "#{basename}:#{k}", v
+            end
+          when Hash
+            connection.mapped_hmset "#{basename}:#{k}", v
+          else
+            handle_relation relation_key: k, value: v, action: :add
+            connection.hset basename, k, v
+          end
+        end
+        get_attributes(reload: true)
+      end
+
+      ##
+      # Redis basename.
+      #
+      # @return [String]
+      #
+      def basename
+        "#{self.class.name.downcase.pluralize}:#{self.id}"
+      end
+
+      ##
+      # Get attribute paths by keys.
+      # Complex types needs to be stored at another path.
+      #
+      # @return [Array]
+      #
+      def attribute_paths
+        keys.map do |k,v|
+          case v.to_s
+          when /Hash/, /Array/ then "#{basename}:#{k}"
+          else basename
+          end
+        end.uniq
+      end
+
+    end
+
+    module ClassMethods
+
+      ##
+      # Fromatted class name.
+      #
+      # @return [String]
+      #
+      def cname
+        self.name.downcase.pluralize
+      end
+
+      ##
+      # Create a new instance and save it to redis store.
+      #
+      # @return [ActiveRedis::Base]
+      #
+      def create attributes
+        a = self.new(attributes)
+        a.save
+        a
+      end
+
+      ##
+      # Get all objects.
+      #
+      # @return [Array<ActiveRedis>]
+      #
+      def all
+        connection.keys("#{cname}:*").map do |key|
+          self.new({id: key[/#{cname}:(\d+)/,1].to_i},reload: true)
+        end
+      end
+
+      ##
+      # Redis base connection.
+      #
+      # @return [Redis]
+      #
+      def connection
+        ActiveRedis.redis
+      end
+
+      ##
+      # @param id [Integer]
+      #
+      # @return [ActiveRedis::Base]
+      #
+      def find id
+        a = connection.hgetall("#{cname}:#{id}")
+        self.new({id: id},reload: true) unless a.empty?
+      end
+
+      ##
+      # @see where
+      #
+      # @return [ActiveRedis::Base]
+      #
+      def find_by basename: nil
+        if basename
+          where(basename: basename).first
+        end
+      end
+
+      ##
+      # @params basename [String]
+      #
+      # @return [Array]
+      #
+      def where basename: nil
+        if basename
+          a = connection.smembers(basename)
+          a.map{ |entry| self.find(entry) }
+        else
+          []
+        end
+      end
+
+      ##
+      # Set the keys/attributs for an ActiveRedis::Base child.
+      #
+      # Example:
+      #
+      #   keys title: String,
+      #     number: Integer
+      #
+      def keys hash=nil
+        hash ? (@keys ||= hash) : @keys
+      end
+
+
+      extend self
+
+    end
+  end
+end

data/lib/active_redis/boolean.rb

@@ -0,0 +1,4 @@
+module Boolean; end 
+TrueClass.include Boolean 
+FalseClass.include Boolean 
+

data/lib/active_redis/relation.rb

@@ -0,0 +1,92 @@
+module ActiveRedis
+  module Relation
+
+    module InstanceMethods
+
+      module_function
+
+      ##
+      # Generate methods for relations.
+      #
+      # @return [void]
+      #
+      def create_relation_methods
+        self.class.instance_eval do
+          (@has_many || []).each do |x|
+            define_method(x.to_s.pluralize) do
+              klazz = Object.const_get(x.to_s.capitalize.singularize)
+              klazz.where(
+                basename: "#{basename}:#{x.to_s.downcase.pluralize}")
+            end
+          end
+          (@belongs_to || []).each do |x|
+            keys.merge!({"#{x.to_s.downcase.singularize}_id".to_sym => Integer}) 
+            define_method(x.to_s.singularize) do 
+              klazz = Object.const_get(x.to_s.capitalize.singularize) 
+              klazz.find send("#{x.to_s.downcase.singularize}_id") 
+            end 
+          end 
+          (@has_one || []).each do |x| 
+            define_method(x.to_s) do 
+              klazz = Object.const_get(x.to_s.capitalize.singularize) 
+              klazz.find_by(basename: "#{basename}:"+
+                            "#{x.to_s.downcase.singularize}") 
+            end 
+          end 
+        end 
+      end
+
+      ##
+      # Create a set for each relation. This is needed to 
+      # fetch directly the objects by id from redis store.
+      # Nobody wan't to do it only at application level.
+      #
+      # @param relation_key [String] Like Author - Post.author_id
+      # @param value [String]
+      # @param action [:add,:del]
+      #
+      # @return [void]
+      #
+      def handle_relation relation_key: nil, value: nil, action: :add
+        blto = self.class.instance_variable_get(:@belongs_to)
+        relation = relation_key.to_s[/^([a-z_]+)_id$/,1].to_s
+        if blto.is_a?(Array) and
+          blto.include?(relation.to_sym)
+          if action == :add
+            connection.sadd(
+              "#{relation.pluralize}:#{value}:#{self.class.cname}",
+              id)
+          elsif action == :del
+            connection.srem(
+              "#{relation.pluralize}:"+
+              "#{value || send(relation_key)}:"+
+              "#{self.class.cname}",
+              id)
+          end
+        end
+      end
+
+
+    end
+
+    module ClassMethods
+
+      ##
+      # Create class level methods.
+      #
+      %w{has_many has_one belongs_to}.each do |m|
+        define_method(m) do |symbol|
+          unless instance_variable_get("@#{m}").is_a?(Array)
+            instance_variable_set("@#{m}",[])
+          end
+          instance_variable_get("@#{m}") << symbol
+        end
+      end
+
+
+      extend self
+
+    end
+
+  end
+end

data/lib/active_redis/version.rb

@@ -0,0 +1,3 @@
+module ActiveRedis
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: active_kv
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tim Foerster
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.7.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.7.3
+- !ruby/object:Gem::Dependency
+  name: redis
+  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: active_model
+  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'
+description: 
+email:
+- timhormersdorf@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/active_redis.rb
+- lib/active_redis/attributes.rb
+- lib/active_redis/boolean.rb
+- lib/active_redis/relation.rb
+- lib/active_redis/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Get redis relational
+test_files: []