simple-orm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 59a7344e57f7b6ead0f7d01a44560bae74264ab4
+  data.tar.gz: b4fda3c6faf544e63922d4e055898d895ead01e8
+SHA512:
+  metadata.gz: 59ddba5e0a9507c1ab2f81edc4c55e1c09cf4ef16dd8222346213aaa8d09c40e589df8c5ebf78b620415e489e20576016334c122cbe0b6ebfe30550786dbf236
+  data.tar.gz: 657f8ef0fabaa3dbd72cc1db1bc5b00776cf419d61c96b3ca76abb7a27e43f74f26a135a251201b20030437cbfd53878a55acd2fcf46038cb10bc084df56b55a

data/lib/simple-orm/db.rb

@@ -0,0 +1,61 @@
+require 'redis'
+require 'ppt/presenters'
+
+class PPT
+  module DB
+    def self.redis
+      @redis ||= Redis.new(driver: :hiredis)
+    end
+
+    class Entity
+      def self.presenter(klass = nil)
+        @presenter ||= klass
+      end
+
+      attr_reader :presenter
+      def initialize(values)
+        @presenter = self.class.presenter.new(values)
+        @is_new_record = true
+      end
+
+      def new_record?
+        @is_new_record
+      end
+
+      def values(stage = nil)
+        @presenter.values(stage)
+      end
+
+      def save
+        stage = self.new_record? ? :create : :update
+        self.values(stage).each do |key, value|
+          PPT::DB.redis.hset(self.key, key, value)
+        end
+      end
+    end
+
+    class User < Entity
+      presenter PPT::Presenters::User
+
+      def key
+        "users.#{@presenter.username}"
+      end
+    end
+
+    class Developer < Entity
+      presenter PPT::Presenters::Developer
+
+      def key
+        "devs.#{@presenter.company}.#{@presenter.username}"
+      end
+    end
+
+    class Story < Entity
+      presenter PPT::Presenters::Story
+
+      def key
+        "stories.#{@presenter.company}.#{@presenter.id}"
+      end
+    end
+  end
+end

data/lib/simple-orm/presenters.rb

@@ -0,0 +1,208 @@
+require 'json'
+require 'ppt/extensions'
+
+class PPT
+  module Presenters
+    class ValidationError < ::StandardError
+    end
+
+    class Validator
+      def initialize(message, &block)
+        @message, @block = message, block
+      end
+
+      def validate!(name, value)
+        unless @block.call(value)
+          raise ValidationError.new("Value of #{name} is invalid (value is #{value.inspect}).")
+        end
+      end
+    end
+
+    class Attribute
+      attr_accessor :instance
+      attr_reader :name
+      def initialize(name)
+        @name = name
+        @validators, @hooks = Array.new, Hash.new
+      end
+
+      # DSL
+      def private
+        @private = true
+        self
+      end
+
+      def required
+        @validators << Validator.new('is required') do |value|
+          value != nil && ! value.empty?
+        end
+
+        self
+      end
+
+      def validate(message, &block)
+        self.validators << Validator.new(message, &block)
+        self
+      end
+
+      def type(type)
+        @type = type
+        self
+      end
+
+      def default(value = nil, &block)
+        @hooks[:default] = value ? Proc.new { value } : block
+        self
+      end
+
+      def on_create(value = nil, &block)
+        @hooks[:on_create] = value ? Proc.new { value } : block
+        self
+      end
+
+      def on_update(value = nil, &block)
+        @hooks[:on_update] = value ? Proc.new { value } : block
+        self
+      end
+
+      # API
+      def private?
+        @private
+      end
+
+      def run_hook(name)
+        @hooks[name] && @instance.instance_eval(&@hooks[name])
+      end
+
+      def set(value)
+        if self.private?
+          raise "Attribute #{@name} is private!"
+        end
+
+        @value = value
+      end
+
+      def get(stage = nil)
+        if stage.nil?
+          @value ||= self.run_hook(:default)
+        elsif stage == :create
+          @value ||= self.run_hook(:on_create)
+        elsif stage == :update
+          @value ||= self.run_hook(:on_update)
+        else
+          raise ArgumentError.new("Attribute#get takes an optional argument which can be either :create or :update.")
+        end
+      end
+
+      def validate!(stage = nil)
+        @validators.each do |validator|
+          validator.validate!(self.name, self.get(stage))
+        end
+      end
+    end
+
+    class Entity
+      def self.attributes
+        @attributes ||= Hash.new
+      end
+
+      def self.attribute(name, options = Hash.new)
+        self.attributes[name] = Attribute.new(name)
+      end
+
+      def initialize(values = Hash.new)
+        # Let's consider it safe since this is not user input.
+        # It might not be the best idea, but for now, who cares.
+        values = PPT.symbolise_keys(values)
+
+        values.each do |key, value|
+          unless attribute = self.attributes[key]
+            raise ArgumentError.new("No such attribute: #{key}")
+          end
+
+          attribute.set(value)
+        end
+      end
+
+      def attributes
+        @attributes ||= self.class.attributes.reduce(Hash.new) do |buffer, (name, attribute)|
+          buffer.merge(name => attribute.dup.tap { |attribute| attribute.instance = self })
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        if self.attributes.has_key?(name)
+          self.attributes[name].get
+        elsif name[-1] == '=' && self.attributes.has_key?(name.to_s[0..-2].to_sym)
+          self.attributes[name.to_s[0..-2].to_sym].set(args.first)
+        else
+          super(name, *args, &block)
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        self.attributes.has_key?(name) ||
+          name[-1] == '=' && self.attributes.has_key?(name.to_s[0..-2].to_sym) ||
+          super(name, include_private)
+      end
+
+      def values(stage = nil)
+        self.attributes.reduce(Hash.new) do |buffer, (name, attribute)|
+          value = attribute.get(stage)
+          buffer[name] = value if value && value != ''
+          buffer
+        end
+      end
+
+      def to_json
+        self.values.to_json
+      end
+
+      def validate
+        self.attributes.each do |_, attribute|
+          attribute.validate!
+        end
+      end
+    end
+
+    # User is either a person or most likely a company.
+    #
+    # Each user can have only one service, just to make it simple.
+    # Besides, not many people use both Jira and Pivotal Tracker.
+    require 'securerandom'
+
+    class User < Entity
+      attribute(:service).required
+      attribute(:username).required
+      attribute(:name).required
+      attribute(:email).required
+      attribute(:accounting_email).default { self.email }
+      attribute(:auth_key).private.default { SecureRandom.hex }
+
+      attribute(:created_at).type(Time).on_create { Time.now.utc.to_i }
+      attribute(:updated_at).type(Time).on_update { Time.now.utc.to_i }
+    end
+
+    class Developer < Entity
+      attribute(:company).required
+      attribute(:username).required
+      attribute(:name).required
+      attribute(:email).required
+
+      attribute(:created_at).type(Time).on_create { Time.now.utc.to_i }
+      attribute(:updated_at).type(Time).on_update { Time.now.utc.to_i }
+    end
+
+    class Story < Entity
+      attribute(:company).required
+      attribute(:id).required
+      attribute(:title).required
+      attribute(:price).required
+      attribute(:currency).required
+      attribute(:link).required
+
+      attribute(:created_at).type(Time).on_create { Time.now.utc.to_i }
+      attribute(:updated_at).type(Time).on_update { Time.now.utc.to_i }
+    end
+  end
+end

data/spec/db_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+require 'ppt/db'
+
+describe PPT::DB do
+  let(:redis) { Redis.new(driver: :hiredis) }
+
+  before(:each) do
+    redis.flushdb
+    Time.stub(:now) { Time.at(1403347217) }
+  end
+
+  describe PPT::DB::Entity do
+    let(:subclass) do
+      Class.new(described_class) do |klass|
+        attribute(:id).required
+        attribute(:username).required
+      end
+    end
+  end
+
+  describe PPT::DB::User do
+    subject { described_class.new(attrs) }
+
+    let(:attrs) {{
+      service: 'pt',
+      username: 'ppt',
+      name: 'PayPerTask Ltd',
+      email: 'james@pay-per-task.com',
+      accounting_email: 'accounting@pay-per-task.com'
+    }}
+
+    describe '#key' do
+      it 'is users.username' do
+        expect(subject.key).to eq('users.ppt')
+      end
+    end
+
+    describe '#save' do
+      it 'saves data of its presenter as a Redis hash' do
+        subject.save
+        data = redis.hgetall(subject.key)
+        expect(data).to eq({'service'          => 'pt',
+                            'username'         => 'ppt',
+                            'name'             => 'PayPerTask Ltd',
+                            'email'            => 'james@pay-per-task.com',
+                            'accounting_email' => 'accounting@pay-per-task.com',
+                            'created_at'       => '1403347217'})
+      end
+    end
+  end
+
+  describe PPT::DB::Developer do
+    subject { described_class.new(attrs) }
+
+    let(:attrs) {{
+      company: 'ppt',
+      username: 'botanicus',
+      name: 'James C Russell',
+      email: 'contracts@101ideas.cz'
+    }}
+
+    describe '#key' do
+      it 'is devs.company.username' do
+        expect(subject.key).to eq('devs.ppt.botanicus')
+      end
+    end
+
+    describe '#save' do
+      it 'saves data of its presenter as a Redis hash' do
+        subject.save
+        data = redis.hgetall(subject.key)
+        expect(data).to eq({'company'    => 'ppt',
+                            'username'   => 'botanicus',
+                            'name'       => 'James C Russell',
+                            'email'      => 'contracts@101ideas.cz',
+                            'created_at' => '1403347217'})
+      end
+    end
+  end
+
+  describe PPT::DB::Story do
+    subject { described_class.new(attrs) }
+
+    let(:attrs) {{
+      company: 'ppt',
+      id: 957456,
+      price: 120,
+      currency: 'GBP',
+      link: 'http://www.pivotaltracker.com/story/show/60839620'
+    }}
+
+    describe '#key' do
+      it 'is stories.company.id' do
+        expect(subject.key).to eq('stories.ppt.957456')
+      end
+    end
+
+    describe '#save' do
+      it 'saves data of its presenter as a Redis hash' do
+        subject.save
+        data = redis.hgetall(subject.key)
+        expect(data).to eq({'company'    => 'ppt',
+                            'id'         => '957456',
+                            'price'      => '120',
+                            'currency'   => 'GBP',
+                            'link'       => 'http://www.pivotaltracker.com/story/show/60839620',
+                            'created_at' => '1403347217'})
+      end
+    end
+  end
+end
+

data/spec/presenters_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+require 'ppt/presenters'
+
+describe PPT::Presenters do
+  describe PPT::Presenters::Entity do
+    let(:subclass) do
+      Class.new(described_class) do |klass|
+        attribute(:id).required
+        attribute(:username).required
+      end
+    end
+
+    describe '#validate' do
+      it 'throws an error if whatever has been specified as required is missing' do
+        expect { subclass.new.validate }.to raise_error(PPT::Presenters::ValidationError)
+        expect { subclass.new(Hash.new).validate }.to raise_error(PPT::Presenters::ValidationError)
+        expect { subclass.new(username: 'botanicus').validate }.to raise_error(PPT::Presenters::ValidationError)
+      end
+
+      it 'throws an error if there are any extra arguments' do
+        expect { subclass.new(id: 1, username: 'botanicus', extra: 'x') }.to raise_error(ArgumentError)
+      end
+
+      it 'succeeds if just the right arguments have been provided' do
+        expect { subclass.new(id: 1, username: 'botanicus') }.not_to raise_error
+      end
+    end
+
+    describe '#values' do
+      it 'returns values as a hash' do
+        instance = subclass.new(id: 1, username: 'botanicus')
+        expect(instance.values[:id]).to eq(1)
+        expect(instance.values[:username]).to eq('botanicus')
+      end
+    end
+
+    describe 'accessors' do
+      it 'provides accessors for all the the attributes' do
+        instance = subclass.new(id: 1, username: 'botanicus')
+        expect(instance.id).to eq(1)
+        expect(instance.username).to eq('botanicus')
+
+        expect(instance.respond_to?(:username)).to be(true)
+      end
+    end
+
+    describe '#to_json' do
+      it 'converts #values to JSON' do
+        instance = subclass.new(id: 1, username: 'botanicus')
+        expect(instance.to_json).to eq('{"id":1,"username":"botanicus"}')
+      end
+    end
+  end
+
+  describe PPT::Presenters::User do
+    let(:attrs) {{
+      service: 'pt',
+      username: 'ppt',
+      name: 'PayPerTask Ltd',
+      email: 'james@pay-per-task.com',
+      accounting_email: 'accounting@pay-per-task.com'
+    }}
+
+    it 'raises an exception if service is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :service })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if username is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :username })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if name is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :name })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if email is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :email })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'returns a valid presenter if all the required arguments have been provided' do
+      expect { described_class.new(attrs).validate }.to_not raise_error
+    end
+  end
+
+  describe PPT::Presenters::Developer do
+    let(:attrs) {{
+      company: 'ppt',
+      username: 'botanicus',
+      name: 'James C Russell',
+      email: 'contracts@101ideas.cz'
+    }}
+
+    it 'raises an exception if company is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :company })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if username is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :username })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if name is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :name })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if email is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :email })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'returns a valid presenter if all the required arguments have been provided' do
+      expect { described_class.new(attrs).validate }.to_not raise_error
+    end
+  end
+
+  describe PPT::Presenters::Story do
+    let(:attrs) {{
+      company: 'ppt',
+      id: 957456,
+      title: 'Implement login',
+      price: 120,
+      currency: 'GBP',
+      link: 'http://www.pivotaltracker.com/story/show/60839620'
+    }}
+
+    it 'raises an exception if company is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :company })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if id is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :id })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if title is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :title })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if price is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :price })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if currency is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :currency })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'raises an exception if link is missing' do
+      instance = described_class.new(attrs.reject { |key, value| key == :link })
+      expect { instance.validate }.to raise_error(PPT::Presenters::ValidationError)
+    end
+
+    it 'returns a valid presenter if all the required arguments have been provided' do
+      expect { described_class.new(attrs).validate }.to_not raise_error
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: simple-orm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- https://github.com/botanicus
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: A simple ORM. By default it stores to Redis hashes.
+email: james@101ideas.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/simple-orm.rb
+- lib/simple-orm/db.rb
+- lib/simple-orm/presenters.rb
+- spec/db_spec.rb
+- spec/presenters_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/botanicus/simple-orm
+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: simple-orm
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Does what is says on the can. Nothing more, nothing less.
+test_files: []