marley 0.5.0 → 0.6.0

data/lib/marley/plugins/rest_convenience.rb

@@ -0,0 +1,28 @@
+
+
+module Marley
+  module Plugins
+    class RestConvenience < Plugin
+      def apply(klass)
+        super
+      end
+      module ClassMethods
+        def resource_name; self.name.sub(/.*::/,'').underscore; end
+        def url
+        end
+        def reggae_link(action=nil, title=nil, args=nil)
+          ReggaeLink.new({:url => "/#{self.resource_name}/#{action}?#{args}",:title => (title||"#{action.to_s.humanize} #{self.resource_name.humanize}".strip)})
+        end
+      end
+      module InstanceMethods
+        def resource_type
+          if is_a? Sequel::Model
+            :instance
+          elsif is_a?  MP::Section::Section
+            :section
+          end
+        end
+      end
+    end
+  end
+end

data/lib/marley/reggae.rb

@@ -27,7 +27,6 @@ module Marley
     end
     attr_reader :resource_type
     attr_accessor :properties,:contents
-    # @param [Array] *args an array in Reggae syntax
     def initialize(*args)
       super 
       if is_resource?
@@ -51,7 +50,7 @@ module Marley
       is_resource? ? Marley.const_get("Reggae#{resource_type.to_s.camelize}".to_sym).new(self) : self
     end
     def find_instances(rn,instances=Reggae.new([]))
-      if self.class==ReggaeInstance && self.name.to_s==rn 
+      if self.class==ReggaeInstance && self.name.to_s==rn.to_s 
         instances << self
       else
         (is_resource? ? contents : self).each {|a| a && Reggae.new(a).to_resource.find_instances(rn,instances)}
@@ -68,6 +67,10 @@ module Marley
         super
       end
     end
+    def update(vals)
+      self.properties.update(vals)
+      self
+    end
   end
   class ReggaeSection < ReggaeResource
     properties :title,:description

data/lib/marley/resources.rb

@@ -0,0 +1,10 @@
+module Marley
+  module Resources
+    def self.resources_responding_to(method)
+      constants.map{|c| r=const_get(c); r if r.respond_to?(method)}.compact
+    end
+    def self.map_resource_methods(method)
+      constants.map{|c| r=const_get(c); r.send(method) if r.respond_to?(method)}.compact
+    end
+  end
+end

data/lib/marley/router.rb

@@ -0,0 +1,61 @@
+
+module Marley
+  class Router  
+    attr_reader :opts
+    def initialize(opts={},app=nil)
+      @opts=DEFAULT_OPTS.merge(opts)
+    end
+    def call(env)
+      request= Rack::Request.new(env)
+      $request={:request => request,:opts => @opts}
+      $request[:get_params]=Marley::Utils.hash_keys_to_syms(request.GET)
+      $request[:post_params]=Marley::Utils.hash_keys_to_syms(request.POST)
+      $request[:content_type]=request.xhr? ? 'application/json' : env['HTTP_ACCEPT'].to_s.sub(/,.*/,'') 
+      $request[:content_type]='text/html' unless $request[:content_type] > ''
+
+      if env['rack.test']==true #there has to be a better way to do this...
+        require 'json/add/core' 
+        $request[:content_type]='application/json' 
+      end
+
+      @opts[:authenticate].call(env) if @opts[:authenticate]
+
+      $request[:path]=request.path.sub(/\/\/+/,'/').split('/')[1..-1]
+      verb=request.request_method.downcase
+      verb=$request[:post_params].delete(:_method).match(/^(put|delete)$/i)[1] rescue verb 
+      $request[:verb]="rest_#{verb}"
+
+      rn=$request[:path] ? $request[:path][0].camelize : @opts[:default_resource]
+      return nil if rn=='Favicon.ico'
+      unless Resources.const_defined?(rn) 
+        raise AuthenticationError if (@opts[:authenticate] && $request[:user].new? )
+        raise RoutingError 
+      end
+      resource=Resources.const_get(rn)
+      raise AuthenticationError if @opts[:authenticate] && resource.respond_to?('requires_user?') && resource.requires_user? && $request[:user].new?
+      
+      controller=nil #clear from previous call
+      controller=resource.controller if resource.respond_to?(:controller)
+      controller=resource if resource.respond_to?($request[:verb]) 
+      raise RoutingError unless controller
+
+      json=controller.send($request[:verb]).to_json
+      html=@opts[:client] ? @opts[:client].to_s(json) : json
+      resp_code=RESP_CODES[verb]
+      headers||={'Content-Type' => "#{$request[:content_type]}; charset=utf-8"}
+
+      [resp_code,headers,$request[:content_type].match(/json/) ? json : html]
+    rescue Sequel::ValidationFailed
+      ValidationError.new($!.errors).to_a
+    rescue
+      if $!.class.superclass==MarleyError
+        $!.to_a
+      else
+        p $!,$!.class,$!.backtrace
+      end
+    ensure
+      $log.info $request.merge({:request => nil,:user => $request[:user] ? $request[:user].name : nil})
+      $request=nil #mostly for testing
+    end
+  end
+end

data/lib/marley/test_helpers.rb

@@ -16,6 +16,17 @@ module Marley
       opts||=@opts
       opts[:url] || '/' + [:root_url, :resource_name, :instance_id, :method].map {|k| opts[k]}.compact.join('/') + opts[:extention].to_s
     end
+    def date_hack(reggae_obj)
+      if reggae_obj.class==Marley::Reggae
+        reggae_obj.map {|o| date_hack(o)}
+      elsif reggae_obj.class==Marley::ReggaeInstance
+        reggae_obj.set_values(:date_created => 'date_created') if reggae_obj.schema[:date_created]
+        reggae_obj.set_values(:date_updated => 'date_updated') if reggae_obj.schema[:date_updated]
+        reggae_obj
+      else
+        reggae_obj
+      end
+    end
     def process(verb,params={},opts={})
       #p 'params:',params,'opts:',opts,"-------------" if opts
       opts||={}
@@ -36,7 +47,7 @@ module Marley
       p last_response.status if opts[:debug]
       p expected_code if opts[:debug]
       return false unless (expected_code || RESP_CODES[method])==last_response.status
-      Reggae.get_resource(JSON.parse(last_response.body)) rescue last_response.body
+      date_hack(Reggae.get_resource(JSON.parse(last_response.body))) rescue last_response.body
     end
     ['create','read','update','del'].each do |op|
       define_method op.to_sym, Proc.new { |*args| 

data/lib/marley/utils.rb

@@ -1,36 +1,68 @@
 
 module Marley
   module Utils
-    def self.hash_keys_to_syms(hsh)
-      hsh.inject({}) {|h,(k,v)| h[k.to_sym]= v.class==Hash ? hash_keys_to_syms(v) : v;h }
-    end
-    # @todo:  make options inheritable?
-    def self.rest_opts_mod(name,opts,key_proc)
-      Module.new do |m|
-        @create_opts=[name,opts,key_proc]
-        def self.create_opts
-          @create_opts
-        end
-        def self.new(name=nil,opts=nil,key_proc=nil)
-          Marley::Utils.rest_opts_mod(*@create_opts)
-        end
-        opts.each {|opt| attr_accessor "#{name}_#{opt}"}
-        define_method "rest_#{name}" do
-          if opts.find {|opt| send(:"#{name}_#{opt}").to_s > ""}
-            foo=opts.inject({}) do |h,k|
-              i=send("#{name}_#{k}".sub(/^_/,''))
-              h[k.to_sym]=i.class==Hash ? i[key_proc.call] : i
-              h
+    module ClassAttrs
+      def lazy_class_attrs(key_proc,atts,op=nil,&block)
+        atts.to_a.each do |att|
+          att=[att] unless att.is_a?(Array)
+          class_attr(att[0], {key_proc => att[1]}, op, &block)
+          include(Module.new do |m|
+            define_method :"_#{att[0]}" do
+              a=self.class.send(att[0])
+              a.keys.inject(nil) {|res,key| 
+                if self.respond_to?(key)
+                  all=a[key][:all]
+                  v=(a[key].has_key?(dyn_key=self.send(key)) && a[key][dyn_key] ) || all || res
+                  Marley::Utils.combine(res,Marley::Utils.combine(all, v)) 
+                else
+                  Marley::Utils.combine(res,a[key])
+                end
+              }
             end
-            if Marley.constants.include?("Reggae#{name.camelcase}")
-              Marley.const_get(:"Reggae#{name.camelcase}").new(foo)
+          end)
+        end
+      end
+      def class_attr(attr_name, val=nil, op=nil, &block)
+        block||=op ? lambda{ |o, x| o.__send__(op, x) } : lambda {|old, new| Marley::Utils.combine(old,new)}
+        extend(Module.new do |m|
+          define_method :"#{attr_name}!" do |*args|
+            if instance_variable_defined?("@#{attr_name}")
+              instance_variable_get("@#{attr_name}")
             else
-              foo 
+              instance_variable_set("@#{attr_name}", Marshal.load(Marshal.dump(val)))
             end
           end
-        end
+          define_method attr_name.to_sym do
+            ancestors.reverse.inject(Marshal.load(Marshal.dump(val))) do |v, a|
+              if a.respond_to?(:"#{attr_name}!")
+                block.call(v,a.__send__(:"#{attr_name}!"))
+              else
+                v
+              end
+            end
+          end
+        end)
+      end
+    end
+    def self.combine(old,new)
+      if old.is_a?(Hash) && new.is_a?(Hash)
+        old.merge(new) {|k,o,n|Marley::Utils.combine(o,n)}
+      elsif old.is_a?(Array) && new.is_a?(Array)
+        (old + new).uniq
+      else
+        new
       end
     end
+    def self.sti(klass)
+      klass.plugin :single_table_inheritance, :"#{klass.to_s.sub(/.*::/,'').underscore}_type", :model_map => lambda{|v| MR.const_get(v.to_sym)}, :key_map => lambda{|clss|clss.name.sub(/.*::/,'')}
+    end
+    def self.many_to_many_join(lclass, rclass)
+      join_table=[lclass.table_name.to_s,rclass.table_name.to_s ].sort.join('_')
+      lclass.many_to_many(rclass.resource_name.pluralize.to_sym,:join_table => join_table,:class =>rclass, :left_key => lclass.foreign_key_name, :right_key => rclass.foreign_key_name)
+      rclass.many_to_many(lclass.resource_name.pluralize.to_sym,:join_table => join_table, :class =>lclass,:left_key => rclass.foreign_key_name, :right_key => lclass.foreign_key_name)
+    end
+    def self.hash_keys_to_syms(hsh)
+      hsh.inject({}) {|h,(k,v)| h[k.to_sym]= v.class==Hash ? hash_keys_to_syms(v) : v;h }
+    end
   end
-  RestActions=Utils.rest_opts_mod('actions',['get','post','put','delete'],lambda {$request[:user].class})
 end

data/rdoc/example_joint.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'marley'
+
+module Marley
+  module Plugins
+    class HelloPlugin < Plugin
+      module ClassMethods
+        def rest_post
+          new($request[:path][1])
+        end
+      end
+      module InstanceMethods
+        def initialize(greeting)
+          @greeting=greeting
+        end
+        def to_json
+          "#{@greeting} world"
+        end
+      end
+    end
+  end
+  module Joints
+    class ExampleJoint < Joint
+      module Resources
+        class GoodBye
+          def self.rest_get
+            "goodbye"
+          end
+        end
+      end
+    end
+  end
+end

data/rdoc/example_plugin.rb

@@ -0,0 +1,20 @@
+
+module Marley
+  module Plugins
+    class ExamplePlugin < Plugin
+      module ClassMethods
+        def rest_post
+          new($request[:path][1])
+        end
+      end
+      module InstanceMethods
+        def initialize(greeting)
+          @greeting=greeting
+        end
+        def to_json
+          "#{@greeting} world"
+        end
+      end
+    end
+  end
+end

data/rdoc/forum_joint.rb

@@ -0,0 +1,50 @@
+require 'marley'
+require 'marley/test_helpers'
+
+
+DB=Sequel.sqlite('')
+DB.create_table :users do
+  primary_key :id
+  text :name, :unique => true
+  text :user_type, :index => true
+  text :pw_hash
+  datetime :date_created
+  text :description
+end
+DB.create_table :messages do
+  primary_key :id
+  integer :topic_id, :index => true
+  integer :parent_id, :index => true
+  integer :user_id, :index => true
+  datetime :date_created, :index => true
+  text :message_type, :index => true
+  text :title,  :index => true,:null => false
+  clob :content
+end
+DB.create_table :messages_users do
+  primary_key :id
+  integer :user_id
+  integer :message_id
+  boolean :read, :index => true
+  index [:user_id, :message_id], :unique => true
+end
+DB.create_table :tags do
+  primary_key :id
+  integer :user_id,:index => true
+  text :tag,:index => true
+end
+DB.create_table :messages_tags do
+  primary_key :id
+  integer :tag_id
+  integer :message_id
+  index [:tag_id, :message_id], :unique => true
+end
+DB.create_table :topics_tags do
+  primary_key :id
+  integer :tag_id
+  integer :topic_id
+  index [:tag_id, :topic_id], :unique => true
+end
+ 
+
+Marley.joint('forum')

data/rdoc/forum_joint.rdoc

@@ -0,0 +1,19 @@
+==Forum Joint
+
+setup
+    DB[:users].delete
+    DB[:messages].delete
+    DB[:messages_users].delete
+    DB[:tags].delete
+    DB[:SQLITE_SEQUENCE].update(:seq => 0)
+    user_client=Marley::TestClient.new(:resource_name => 'user')
+    user=user_client.read({},:method => 'new').set_values(:password => 'asdfasdf', :confirm_password => 'asdfasdf')
+    (1 .. 5).each { |i|
+      user_client.create(user.set_values(:name => "user#{i}"))
+      instance_variable_set(:"@client#{i}", Marley::TestClient.new(:auth => ["user#{i}",'asdfasdf'] ))
+    }
+end
+
+example:
+
+!!!

data/rdoc/hello.rb

@@ -0,0 +1,14 @@
+require 'marley'
+require 'marley/test_helpers'
+
+Marley.config :http_auth => false
+module Marley
+  module Resources
+    class Hello
+      def self.rest_get
+        @who=$request[:get_params][:who] || 'World'
+        "Hello #{@who}!"
+      end
+    end
+  end
+end

data/rdoc/hello.rdoc

@@ -0,0 +1,14 @@
+
+=Marley Basics
+
+setup
+   @client=Marley::TestClient.new({:resource_name => 'hello'}) 
+end
+
+example: return hello world
+
+    >> @client.read
+    => "\"Hello World!\""
+    >> @client.read({:who => 'Dolly'})
+    => "\"Hello Dolly!\""
+

data/rdoc/joints.rdoc

@@ -0,0 +1,69 @@
+
+==Joints
+
+
+"Joints" are pre-packaged resource sets that can be included in a Marley application.  A joint can be added to the current Resources by running Marley.joint('_joint_name_').  The Marley.joint method will then do the following:
+
+* Find a file named '_joint_name_' in the 'joints/' directory.
+* Require that file.
+* run its #smoke method.
+
+The Joint#smoke method scans the classes constants for a module namee 'Resources' and any modules whose name ends in 'Plugin'.
+
+* If the 'Resources' module exists, Joint#smoke will copy all of its constants to Marley::Resources.
+* For every module whose name ends in 'Plugin', if a corresponding class exists in Marley::Resources, it will be extended by the internal 'ClassMethods' module and have the internal 'InstanceMethods' module's features appended to it.
+
+:include: rdoc/hello.rb
+
+:include: rdoc/example_joint.rb
+
+For now, there are 4 joints included in the Marley distribution:
+
+* User
+* Messages
+* Tags
+* Section
+
+With a bit of configuration, these comprise the example forum application.
+
+    setup
+      @client=Marley::TestClient.new(:resource_name => 'hello')
+    end
+
+example: without the joint, then with the joint
+
+    >> MR.constants
+    => ["Hello"]
+    >> @client.read
+    => "\"Hello World!\""
+    >> @client.read({}, :resource_name => 'goodbye',:code => 404)
+    => [:error, {:description=>"Not Found", :error_type=>"routing", :error_details=>nil}]
+    >> @client.create({}, :code => 404)
+    => [:error, {:description=>"Not Found", :error_type=>"routing", :error_details=>nil}]
+
+
+    >> Marley.joint('example_joint').class
+    => Marley::Joints::ExampleJoint
+    >> MR.constants.sort
+    => ["GoodBye", "Hello"]
+    >> Marley.plugin('HelloPlugin').apply(MR::Hello)
+    => nil
+
+    >> @client.read({}, :resource_name => 'goodbye')
+    => false
+    >> @client.read({}, :resource_name => 'good_bye')
+    => "\"goodbye\""
+    >> @client.create({})
+    => " world"
+    >> @client.create({},:method => 'howdy')
+    => "howdy world"
+
+:include: rdoc/user_joint.rdoc
+
+:include: rdoc/tags_joint.rdoc
+
+:include: rdoc/messages_joint.rdoc
+
+:include: rdoc/section_joint.rdoc
+
+