rrrmatey 0.1.0

data/lib/rrrmatey/discrete_result.rb

@@ -0,0 +1,31 @@
+module RRRMatey
+    class DiscreteResult
+        attr_reader :offset, :discrete_length, :length, :results
+
+        def initialize(opts = {})
+            @results = opts[:results].to_a
+            @length = opts[:length]
+            @offset = opts[:offset]
+            @discrete_length = opts[:discrete_length]
+        end
+
+        def to_json(opts = {})
+            to_consumer_hash.to_json
+        end
+
+        def to_xml(opts = {})
+            to_consumer_hash.to_xml
+        end
+
+        private
+
+        def to_consumer_hash
+            {
+                :length => length,
+                :offset => offset,
+                :limit => discrete_length,
+                :results => results.map { |it| it.send(:to_consumer_hash) }
+            }
+        end
+    end
+end

data/lib/rrrmatey/errors.rb

@@ -0,0 +1,11 @@
+module RRRMatey
+    class PlankError < StandardError; end
+    class UnknownContentTypeError < PlankError; end
+    class UnparseableContentError < PlankError; end
+    class InvalidModelError < PlankError; end
+    class UnsupportedTypeError < PlankError
+        def initialize(type)
+            super("Unsupported type: #{type}")
+        end
+    end
+end

data/lib/rrrmatey/retryable.rb

@@ -0,0 +1,28 @@
+module RRRMatey
+    class Retryable
+        def initialize(conn, opts = {})
+            @retries = opts[:retries] || 3
+            @retry_delay = opts[:retry_delay] || 0.1
+            @conn = conn
+            @conn_respond_to_with = conn.respond_to?(:with)
+        end
+
+        def with(&block)
+            return unless block_given?
+            ex = nil
+            1.upto(@retries) do
+                begin
+                    if @conn_respond_to_with
+                        return @conn.with { |conn| block.call(conn) }
+                    else
+                        return block.call(@conn)
+                    end
+                rescue StandardError => e
+                    ex = e
+                    sleep(@retry_delay)
+                end
+            end
+            raise ex
+        end
+    end
+end

data/lib/rrrmatey/string_model/connection_methods.rb

@@ -0,0 +1,47 @@
+module RRRMatey
+    module StringModel
+        module ConnectionMethods
+            def cache_proxy()
+                if @cache_proxy.nil? && self.name != RRRMatey::StringModel.name
+                    return StringModel.cache_proxy
+                end
+                @cache_proxy
+            end
+
+            def cache_proxy=(v)
+                @cache_proxy = v
+            end
+ 
+            def riak()
+                if @riak.nil? && self.name != RRRMatey::StringModel.name
+                    return StringModel.riak
+                end
+                @riak
+            end
+
+            def riak=(v)
+                @riak = v
+                unless @riak.nil?
+                    ensure_search_index()
+                end
+                @riak
+            end
+
+            private
+
+            def ensure_search_index()
+                return unless respond_to_index_name?
+                bucket = riak.with { |r|
+                    r.create_search_index(index_name, '_yz_default')
+                    r.bucket(namespace)
+                }
+                bucket.properties = { 'search_index' => index_name }
+            end
+
+            def respond_to_index_name?()
+                @respond_to_index_name ||= respond_to?(:index_name)
+            end
+        end
+        self.extend ConnectionMethods
+    end
+end

data/lib/rrrmatey/string_model/consumer_adapter_methods.rb

@@ -0,0 +1,9 @@
+module RRRMatey
+    module StringModel
+        module ConsumerAdapterMethods
+            def from_params(params, id = nil, content_type = nil)
+                send(:object_from_hash, params, id || params[:id], content_type || :json)
+            end
+        end
+    end
+end

data/lib/rrrmatey/string_model/delete_methods.rb

@@ -0,0 +1,12 @@
+module RRRMatey
+    module StringModel
+        module DeleteMethods
+            def delete(id)
+                return 0 if cache_proxy.nil?
+                cache_proxy.with { |r|
+                    r.del(self.namespaced_key(id))
+                }
+            end
+        end
+    end
+end

data/lib/rrrmatey/string_model/field_definition_methods.rb

@@ -0,0 +1,101 @@
+module RRRMatey
+    module StringModel
+        module FieldDefinitionMethods
+            def fields(*field_syms)
+                if field_syms.blank?
+                    @fields
+                else
+                    @fields =
+                        field_syms.each { |field_sym| attr_accessor field_sym }
+
+                    define_method('initialize') do |opts={}|
+                        opts.each do |k,v|
+                            send("#{k}=", v)
+                        end
+                    end
+                end
+            end
+
+            def consumer_fields
+                @consumer_fields || []
+            end
+
+            def field(field_sym, opts = {})
+                fs = @fields || []
+                type = opts[:type] || :string
+                default = opts[:default]
+                f = append_type(field_sym, type)
+                
+                cfs = self.consumer_fields
+                cfs << field_sym
+                @consumer_fields = cfs
+
+                fs << f[:name]
+                self.fields(*fs)
+
+                define_method(field_sym) do
+                    v = send(f[:name]) || default
+                    v.send(f[:from_underlying])
+                end
+                define_method("#{field_sym}=") do |v|
+                    v = v.send(f[:to_underlying] || :to_s)
+                    send("#{f[:name]}=", v)
+                end
+                nil
+            end
+
+            private
+
+            def append_type(field_sym, type)
+                tms = type_mappings()
+                unless tms.has_key?(type)
+                    raise UnsupportedTypeError.new(field_sym)
+                end
+                tm = tms[type]
+                tm[:name] = "#{field_sym}#{tm[:suffix]}".to_sym
+                tm
+            end
+
+            def type_mappings()
+                {
+                    :string =>
+                    {
+                        :suffix => '_s',
+                        :from_underlying => :to_s
+                    },
+                    :boolean =>
+                    {
+                        :suffix => '_b',
+                        :from_underlying => :to_b
+                    },
+                    :date =>
+                    {
+                        :suffix => '_ti',
+                        :from_underlying => :to_fixnum_to_date,
+                        :to_underlying => :seconds_since_epoch
+                    },
+                    :integer =>
+                    {
+                        :suffix => '_i',
+                        :from_underlying => :to_i
+                    },
+                    :long =>
+                    {
+                        :suffix => '_l',
+                        :from_underlying => :to_i
+                    },
+                    :double =>
+                    {
+                        :suffix => '_d',
+                        :from_underlying => :to_f
+                    },
+                    :float =>
+                    {
+                        :suffix => '_f',
+                        :from_underlying => :to_f
+                    }
+                }
+            end
+        end
+    end
+end

data/lib/rrrmatey/string_model/find_methods.rb

@@ -0,0 +1,85 @@
+module RRRMatey
+    module StringModel
+        module FindMethods
+            def get(id)
+                return if id.blank? || self.cache_proxy.nil?
+                s = nil
+                self.cache_proxy.with { |r|
+                    s = r.get(namespaced_key(id))
+                }
+
+                type = interpolate_type(s)
+                h = typed_string_to_hash(s, type)
+                o = object_from_hash(h, id, type)
+                if o.content_type == 'application/unknown'
+                    o.content_type = 'application/json'
+                end
+                o
+            end
+
+            private
+
+            def interpolate_type(s)
+                if s.blank? || s.start_with?('{') && s.end_with?('}')
+                    :json
+                elsif s.start_with?('<') && s.end_with?('>')
+                    :xml
+                else
+                    :string
+                end
+            end
+
+            def content_type_from_type(type)
+                case type
+                when :json
+                    'application/json'
+                when :xml
+                    'application/xml'
+                # NOTE: unreachable since typed_string_to_hash throws for unknown
+                # else
+                #     'application/unknown'
+                end
+            end
+
+            def typed_string_to_hash(s, type)
+                return {} if s.blank?
+                case type
+                when :json
+                    JSON.parse(s)
+                when :xml
+                    Hash.from_xml(s)
+                else
+                    raise UnknownContentTypeError
+                end
+            rescue
+                raise UnparseableContentError
+            end
+
+            def object_from_hash(h, id, type)
+                o = new
+                o.id = id
+                o.content_type = content_type_from_type(type)
+
+                h = h[self.item_name]
+                if h.nil?
+                    # ie, search result with extractor missing
+                    o.content_type = 'application/unknown'
+                else
+                    consumer_fields.each do |f|
+                        fs = f.to_s
+                        if h.has_key?(fs)
+                            o.send("#{f}=", h[fs])
+                        end
+                    end
+                    fields.each do |f|
+                        fs = f.to_s
+                        if h.has_key?(fs)
+                            o.send("#{f}=", h[fs])
+                        end
+                    end
+                end
+                o
+            end
+        end
+    end
+end

data/lib/rrrmatey/string_model/index_methods.rb

@@ -0,0 +1,90 @@
+module RRRMatey
+    module StringModel
+        module IndexMethods
+            def index_name()
+                @index_name ||= self.namespace
+            end
+
+            def index_name=(v)
+                @index_name = v
+            end
+
+            def list(offset = 0, limit = 20)
+                index_by_index_term('*:*', offset, limit)
+            end
+
+            def list_by(offset = 0, limit = 20, field_qs = {})
+                index_term = field_qs_to_index_term(field_qs)
+                index_by_index_term(index_term, offset, limit)
+            end
+
+            private
+
+            def index_by_index_term(index_term, offset, limit)
+                search_result = nil
+                unless self.riak.nil?
+                    self.riak.with { |r|
+                        # for consistent result, sort by key
+                        search_result = r.search(self.index_name,
+                                                 index_term,
+                                                 {:start => offset,
+                                                     :rows => limit,
+                                                     :sort => '_yz_rk asc'})
+                    }
+                end
+                search_result_to_discrete_result(search_result, offset, limit)
+            end
+
+            def search_result_to_discrete_result(search_result, offset, limit)
+                search_result = {} if search_result.nil?
+
+                if search_result['docs'].blank?
+                    results = []
+                else
+                    results = search_result['docs'].map { |h|
+                        if h.nil?
+                            nil
+                        else
+                            id = h['_yz_rk']
+                            h = normalize_hash(h)
+                            object_from_hash(h, id, :json)
+                        end
+                    }
+                end
+                DiscreteResult.new(:length => search_result['num_found'] || 0,
+                                   :offset => offset,
+                                   :discrete_length => limit,
+                                   :results => results)
+            end
+
+            def item_name_prefix()
+                @item_name_prefix ||= "#{self.item_name}."
+            end
+
+            def normalize_hash(h)
+                h_norm = {}
+                item_name_prefix_len = item_name_prefix.length
+                h.each do |k,v|
+                    if k.start_with?(item_name_prefix)
+                        normalized_key = k[item_name_prefix_len..-1]
+                        h_norm[normalized_key] = v
+                    end
+                end
+                return {} if h_norm.length <= 0
+                { self.item_name => h_norm }
+            end
+
+            def field_qs_to_index_term(field_qs)
+                return "*:*" if field_qs.blank?
+                field_qs.reduce("") do |q, (k, v)|
+                    q_part = "#{item_name_prefix}#{k}:#{v}"
+                    if q.blank?
+                        q += q_part
+                    else
+                        q += " OR #{q_part}"
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/rrrmatey/string_model/namespaced_key_methods.rb

@@ -0,0 +1,21 @@
+module RRRMatey
+    module StringModel
+        module NamespacedKeyMethods
+            def item_name()
+                @item_name ||= name.underscore
+            end
+            
+            def item_name=(v)
+                @item_name = v
+            end
+
+            def namespace()
+                @namespace ||= item_name.pluralize
+            end
+
+            def namespaced_key(id)
+                "#{namespace}:#{id}"
+            end
+        end
+    end
+end