lolita 3.0.5 → 3.0.6

data/lib/lolita/adapter/mongoid.rb

@@ -1,105 +1,105 @@
-module Lolita
-  module Adapter
-    class Mongoid
-      include Lolita::Adapter::AbstractAdapter
-
-      attr_reader :dbi, :klass
-      def initialize(dbi)
-        @dbi=dbi
-        @klass=dbi.klass
-      end
-
-      def associations
-        klass.relations
-      end
-
-      def associations_class_names
-        names=[]
-        associations.each{|name,association|
-          names<<association.class_name
-        }
-        names
-      end
-
-      def reflect_on_association(name)
-        klass.reflect_on_association(name)
-      end
-
-      def association_macro(association)
-        macro=association.macro
-        case macro
-        when :references_many
-          :many
-        when :referenced_in
-          :one
-        when :embeds_one
-          :one
-        when :embeds_many
-          :many
-        when :references_one
-          :one
-        end
-      end
-
-      def association_class_name(association)
-        association.class_name
-      end
-
-      def fields
-        @fields||=self.klass.fields.collect{|name,field|
-          field_to_hash(name,field)
-        }
-        @fields
-      end
-
-      def find_by_id(id)
-        self.klass.where(:_id=>id).first
-      end
-
-      def find *args
-        self.klass.find(*args)
-      end
-
-      def paginate(options={})
-        self.klass.paginate(options)
-      end
-
-      def db
-        self.klass.db
-      end
-
-      def db_name
-        self.klass.db.name
-      end
-
-      def collection
-        self.klass.collection
-      end
-
-      def collection_name
-        collection.name
-      end
-
-      def collections
-        db.collections
-      end
-
-      def collection_names
-        db.collection_names
-      end
-
-      private
-
-      def field_to_hash(name,field)
-        {
-          :name=>name,
-          :type=>field.type.to_s,
-          :title=>name.to_s.humanize,
-          :options=>field.options.merge({
-            :primary=>name.to_s=="_id"
-          })
-        }
-      end
-    end
-  end
+module Lolita
+  module Adapter
+    class Mongoid
+      include Lolita::Adapter::AbstractAdapter
+
+      attr_reader :dbi, :klass
+      def initialize(dbi)
+        @dbi=dbi
+        @klass=dbi.klass
+      end
+
+      def associations
+        klass.relations
+      end
+
+      def associations_class_names
+        names=[]
+        associations.each{|name,association|
+          names<<association.class_name
+        }
+        names
+      end
+
+      def reflect_on_association(name)
+        klass.reflect_on_association(name)
+      end
+
+      def association_macro(association)
+        macro=association.macro
+        case macro
+        when :references_many
+          :many
+        when :referenced_in
+          :one
+        when :embeds_one
+          :one
+        when :embeds_many
+          :many
+        when :references_one
+          :one
+        end
+      end
+
+      def association_class_name(association)
+        association.class_name
+      end
+
+      def fields
+        @fields||=self.klass.fields.collect{|name,field|
+          field_to_hash(name,field)
+        }
+        @fields
+      end
+
+      def find_by_id(id)
+        self.klass.where(:_id=>id).first
+      end
+
+      def find *args
+        self.klass.find(*args)
+      end
+
+      def paginate(options={})
+        self.klass.paginate(options)
+      end
+
+      def db
+        self.klass.db
+      end
+
+      def db_name
+        self.klass.db.name
+      end
+
+      def collection
+        self.klass.collection
+      end
+
+      def collection_name
+        collection.name
+      end
+
+      def collections
+        db.collections
+      end
+
+      def collection_names
+        db.collection_names
+      end
+
+      private
+
+      def field_to_hash(name,field)
+        {
+          :name=>name,
+          :type=>field.type.to_s,
+          :title=>name.to_s.humanize,
+          :options=>field.options.merge({
+            :primary=>name.to_s=="_id"
+          })
+        }
+      end
+    end
+  end
 end

data/lib/lolita/base_configuration.rb

@@ -3,12 +3,13 @@ module Lolita
   # Like Lolita.modules and Lolita.routes and so on.
   class BaseConfiguration
   
-    attr_reader :scope, :modules, :routes, :controllers
+    attr_reader :scope, :modules, :routes, :controllers,:resources
     attr_accessor :mappings,:default_route,:user_classes,:authentication
 
     def initialize(scope)
       @scope=scope
       @mappings={}
+      @resources={}
       @default_module=nil
       @user_classes=[]
       @modules=[]
@@ -16,16 +17,30 @@ module Lolita
       @controllers={}
     end
 
+    # Call (with #call) to route klass
+    # And return all names of routes that are needed for resource.
     def conditional_routes(klass=nil)
       @routes.map{|name,route|
-        if route.is_a?(Proc)
-          route.call(klass)
-        else
-          nil
+        if route.first
+          if route.last.respond_to?(:call)
+            route.last.call(klass)
+          else
+            nil
+          end
         end
       }.compact
     end
 
+    # Find all routes that is needed for defined classes
+    # And return only one for each different route.
+    def common_routes(klasses)
+      @routes.map{|name,route|
+        unless route.first
+          klasses.map{|klass| route.last.is_a?(Proc) ? route.last.call(klass) : nil}
+        end
+      }.flatten.compact.uniq
+    end
+      
     # Include module in Lolita, don't know why i need this
     def use(module_name)
       Lolita.send(:include,module_name)
@@ -40,6 +55,7 @@ module Lolita
     # Add new module to Lolita
     # Accpted options
     # * <tt>controller</tt> - not in use
+    # * <tt>nested</tt> - is route stands itsefl or is used in combination with resource
     # * <tt>route</tt> - Symbol of route name or lambad, that return route name based on resource.
     # Route name is used to call method lolita_[route_name] in Mapper class, and that should draw route.
     # * <tt>:name</tt> - name of module, underscored symbol. Used to draw default route, by default always
@@ -51,25 +67,37 @@ module Lolita
     #     lolita_for :posts #=> create url whatever is defined in lolita_post method, and goes to :controller=>"lolita/posts"
     #     Lolita.add_module Lolita::FileUpload, :route=>lambda{|resource| resource.lolita.tabs.by_type(:file) ? :file_upload : nil}
     #     lolita_for :users #=> creat default rest urls and also call method lolita_file_upload if user lolita define :file tab.
+    # To add route for public interface that goes to added module, than use 
+    #    Lolita.add_module Post, :name=>:posts
+    # And then when in routes.rb will be defined lolita_for(:posts) it will call method <i>lolita_posts_route</i>
+    # and that method should define resource. 
+    # ====Example
+    #     # require this in your gem or lib
+    #     module ActionDispatch::Routing
+    #        class Mapper
+    #          protected
+    #          def lolita_posts_route mapping, controllers
+    #            resources mapping.plural,:only=>[:index,:new,:create],
+    #              :controller=>controllers[:posts],:module=>mapping.module
+    #          end
+    #        end
+    #      end
+    # You open Mapper class and add your method that call #resources or #match or other method that define route
+    # For common route for all lolita resources your method should look like this
+    # ====Example
+    #     def lolita_files_route 
+    #        mapping=Lolita.add_mapping(:files,:class_name=>"Lolita::Multimedia::File",:module=>"file_upload")
+    #        scope :module=>mapping.module do
+    #            resources mapping.name
+    #        end
+    #     end
     def add_module module_container, options={}
-      options.assert_valid_keys(:controller,:route,:model,:path,:name)
+      options.assert_valid_keys(:controller,:route,:model,:path,:name,:nested)
       name=options[:name]||module_container.to_s.to_sym
       self.modules<<module_container
-      config={
-        :route=>self.routes,
-        :controller=>self.controllers
-      }
-      config.each{|key,value|
-        next unless options[key]
-        new_value=options[key]
-        if value.is_a?(Hash)
-          value[name]=new_value
-        elsif value.is_a?(Proc)
-          value[name]=new_value
-        elsif value.respond_to?(:include?) && !value.include?(new_value)
-          value << new_value
-        end
-      }
+
+      self.routes[name]=[options.has_key?(:nested) ? options[:nested] : true,options[:route]]
+      self.controllers[name]=options[:controller] if options.has_key?(:controller)
 
       if options[:path]
         require File.join(options[:path],name.to_s)

data/lib/lolita/configuration/base.rb

@@ -1,76 +1,76 @@
-# Every class that include Lolita::Configuration this module assign
-# #lolita and #lolita= methods. First one is for normal Lolita configuration
-# definition, and the other one made to assing Lolita to class as a Lolita::Configuration::Base
-# object. You may want to do that to change configuration or for testing purpose.
-module Lolita
-  module Configuration
-    # Lolita could be defined inside of any class that is supported by Lolita::Adapter, for now that is
-    # * ActiveRecord::Base
-    # * Mongoid::Document
-    # Main block can hold these methods:
-    # <tt>list</tt> - List definition, see Lolitia::Configuration::List
-    # <tt>tab</tt> - Tab definition, see Lolita::Configuration::Tab
-    # <tt>tabs</tt> - Tabs definition, see Lolita::Configuration::Tabs
-    class Base
-
-      attr_reader :dbi,:klass
-      @@generators=[:tabs,:list]
-      class << self
-        def add_generator(method)
-          @@generators<<method.to_sym
-        end
-      end
-      # When configuration is defined in class than you don't need to worry about
-      # creating new object, because Lolita itself create it for that class.
-      # New object is created like when you define it in class, but <i>parent_class</i>
-      # must be given.
-      # ====Example
-      #     class Person < ActiveRecord::Base
-      #        include Lolita::Configuration
-      #        lolita
-      #     end
-      #     Person.lolita.klass #=> Person
-      #     # Init Lolita by youself
-      #
-      #     class Person < ActiveRecord::Base
-      #       include Lolita::Configuration
-      #     end
-      #     Person.lolita=Lolita::Configuration::Base.new(Person)
-      #     Person.lolita.klass #=> Person
-      def initialize(orm_class,&block)
-        @klass=orm_class
-        @dbi=Lolita::DBI::Base.new(orm_class)
-        block_given? ? self.instance_eval(&block) : self.generate!
-      end
-
-
-      # Create list variable for ::Base class and create lazy object of Lolita::LazyLoader.
-      # See Lolita::Configuration::List for more information.
-      def list &block
-        Lolita::LazyLoader.lazy_load(self,:@list,Lolita::Configuration::List,@dbi,&block)
-      end
-
-      # Create collection of Lolita::Configuration::Tab, loading lazy.
-      # See Lolita::Configuration::Tabs for details.
-      def tabs &block
-        Lolita::LazyLoader.lazy_load(self, :@tabs,Lolita::Configuration::Tabs,@dbi,&block)
-      end
-
-      # Shortcut for Lolita::Configuration::Tabs <<.
-      # Tabs should not be defined in lolita block to create onew or more Lolita::Configuration::Tab
-      # See Lolita::Configuration::Tab for details of defination.
-      def tab *args, &block
-        self.tabs<<Lolita::Configuration::Tab.add(@dbi,*args,&block)
-      end
-      
-      # Call all supported instance metods to set needed variables and initialize object with them.
-      def generate!
-        @@generators.each{|generator|
-          self.send(generator)
-        }
-      end
-      
-    end
-  end
-end
-
+# Every class that include Lolita::Configuration this module assign
+# #lolita and #lolita= methods. First one is for normal Lolita configuration
+# definition, and the other one made to assing Lolita to class as a Lolita::Configuration::Base
+# object. You may want to do that to change configuration or for testing purpose.
+module Lolita
+  module Configuration
+    # Lolita could be defined inside of any class that is supported by Lolita::Adapter, for now that is
+    # * ActiveRecord::Base
+    # * Mongoid::Document
+    # Main block can hold these methods:
+    # <tt>list</tt> - List definition, see Lolitia::Configuration::List
+    # <tt>tab</tt> - Tab definition, see Lolita::Configuration::Tab
+    # <tt>tabs</tt> - Tabs definition, see Lolita::Configuration::Tabs
+    class Base
+
+      attr_reader :dbi,:klass
+      @@generators=[:tabs,:list]
+      class << self
+        def add_generator(method)
+          @@generators<<method.to_sym
+        end
+      end
+      # When configuration is defined in class than you don't need to worry about
+      # creating new object, because Lolita itself create it for that class.
+      # New object is created like when you define it in class, but <i>parent_class</i>
+      # must be given.
+      # ====Example
+      #     class Person < ActiveRecord::Base
+      #        include Lolita::Configuration
+      #        lolita
+      #     end
+      #     Person.lolita.klass #=> Person
+      #     # Init Lolita by youself
+      #
+      #     class Person < ActiveRecord::Base
+      #       include Lolita::Configuration
+      #     end
+      #     Person.lolita=Lolita::Configuration::Base.new(Person)
+      #     Person.lolita.klass #=> Person
+      def initialize(orm_class,&block)
+        @klass=orm_class
+        @dbi=Lolita::DBI::Base.new(orm_class)
+        block_given? ? self.instance_eval(&block) : self.generate!
+      end
+
+
+      # Create list variable for ::Base class and create lazy object of Lolita::LazyLoader.
+      # See Lolita::Configuration::List for more information.
+      def list &block
+        Lolita::LazyLoader.lazy_load(self,:@list,Lolita::Configuration::List,@dbi,&block)
+      end
+
+      # Create collection of Lolita::Configuration::Tab, loading lazy.
+      # See Lolita::Configuration::Tabs for details.
+      def tabs &block
+        Lolita::LazyLoader.lazy_load(self, :@tabs,Lolita::Configuration::Tabs,@dbi,&block)
+      end
+
+      # Shortcut for Lolita::Configuration::Tabs <<.
+      # Tabs should not be defined in lolita block to create onew or more Lolita::Configuration::Tab
+      # See Lolita::Configuration::Tab for details of defination.
+      def tab *args, &block
+        self.tabs<<Lolita::Configuration::Tab.add(@dbi,*args,&block)
+      end
+      
+      # Call all supported instance metods to set needed variables and initialize object with them.
+      def generate!
+        @@generators.each{|generator|
+          self.send(generator)
+        }
+      end
+      
+    end
+  end
+end
+