restruct 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a3ceeabf9eae0c207f69176f1f7933eb46068e6
+  data.tar.gz: c52480abf0ad9fe754617cc4b8c845e7b8e16e27
+SHA512:
+  metadata.gz: dc9c0deaa324df308c8725e754e6195222a0d3749d7d436333c36451e394cadb2bca408bfdc3c00f730287cb46c4b2d12bbc4a0b68c1f3f13ef267fadf645648
+  data.tar.gz: 249265a027998c43c5ace27ec7f5bb1871960bae74ba73e50cd8a77ce4aa5c3dacea6b45d637060e99e8e672be11bf33da91f51e6aab8fa0228baeecfff05379

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: mW2pXg2OXu39MNr3mg8HNDObqmiASx232

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.ruby-gemset

@@ -0,0 +1 @@
+restruct

data/.ruby-version

@@ -0,0 +1 @@
+ruby 2.1

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - jruby
+services:
+  - redis-server

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in restruct.gemspec
+gemspec
+
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Gabriel Naiman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# Restruct
+
+[![Gem Version](https://badge.fury.io/rb/restruct.png)](https://rubygems.org/gems/restruct)
+[![Build Status](https://travis-ci.org/gabynaiman/restruct.png?branch=master)](https://travis-ci.org/gabynaiman/restruct)
+[![Coverage Status](https://coveralls.io/repos/gabynaiman/restruct/badge.png?branch=master)](https://coveralls.io/r/gabynaiman/restruct?branch=master)
+[![Code Climate](https://codeclimate.com/github/gabynaiman/restruct.png)](https://codeclimate.com/github/gabynaiman/restruct)
+[![Dependency Status](https://gemnasium.com/gabynaiman/restruct.png)](https://gemnasium.com/gabynaiman/restruct)
+
+Redis structures
+
+- Array
+- Set
+- Hash
+- NestedHash
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'restruct'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install restruct
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/gabynaiman/restruct/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/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+task :console do
+  require 'pry'
+  require 'restruct'
+  ARGV.clear
+  Pry.start
+end
+
+task default: :spec

data/lib/restruct.rb

@@ -0,0 +1,30 @@
+require 'redic'
+require 'class_config'
+require 'forwardable'
+require 'securerandom'
+
+require_relative 'restruct/version'
+require_relative 'restruct/structure'
+require_relative 'restruct/id'
+require_relative 'restruct/array'
+require_relative 'restruct/set'
+require_relative 'restruct/hash'
+require_relative 'restruct/nested_hash'
+require_relative 'restruct/marshalizable'
+require_relative 'restruct/marshal_array'
+require_relative 'restruct/marshal_set'
+require_relative 'restruct/marshal_hash'
+
+module Restruct
+
+  extend ClassConfig
+
+  attr_config :redis, Redic.new
+  attr_config :id_separator, ':'
+  attr_config :id_generator, ->() { Id.new(:restruct)[SecureRandom.uuid] }
+
+  def self.generate_id
+    id_generator.call
+  end
+
+end

data/lib/restruct/array.rb

@@ -0,0 +1,188 @@
+module Restruct
+  class Array < Structure
+
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :to_a, :uniq, :join, :reverse, :+, :-, :&, :|
+
+    def at(index)
+      deserialize redis.call('LINDEX', id, index)
+    end
+
+    def values_at(*args)
+      args.each_with_object([]) do |arg, array|
+        elements = self[arg]
+        array.push *(elements ? Array(elements) : [nil])
+      end
+    end
+
+    def fetch(index, default=nil, &block)
+      validate_index_type! index
+
+      if index < size
+        at index
+      else
+        validate_index_bounds! index if default.nil? && block.nil?
+        default || block.call(index)
+      end
+    end
+
+    def [](*args)
+      if args.count == 1
+        if args[0].is_a? Integer
+          at args[0].to_i
+        elsif args[0].is_a? Range
+          range args[0].first, args[0].last
+        else
+          validate_index_type! args.first
+        end
+      elsif args.count == 2
+        range args[0], args[0] + args[1] - 1
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.count} for 1..2)"
+      end
+    end
+
+    def []=(index, element)
+      validate_index_type! index
+      validate_index_bounds! index
+
+      redis.call 'LSET', id, index, serialize(element)
+    end
+
+    def push(*elements)
+      redis.call 'RPUSH', id, *elements.map { |e| serialize e }
+      self
+    end
+    alias_method :<<, :push
+
+    def insert(index, *elements)
+      validate_index_type! index
+      tail_size = index >= 0 ? size - index : size - (size + index) - 1
+      tail = Array(pop(tail_size))
+      push *(elements + tail)
+    end
+
+    def concat(array)
+      push *array
+    end
+
+    def pop(count=1)
+      if count == 1
+        deserialize redis.call('RPOP', id)
+      else
+        [count, size].min.times.map { pop }.reverse
+      end
+    end
+
+    def shift(count=1)
+      if count == 1
+        deserialize redis.call('LPOP', id)
+      else
+        [count, size].min.times.map { shift }
+      end
+    end
+
+    def delete(element)
+      removed_count = redis.call 'LREM', id, 0, serialize(element)
+      removed_count > 0 ? element : nil
+    end
+
+    def delete_at(index)
+      validate_index_type! index
+      return nil if out_of_bounds? index
+      
+      element = at index
+      tail_size = index >= 0 ? size - index : size - (size + index)
+      tail = Array(pop(tail_size))
+      push *tail[1..-1]
+      element
+    end
+
+    def delete_if
+      each { |e| delete e if yield e }
+      self
+    end
+
+    def keep_if
+      each { |e| delete e unless yield e }
+      self
+    end
+    alias_method :select!, :keep_if
+
+    def clear
+      destroy
+      self
+    end
+
+    def size
+      redis.call 'LLEN', id
+    end
+    alias_method :count, :size
+    alias_method :length, :size
+
+    def empty?
+      size == 0
+    end
+
+    def include?(element)
+      each { |e| return true if e == element }
+      false
+    end
+
+    def each
+      index = 0
+      while index < size
+        yield at(index), index
+        index += 1
+      end
+    end
+
+    def each_index
+      each { |_,i| yield i }
+    end
+
+    def first
+      at 0
+    end
+
+    def last
+      at -1
+    end
+
+    def to_a
+      range 0, -1
+    end
+    alias_method :to_ary, :to_a
+    alias_method :to_primitive, :to_a
+
+    private
+
+    def range(start, stop)
+      return nil if start > size
+      redis.call('LRANGE', id, start, stop).map { |e| deserialize e }
+    end
+
+    def validate_index_type!(index)
+      raise TypeError, "no implicit conversion from #{index.nil? ? 'nil' : index.class.name.downcase} to integer" unless index.is_a? Integer
+    end
+
+    def validate_index_bounds!(index)
+      raise IndexError, "index #{index} outside of array bounds: -#{size}...#{size}" if out_of_bounds? index
+    end
+
+    def out_of_bounds?(index)
+      !(-size..size).include?(index)
+    end
+
+    def serialize(string)
+      string
+    end
+
+    def deserialize(string)
+      string
+    end
+
+  end
+end

data/lib/restruct/hash.rb

@@ -0,0 +1,124 @@
+module Restruct
+  class Hash < Structure
+
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :to_h, :merge, :flatten, :invert
+
+    def [](key)
+      deserialize redis.call('HGET', id, key)
+    end
+
+    def fetch(key, default=nil, &block)
+      if key? key
+        self[key]
+      else
+        raise KeyError, "key not found: #{key}" if default.nil? && block.nil?
+        default || block.call(key)
+      end
+    end
+
+    def key(value)
+      index = values.index value
+      keys[index] if index
+    end
+
+    def store(key, value)
+      redis.call 'HSET', id, key, serialize(value)
+      value
+    end
+    alias_method :[]=, :store
+
+    def update(hash)
+      hash.each { |k,v| store k, v }
+      self
+    end
+    alias_method :merge!, :update
+
+    def delete(key)
+      value = self[key]
+      redis.call 'HDEL', id, key
+      value
+    end
+
+    def delete_if
+      each { |k,v| delete k if yield k, v }
+      self
+    end
+
+    def keep_if
+      each { |k,v| delete k unless yield k, v }
+      self
+    end
+    alias_method :select!, :keep_if
+
+    def clear
+      destroy
+      self
+    end
+
+    def keys
+      redis.call 'HKEYS', id
+    end
+
+    def values
+      redis.call('HVALS', id).map { |v| deserialize v }
+    end
+
+    def values_at(*keys)
+      keys.map { |k| self[k] }
+    end
+
+    def key?(key)
+      redis.call('HEXISTS', id, key) == 1
+    end
+    alias_method :has_key?, :key?
+
+    def value?(value)
+      values.include? value
+    end
+    alias_method :has_value?, :value?
+
+    def size
+      redis.call 'HLEN', id
+    end
+    alias_method :count, :size
+    alias_method :length, :size
+
+    def empty?
+      size == 0
+    end
+
+    def each
+      keys.each { |key| yield key, self[key] }
+    end
+    alias_method :each_pair, :each
+
+    def each_key
+      each { |k,v| yield k }
+    end
+
+    def each_value
+      each { |k,v| yield v }
+    end
+
+    def to_h
+      redis.call('HGETALL', id).each_slice(2).each_with_object({}) do |(k,v), hash|
+        hash[k] = deserialize v
+      end
+    end
+    alias_method :to_primitive, :to_h
+
+    private
+
+    def serialize(string)
+      string
+    end
+
+    def deserialize(string)
+      string
+    end
+
+  end
+end