equipment 0.1.0

data/lib/ext/og.rb

@@ -0,0 +1,95 @@
+require 'equipment'
+require 'og'
+
+module Ext 
+
+  # Add some facilities for using Og in Camping. Stores the manager outside of
+  # the app so that you can reload it without sideeffects.
+  #
+  # == BUGS
+  #
+  # Does not work if app.create was defined before inclusion of that module
+  # and doesn't call `super`.
+  #
+  # == TODO
+  # 
+  # * Change table names
+  # * Add E as Entity in Models
+  module Og
+    extend Equipment
+
+    module CClassMethods
+      # Useful for extenal control. Filled by .create.
+      attr_reader :og_manager
+
+      # Adds Og initialization when you start your app.
+      def create
+        @og_manager = ::Equipment::Og.setup(self) if self::Models.og
+        super
+      rescue NoMethodError, ArgumentError
+      end
+    end
+
+    module ModelsClassMethods
+      # Og setting.
+      #
+      # == Sqlite example
+      #
+      #  MyApp::Models.og = { :store => :sqlite }
+      #
+      # == MySQL example
+      #
+      #  MyApp::Models.og = { 
+      #    :store => :mysql,
+      #    :name => 'data',
+      #    :hostname => 'localhost',
+      #    :user => 'root',
+      #    :pass => '1234'
+      #  }
+      attr_accessor :og
+    end
+
+    module Views
+
+      def _form_for(entity, opts)
+        entity = entity.new if entity.kind_of? Class
+        form({:method=>:post}.merge(opts)) do
+          entity.class.serializable_attributes.each do |prop|
+            unless /^oid$|_oid$/.match prop.to_s
+              label prop.to_s, :for=>prop; br
+              input :type=>:text, :name=>prop, :value=>entity.send(prop); br
+            end
+          end
+
+          input :type=>:hidden, :name=>'oid', :value=>entity.oid
+          input :type=>:submit
+        end
+      end
+
+    end
+  end
+
+  class << Og
+    # Returns a manager for you app.
+    def setup(app)
+      ::Og.thread_safe = false
+      unless manager = managers[app.name]
+        manager = ::Og::Manager.new(app::Models.og || {})
+        managers[app.name] = manager
+      end
+
+      manager.unmanage_classes # needed ?
+
+      app::Models.constants.each do |model|
+        manager.manage_class(model) if manager.manageable?(model)
+      end
+      
+      manager
+    end
+
+    def managers
+      @managers ||= {}
+    end
+  end
+end
+

data/lib/ext/og_scaffold.rb

@@ -0,0 +1,119 @@
+require 'equipment'
+require 'ext/flash'
+require 'ext/og'
+require 'ext/ressource'
+require 'ext/forms'
+
+module Ext
+
+  # Allows Og Entities scaffolding. Not working yet.
+  #
+  # == Dependencies
+  #
+  # * Equipment
+  # * Og
+  # * Ressources
+  # * Flash
+  # * FormHelper
+  #
+  # == TODO
+  #
+  # * Not working. Finish this.
+  module OgScaffold
+    extend Equipment
+    depends_on Flash
+    depends_on Og
+    depends_on Ressource
+    depends_on Forms
+
+    module ControllersClassMethods
+      def scaffold(model, opts={})
+        defaults = {
+          :path => "/#{model.downcase}",
+          :name => "#{model}Scaffold"
+        }
+        opts = opts.merge(defaults)
+
+        klass = Class.new(OgScaffolder)
+        klass.path, klass.model = opts[:path], model
+
+        const_set(opts[:name], klass) if opts[:name]
+
+        klass
+      end
+      alias :S :scaffold
+    end
+
+    class OgScaffolder < Equipment::Ressource::RestController
+      class << self
+        attr_accessor :model
+      end
+
+      ### CRUD ###
+      def create
+        m = model.new
+        input.fill(m) # TODO : Make this work
+        m.save
+        flash.errors = m.errors
+        redirect R(self, :show, m.oid)
+      end
+
+      def show(oid)
+        @model = model
+        @model_instance = model[oid]
+        render :show
+      end
+
+      def update(oid)
+        m = model[oid]
+        input.fill(m)
+        m.save
+        flash.errors = m.errors
+        redirect R(self, :show, m.oid)
+      end
+
+      def destroy(oid)
+        flash.errors = model.delete(oid)        
+        redirect R(self)
+      end
+
+      ### Views ###
+      
+      def index
+        @model = model
+        render :index
+      end
+
+      def edit(oid)
+        @model = model
+        @model_instance = model[oid]
+        render :edit
+      end
+
+    private
+      def _model; self.class.model; end
+      def render(view, *a, &b) # look for local redefinition
+        if has_view?("#{self.class.name.downcase}_#{view}")
+          super("#{self.class.name.downcase}_#{view}", *a, &b)
+        else
+          super("og_scaffold_#{view}", *a, &b)
+        end
+      end
+    end
+
+    module Views
+      def og_scaffold_index
+        form_for(@model)
+      end
+
+      def og_scaffold_show
+        print(@model_instance)
+      end
+
+      def og_scaffold_edit
+        form_for(@model, @model_instance)
+      end
+    end
+  end
+end
+

data/lib/ext/og_session.rb

@@ -0,0 +1,76 @@
+require 'equipment'
+require 'ext/og'
+require 'glue/timestamped'
+
+module Ext 
+
+  # It's like Camping's Session but works with Og.
+  #
+  # TODO : Not working. Test this.
+  module OgSession
+    include Equipment
+    depends_on Og
+
+    module Models
+      class OgSession
+        attr_accessor :hashid,  String
+        attr_accessor :ivars,   Hash
+
+        is Glue::Timestamped
+
+        def []=(k, v)
+          self.ivars[k] = v
+        end
+        def [](k)
+          self.ivars[k] rescue nil
+        end
+
+        RAND_CHARS = [*'A'..'Z'] + [*'0'..'9'] + [*'a'..'z']
+
+        # Generates a new session ID and creates a row for the new session in the database.
+        def self.generate cookies
+          rand_max = RAND_CHARS.size
+          sid = (0...32).inject("") { |ret,_| ret << RAND_CHARS[rand(rand_max)] }
+          sess = self.create :hashid => sid, :ivars => Camping::H[]
+          cookies.camping_sid = sess.hashid
+          sess
+        end
+
+        # Gets the existing session based on the <tt>camping_sid</tt> available in cookies.
+        # If none is found, generates a new session.
+        def self.persist cookies
+          if cookies.camping_sid
+            session = self.find_by_hashid cookies.camping_sid
+          end
+          unless session
+            session = self.generate cookies
+          end
+          session
+        end
+      end
+    end
+
+    module Base
+      # This <tt>service</tt> method, when mixed into controllers, intercepts requests
+      # and wraps them with code to start and close the session.  If a session isn't found
+      # in the database it is created.  The <tt>@state</tt> variable is set and if it changes,
+      # it is saved back into the database.
+      def service(*a)
+        session = OgSession.persist @cookies
+        app = self.class.name.gsub(/^(\w+)::.+$/, '\1')
+        @state = (session[app] ||= Camping::H[])
+        hash_before = Marshal.dump(@state).hash
+        s = super(*a)
+        if session
+          hash_after = Marshal.dump(@state).hash
+          unless hash_before == hash_after
+            session[app] = @state
+            session.save
+          end
+        end
+        s
+      end
+    end
+  end
+end
+

data/lib/ext/patches.rb

@@ -0,0 +1,130 @@
+require 'equipment'
+require 'ext/app_util'
+
+module Ext
+
+  # Fixes some Camping defaults.
+  #
+  # == Dependencies
+  # 
+  # * Equipment
+  # * AppUtil
+  #
+  module Patches
+    extend Equipment
+    depends_on AppUtil
+
+    # Removes method_missing, it makes things too complicated and debug
+    # unclear.
+    #
+    # Redefines the D method
+    def self.equip(app)
+      super
+
+=begin
+      # remove method_missing, it makes things too complicated
+      if app::Base.method_defined? :method_missing
+        app::Base.send :undef_method, :method_missing
+      end
+=end
+
+=begin # not needed in 1.5
+      app::Controllers.module_eval do
+        # New D method which uses respond_to? instead of kind_of?(R)
+        def self.D(path)
+          puts "REQUEST: #{path}" if $DBG
+          constants.inject(nil) do |d,c|
+            k = const_get(c)
+            k.meta_def(:urls){["/#{c.downcase}"]}unless k.respond_to? :urls
+            d||([k, $~[1..-1]] if k.urls.find { |x| path =~ /^#{x}\/?$/ })
+          end||[self::NotFound, [path]]
+        end
+      end
+=end
+
+#      app::Controllers::NotFound.send    :include, app::C, app::Base, app::Models
+#      app::Controllers::ServerError.send :include, app::C, app::Base, app::Models
+    end
+    module Base
+
+      # = Re-defined render
+      # 
+      # The method_missing method is great but it ties the system too much to
+      # markaby. It makes also harder to debunk wrong methods since the call-
+      # stack is longer. Finally, it encourages to put the view in the
+      # controller, which is considered bad in MVC style (that's what ppl say)
+      # 
+      # Render is a method that gets the view and puts a layout around it if
+      # found.
+      #
+      # Layout was renamed to _layout because it is a partial. Also partials
+      # don't use the layout feature (so layout doesn't have a layout)
+      def render(m, *a, &b)
+        str = view(m, *a, &b)
+        # allow content-negotiation
+        if m.to_s[0] != ?_ and has_view? :_layout
+          str = view(:_layout) { str }
+        end
+        str
+      end
+
+      # Temporary there until markaview is restored or replaced in
+      # camping-unabridged.
+      def markaview(m,*a,&b)
+        h=markaby 
+        h.send m,*a,&b 
+        h.to_s 
+      end 
+
+      # Useful if you want to implement your own view
+      alias :view :markaview
+
+      # Shortcut. 
+      # 
+      # This is useful if you want to implement your own view lookup
+      # (cf. TemplateView, ErubisView)
+      def has_view?(v)
+        /text\/html|\*\/\*/ =~ (env.HTTP_ACCEPT || '*/*') and
+          app::Views.method_defined? v  # this is specific to markaby
+      end
+    end
+
+=begin
+    module Controllers
+      # Changed usage of markaby template after removing method_missing.
+      class NotFound
+        def self.urls; [] end # do not serve urls directly
+        def get(p); r(404, app::Mab.new { h1 "Camping Problem!"; h2 "#{p} not found"}) end
+      end
+
+      class ServerError
+        def self.urls; [] end # do not serve urls directly
+        def get(k,m,e)
+          r(500, app::Mab.new do
+              h1 "Camping Problem!"
+#              if $DBG
+                h2 "#{k}.#{m}"
+                h3 "#{e.class} #{e.message}:"
+                ul { e.backtrace.each { |bt| li bt } } 
+#              end
+            end.to_s
+          )
+        end
+      end
+    end
+=end
+
+=begin
+    module CClassMethods
+      # Does noting. Allows calling super to chain initialization processes
+      # without having to check for NoMethodError.
+      def create
+        super
+      rescue NoMethodError, ArgumentError
+      end
+    end
+=end
+
+  end
+end
+

data/lib/ext/ressource.rb

@@ -0,0 +1,88 @@
+require 'equipment'
+
+module Ext
+  # Unfinished work.
+  #
+  # I'm currently implementing a Controller that works like rail's
+  # ActiveRessouce.
+  #
+  # == Dependencies
+  #
+  # * None
+  #
+  module Ressource
+    class RestController
+      class << self
+        attr_accessor :model, :path
+
+        def urls
+          @__urls  ||= [
+            #      POST                  GET                     POST                      POST
+            "#{path}/(create)", "#{path}/(show)/(\d+)", "#{path}/(update)/(\d+)", "#{path}/(destroy)/(\d+)",
+            "#{path}/(\d+)", "#{path}", # POST,GET,PUT,DELETE  : rest methods
+            "#{path};(\w+)", "#{path}/(\d+);(\w+)" # POST,GET : forms
+          ]
+        end
+      end
+
+      # GET method dispatching
+      def get(action, id)
+        if action.to_i > 0                     #/id , /id;actions
+          id = 'show' unless id
+          send(id, action)
+        elsif id                               #/show/id
+          show(id)
+        else                                   # ;actions
+          action = 'index' if action.empty?
+          send(action)
+        end
+      end
+
+      # POST method dispatching
+      def post(action, id)
+        if action.to_i > 0
+          id = id ? "_#{id}" : 'update'
+          send(id, action)
+        elsif id
+          send(action, id)
+        elsif action=='create'
+          create
+        else
+          send("_#{action}")
+        end
+      end
+
+      def put(id); update(id); end
+      def delete(id); destroy(id); end
+
+      ### CRUD operations ###
+
+      def create # POST
+      end
+
+      def show(id) # GET
+      end
+
+      def update(id) # PUT
+        redirect R(self, :show, id)
+      end
+
+      def destroy(id) # DELETE
+        redirect R(self, :index)
+      end
+
+      ### Pages ###
+
+      def index
+      end
+
+      def new
+      end
+
+      def edit
+      end
+    end
+
+  end
+end
+