modis 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dcfeb39afdb8de9cd3ffe9ec674b286eb70d06de
+  data.tar.gz: d7249376be524136201103ab7e9e3252311691e1
+SHA512:
+  metadata.gz: ca3a68ca27c5b974b150683440d1d5112ab1c78ea171219c05667c434015fbc9cd27e8e30f3d32fbd6eeb04626fff6d156196e037df1da343c232207c640cc79
+  data.tar.gz: f268573540e3e4c02cfe12c91fdf824a7c6550efd8092fc0ea5345c3bf9c63bfd2f3d0a61fafed693019bbad04f60c641f8a4313bf91f5f21219fca1eda05c7a

data/.coveralls.yml

@@ -0,0 +1 @@
+service-name: travis-ci

data/.gitignore

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

data/.ruby-gemset

@@ -0,0 +1 @@
+modis

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.1

data/.travis.yml

@@ -0,0 +1,8 @@
+services:
+  - redis-server
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.1
+  - jruby
+  - rbx

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'rspec'
+gem 'simplecov'
+gem 'coveralls'
+
+platform :mri_19, :mri_20, :mri_21 do
+  gem 'cane'
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Ian Leitch
+
+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,45 @@
+[![Build Status](https://secure.travis-ci.org/ileitch/modis.png?branch=master)](http://travis-ci.org/ileitch/modis)
+[![Code Climate](https://codeclimate.com/github/ileitch/modis.png)](https://codeclimate.com/github/ileitch/modis)
+[![Coverage Status](https://coveralls.io/repos/ileitch/modis/badge.png?branch=master)](https://coveralls.io/r/ileitch/modis?branch=master)
+
+# Modis
+
+ActiveModel + Redis with the aim to mimic ActiveRecord where possible.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'modis'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install modis
+
+## Usage
+
+```ruby
+class MyModel
+  include Modis::Models
+  attribute :name, String
+  attribute :age, Integer
+end
+
+MyModel.create!(:name => 'Ian', :age => 28)
+```
+
+## Supported Features
+
+TODO.
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,15 @@
+require "rake"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+Dir["lib/tasks/*.rake"].each { |rake| load rake }
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+end
+
+if RUBY_VERSION > '1.9' && defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
+  task :default => 'spec:cane'
+else
+  task :default => 'spec'
+end

data/lib/modis/attributes.rb

@@ -0,0 +1,136 @@
+module Modis
+  module Attributes
+    TYPES = [:string, :integer, :float, :timestamp, :boolean, :array, :hash]
+
+    def self.included(base)
+      base.extend ClassMethods
+
+      base.instance_eval do
+        bootstrap_attributes
+      end
+    end
+
+    module ClassMethods
+      def bootstrap_attributes
+        class << self
+          attr_accessor :attributes
+        end
+
+        self.attributes = {}
+
+        attribute :id, :integer
+      end
+
+      def attribute(name, type = :string, options = {})
+        name = name.to_s
+        return if attributes.keys.include?(name)
+        raise UnsupportedAttributeType.new(type) unless TYPES.include?(type)
+
+        attributes[name] = options.update({ :type => type })
+        define_attribute_methods [name]
+        class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            attributes['#{name}']
+          end
+
+          def #{name}=(value)
+            value = coerce_to_type('#{name}', value)
+            #{name}_will_change! unless value == attributes['#{name}']
+            attributes['#{name}'] = value
+          end
+        EOS
+      end
+    end
+
+    def attributes
+      @attributes ||= Hash[self.class.attributes.keys.zip]
+    end
+
+    def assign_attributes(hash)
+      hash.each do |k, v|
+        setter = "#{k}="
+        send(setter, v) if respond_to?(setter)
+      end
+    end
+
+    def write_attribute(key, value)
+      attributes[key.to_s] = value
+    end
+
+    protected
+
+    def set_sti_type
+      if self.class.sti_child?
+        assign_attributes(type: self.class.name)
+      end
+    end
+
+    def reset_changes
+      @changed_attributes.clear if @changed_attributes
+    end
+
+    def apply_defaults
+      defaults = {}
+      self.class.attributes.each do |attribute, options|
+        defaults[attribute] = options[:default] if options[:default]
+      end
+      assign_attributes(defaults)
+    end
+
+    def coerce_to_string(attribute, value)
+      attribute = attribute.to_s
+      return if value.blank?
+      type = self.class.attributes[attribute][:type]
+      if type == :array || type == :hash
+        MultiJson.encode(value) if value
+      elsif type == :timestamp
+        value.iso8601
+      else
+        value.to_s
+      end
+    end
+
+    def coerce_to_type(attribute, value)
+      # TODO: allow an attribute to be set to nil
+      return if value.blank?
+      attribute = attribute.to_s
+      type = self.class.attributes[attribute][:type]
+      strict = self.class.attributes[attribute][:strict] != false
+
+      if type == :string
+        value.to_s
+      elsif type == :integer
+        value.to_i
+      elsif type == :float
+        value.to_f
+      elsif type == :timestamp
+        return value if value.kind_of?(Time)
+        Time.parse(value)
+      elsif type == :boolean
+        return true if [true, 'true'].include?(value)
+        return false if [false, 'false'].include?(value)
+        raise AttributeCoercionError.new("'#{value}' cannot be coerced to a :boolean.")
+      elsif type == :array
+        decode_json(value, Array, attribute, strict)
+      elsif type == :hash
+        decode_json(value, Hash, attribute, strict)
+      else
+        value
+      end
+    end
+
+    def decode_json(value, type, attribute, strict)
+      return value if value.kind_of?(type)
+      begin
+        value = MultiJson.decode(value) if value.kind_of?(String)
+      rescue MultiJson::ParseError
+        raise if strict
+      end
+      if strict
+        return value if value.kind_of?(type)
+        raise AttributeCoercionError.new("Expected #{attribute} to be an #{type}, got #{value.class} instead.")
+      end
+      value
+    end
+  end
+end

data/lib/modis/configuration.rb

@@ -0,0 +1,12 @@
+module Modis
+  def self.configure
+    yield config
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  class Configuration < Struct.new(:namespace)
+  end
+end

data/lib/modis/errors.rb

@@ -0,0 +1,14 @@
+module Modis
+  class ModisError < StandardError; end
+  class RecordNotSaved < ModisError; end
+  class RecordNotFound < ModisError; end
+  class RecordInvalid < ModisError; end
+  class UnsupportedAttributeType < ModisError; end
+  class AttributeCoercionError < ModisError; end
+
+  module Errors
+    def errors
+      @errors ||= ActiveModel::Errors.new(self)
+    end
+  end
+end

data/lib/modis/finders.rb

@@ -0,0 +1,43 @@
+module Modis
+  module Finders
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def find(id)
+        record = attributes_for(id)
+        model_class(record).new(record, new_record: false)
+      end
+
+      def all
+        ids = Modis.redis.smembers(key_for(:all))
+        records = Modis.redis.pipelined do
+          ids.map { |id| Modis.redis.hgetall(key_for(id)) }
+        end
+        records.map do |record|
+          klass = model_class(record)
+          klass.new(record, new_record: false)
+        end
+      end
+
+      def attributes_for(id)
+        if id.nil?
+          raise RecordNotFound, "Couldn't find #{name} without an ID"
+        end
+        values = Modis.redis.hgetall(key_for(id))
+        unless values['id'].present?
+          raise RecordNotFound, "Couldn't find #{name} with id=#{id}"
+        end
+        values
+      end
+
+      private
+
+      def model_class(record)
+        return self if record["type"].blank?
+        return record["type"].constantize
+      end
+    end
+  end
+end

data/lib/modis/model.rb

@@ -0,0 +1,50 @@
+module Modis
+  module Model
+    def self.included(base)
+      base.instance_eval do
+        include ActiveModel::Dirty
+        include ActiveModel::Validations
+        include ActiveModel::Serialization
+
+        extend ActiveModel::Naming
+        extend ActiveModel::Callbacks
+
+        define_model_callbacks :save
+        define_model_callbacks :create
+        define_model_callbacks :update
+        define_model_callbacks :destroy
+
+        include Modis::Errors
+        include Modis::Transaction
+        include Modis::Persistence
+        include Modis::Finders
+        include Modis::Attributes
+
+        base.extend(ClassMethods)
+      end
+    end
+
+    module ClassMethods
+      def inherited(child)
+        super
+        bootstrap_sti(self, child)
+      end
+    end
+
+    def initialize(record=nil, options={})
+      set_sti_type
+      apply_defaults
+      assign_attributes(record.symbolize_keys) if record
+      reset_changes
+
+       if options.key?(:new_record)
+        instance_variable_set('@new_record', options[:new_record])
+      end
+    end
+
+    def ==(other)
+      super || other.instance_of?(self.class) && id.present? && other.id == id
+    end
+    alias :eql? :==
+  end
+end

data/lib/modis/persistence.rb

@@ -0,0 +1,162 @@
+module Modis
+  module Persistence
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # :nodoc:
+      def bootstrap_sti(parent, child)
+        child.instance_eval do
+        parent.instance_eval do
+          class << self
+              attr_accessor :sti_parent
+            end
+            attribute :type, :string
+          end
+
+          class << self
+            delegate :attributes, to: :sti_parent
+          end
+
+          @sti_child = true
+          @sti_parent = parent
+        end
+      end
+
+      # :nodoc:
+      def sti_child?
+        @sti_child == true
+      end
+
+      def namespace
+        return sti_parent.namespace if sti_child?
+        return @namespace if @namespace
+        @namespace = name.split('::').map(&:underscore).join(':')
+      end
+
+      def namespace=(value)
+        @namespace = value
+      end
+
+      def absolute_namespace
+        parts = [Modis.config.namespace, namespace]
+        @absolute_namespace = parts.compact.join(':')
+      end
+
+      def key_for(id)
+        "#{absolute_namespace}:#{id}"
+      end
+
+      def create(attrs)
+          model = new(attrs)
+          model.save
+          model
+      end
+
+      def create!(attrs)
+        model = new(attrs)
+        model.save!
+        model
+      end
+    end
+
+    def persisted?
+      true
+    end
+
+    def key
+      new_record? ? nil : self.class.key_for(id)
+    end
+
+    def new_record?
+      defined?(@new_record) ? @new_record : true
+    end
+
+    def save(args={})
+      begin
+        create_or_update(args)
+      rescue Modis::RecordInvalid
+        false
+      end
+    end
+
+    def save!(args={})
+      create_or_update(args) || (raise RecordNotSaved)
+    end
+
+    def destroy
+      self.class.transaction do
+        run_callbacks :destroy do
+          Modis.redis.del(key)
+          untrack(id)
+        end
+      end
+    end
+
+    def reload
+      new_attributes = self.class.attributes_for(id)
+      initialize(new_attributes)
+      self
+    end
+
+    def update_attribute(name, value)
+      assign_attributes(name => value)
+      save(validate: false)
+    end
+
+    def update_attributes(attrs)
+      assign_attributes(attrs)
+      save
+    end
+
+    def update_attributes!(attrs)
+      assign_attributes(attrs)
+      save!
+    end
+
+    protected
+
+    def create_or_update(args={})
+      skip_validate = args.key?(:validate) && args[:validate] == false
+      if !skip_validate && !valid?
+        raise Modis::RecordInvalid, errors.full_messages.join(', ')
+      end
+
+      future = nil
+      set_id if new_record?
+
+      self.class.transaction do
+        run_callbacks :save do
+          callback = new_record? ? :create : :update
+          run_callbacks callback do
+            attrs = []
+            attributes.each { |k, v| attrs << k << coerce_to_string(k, v) }
+            future = Modis.redis.hmset(self.class.key_for(id), attrs)
+            track(id) if new_record?
+          end
+        end
+      end
+
+      if future && future.value == 'OK'
+        reset_changes
+        @new_record = false
+        true
+      else
+        false
+      end
+    end
+
+    def set_id
+      self.id = Modis.redis.incr("#{self.class.absolute_namespace}_id_seq")
+    end
+
+    def track(id)
+      Modis.redis.sadd(self.class.key_for(:all), id)
+    end
+
+    def untrack(id)
+      Modis.redis.srem(self.class.key_for(:all), id)
+    end
+  end
+end

data/lib/modis/transaction.rb

@@ -0,0 +1,13 @@
+module Modis
+  module Transaction
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def transaction
+        Modis.redis.multi { yield }
+      end
+    end
+  end
+end

data/lib/modis/version.rb

@@ -0,0 +1,3 @@
+module Modis
+  VERSION = "0.0.1"
+end

data/lib/modis.rb

@@ -0,0 +1,27 @@
+require 'redis'
+require 'active_model'
+require 'active_support/all'
+require 'multi_json'
+
+require 'modis/version'
+require 'modis/configuration'
+require 'modis/attributes'
+require 'modis/errors'
+require 'modis/persistence'
+require 'modis/transaction'
+require 'modis/finders'
+require 'modis/model'
+
+module Modis
+  @mutex = Mutex.new
+
+  def self.redis
+    return @redis if @redis
+    @mutex.synchronize { @redis = Redis.new }
+    @redis
+  end
+
+  def self.redis=(redis)
+    @redis = redis
+  end
+end

data/lib/tasks/spec.rake

@@ -0,0 +1,18 @@
+begin
+  require 'cane/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new(:quality) do |cane|
+    cane.add_threshold 'coverage/covered_percent', :>=, 99
+    cane.no_style = false
+    cane.style_measure = 1000
+    cane.no_doc = true
+    cane.abc_max = 25
+  end
+
+  namespace :spec do
+    task :cane => ['spec', 'quality']
+  end
+rescue LoadError
+  warn "cane not available, quality task not provided."
+end

data/redis_model.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'modis/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "modis"
+  gem.version       = Modis::VERSION
+  gem.authors       = ["Ian Leitch"]
+  gem.email         = ["port001@gmail.com"]
+  gem.description   = "ActiveModel + Redis"
+  gem.summary       = "ActiveModel + Redis"
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'activemodel', '>= 3.0'
+  gem.add_dependency 'activesupport', '>= 3.0'
+  gem.add_dependency 'redis', '>= 3.0'
+end