RubyGems - Medea - Versions diffs - 0.2.26 - Mend

Medea 0.2.26

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

data/Gemfile +4 -0
data/README +0 -0
data/Rakefile +2 -0
data/VERSION +1 -0
data/index.html +78 -0
data/lib/medea.rb +10 -0
data/lib/medea/active_model_methods.rb +24 -0
data/lib/medea/inheritable_attributes.rb +31 -0
data/lib/medea/jasondb.rb +20 -0
data/lib/medea/jasondeferredquery.rb +147 -0
data/lib/medea/jasonlistproperty.rb +131 -0
data/lib/medea/jasonobject.rb +271 -0
data/lib/medea/list_properties.rb +31 -0
data/lib/medea/version.rb +3 -0
data/lib/test.rb +31 -0
data/lib/testjdq.rb +40 -0
data/lib/testjlp.rb +30 -0
data/lib/testmeta.rb +38 -0
data/lib/testsublist.rb +46 -0
data/medea.gemspec +23 -0
metadata +128 -0

data/Gemfile ADDED

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+# Dependencies are specified in medea.gemspec
+gemspec

data/README ADDED

File without changes

data/Rakefile ADDED

	@@ -0,0 +1,2 @@
1	+ require 'bundler'
2	+ Bundler::GemHelper.install_tasks

data/VERSION ADDED

	@@ -0,0 +1 @@
1	+ 0.2.25

data/index.html ADDED

@@ -0,0 +1,78 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+	"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+	<title>rob-linton/Medea @ GitHub</title>
+	<style type="text/css">
+		body {
+  		margin-top: 1.0em;
+  		background-color: #28904b;
+		  font-family: "Helvetica,Arial,FreeSans";
+  		color: #ffffff;
+    }
+    #container {
+      margin: 0 auto;
+      width: 700px;
+    }
+		h1 { font-size: 3.8em; color: #d76fb4; margin-bottom: 3px; }
+		h1 .small { font-size: 0.4em; }
+		h1 a { text-decoration: none }
+		h2 { font-size: 1.5em; color: #d76fb4; }
+    h3 { text-align: center; color: #d76fb4; }
+    a { color: #d76fb4; }
+    .description { font-size: 1.2em; margin-bottom: 30px; margin-top: 30px; font-style: italic;}
+    .download { float: right; }
+		pre { background: #000; color: #fff; padding: 15px;}
+    hr { border: 0; width: 80%; border-bottom: 1px solid #aaa}
+    .footer { text-align:center; padding-top:30px; font-style: italic; }
+	</style>
+</head>
+<body>
+  <a href="http://github.com/rob-linton/Medea"><img style="position: absolute; top: 0; right: 0; border: 0;" src="http://s3.amazonaws.com/github/ribbons/forkme_right_darkblue_121621.png" alt="Fork me on GitHub" /></a>
+  <div id="container">
+    <div class="download">
+      <a href="http://github.com/rob-linton/Medea/zipball/master">
+        <img border="0" width="90" src="http://github.com/images/modules/download/zip.png"></a>
+      <a href="http://github.com/rob-linton/Medea/tarball/master">
+        <img border="0" width="90" src="http://github.com/images/modules/download/tar.png"></a>
+    </div>
+    <h1><a href="http://github.com/rob-linton/Medea">Medea</a>
+      <span class="small">by <a href="http://github.com/rob-linton">rob-linton</a></span></h1>
+    <div class="description">
+      Jasondb library for Ruby
+    </div>
+    <p>This is the main site for the Ruby interface to Jasondb.  </p><h2>Contact</h2>
+<p>robl@jasondb.com
+    <h2>Download</h2>
+    <p>
+      You can download this project in either
+      <a href="http://github.com/rob-linton/Medea/zipball/master">zip</a> or
+      <a href="http://github.com/rob-linton/Medea/tarball/master">tar</a> formats.
+    </p>
+    <p>You can also clone the project with <a href="http://git-scm.com">Git</a>
+      by running:
+      <pre>$ git clone git://github.com/rob-linton/Medea</pre>
+    </p>
+    <div class="footer">
+      get the source code on GitHub : <a href="http://github.com/rob-linton/Medea">rob-linton/Medea</a>
+    </div>
+  </div>
+</body>
+</html>

data/lib/medea.rb ADDED

@@ -0,0 +1,10 @@
+module Medea
+  require 'medea/inheritable_attributes'
+  require 'medea/active_model_methods'
+  require 'medea/list_properties'
+  require 'medea/jasonobject'
+  require 'medea/jasondeferredquery'
+  require 'medea/jasonlistproperty'
+  require 'medea/jasondb'
+end

data/lib/medea/active_model_methods.rb ADDED

@@ -0,0 +1,24 @@
+module Medea
+  module ActiveModelMethods
+    def to_model
+      self
+    end
+    def errors
+      obj = Object.new
+      def obj.[](key)         []    end
+      def obj.full_messages() []    end
+      def obj.any?()          false end
+      def obj.count()         0     end
+      obj
+    end
+    def persisted?
+      jason_state == :stale
+    end
+    def valid?
+      true
+    end
+  end
+end

data/lib/medea/inheritable_attributes.rb ADDED

@@ -0,0 +1,31 @@
+#This module allows for an attribute to be defined on a superclass and carry down into sub-classes with its default.
+#Taken from http://railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/
+module ClassLevelInheritableAttributes
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  module ClassMethods
+    def inheritable_attributes(*args)
+      #for some reason, in rails, @inheritable_attributes is set to be an empty hash here...
+      #check for this strange case and account for it.
+      @inheritable_attributes = [:inheritable_attributes] if @inheritable_attributes == {} ||
+                                                             @inheritable_attributes == nil
+      @inheritable_attributes += args
+      args.each do |arg|
+        class_eval %(
+          class << self; attr_accessor :#{arg} end
+        )
+      end
+      @inheritable_attributes
+    end
+    def inherited(subclass)
+      @inheritable_attributes.each do |inheritable_attribute|
+        instance_var = "@#{inheritable_attribute}"
+        subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+      end
+    end
+  end
+end

data/lib/medea/jasondb.rb ADDED

@@ -0,0 +1,20 @@
+module JasonDB
+  #jason_url here doesn't include the http[s]:// part, but does include the domain and a trailing '/'
+  #( so it's "rest.jasondb.com/<domain>/" )
+  def JasonDB::db_auth_url mode=:secure
+    config = Rails.configuration.database_configuration[Rails.env]
+    user = config["user"]
+    topic = config["topic"]
+    password = config["password"]
+    if config["jason_host"]
+      host = config["jason_host"]
+    else
+      host = "rest.jasondb.com"
+    end
+    protocol = "http"
+    protocol << "s" if mode == :secure
+    "#{protocol}://#{user}:#{password}@#{host}/#{topic}/"
+  end
+end

data/lib/medea/jasondeferredquery.rb ADDED

@@ -0,0 +1,147 @@
+module Medea
+  class JasonDeferredQuery
+    require 'rest_client'
+    require 'uri'
+    attr_accessor :time_limit, :result_format, :type, :time_limit, :state, :contents, :filters
+    def initialize a_class, format=:search
+      self.type = a_class
+      self.filters = { :VERSION0 => nil }
+      if self.type
+        self.filters[:FILTER] = {:HTTP_X_CLASS => a_class.name.to_s}
+      end
+      self.result_format = format
+      self.time_limit = 0
+      self.state = :prefetch
+      self.contents = []
+    end
+    #Here we're going to put the "query" interface
+    #here we will capture:
+    #members_of(object) (where object is an instance of a class that this class can be a member of)
+    #members_of_<classname>(key)
+    #find_by_<property>(value)
+    #Will return a JasonDeferredQuery for this class with the appropriate data filter set
+    def method_missing(name, *args, &block)
+      #if we are postfetch, we throw away all our cached results
+      if self.state == :postfetch
+        self.state = :prefetch
+        self.contents = []
+      end
+      field = name.to_s
+      if field =~ /^members_of$/
+        #use the type and key of the first arg (being a JasonObject)
+        #args[0] must be a JasonObject (or child)
+        raise ArgumentError, "When looking for members, you must pass a JasonObject" unless args[0].is_a? JasonObject
+        self.filters[:DATA_FILTER] ||= {}
+        self.filters[:DATA_FILTER]["__member_of"] ||= []
+        self.filters[:DATA_FILTER]["__member_of"] << args[0].jason_key
+      elsif field =~ /^find_by_(.*)$/
+        #use the property name from the name variable, and the value from the first arg
+        add_data_filter $1, args[0].to_s
+      else
+        #no method!
+        super
+        return
+      end
+      #return self, so that we can chain up query refinements
+      self
+    end
+    #end query interface
+    def add_data_filter property, value
+      self.filters[:DATA_FILTER] ||= {}
+      self.filters[:DATA_FILTER][property] = value
+    end
+    def to_url
+      url = "#{JasonDB::db_auth_url}@#{self.time_limit}.#{self.result_format}?"
+      filter_array = []
+      self.filters.each do |name, val|
+        if not val
+          filter_array << name.to_s
+          next
+        else
+          #FILTER's value is a hash (to avoid dupes)
+          #DATA_FILTER's value is a hash
+          if val.is_a? Hash
+            #for each k/v in the hash, we want to add an entry to filter_array
+            val.each do |field ,value|
+              if value.is_a? Array
+                value.each do |i|
+                  filter_array << "#{name.to_s}=#{URI.escape(field)}:#{URI.escape(i)}"
+                end
+              else
+                filter_array << "#{name.to_s}=#{URI.escape(field.to_s)}:#{URI.escape(value.to_s)}"
+              end
+            end
+          end
+        end
+      end
+      url + filter_array.join("&")
+    end
+    #array access interface
+    def [](index)
+      execute_query unless self.state == :postfetch
+      self.contents[index]
+    end
+    def each(&block)
+      execute_query unless self.state == :postfetch
+      self.contents.each &block
+    end
+    def count
+      execute_query unless self.state == :postfetch
+      self.contents.count
+    end
+    def include?(item)
+      execute_query unless self.state == :postfetch
+      self.contents.each do |i|
+        return true if i.jason_key == item.jason_key
+      end
+      false
+    end
+    #end array interface
+    def execute_query
+      #hit the URL
+      #fill self.contents with :ghost versions of JasonObjects
+      begin
+        #puts "   = Executing #{type.name} deferred query! (#{to_url})"
+        result = JSON.parse(RestClient.get to_url)
+        self.contents = []
+        #results are in a hash, their keys are just numbers
+        result.keys.each do |k|
+          if k =~ /^[0-9]+$/
+            #this is a result! get the key
+            /\/([^\/]*)\/([^\/]*)$/.match result[k]["POST_TO"]
+            #$1 is the class name, $2 is the key
+            item = type.new($2, :lazy)
+            if result[k].has_key?("CONTENT") && result[k]["CONTENT"] != ""
+              item.instance_variable_set(:@__jason_data, result[k]["CONTENT"])
+              item.instance_variable_set(:@__jason_state, :stale)
+            end
+            if result[k].has_key?("HTTP_X_PARENT") && result[k]["HTTP_X_PARENT"] != ""
+              item.jason_parent_key = result[k]["HTTP_X_PARENT"]
+            end
+            self.contents << item
+          end
+        end
+        self.state = :postfetch
+        result
+      rescue
+        self.contents = []
+      end
+    end
+  end
+end

data/lib/medea/jasonlistproperty.rb ADDED

@@ -0,0 +1,131 @@
+module Medea
+  require 'uri'
+  require 'rest_client'
+  class JasonListProperty < JasonDeferredQuery
+    attr_accessor :list_name, :parent, :list_type
+    def initialize parent, list_name, list_class, list_type
+      @type = list_class
+      @list_name = list_name
+      @list_type = list_type
+      @parent = parent
+      @result_format = :search
+      @time_limit = 0
+      @state = :prefetch
+      @contents = []
+    end
+    def method_missing name, *args, &block
+      #is this a list property on the base class?
+      if (@type.class_variable_defined? :@@lists) && (@type.class_variable_get(:@@lists).has_key? name)
+        #if so, we'll just return a new ListProperty with my query as the parent
+        new_list_class, new_list_type = @type.class_variable_get(:@@lists)[name]
+        base_query = self.clone
+        base_query.result_format = :keylist
+        JasonListProperty.new base_query, name.to_sym, new_list_class, new_list_type
+      else
+        #no method, let JasonDeferredQuery handle it
+        super
+      end
+    end
+    def add! member, save=true
+      raise RuntimeError, "You can only add an item if you are accessing this list from an object." unless @parent.is_a? JasonObject
+      raise ArgumentError, "You can only add #{@type.name} items to this collection!" unless member.is_a? @type
+      if @list_type == :value
+        member.jason_parent = @parent
+        member.jason_parent_list = @list_name
+      elsif @list_type == :reference
+        #post to JasonDB::db_auth_url/a_class.name/
+        url = "#{JasonDB::db_auth_url}#{@type.name}/#{@parent.jason_key}/#{@list_name}/#{member.jason_key}"
+        post_headers = {
+              :content_type => 'application/json',
+              "X-CLASS" => @list_name.to_s,
+              "X-KEY" => member.jason_key,
+              "X-PARENT" => @parent.jason_key,
+              "X-LIST" => @list_name.to_s
+        }
+        content = {
+            "_id" => member.jason_key,
+            "_parent" => @parent.jason_key
+        }
+        #puts "   = " + url
+        #puts "   = #{post_headers}"
+        response = RestClient.post url, content.to_json, post_headers
+        if response.code == 201
+            #save successful!
+            #store the new eTag for this object
+            #puts response.raw_headers
+            #@__jason_etag = response.headers[:location] + ":" + response.headers[:content_md5]
+        else
+            raise "POST failed! Could not save membership"
+        end
+      else
+        #parent is a JasonObject, but this list is something other than :value or :reference??
+        raise "Invalid list type or trying to add an item to a subquery list!"
+      end
+      if member.jason_state == :new
+        #we want to save it? probably...
+        member.save! if save
+      end
+      @state = :prefetch
+    end
+    def remove! member
+      raise RuntimeError, "You can only remove an item if you are accessing this list from an object." unless @parent.is_a? JasonObject
+      raise ArgumentError, "You can only remove #{@type.name} items from this collection!" unless member.is_a? @type
+      raise ArgumentError, "This item (#{member.jason_key}) doesn't exist in the list you're trying to remove it from!" unless self.include? member
+      if @list_type == :value
+        member.jason_parent = nil
+        member.jason_parent_list = nil
+        member.save!
+      elsif @list_type == :reference
+        #send DELETE to JasonDB::db_auth_url/a_class.name/
+        url = "#{JasonDB::db_auth_url}#{@type.name}/#{@parent.jason_key}/#{@list_name}/#{member.jason_key}"
+        response = RestClient.delete url
+        if response.code == 201
+            #delete successful!
+        else
+            raise "DELETE failed! Could not remove membership"
+        end
+      else
+        #parent is a JasonObject, but this list is something other than :value or :reference??
+        raise "Invalid list type or trying to remove an item from a subquery list!"
+      end
+      @state = :prefetch
+    end
+    def to_url
+      url = "#{JasonDB::db_auth_url}@#{@time_limit}.#{@result_format}?"
+      params = ["VERSION0"]
+      params << "FILTER=HTTP_X_CLASS:#{@list_name.to_s}"
+      if @parent.is_a? JasonObject
+        params << "FILTER=HTTP_X_PARENT:#{@parent.jason_key}"
+      else # @parent.is_a? JasonListProperty ##(or DeferredQuery?)
+        #we can get the insecure url here, because it will be resolved and executed at JasonDB - on a secure subnet.
+        #subquery = "<%@LANGUAGE=\"URL\" #{@parent.to_url}%>"
+        #puts "   = Fetching subquery stupidly. (#{@parent.to_url})"
+        subquery = (RestClient.get @parent.to_url).strip
+        #puts "   =   Result: #{subquery}"
+        params << URI.escape("FILTER={HTTP_X_PARENT:#{subquery}}", Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+      end
+      url << params.join("&")
+    end
+  end
+end

data/lib/medea/jasonobject.rb ADDED

@@ -0,0 +1,271 @@
+#Medea/JasonObject - Written by Michael Jensen
+module Medea
+  require 'rest_client'
+  require 'json'
+  require 'uuidtools'
+  class JasonObject
+    include Medea::ActiveModelMethods
+    #include JasonDB
+    #meta-programming interface for lists
+    include ClassLevelInheritableAttributes
+    inheritable_attributes :owned
+    @owned = false
+    include JasonObjectListProperties
+    #end meta
+    #Here we're going to put the "query" interface
+    #create a JasonDeferredQuery with no conditions, other than HTTP_X_CLASS=self.name
+    #if mode is set to :eager, we create the JasonDeferredQuery, invoke it's execution and then return it
+    def JasonObject.all(mode=:lazy)
+      JasonDeferredQuery.new self
+    end
+    #returns the JasonObject by directly querying the URL
+    #if mode is :lazy, we return a GHOST, if mode is :eager, we return a STALE JasonObject
+    def JasonObject.get_by_key(key, mode=:eager)
+      return self.new key, mode
+    end
+    #here we will capture:
+    #members_of(object) (where object is an instance of a class that this class can be a member of)
+    #find_by_<property>(value)
+    #Will return a JasonDeferredQuery for this class with the appropriate data filter set
+    def JasonObject.method_missing(name, *args, &block)
+      q = JasonDeferredQuery.new self
+      if name.to_s =~ /^members_of$/
+        #use the type and key of the first arg (being a JasonObject)
+        return q.members_of args[0]
+      elsif name.to_s =~ /^find_by_(.*)$/
+        #use the property name from the name variable, and the value from the first arg
+        q.add_data_filter $1, args[0]
+        return q
+      else
+        #no method!
+        super
+      end
+    end
+    #end query interface
+    #the resolve method takes a key and returns the JasonObject that has that key
+    #This is useful when you have the key, but not the class
+    def JasonObject.resolve(key, mode=:lazy)
+      q = JasonDeferredQuery.new nil
+      q.filters[:FILTER] ||= {}
+      q.filters[:FILTER][:HTTP_X_KEY] = key
+      resp = JSON.parse(RestClient.get(q.to_url))
+      if resp.has_key? "1"
+        #this is the object, figure out its class
+        resp["1"]["POST_TO"] =~ /([^\/]+)\/#{key}/
+        begin
+          result = Kernel.const_get($1).get_by_key key, :lazy
+          if result["1"].has_key? "CONTENT"
+            result.instance_variable_set(:@__jason_data, result["1"]["CONTENT"])
+            result.instance_variable_set(:@__jason_state, :stale)
+          end
+          if mode == :eager
+            result.send(:load)
+          end
+        rescue
+          nil
+        end
+      end
+    end
+    #"flexihash" access interface
+    def []=(key, value)
+      @__jason_data ||= {}
+      @__jason_state = :dirty if jason_state == :stale
+      @__jason_data[key] = value
+    end
+    def [](key)
+      @__jason_data[key]
+    end
+    #The "Magic" component of candy (https://github.com/SFEley/candy), repurposed to make this a
+    # "weak object" that can take any attribute.
+    # Assigning any attribute will add it to the object's hash (and then be POSTed to JasonDB on the next save)
+    def method_missing(name, *args, &block)
+        load if @__jason_state == :ghost
+        field = name.to_s
+        if field =~ /(.*)=$/  # We're assigning
+            self[$1] = args[0]
+        elsif field =~ /(.*)\?$/  # We're asking
+            (self[$1] ? true : false)
+        else
+            self[field]
+        end
+    end
+    #end "flexihash" access
+    def initialize key = nil, mode = :eager
+      if key
+        @__id = key
+        if mode == :eager
+          load
+        else
+          @__jason_state = :ghost
+        end
+      else
+        @__jason_state = :new
+        @__jason_data = {}
+      end
+    end
+    def jason_key
+        #Generate a random UUID for this object.
+	#since jason urls must start with a letter, we'll use the first letter of the class name
+        @__id ||= "#{self.class.name[0].chr.downcase}#{UUIDTools::UUID::random_create.to_s}"
+    end
+    def to_s
+      jason_key
+    end
+    def jason_state
+      @__jason_state
+    end
+    def jason_etag
+      @__jason_etag ||= ""
+    end
+    def jason_parent
+      @__jason_parent ||= nil
+      if @__jason_parent == nil && @__jason_parent_key
+        #key is set but parent not? load the parent
+        @__jason_parent = JasonObject.resolve @__jason_parent_key
+      end
+      @__jason_parent
+    end
+    def jason_parent= parent
+      @__jason_parent = parent
+      @__jason_parent_key = parent.jason_key
+    end
+    def jason_parent_key
+      @__jason_parent_key ||= nil
+    end
+    def jason_parent_key= value
+      @__jason_parent_key = value
+      #reset the parent here?
+      @__jason_parent = nil
+    end
+    def jason_parent_list
+      @__jason_parent_list ||= nil
+    end
+    def jason_parent_list= value
+      @__jason_parent_list = value
+    end
+    #object persistence methods
+    #POSTs the current values of this object back to JasonDB
+    #on successful post, sets state to STALE and updates eTag
+    def save!
+        #no changes? no save!
+        return if @__jason_state == :stale or @__jason_state == :ghost
+        payload = self.to_json
+        post_headers = {
+            :content_type => 'application/json',
+            "X-KEY" => self.jason_key,
+            "X-CLASS" => self.class.name
+            #also want to add the eTag here!
+            #may also want to add any other indexable fields that the user specifies?
+        }
+        post_headers["IF-MATCH"] = @__jason_etag if @__jason_state == :dirty
+        if self.class.owned
+          #the parent object needs to be defined!
+          raise "#{self.class.name} cannot be saved without setting a parent and list!" unless self.jason_parent && self.jason_parent_list
+          post_headers["X-PARENT"] = self.jason_parent.jason_key
+          #url = "#{JasonDB::db_auth_url}#{self.jason_parent.class.name}/#{self.jason_parent.jason_key}/#{self.jason_parent_list}/#{self.jason_key}"
+          post_headers["X-LIST"] = self.jason_parent_list
+          #override the class to be the list name. Much simpler to search on.
+          post_headers["X-CLASS"] = self.jason_parent_list
+        end
+        url = JasonDB::db_auth_url + self.class.name + "/" + self.jason_key
+        #puts "Posted to JasonDB!"
+        #puts "Saving to #{url}"
+        response = RestClient.post url, payload, post_headers
+        if response.code == 201
+            #save successful!
+            #store the new eTag for this object
+            #puts response.raw_headers
+            #@__jason_etag = response.headers[:location] + ":" + response.headers[:content_md5]
+        else
+            raise "POST failed! Could not save object"
+        end
+        @__jason_state = :stale
+    end
+    def delete!
+      url = "#{JasonDB::db_auth_url}#{self.class.name}/#{self.jason_key}"
+      response = RestClient.delete url
+      raise "DELETE failed!" unless response.code == 201
+    end
+    #end object persistence
+    #converts the data hash (that is, @__jason_data) to JSON format
+    def to_json
+      JSON.generate(@__jason_data)
+    end
+    private
+    #fetches the data from the JasonDB
+    def load
+      #because this object might be owned by another, we need to search by key.
+      #not passing a format to the query is a shortcut to getting just the object.
+      url = "#{JasonDB::db_auth_url}@0.content?"
+      params = [
+          "VERSION0",
+          "FILTER=HTTP_X_KEY:#{self.jason_key}"
+      ]
+      if not self.class.owned
+        #if the class is owned, we don't want to filter by class name (X-CLASS will be the list name)
+        #if it isn't owned, it is safe to filter by X-CLASS
+        #if this item is "had" rather than owned, we MUST filter by class, otherwise we get the references.
+        params << "FILTER=HTTP_X_CLASS:#{self.class.name}"
+      end
+      url << params.join("&")
+      #url = "#{JasonDB::db_auth_url}#{self.class.name}/#{self.jason_key}"
+      #puts "   = Retrieving #{self.class.name} at #{url}"
+      response = RestClient.get url
+      @__jason_data = JSON.parse response
+      @__jason_etag = response.headers[:etag]
+      @__jason_state = :stale
+    end
+    def lazy_load meta
+      #TODO Implement lazy load
+      @__jason_state = :ghost
+    end
+  end
+end

data/lib/medea/list_properties.rb ADDED

@@ -0,0 +1,31 @@
+module JasonObjectListProperties
+  def self.included(base)
+    base.extend(MetaListProperties)
+  end
+  module MetaListProperties
+    def create_member_list list_name, list_class, list_type
+      list = {}
+      list = self.class_variable_get :@@lists if self.class_variable_defined? :@@lists
+      list[list_name] = [list_class, list_type]
+      self.send(:class_variable_set, "@@lists", list)
+      define_method(list_name) do
+        #puts "Looking at the #{list_name.to_s} list, which is full of #{list_type.name}s"
+        Medea::JasonListProperty.new self, list_name, list_class, list_type
+      end
+    end
+    def has_many list_name, list_class
+      create_member_list list_name, list_class, :reference
+    end
+    def owns_many list_name, list_class
+      create_member_list list_name, list_class, :value
+      #also modify the items in the list so that they know that they're owned
+      #list_type.class_variable_set :@@owner, self
+      list_class.owned = true
+    end
+  end
+end

data/lib/medea/version.rb ADDED

@@ -0,0 +1,3 @@
+module Medea
+  VERSION = "0.2.26"
+end

data/lib/test.rb ADDED

@@ -0,0 +1,31 @@
+$: << "~/Projects/Medea/lib"
+require 'rubygems'
+require 'medea'
+class Person < Medea::JasonObject
+end
+mikey = Person.new
+puts "state: #{mikey.jason_state}"
+mikey.name = "Michael"
+mikey.age = 21
+mikey.location = {:longitude => -30.123213, :latitude => 130.1231458}
+puts mikey.jason_key
+puts mikey.to_json
+mikey.save!
+puts "state: #{mikey.jason_state}"
+puts "Changing name => Bob"
+mikey.name = "Bob"
+puts "state: #{mikey.jason_state}"
+puts mikey.to_json
+mikey.save!
+puts "state: #{mikey.jason_state}"
+puts "Enter a Person key to retrieve: "
+id = gets.strip
+person = Person.new id
+puts person.to_json

data/lib/testjdq.rb ADDED

@@ -0,0 +1,40 @@
+$: << "~/Projects/Medea/lib"
+require 'medea'
+class Person < Medea::JasonObject
+end
+class Company < Medea::JasonObject
+  has_many :employees, Person
+end
+puts "Lets make a person!"
+p = Person.new
+puts "Name?"
+p.name = gets.strip
+puts "Age?"
+p.age = gets.strip.to_i
+puts "OK - Saving"
+p.save!
+puts "", "Lets make a company!"
+c = Company.new
+puts "Name?"
+c.name = gets.strip
+puts "Address?"
+c.address = gets.strip
+puts "OK - Saving"
+c.save!
+puts "", "Making #{p.name} a member of #{c.name}"
+c.employees.add! p
+puts "OK - Saving"
+p.save!
+puts "", "Now querying for Persons that are members of #{c.name}"
+r = c.employees
+puts "Query: #{r.to_url}"
+puts "Got #{r.count} items:"
+r.each do |p|
+  puts p.name
+end

data/lib/testjlp.rb ADDED

@@ -0,0 +1,30 @@
+$: << "~/Projects/Medea/lib"
+require 'medea'
+class Person < Medea::JasonObject
+  has_many :followees, Person
+end
+p = Person.get_by_key "p6c75c02f-ed93-4ee8-9746-3603e915be23"
+puts p.followees.to_url
+puts p.followees.count
+puts "Let's make a new person!"
+p1 = Person.new
+puts "Name?"
+p1.name = gets.strip
+if p1.name != ""
+  puts "Saving..."
+  p1.save!
+  puts "Making #{p.name} follow #{p1.name}..."
+  p.followees.add! p1
+end
+puts "Done!"
+list = p.followees
+puts "#{p.name} now following #{list.count} users:"
+list.each do |f|
+  puts " - #{f.jason_key}: #{f.name}\n"
+end

data/lib/testmeta.rb ADDED

@@ -0,0 +1,38 @@
+$: << "~/Projects/Medea/lib"
+require 'medea'
+class Message < Medea::JasonObject
+end
+class User < Medea::JasonObject
+  owns_many :messages, Message
+end
+puts "Enter an id, or blank to make a new user:"
+id = gets.strip
+if id == ""
+  u = User.new
+  puts "User's name?"
+  u.name = gets.strip
+  puts "Saving"
+  u.save!
+else
+  u = User.get_by_key id
+  puts "#{u.name} has posted #{u.messages.count} messages"
+end
+while true
+  puts "Enter a message (blank to stop):"
+  message = gets.strip
+  break if message == ""
+  m = Message.new
+  m.message = message
+  m.from = u.name
+  u.messages.add! m
+end
+puts "Fetching messages..."
+u.messages.each do |e|
+  puts " - #{e.message}\n"
+end

data/lib/testsublist.rb ADDED

@@ -0,0 +1,46 @@
+$: << "~/Projects/Medea/lib"
+require 'medea'
+class Message < Medea::JasonObject; end
+class User < Medea::JasonObject
+  owns_many :messages, Message
+  has_many :followees, User
+end
+u1 = User.new
+u1.name = "Fred"
+u1.save!
+u2 = User.new
+u2.name = "George"
+u2.save!
+u1.followees.add! u2
+u1.followees.add! (User.get_by_key "p438639000")
+u1.followees.add! u1
+m1 = Message.new
+m1.from = u2.name
+m1.message = "Hello! This is George"
+u2.messages.add! m1
+m3 = Message.new
+m3.from = u1.name
+m3.message = "George sent me here, hope it's fun!"
+u1.messages.add! m3
+m2 = Message.new
+m2.from = u2.name
+m2.message = "Man, this is a long day!"
+u2.messages.add! m2
+puts "#{u2.name} has posted #{u2.messages.count} messages"
+puts "#{u1.name} is following #{u1.followees.count} users"
+puts "#{u1.name}'s timeline has #{u1.followees.messages.count} messages in it"
+u1.followees.messages.each do |m|
+  puts "#{m.from}:"
+  puts "      #{m.message}"
+end

data/medea.gemspec ADDED

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "medea/version"
+Gem::Specification.new do |s|
+  s.name        = "Medea"
+  s.version     = Medea::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Michael Jensen"]
+  s.email       = ["michaelj@jasondb.com"]
+  s.homepage    = ""
+  s.summary     = %q{Simple wrapper for persisting objects to JasonDB}
+  s.description = %q{Simple wrapper for persisting objects to JasonDB}
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_dependency "json"
+  s.add_dependency "rest-client"
+  s.add_dependency "uuidtools"
+end

metadata ADDED

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: Medea
+version: !ruby/object:Gem::Version
+  hash: 35
+  prerelease: false
+  segments:
+  - 0
+  - 2
+  - 26
+  version: 0.2.26
+platform: ruby
+authors:
+- Michael Jensen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-01-05 00:00:00 +11:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        hash: 3
+        segments:
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        hash: 3
+        segments:
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency
+  name: uuidtools
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        hash: 3
+        segments:
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: Simple wrapper for persisting objects to JasonDB
+email:
+- michaelj@jasondb.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README
+- Rakefile
+- VERSION
+- index.html
+- lib/medea.rb
+- lib/medea/active_model_methods.rb
+- lib/medea/inheritable_attributes.rb
+- lib/medea/jasondb.rb
+- lib/medea/jasondeferredquery.rb
+- lib/medea/jasonlistproperty.rb
+- lib/medea/jasonobject.rb
+- lib/medea/list_properties.rb
+- lib/medea/version.rb
+- lib/test.rb
+- lib/testjdq.rb
+- lib/testjlp.rb
+- lib/testmeta.rb
+- lib/testsublist.rb
+- medea.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      hash: 3
+      segments:
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      hash: 3
+      segments:
+      - 0
+      version: "0"
+requirements: []
+rubyforge_project:
+rubygems_version: 1.3.7
+signing_key:
+specification_version: 3
+summary: Simple wrapper for persisting objects to JasonDB
+test_files: []