equipment 0.1.0 → 1.4.84

data/TODO

@@ -0,0 +1,14 @@
+== The global TODO list for Equipment
+
+* More docs
+* Fix Og so that it works better with Camping
+* Finish NegociateContent
+* Finish View content-type negociation
+* Finish Resource and Scaffolding
+* Finish Controls
+* TemplateView is almost useless
+* Fix XmlView
+* Logging mechanism
+* Run mode like in Rails
+* Debug mode
+

data/lib/camping_ext.rb

@@ -0,0 +1,72 @@
+# Basic camping extension
+
+require 'camping'
+require 'stringio' # used in Camping but not required
+
+# remove some things in Camping
+subs = {
+#  "active_support/core_ext/hash"                 => 'active_support',
+#  "metaid "                                      => '',
+#  ";autoload:Base,'camping/db'"                  => '',
+#  ";autoload:ActiveRecord,'camping/db'"          => '',
+  "module Base;include Helpers;"                 => 'module Base;',
+  /module Views;include X,Helpers.end;/m         => "module Views end\n",
+  /class Mab<Markaby::Builder.*include Views;/m  => "class Mab<Markaby::Builder\n",
+}
+
+subs.each_pair do |find, replace|
+  found = Camping::S.sub!(find, replace)
+  raise "`#{find}` not found in Camping. You may use the wrong version of Camping with Equipment" unless found
+end
+
+# adds extension
+unless /CampExt/ =~ Camping::S
+  Camping::S << "Camping.extend_once Ext, CampExt\n" # `CampExt` to avoid that it gets replaced
+end
+
+#puts Camping::S
+
+# This module is included if you use camping. Thid module and file is
+# requires to make Equipment work with Camping.
+module CampExt
+  # This will allow you to chain create methods.
+  # It also restores the the missing modules.
+  #
+  # == Examplanation
+  #
+  # When calling YourApp.create, the call order is :
+  #  * YourApp.create
+  #  * Last extended module.create
+  #  * Second last extended module.create
+  #  * ...
+  #  * First extended module.create
+  #
+  # By extending this app first, it will set a blank create method that
+  # will ensure that you don't get a NoMethodError when calling `super`
+  # 
+  def create
+    puts "INFO: CampExt#create called" if $DBG
+    unless self::Base.ancestors.include? self::Helpers
+      self::Base.send  :include, self::Helpers
+      self::Views.send :include, self::Controllers, self::Helpers
+      self::Mab.send   :include, self::Views
+    end
+    super
+  end
+
+  # Same as for #create.
+  #
+  # This method is intended to be used by launchers that support dynamically
+  # installing and removing applications.
+  # 
+  def install; false end
+
+  # See #install.
+  def uninstall; false end
+
+  # Equips global equipments. Make sure they are included before loading your apps.
+  def self.extended(app)
+    ::Equipment.global_extensions.each{ |ext| ext.equip(app) }
+  end
+end
+

data/lib/equipment.rb

@@ -2,66 +2,22 @@
 # 
 # See the README for more informations.
 
-require 'camping'
-
-=begin # doesn't work
-class << Camping
-  def goes(m)
-    p super(m)
-#    app = const_get(m)
-#    app.extend CampingExt
-#    app
-  end
-end
-=end
-
-# This module extends every app that uses equipments. It provides some
-# useful methods.
-module CampingExt
-  # List of extensions already in the application
-  def exts; @exts ||= [] end
-
-  # Shortcut method to add an equipment to the app.
-  #
-  # You can use YourApp.equip(Extension) instead of
-  # Extension.equip(YourApp) once this extension is
-  # installed.
-  #
-  def equip(*exts)
-    exts.each do |ext|
-      ext.equip(self)
-    end
-    self
-  end
-
-  # This will allow you to chain create methods.
-  #
-  # == Examplanation
-  #
-  # When calling YourApp.create, the call order is :
-  #  * YourApp.create
-  #  * Last extended module.create
-  #  * Second last extended module.create
-  #  * ...
-  #  * First extended module.create
-  #
-  # By extending this app first, it will set a blank create method that
-  # will ensure that you don't get a NoMethodError when calling `super`
-  # 
-  def create; end
-
-  # Same as for #create.
-  #
-  # This method is intended to be used by launchers that support dynamically
-  # installing and removing applications.
-  # 
-  def install; end
-
-  # See #install.
-  def uninstall; end
+require 'metaid'
+require 'ruby_ext'
+require 'ext'
+
+if using? :Camping
+  require 'camping_ext'
+elsif not Object.autoload? :Camping
+  autoload :Camping, 'camping_ext'
 end
 
+# This module provides the facilities for equipments. If included in an app,
+# it will provide a basic set of extensions. If extended in an equipment, it
+# will make it ready to provide new functionnalities to Camping apps.
 module Equipment
+  LIB_PATH = File.expand_path(File.dirname(__FILE__))
+  DATA_PATH = File.join(LIB_PATH, '..', 'share')
 
   # Utility for equipments. Automatically sets a set of rule for importing
   # methods, classes, class methods in your application for your extension.
@@ -88,15 +44,17 @@ module Equipment
   #  YourApp.equip(MyUtil)
   #
   def equip(app)
-    raise "Only for Camping apps" unless app.respond_to? :goes
-    app.extend CampingExt
+#    if not app.respond_to? :goes and defined? Camping
+#      raise "Cannot equip #{self} to #{app}, only for Camping apps"
+#    end
+    app.extend Ext unless app.metaclass.ancestors.include? Ext
 
     # Only equip once
-    return false if app.exts.include?(self)
-    app.exts << self
+    return false if app.equipments.include?(self)
+    app.equipments << self
 
     # dependencies
-    deps.each { |ext| ext.equip(app) }
+    dependencies.each { |ext| ext.equip(app) }
 
     puts "** equipped #{self} in #{app}" if $DBG
 
@@ -114,25 +72,10 @@ module Equipment
         if mod.public_instance_methods.size > 0 or
            mod.protected_instance_methods.size > 0 or
            mod.private_instance_methods.size > 0
-          app_mod.send :include, mod
-          puts "Included  : #{mod} -> #{app_mod}" if $DBG
-          # Exceptions until include_deep is working
-          case name
-          when "Helpers"
-            app::Base.send :include, mod
-            puts "Included  : #{mod} -> #{app::Base}" if $DBG
-            app::Mab.send  :include, mod
-            puts "Included  : #{mod} -> #{app::Mab}"  if $DBG
-            if app.const_defined? :V
-              app::V.send  :include, mod
-              puts "Included  : #{mod} -> #{app::V}"  if $DBG
-            end
-          when "Views"
-            app::Mab.send  :include, mod
-            puts "Included  : #{mod} -> #{app::Mab}"  if $DBG
-          end
-        end
-        if mod.constants.size > 0
+          app_mod.insert(mod)
+#          app_mod.include(mod)
+          puts "Inserted  : #{mod} -> #{app_mod}" if $DBG
+        elsif mod.constants.size > 0
           mod.transfer_classes_to(app_mod, :force)
           puts "Cls trans : #{mod} -> #{app_mod}" if $DBG
         end
@@ -147,49 +90,29 @@ module Equipment
 
   # An array of equipment modules on which that equipment depends on for
   # working. Works with #included.
-  def deps
-    @__deps ||= []
+  def dependencies
+    @__dependencies ||= []
   end
 
   # Asynchronous dependencies for later inclusion in a camping app. Fills
   # #dependencies for #included.
-  def depends_on(mod); deps << mod; end
-
-end
+  def depends_on(mod); dependencies << mod; end
 
-class Module
+  # If called, your equipment will be available to all apps. Call this
+  # before defining any application.
+  def equip_all
+    ::Equipment.global_extensions << self unless ::Equipment.global_extensions.include? self
+  end
 
-  # Utility method to transfer all classes of a module into another. It is
-  # useful when you write Camping extensions. cf. other equipments.
-  #
-  # I'm using this to override ServerError and NotFound controllers.
-  def transfer_classes_to(dest, force=false)
-    constants.each do |str|
-      k = const_get(str)
-      if k.kind_of? Class
-        dest.send :remove_const, str if force and dest.const_defined? str
-        dest.const_set str, k.dup unless dest.const_defined? str
-      end
-    end
+  # If you include Equipment in your app, you'll get some default
+  # extensions.
+  def self.included(app)
+    app.equip Ext::AppUtil, Ext::View, Ext::Forward
   end
 
+  # List of global extensions from #equip_all
+  def self.global_extensions; @global_extensions; end
+  @global_extensions = []
 end
 
-=begin
-class Object
-
-  # Sets all instance variables of an object to another
-  #
-  # if force is set to true, existing instance variables will be overwritten
-  def instance_variables_send(obj, force=false)
-    instance_variables.each do |v|
-      if force or not obj.instance_variables.include? v
-        obj.instance_variable_set(v, instance_variable_get(v))
-      end
-    end
-    obj
-  end
-  alias :ivs_send :instance_variables_send
-end
-=end
 

data/lib/ext.rb

@@ -0,0 +1,33 @@
+require 'equipment'
+
+# This module should be included in your app if you want to use any
+# equipment. It's also used as a namespace for the various extensions.
+module Ext
+  class << self
+    # Utility method that adds extension mechanism to any module.
+    def extendable(mod)
+      mod.extend self
+    end
+    alias_method :endable, :extendable
+  end
+
+  # List of extensions already in the application
+  def equipments; @equipments ||= [] end
+
+  # Shortcut method to add an equipment to the app.
+  #
+  # You can use YourApp.equip(Extension) instead of
+  # Extension.equip(YourApp) once this extension is
+  # installed.
+  #
+  def equip(*exts)
+    exts.each{|ext| ext.equip(self)}
+  end
+
+  # Create terminator.
+  def create 
+    puts "INFO: Ext#create called" if $DBG
+    self
+  end
+end
+

data/lib/ext/active_record.rb

@@ -0,0 +1,146 @@
+# Override the camping's autoload
+#autoload :ActiveRecord,'camping_ext'
+
+require 'equipment'
+
+begin
+  ActiveRecord # loads 'camping/db' if camping is loaded.
+rescue NameError # camping not used
+  class MissingLibrary < Exception #:nodoc: all
+  end
+  begin
+    require 'active_record'
+  rescue LoadError => e
+    raise MissingLibrary, "ActiveRecord could not be loaded (is it installed?): #{e.message}"
+  end
+end
+
+# restoring some adapters
+#RAILS_CONNECTION_ADAPTERS.replace ["mysql", "postgresql", "sqlite", "firebird", "sqlserver", "db2", "oracle", "sybase", "openbase"]
+
+#RAILS_CONNECTION_ADAPTERS.each do |adapter|
+#  require "active_record/connection_adapters/" + adapter + "_adapter"
+#end
+
+
+module Ext
+  # ActiveRecord extension. Overrides Camping's behaviour.
+  #
+  # NOTE : This Equipment is usable without Camping.
+  # 
+  # == Dependencies
+  #
+  # * ActiveRecord
+  # * Equipment
+  #
+  module ActiveRecord
+    extend Equipment
+
+    def self.equip(app)
+      unless app.const_defined? :C
+        app.module_eval "C=self"
+      end
+      app.module_eval "module Models;end"
+      super
+    end
+
+    module Models
+      class AllYourBase < ::ActiveRecord::Base;end
+      class << AllYourBase
+        # This is a facility to create your schemas.
+        #
+        # == Example (in your models)
+        #
+        #  class Post < Base
+        #    self.schema do |c|
+        #      c.create_table table_name, :force=>true do |t|
+        #        t.column :title, :string, :limit => 255
+        #        t.column :body, :text
+        #      end
+        #    end
+        #  end
+        #
+        def schema(&block)
+          @schema = block if block_given?
+          @schema
+        end
+
+        # This method checks if your table exists, otherwise it calls
+        # the #schema with the model's connection.
+        def check_create
+          if schema and connection and not table_exists?
+            schema.call(connection)
+            reset_column_information
+          end
+        end
+
+        # The default prefix for Camping model classes is the topmost module name lowercase
+        # and followed with an underscore.
+        #
+        #   Tepee::Models::Page.table_name_prefix
+        #     #=> "tepee_pages"
+        #
+        def table_name_prefix
+          "#{name[/\w+/]}_".downcase.sub(/^(activerecord|camping)_/i,'')
+        end
+
+        # I has to override this method too to get the right table name
+        # working
+        def reset_table_name #:nodoc:
+          table_name = Inflector.underscore(Inflector.demodulize(self.name))
+          table_name = Inflector.pluralize(table_name) if pluralize_table_names
+          name = "#{table_name_prefix}#{table_name}#{table_name_suffix}"
+          set_table_name(name)
+          name
+        end
+
+      end
+    end
+
+    # Class methods for you app
+    module CClassMethods
+      # If set, #create will launch your database with those params.
+      attr_accessor :database
+
+      # Set if #create initialized your database.
+      attr_reader :manager
+
+      # Tries to connect and create the databases.
+      def create
+        puts "INFO: ActiveRecord#create called" if $DBG
+
+        if self.database and not @manager
+
+          # Loads the adapter dynamically
+          adapter = self.database[:adapter] || self.database['adapter']
+          unless adapter.nil? or RAILS_CONNECTION_ADAPTERS.include? adapter
+            require "active_record/connection_adapters/" + adapter + "_adapter"
+            RAILS_CONNECTION_ADAPTERS << adapter
+          end
+
+          @manager = self::Models::AllYourBase.establish_connection self.database
+          puts "INFO: ActiveRecord connection established : #{@manager.inspect}" if $DBG
+          case @logger
+          when Logger
+            self::Models::AllYourBase.logger = @logger
+          when String
+            self::Models::AllYourBase.logger = Logger.new(@logger == "-" ? STDOUT : @logger)
+          else
+            self::Models::AllYourBase.logger = Logger.new(STDOUT)
+          end
+        end
+
+        # run check_create on models
+        self::Models.constants.each do |c|
+          if c != 'Base'
+            c = self::Models.const_get(c)
+            c.check_create if c.respond_to? :check_create
+          end
+        end
+
+        super
+      end
+    end
+  end
+end
+