marley 0.1.0

data/lib/joints/user_based_navigation.rb

@@ -0,0 +1,39 @@
+
+module Marley
+  module Joints
+    class UserBasedNavigation < Joint
+      LOGIN_FORM= [:instance,{:url => 'login',:description => 'Existing users please log in here:',:new_rec => true,:schema => [[:text,'name',RESTRICT_REQ],[:password,'password',RESTRICT_REQ]]}]
+      module ClassMethods
+        module User
+          def sections
+          end
+        end
+      end
+      module Resources
+        class MainMenu
+          attr_accessor :title,:name,:description, :items
+          def self.rest_get
+            new.to_json
+          end
+          def initialize
+            if $request[:user].new?
+              u=$request[:user].to_a
+              u[1].merge!({:description => 'If you don\'t already have an account, please create one here:'})
+              @title="Welcome to #{$request[:opts][:app_name]}"
+              @description='Login or signup here.'
+              @items=[LOGIN_FORM,u]
+            else
+              $request[:user].class.sections
+            end
+          end
+          def self.requires_user?
+            true
+          end
+          def to_json
+            [:section,{:title => @title,:description => @description,:name => @name, :navigation => @items}]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/marley.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/ruby
+require 'json/ext'
+require 'rack'
+require 'rack/auth/basic'
+require 'rack/builder'
+require 'sequel_plugins'
+require 'controllers'
+require 'reggae'
+require 'logger'
+Sequel.extension :inflector
+
+Sequel::Model.plugin :rest_convenience
+Sequel::Model.plugin :rest_authorization
+Sequel::Model.plugin :validation_helpers
+Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS.merge!(:presence => {:message => 'is required'})
+Sequel::Model.plugin :timestamps, :create => :date_created, :update => :date_updated
+
+log_fn='log/marley.log'
+$log=Logger.new(File.exists?(log_fn) ? log_fn : $stdout) 
+
+
+module Marley #The main Marley namespace.
+  JOINT_DIRS=[File.expand_path("joints/",File.dirname(__FILE__)),"#{Dir.pwd}/joints"]
+  DEFAULT_OPTS={:http_auth => true,:app_name => 'Application',:port => 1620,:default_user_class => :User, :auth_class => :User,:default_resource => 'Menu', :server => 'thin'}
+  RESP_CODES={'get' => 200,'post' => 201,'put' => 204,'delete' => 204}
+  
+  module Resources #All objects in the Resources namespace are exposed by the server.
+  end
+  require 'joint' #this needs to happen after Marley::Resources is defined
+  def self.config(opts=nil)
+    @marley_opts||=DEFAULT_OPTS
+    @marley_opts.merge!(opts) if opts
+    yield @marley_opts if block_given?
+    @marley_opts
+  end
+  def self.joint(joint_name, *opts)
+    joint_d=JOINT_DIRS.find {|d| File.exists?("#{d}/#{joint_name}.rb") }
+    require "#{joint_d}/#{joint_name}"
+    @marley_opts[:client] && @marley_opts[:client].joint(joint_d,joint_name)
+    joint=Marley::Joints.const_get(joint_name.camelize).new(*opts).smoke
+  end
+  def self.run(opts={})
+    @marley_opts||=DEFAULT_OPTS
+    marley_opts=@marley_opts.merge!(opts)
+    Rack::Handler.get(marley_opts[:server]).run(Rack::Builder.new {
+      use Rack::Reloader,0
+      use Rack::Static, :urls => [opts[:image_path]] if opts[:image_path]
+      run(Marley::Router.new(marley_opts))
+    }.to_app,{:Port => @marley_opts[:port]})
+  end
+  class Router  #the default Marley router.  Creates the $request object, locates the resource requested and calls either its controller's or its own rest verb method
+    def initialize(opts={},app=nil)
+      @opts=DEFAULT_OPTS.merge(opts)
+    end
+    def call(env)
+      request= Rack::Request.new(env)
+      @auth =  Rack::Auth::Basic::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] > ''
+      $request[:content_type]='application/json' if env['rack.test']==true #there has to be a better way to do this...
+      if @opts[:http_auth]
+        if (@auth.provided? && @auth.basic? && @auth.credentials)
+          $request[:user]=Resources.const_get(@opts[:auth_class]).authenticate(@auth.credentials)
+          raise AuthenticationError unless $request[:user]
+        else
+          $request[:user]=Resources.const_get(@opts[:default_user_class]).new
+        end
+      end
+      $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]
+      raise RoutingError unless Resources.constants.include?(rn)
+      @resource=Resources.const_get(rn)
+      raise AuthenticationError if @opts[:http_auth] && @resource.respond_to?('requires_user?') && @resource.requires_user? && $request[:user].new?
+      @controller=@resource.respond_to?($request[:verb]) ? @resource : @resource.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).response
+    rescue
+      ($!.class.new.respond_to?(:response) ?  $!.class : MarleyError).new.response
+    ensure
+      $log.info $request.merge({:request => nil,:user => $request[:user] ? $request[:user].name : nil})
+    end
+  end
+  class MarleyError < StandardError
+    class << self
+      attr_accessor :resp_code,:headers,:description,:details
+    end
+    @resp_code=500
+    def initialize
+      self.class.details=self.backtrace
+    end
+    def log_error
+      $log.fatal("#$!.message}\n#{$!.backtrace}")
+    end
+    def response
+      log_error
+      json=[:error,{:error_type => self.class.name.underscore.sub(/_error$/,'').sub(/^marley\//,''),:description => self.class.description, :error_details => self.class.details}].to_json
+      self.class.headers||={'Content-Type' => "#{$request[:content_type]}; charset=utf-8"}
+      [self.class.resp_code,self.class.headers,json]
+    end
+  end
+  class ValidationError < MarleyError
+    @resp_code=400
+    def initialize(errors)
+      self.class.details=errors
+    end
+    def log_error
+      $log.error(self.class.details)
+    end
+  end
+  class AuthenticationError < MarleyError
+    @resp_code=401
+    @headers={'WWW-Authenticate' => %(Basic realm="Application")}
+    def log_error
+      $log.error("Authentication failed for #{@auth.credentials[0]}") if (@auth && @auth.provided? && @auth.basic? && @auth.credentials)
+    end
+  end
+  class AuthorizationError < MarleyError
+    @resp_code=403
+    @description='You are not authorized for this operation'
+    def log_error
+      $log.error("Authorizationt Error:#{self.message}")
+    end
+  end
+  class RoutingError < MarleyError
+    @resp_code=404
+    @description='Not Found'
+    def log_error
+      $log.fatal("path:#{$request[:path]}\n   msg:#{$!.message}\n   backtrace:#{$!.backtrace}")
+    end
+  end
+  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
+  end
+end
+at_exit {Marley.run  if ARGV[0]=='run'}

data/lib/reggae.rb

@@ -0,0 +1,110 @@
+
+module Marley
+  class Reggae < Array
+    class << self
+      attr_accessor :valid_properties
+      def mk_prop_methods
+        @valid_properties && @valid_properties.each do |meth|
+          define_method(meth) {properties[meth].respond_to?(:to_resource) ? properties[meth].to_resource : properties[meth]} 
+          define_method(:"#{meth}=") {|val|properties[meth]=val} 
+        end
+      end
+      def get_resource(*args)
+        self.new(*args).to_resource
+      end
+    end
+    def initialize(*args)
+      super
+      self.class.mk_prop_methods
+    end
+    def resource_type
+      [String, Symbol].include?(self[0].class) ? self[0].to_s : nil
+    end
+    def is_resource?
+      ! resource_type.nil?
+    end
+    def properties
+      self[1].class==Hash ? Utils.hash_keys_to_syms(self[1]) : nil
+    end
+    def contents
+      is_resource? ? Reggae.new(self[2 .. -1]) : nil
+    end
+    def contents=(*args)
+      self[2]=*args
+      while length>3;delete_at -1;end
+    end
+    def [](*args)
+      super.class==Array ?  Reggae.new(super).to_resource : super
+    end
+    def to_resource
+      is_resource? ? Marley.const_get("Reggae#{resource_type.camelize}".to_sym).new(self) : self
+    end
+    def find_instances(rn,instances=Reggae.new([]))
+      if self.class==ReggaeInstance && self.name.to_s==rn 
+        instances << self
+      else
+        (is_resource? ? contents : self).each {|a| a && Reggae.new(a).to_resource.find_instances(rn,instances)}
+      end
+      instances
+    end
+  end
+  class ReggaeResource < Reggae
+    def initialize(*args)
+      super
+      unshift self.class.to_s.sub(/.*Reggae/,'').underscore.to_sym unless is_resource?
+    end
+  end
+  class ReggaeSection < ReggaeResource
+    self.valid_properties=[:title,:description]
+    def navigation
+      properties[:navigation].map{|n|Reggae.get_resource(n)}
+    end
+  end
+  class ReggaeLink < ReggaeResource
+    self.valid_properties=[:title,:description,:url]
+  end
+  class ReggaeInstance < ReggaeResource
+    self.valid_properties=[:name,:new_rec,:search,:url,:get_actions,:delete_action]
+    def schema
+      ReggaeSchema.new(self.properties[:schema])
+    end
+    def to_params
+      resource_name=name
+      schema.inject({}) do |params,spec| 
+        s=ReggaeColSpec.new(spec)
+        params["#{resource_name}[#{s.col_name}]"]=s.col_value unless (s.col_restrictions & RESTRICT_RO > 0)
+        params
+      end
+    end
+    def instance_action_url(action_name)
+      "#{url}#{action_name}" if get_actions.include?(action_name.to_s)
+    end
+  end
+  class ReggaeInstanceList < ReggaeResource
+    self.valid_properties=[:name,:description,:get_actions,:delete_action,:items]
+    def schema
+      ReggaeSchema.new(self.properties[:schema])
+    end
+  end
+  class ReggaeMsg < ReggaeResource
+    self.valid_properties=[:title,:description]
+  end
+  class ReggaeError < ReggaeResource
+    self.valid_properties=[:error_type,:description,:error_details]
+  end
+  class ReggaeSchema < Array
+    def [](i)
+      if i.class==Fixnum
+        ReggaeColSpec.new(super)
+      else
+        self[find_index {|cs|ReggaeColSpec.new(cs).col_name==i.to_s}]
+      end
+    end
+  end
+  class ReggaeColSpec < Array
+    ['col_type','col_name','col_restrictions', 'col_value'].each_with_index do |prop_name, i|
+      define_method(prop_name.to_sym) {self[i]} 
+      define_method(:"#{prop_name}=") {|val|self[i]=val} 
+    end
+  end
+end

data/lib/sequel_plugins.rb

@@ -0,0 +1,141 @@
+RESTRICT_HIDE=1
+RESTRICT_RO=2
+RESTRICT_REQ=4
+TYPE_INDEX=0
+NAME_INDEX=1
+RESTRICTIONS_INDEX=2
+module Sequel::Plugins::RestConvenience
+  module ClassMethods
+    def controller
+      Marley::ModelController.new(self)
+    end
+    def resource_name
+      self.name.sub(/.*::/,'').underscore
+    end
+    def reggae_link(action=nil)
+      [:link,{:url => "/#{self.resource_name}/#{action}",:title => "#{action.humanize} #{self.resource_name.humanize}".strip}]
+    end
+    def list(params=nil)
+      user=$request[:user]
+      if user.respond_to?(otm=self.resource_name.pluralize)
+        if user.method(otm).arity==0  
+          if (relationship=user.send(otm)).respond_to?(:filter)
+            relationship.filter($request[:get_params][resource_name.to_sym])
+          else
+            user.send(otm)
+          end
+        else
+          user.send(otm,$request[:get_params][resource_name.to_sym])
+        end
+      else
+        raise Marley::AuthorizationError
+      end
+    end
+    def autocomplete(input_content)
+      filter(:name.like("#{input_content.strip}%")).map {|rec| [rec.id, rec.name]}
+    end
+  end
+  module InstanceMethods
+    def get_actions; [];end
+    def edit; self; end
+    def rest_cols
+      columns.reject do |c| 
+        if new?
+          c.to_s.match(/(^id$)|(_type$)|(date_(created|updated))/)
+        else
+          c.to_s.match(/_type$/)
+        end
+      end
+    end
+    def hidden_cols
+      columns.select {|c| c.to_s.match(/(_id$)/)}
+    end
+    def write_cols
+      rest_cols.reject {|c| c.to_s.match(/(^id$)|(date_(created|updated))/)}
+    end
+    def required_cols;[];end
+    def rest_schema
+      rest_cols.map do |col_name|
+        db_spec=db_schema.to_hash[col_name]
+        col_type=db_spec ? db_spec[:db_type].downcase : col_name
+        restrictions=0
+        restrictions|=RESTRICT_HIDE if hidden_cols.include?(col_name)
+        restrictions|=RESTRICT_RO unless write_cols.include?(col_name)
+        restrictions|=RESTRICT_REQ if required_cols.include?(col_name) || (db_spec && !db_spec[:allow_null])
+        [col_type, col_name, restrictions,send(col_name)]
+      end
+    end
+    def to_s
+      respond_to?('name') ? name : id.to_s
+    end
+    def to_a
+      a=Marley::ReggaeInstance.new([ {:name => self.class.resource_name,:url => url ,:new_rec => self.new?,:schema => rest_schema,:get_actions => get_actions}])
+      if respond_to?(:rest_associations) && ! new?
+        a.contents=rest_associations.map do |assoc|
+          (assoc.class==Symbol ? send(assoc) : assoc).map{|instance| instance.to_a}
+        end
+      end
+      a
+    end
+    def to_json
+      to_a.to_json
+    end
+    def url(action=nil)
+      "/#{self.class.resource_name}/#{self[:id]}/#{action}".sub('//','/')
+    end
+    def reggae_link(action=nil)
+      [:link,{:url => url,:title => "#{action.humanize}"}]
+    end
+  end
+end
+module Sequel::Plugins::RestAuthorization
+  module ClassMethods
+    attr_accessor :owner_col, :allowed_get_methods
+    def inherited(c)
+      super
+      c.owner_col=@owner_col
+      c.allowed_get_methods=@allowed_get_methods
+    end
+    def requires_user?(verb=nil,meth=nil);true;end
+    def authorize(meth)
+      if respond_to?(auth_type="authorize_#{$request[:verb]}")
+        send(auth_type,meth)
+      else
+        case $request[:verb]
+        when 'rest_put','rest_delete'
+          false 
+        when 'rest_post'
+          new($request[:post_params][resource_name.to_sym]||{}).current_user_role=='owner' && meth.nil?
+        when 'rest_get'
+          (@allowed_get_methods || ['section','list','new']).include?(meth)
+        end
+      end
+    end
+  end
+  module InstanceMethods
+    def after_initialize
+      send("#{self.class.owner_col}=",$request[:user][:id]) if self.class.owner_col && new?
+    end
+    def requires_user?(verb=nil,meth=nil);true;end
+    def authorize(meth)
+      if respond_to?(auth_type="authorize_#{$request[:verb]}")
+        send(auth_type,meth)
+      else
+        current_user_role=='owner'
+      end
+    end
+    def current_user_role
+      "owner" if owners.include?($request[:user])
+    end
+    def owners
+      if self.class.to_s.match(/User$/)||self.class.superclass.to_s.match(/User$/)
+        [self]
+      elsif @owner_col
+        [User[send(@owner_col)]]
+      else
+        self.class.association_reflections.select {|k,v| v[:type]==:many_to_one}.map {|a| self.send(a[0]) && self.send(a[0]).owners}.flatten.compact
+      end
+    end
+  end
+end
+

data/lib/test_helpers.rb

@@ -0,0 +1,52 @@
+require "rack/test"
+require 'reggae'
+module Marley
+  #simple mocking framework; could be expanded to a general use client by adding display code.
+  class TestClient
+    CRUD2REST={'create' => 'post','read' => 'get','update' => 'put', 'del' => 'delete'}
+    DEFAULT_OPTS={:url => nil,:root_url => nil, :resource_name => nil, :instance_id => nil, :method => nil, :extention =>nil, :auth => nil, :code => nil, :debug => nil}
+    include Rack::Test::Methods
+    attr_reader :opts
+    def app
+      Marley::Router.new
+    end
+    def initialize(opts)
+      @opts=DEFAULT_OPTS.merge(opts)
+    end
+    def make_url(opts=nil)
+      opts||=@opts
+      opts[:url] || '/' + [:root_url, :resource_name, :instance_id, :method].map {|k| opts[k]}.compact.join('/') + opts[:extention].to_s
+    end
+    def process(verb,params={},opts={})
+      opts||={}
+      opts=@opts.merge(opts)
+      expected_code=opts[:code] || RESP_CODES[verb]
+      if opts[:debug]
+        p opts
+        p "#{verb} to: '#{make_url(opts)}'" 
+        p params 
+        p opts[:auth]
+      end
+      authorize opts[:auth][0],opts[:auth][1] if opts[:auth]
+      header 'Authorization',nil unless opts[:auth]  #clear auth from previous requests
+      send(verb,make_url(opts),params)
+      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
+    end
+    ['create','read','update','del'].each do |op|
+      define_method op.to_sym, Proc.new { |params,opts| 
+        process(CRUD2REST[op],params,opts)
+      }
+    end
+    DEFAULT_OPTS.keys.each do |opt|
+      define_method opt, Proc.new { 
+        @opts[opt]
+      }
+      define_method "#{opt}=", Proc.new { |val| 
+        @opts[opt]=val
+      }
+    end
+  end
+end