rrrmatey 0.1.0

data/lib/rrrmatey/string_model/string_model.rb

@@ -0,0 +1,92 @@
+module RRRMatey
+    module StringModel
+        require 'json'
+        require 'xmlsimple'
+        require_relative 'connection_methods'
+        require_relative 'namespaced_key_methods'
+        require_relative 'field_definition_methods'
+        require_relative 'index_methods'
+        require_relative 'find_methods'
+        require_relative 'delete_methods'
+        require_relative 'consumer_adapter_methods'
+
+        def self.included(base)
+            base.extend ConnectionMethods
+            base.extend NamespacedKeyMethods
+            base.extend FieldDefinitionMethods
+            base.extend IndexMethods
+            base.extend FindMethods
+            base.extend DeleteMethods
+            base.extend ConsumerAdapterMethods
+        end
+
+        self.extend ConnectionMethods
+
+        attr_accessor :content_type, :id
+        def content_type()
+            @content_type || 'application/json'
+        end
+
+        def save()
+            raise UnsupportedTypeError.new(content_type) if content_type == 'application/unknown'
+            raise InvalidModelError if id.blank?
+            raise InvalidModelError if has_valid? && !valid?
+            h = to_hash()
+            s = hash_to_typed_string(h)
+            unless self.class.cache_proxy.nil?
+                self.class.cache_proxy.with { |r|
+                    r.set(self.class.namespaced_key(id), s)
+                }
+            end
+            self
+        end
+
+        def delete()
+            self.class.delete(id)
+        end
+
+        def to_json(opts = {})
+            to_consumer_hash.to_json
+        end
+
+        def to_xml(opts = {})
+            to_consumer_hash.to_xml(:root => self.class.item_name)
+        end
+
+        private
+
+        def to_consumer_hash
+            h = {
+                'id' => id
+            }
+            self.class.consumer_fields.each do |f|
+                h[f] = send(f.to_sym)
+            end
+            h
+        end
+
+        def has_valid?
+            @has_valid ||= respond_to?(:valid?)
+        end
+
+        def to_hash()
+            h = {}
+            unless self.class.fields.nil?
+                self.class.fields.each {|f| h[f.to_s] = send(f) }
+            end
+            h
+        end
+
+        def hash_to_typed_string(h)
+            case content_type
+            when 'application/json'
+                { self.class.item_name => h }.to_json
+            when 'application/xml'
+                h.to_xml(:root => self.class.item_name, :skip_instruct => true,
+                         :indent => 0)
+            else
+                raise UnknownContentTypeError
+            end
+        end
+    end
+end

data/lib/rrrmatey/type_coercion.rb

@@ -0,0 +1,61 @@
+class String
+    def to_fixnum_to_date
+        to_i.to_date
+    end
+
+    unless respond_to?(:underscore)
+        def underscore
+            self.gsub(/::/, '/').
+                gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+                gsub(/([a-z\d])([A-Z])/,'\1_\2').
+                tr("- ", "_").
+                downcase
+        end
+    end
+
+    unless respond_to?(:pluralize)
+        def pluralize
+            self + "s"
+        end
+    end
+
+    unless respond_to?(:constantize)
+        def constantize
+            Module.const_get(self)
+        end
+    end
+end
+
+class Hash
+    unless respond_to?(:to_xml)
+        def to_xml(opts = {})
+            root_name = opts[:root] || 'root'
+            self.keys.each { |k| self[k] = 'null' if self[k].nil? }
+            XmlSimple.xml_out(self, :root_name => root_name)
+        end
+    end
+
+    unless self.class.respond_to?(:from_xml)
+        def self.from_xml(s, opts={})
+            XmlSimple.xml_in(s, :force_array => false)
+        end
+    end
+end
+
+class Fixnum
+    def to_date
+        Time.at(self).to_datetime
+    end
+end
+
+class DateTime
+    def seconds_since_epoch
+        to_time.to_i
+    end
+end
+
+class Date
+    def seconds_since_epoch
+        to_date.to_time.to_i
+    end
+end

data/lib/rrrmatey/version.rb

@@ -0,0 +1,3 @@
+module RRRMatey
+    VERSION = '0.1.0'
+end

data/spec/rrrmatey/crud_controller/crud_controller_spec.rb

@@ -0,0 +1,258 @@
+require 'spec_helper'
+
+class Model
+    attr_accessor :id, :content_type
+    attr_accessor :name
+    attr_accessor :name_s
+
+    def initialize(opts = {})
+        opts.each {|k,v| send("#{k}=".to_sym, v) }
+    end
+
+    def self.list(offset = 0, limit = 20)
+        results = offset.upto(offset + limit - 1).map do |i|
+            factory_by_i(i)
+        end
+        RRRMatey::DiscreteResult.new(:results => results,
+                                     :length => 420,
+                                     :offset => offset,
+                                     :discrete_length => limit)
+    end
+    
+    def self.get(id)
+        return if id == 'dne'
+        factory_by_id(id, "enam")
+    end
+
+    def self.delete(id)
+        return 0 if id.nil?
+        1
+    end
+
+    private
+
+    def self.factory_by_i(i)
+        factory_by_id("di#{i}", "#eman#{i}")
+    end
+
+    def self.factory_by_id(id, name)
+        Model.new(:id => id, :name => name)
+    end
+end
+
+class ModelsController
+    include RRRMatey::CrudController
+
+    attr_accessor :params
+
+    # override respond_ methods to make testable
+    def respond_bad_request
+        { :status => 400, :content_type => 'application/json', :body => nil }
+    end
+
+    def respond_not_found
+        { :status => 404, :content_type => 'application/json', :body => nil }
+    end
+
+    def respond_internal_server_error(e)
+        { :status => 400, :content_type => 'application/json', :body => { :message => e.message } }
+    end
+
+    def respond_ok(item)
+        { :status => 200, :content_type => 'application/json', :body => item }
+    end
+end
+
+describe RRRMatey::CrudController do
+    let(:kontroller_modyule) { RRRMatey::CrudController }
+    let(:kontroller_klass) { ModelsController }
+    let(:kontroller) { kontroller_klass.new }
+
+    describe '#included' do
+        it 'included extends ModelMethods' do
+            expect(extends_all_instance_methods(kontroller_klass, RRRMatey::CrudController::ModelMethods)).to eq(true)
+        end
+    end
+
+    describe '#index' do
+        let(:params) { { :offset => 40, :limit => 2 } }
+        let(:kontroller) {
+            k = kontroller_klass.new
+            k.params = params
+            k
+        }
+        let(:response) {
+            kontroller.index()
+        }
+        let(:status) { response[:status] }
+        let(:content_type) { response[:content_type] }
+        let(:body) { response[:body] }
+
+        it 'responds with an :ok status' do
+            expect(status).to eq(200)
+        end
+
+        it 'responds with a json content_type' do
+            expect(content_type).to eq('application/json')
+        end
+
+        it 'responds with the specifid offset' do
+            expect(body.offset).to eq(40)
+        end
+
+        it 'responds with the specifid limit' do
+            expect(body.discrete_length).to eq(2)
+        end
+
+        it 'responds with the underlying length' do
+            expect(body.length).to eq(420)
+        end
+
+        it 'lists the first page of model results' do
+            expect(body.results.length).to eq(2)
+        end
+    end
+
+    describe '#show' do
+        context 'item found in store' do
+            let(:params) { { :id => 'di2' } }
+            let(:kontroller) {
+                k = kontroller_klass.new
+                k.params = params
+                k
+            }
+            let(:response) {
+                kontroller.show()
+            }
+            let(:status) { response[:status] }
+            let(:content_type) { response[:content_type] }
+            let(:body) { response[:body] }
+
+            it 'responds with an :ok status' do
+                expect(status).to eq(200)
+            end
+
+            it 'responds with a json content_type' do
+                expect(content_type).to eq('application/json')
+            end
+
+            it 'responds with a model item' do
+                expect(body.class.name).to eq('Model')
+            end
+        end
+
+        context 'item not found in store' do
+            let(:params) { { :id => 'dne' } }
+            let(:kontroller) {
+                k = kontroller_klass.new
+                k.params = params
+                k
+            }
+            let(:response) {
+                kontroller.show()
+            }
+            let(:status) { response[:status] }
+            let(:content_type) { response[:content_type] }
+            let(:body) { response[:body] }
+
+            it 'responds with an :ok status' do
+                expect(status).to eq(404)
+            end
+
+            it 'responds with a json content_type' do
+                expect(content_type).to eq('application/json')
+            end
+
+            it 'responds with a nil body' do
+                expect(body).to be(nil)
+            end
+        end
+
+        context 'id not specified' do
+            let(:params) { { } }
+            let(:kontroller) {
+                k = kontroller_klass.new
+                k.params = params
+                k
+            }
+            let(:response) {
+                kontroller.show()
+            }
+            let(:status) { response[:status] }
+            let(:content_type) { response[:content_type] }
+            let(:body) { response[:body] }
+
+            it 'responds with an :ok status' do
+                expect(status).to eq(400)
+            end
+
+            it 'responds with a json content_type' do
+                expect(content_type).to eq('application/json')
+            end
+
+            it 'responds with a model item' do
+                expect(body).to be(nil)
+            end
+        end
+
+    end
+
+    describe '#destroy' do
+        context 'id specified' do
+            let(:params) { { :id => 'di2' } }
+            let(:kontroller) {
+                k = kontroller_klass.new
+                k.params = params
+                k
+            }
+            let(:response) {
+                kontroller.destroy()
+            }
+            let(:status) { response[:status] }
+            let(:content_type) { response[:content_type] }
+            let(:body) { response[:body] }
+
+            it 'responds with an :ok status' do
+                expect(status).to eq(200)
+            end
+
+            it 'responds with a json content_type' do
+                expect(content_type).to eq('application/json')
+            end
+
+            it 'responds with an empty body' do
+                expect(body).to be(nil)
+            end
+        end
+
+        context 'id not specified' do
+            let(:params) { { } }
+            let(:kontroller) {
+                k = kontroller_klass.new
+                k.params = params
+                k
+            }
+            let(:response) {
+                kontroller.destroy()
+            }
+            let(:status) { response[:status] }
+            let(:content_type) { response[:content_type] }
+            let(:body) { response[:body] }
+
+            it 'responds with an :ok status' do
+                expect(status).to eq(400)
+            end
+
+            it 'responds with a json content_type' do
+                expect(content_type).to eq('application/json')
+            end
+
+            it 'responds with a model item' do
+                expect(body).to be(nil)
+            end
+        end
+    end
+
+    describe '#update' do
+    end
+end

data/spec/rrrmatey/crud_controller/model_methods_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+class OtherModel
+end
+
+class Model
+end
+
+class ModelsController
+    extend RRRMatey::CrudController::ModelMethods
+end
+
+describe RRRMatey::CrudController::ModelMethods do
+    let(:kontroller_klass) { ModelsController }
+
+    describe '#model' do
+        it 'defaults to controller name derived model' do
+            expect(kontroller_klass.model).to eq(Model)
+        end
+
+        it 'allows specification' do
+            kontroller_klass.model(OtherModel)
+            expect(kontroller_klass.model).to eq(OtherModel)
+        end
+    end
+end

data/spec/rrrmatey/discrete_result_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+class DiscreteModel
+    attr_accessor :id, :name
+
+    def initialize(opts = {})
+        @id = opts[:id]
+        @name = opts[:name]
+    end
+
+    def to_consumer_hash
+        { 'id' => id, :name => name }
+    end
+end
+
+describe RRRMatey::DiscreteResult do
+    context 'empty results' do
+        let(:results) { nil }
+        let(:discrete_result) {
+            RRRMatey::DiscreteResult.new(:results => results,
+                                         :length => 42,
+                                         :offset => 40,
+                                         :discrete_length => 10)
+        }
+
+        describe '#initialize' do
+            it 'sets results' do
+                expect(discrete_result.results).to eq([])
+            end
+
+            it 'sets length' do
+                expect(discrete_result.length).to eq(42)
+            end
+
+            it 'sets offset' do
+                expect(discrete_result.offset).to eq(40)
+            end
+
+            it 'sets discrete_length' do
+                expect(discrete_result.discrete_length).to eq(10)
+            end
+        end
+
+        describe '#to_json' do
+            it 'yields json array of results' do
+                expect(discrete_result.to_json).to eq('{"length":42,"offset":40,"limit":10,"results":[]}')
+            end
+        end
+
+        describe '#to_xml' do
+            it 'yields xml array of results' do
+                expect(discrete_result.to_xml.gsub(/\n/, '').
+                       gsub(/\>\s+\</, '><')).
+                       to eq('<root length="42" offset="40" limit="10"></root>')
+            end
+        end
+
+    end
+
+    context 'hydrated results' do
+        let(:results) { [
+            DiscreteModel.new(:id => 'di1', :name => 'name1'),
+            DiscreteModel.new(:id => 'di2', :name => 'name2')
+        ]}
+        let(:discrete_result) {
+            RRRMatey::DiscreteResult.new(:results => results,
+                                         :length => 42,
+                                         :offset => 40,
+                                         :discrete_length => 10)
+        }
+
+        describe '#initialize' do
+            it 'sets results' do
+                expect(discrete_result.results).to eq(results)
+            end
+
+            it 'sets length' do
+                expect(discrete_result.length).to eq(42)
+            end
+
+            it 'sets offset' do
+                expect(discrete_result.offset).to eq(40)
+            end
+
+            it 'sets discrete_length' do
+                expect(discrete_result.discrete_length).to eq(10)
+            end
+        end
+
+        describe '#to_json' do
+            it 'yields json array of results' do
+                expect(discrete_result.to_json).to eq('{"length":42,"offset":40,"limit":10,"results":[{"id":"di1","name":"name1"},{"id":"di2","name":"name2"}]}')
+            end
+        end
+
+        describe '#to_xml' do
+            it 'yields xml array of results' do
+                expect(discrete_result.to_xml.gsub(/\n/, '').
+                       gsub(/\>\s+\</, '><')).
+                       to eq('<root length="42" offset="40" limit="10"><results id="di1" name="name1" /><results id="di2" name="name2" /></root>')
+            end
+        end
+    end
+end