lolita 3.0.4 → 3.0.5

data/features/support/env.rb

@@ -0,0 +1,73 @@
+# IMPORTANT: This file is generated by cucumber-rails - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a 
+# newer version of cucumber-rails. Consider adding your own code to a new file 
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# files.
+
+ENV["RAILS_ENV"] ||= "test"
+require File.expand_path(File.dirname(__FILE__) + '/../../spec/rails_app/config/environment')
+
+require 'cucumber/formatter/unicode' # Remove this line if you don't want Cucumber Unicode support
+require 'cucumber/rails/world'
+require 'cucumber/rails/active_record'
+require 'cucumber/web/tableish'
+
+require 'capybara/rails'
+require 'capybara/cucumber'
+require 'capybara/session'
+#require 'cucumber/rails/capybara_javascript_emulation' # Lets you click links with onclick javascript handlers without using @culerity or @javascript
+# Capybara defaults to XPath selectors rather than Webrat's default of CSS3. In
+# order to ease the transition to Capybara we set the default here. If you'd
+# prefer to use XPath just remove this line and adjust any selectors in your
+# steps to use the XPath syntax.
+Capybara.default_selector = :css
+
+require 'akephalos'
+Capybara.default_driver = :akephalos
+#Capybara.default_driver = :selenium
+
+# If you set this to false, any error raised from within your app will bubble 
+# up to your step definition and out to cucumber unless you catch it somewhere
+# on the way. You can make Rails rescue errors and render error pages on a
+# per-scenario basis by tagging a scenario or feature with the @allow-rescue tag.
+#
+# If you set this to true, Rails will rescue all errors and render error
+# pages, more or less in the same way your application would behave in the
+# default production environment. It's not recommended to do this for all
+# of your scenarios, as this makes it hard to discover errors in your application.
+ActionController::Base.allow_rescue = false
+
+# If you set this to true, each scenario will run in a database transaction.
+# You can still turn off transactions on a per-scenario basis, simply tagging 
+# a feature or scenario with the @no-txn tag. If you are using Capybara,
+# tagging with @culerity or @javascript will also turn transactions off.
+#
+# If you set this to false, transactions will be off for all scenarios,
+# regardless of whether you use @no-txn or not.
+#
+# Beware that turning transactions off will leave data in your database 
+# after each scenario, which can lead to hard-to-debug failures in 
+# subsequent scenarios. If you do this, we recommend you create a Before
+# block that will explicitly put your database in a known state.
+#Cucumber::Rails::World.use_transactional_fixtures = true
+# How to clean your database when transactions are turned off. See
+# http://github.com/bmabey/database_cleaner for more info.
+if defined?(ActiveRecord::Base)
+  begin
+    require 'database_cleaner'
+    DatabaseCleaner.strategy = :truncation
+  rescue LoadError => ignore_if_database_cleaner_not_present
+  end
+end
+
+require 'mongoid'
+Mongoid.configure do |config|
+  name = "lolita3_test"
+  host = "localhost"
+  config.master = Mongo::Connection.new.db(name)
+  config.slaves = [
+    Mongo::Connection.new(host, 27017, :slave_ok => true).db(name)
+  ]
+  #config.use_object_ids = true
+  config.persist_in_safe_mode = false
+end

data/features/support/paths.rb

@@ -0,0 +1,35 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+
+    when /list/
+      lolita_posts_path
+    when /the home\s?page/
+      '/'
+
+    # Add more mappings here.
+    # Here is an example that pulls values out of the Regexp:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    else
+      begin
+        page_name =~ /the (.*) page/
+        path_components = $1.split(/\s+/)
+        self.send(path_components.push('path').join('_').to_sym)
+      rescue Object => e
+        raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+          "Now, go and add a mapping in #{__FILE__}"
+      end
+    end
+  end
+end
+
+World(NavigationHelpers)

data/lib/lolita.rb

@@ -83,6 +83,10 @@ module Lolita
     end
   end
 
+  module Test
+    autoload :Matchers, 'lolita/test/matchers'
+  end
+  
   module Controllers
     autoload :InternalHelpers, 'lolita/controllers/internal_helpers'
     autoload :UserHelpers, 'lolita/controllers/user_helpers'
@@ -124,9 +128,7 @@ end
 engine_time=Time.now
 
 if defined?(Rails)
-  require 'lolita/mapping'
-  require 'lolita/rails'
-  require 'lolita/modules'
+  require 'lolita/rails/all'
 end
 
 puts "Lolita engine started in #{Time.at(Time.now-engine_time).strftime("%M:%S.%3N")}"

data/lib/lolita/adapter/abstract_adapter.rb

@@ -8,6 +8,7 @@ module Lolita
       abstract_method 'name',:reflect_on_association
       abstract_method 'association',:association_macro,:association_class_name
       abstract_method 'id',:find_by_id
+      abstract_method '*args', :find
     end
   end
 end

data/lib/lolita/adapter/active_record.rb

@@ -57,6 +57,10 @@ module Lolita
         self.klass.where(:id=>id).first
       end
       
+      def find(*args)
+        self.klass.find(*args)
+      end
+
       def paginate(opt={})
         #FIXME depend on will_paginate
         if order=opt.delete(:sort)

data/lib/lolita/adapter/mongoid.rb

@@ -56,6 +56,10 @@ module Lolita
         self.klass.where(:_id=>id).first
       end
 
+      def find *args
+        self.klass.find(*args)
+      end
+
       def paginate(options={})
         self.klass.paginate(options)
       end

data/lib/lolita/base_configuration.rb

@@ -1,8 +1,10 @@
 module Lolita
+  # Base::Configuration methods are accessable through Lolita module.
+  # Like Lolita.modules and Lolita.routes and so on.
   class BaseConfiguration
   
     attr_reader :scope, :modules, :routes, :controllers
-    attr_accessor :mappings,:default_module,:user_classes,:authentication
+    attr_accessor :mappings,:default_route,:user_classes,:authentication
 
     def initialize(scope)
       @scope=scope
@@ -14,30 +16,57 @@ module Lolita
       @controllers={}
     end
 
-    def use(module_name)
+    def conditional_routes(klass=nil)
+      @routes.map{|name,route|
+        if route.is_a?(Proc)
+          route.call(klass)
+        else
+          nil
+        end
+      }.compact
+    end
 
+    # Include module in Lolita, don't know why i need this
+    def use(module_name)
+      Lolita.send(:include,module_name)
     end
 
     def add_mapping(resource,options={})
       mapping = Lolita::Mapping.new(resource, options)
       self.mappings[mapping.name] = mapping
-      #self.default_scope ||= mapping.name
       mapping
     end
 
-    def add_module name, options={}
-      options.assert_valid_keys(:controller,:route,:model,:path)
-      self.modules<<name.to_sym
+    # Add new module to Lolita
+    # Accpted options
+    # * <tt>controller</tt> - not in use
+    # * <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
+    # lolita_rest is called, but if route with resource name is found, than by default this route will be drawn.
+    # Like lolita_for :posts, can go to different controller than rest and do other things.
+    # * <tt>:path</tt> - some file that will be included. Deprecated will be removed
+    # ====Example
+    #     Lolita.add_module Lolita::Posts, :route=>:post, :name=>:post
+    #     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.
+    def add_module module_container, options={}
+      options.assert_valid_keys(:controller,:route,:model,:path,:name)
+      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]==true ? name : options[key]
+        new_value=options[key]
         if value.is_a?(Hash)
           value[name]=new_value
-        elsif !value.include?(new_value)
+        elsif value.is_a?(Proc)
+          value[name]=new_value
+        elsif value.respond_to?(:include?) && !value.include?(new_value)
           value << new_value
         end
       }
@@ -45,11 +74,20 @@ module Lolita
       if options[:path]
         require File.join(options[:path],name.to_s)
       end
-      #    if options[:model]
-      #      model_path = (options[:model] == true ? "lolita/models/#{name}" : options[:model])
-      #      Lolita::Models.send(:autoload, name.to_s.camelize.to_sym, model_path)
-      #    end
+  
     end
 
+    # Lolita.extend_route_for(:any,:posts,:file_upload) do |resource|
+    #   if resource.tabs.by_type(:metadata)
+    #     with do
+    #       resources :metadata
+    #     end 
+    #   end
+    #end
+    # :any for any
+    # lolita/posts/metadata
+    # lolita/posts/files/metadata
+    def lolita_extend_route_for()
+    end
   end
 end

data/lib/lolita/configuration/tab.rb

@@ -23,8 +23,8 @@ module Lolita
       
         def add(dbi,*args,&block)
           type=args.first if args
-          unless type
-            temp_tab=self.new(dbi,*args,&block).type 
+          if !type || type==:default
+            temp_tab=self.new(dbi,*args,&block)
             type=temp_tab.type
           end
           unless type==:default
@@ -34,15 +34,15 @@ module Lolita
               raise Lolita::TabNotFoundError, "Lolita::Configuration::#{type.to_s.camelize}Tab not found. Add it in /lolita/configuration/tab/#{type}.rb"
             end
           else
-            temp
+            temp_tab
           end
         end
       end
       # For different types there are different builders(cells)
       @@available_types=[:content]
    
-      lolita_accessor :title,:name
-      attr_accessor :dbi,:type,:current_fieldset,:current_dbi
+      lolita_accessor :title,:name,:type
+      attr_accessor :dbi,:current_fieldset,:current_dbi
       attr_reader :field_sets,:nested_form
 
       # To create new tab the following parametrs need to be provided.
@@ -160,7 +160,7 @@ module Lolita
       def set_attributes *args
         if args
           options=args.extract_options!
-          self.type=args.first || :default
+          self.type=args.first if args.first.is_a?(Symbol)
           options.each{|method,options|
             self.send(:"#{method}=",options)
           }
@@ -175,6 +175,7 @@ module Lolita
       end
 
       def set_default_attributes
+        @type=:default unless @type
         @name="tab_#{self.__id__}" unless @name
         @title=@type.to_s.humanize unless @title
       end

data/lib/lolita/configuration/tabs.rb

@@ -1,5 +1,9 @@
 module Lolita
   module Configuration
+    # Lolita::Configuration::Tabs is container class that holds all
+    # tabs for each lolita instance. 
+    # Also it has some useful methods.
+
     class Tabs
       include Enumerable
       include Lolita::ObservedArray
@@ -38,6 +42,10 @@ module Lolita
         self<<Lolita::Configuration::Tab.add(@dbi,*args,&block)
       end
 
+      def by_type(type)
+        @tabs.detect{|tab| tab.type==type.to_sym}
+      end
+
       def exclude=(values)
         exclude(values)
       end
@@ -77,6 +85,7 @@ module Lolita
           }
         end
       end
+
       private
 
       def create_content_tab

data/lib/lolita/mapping.rb

@@ -3,6 +3,7 @@ module Lolita
     attr_reader :class_name,:path,:singular,:plural,:path_prefix,:module,:controllers,:as
     alias :name :singular
     
+    # TODO how it is when lolita plugin extend default path and there is module is this not break the logic?
     def initialize(name,options={})
       @plural=name.to_sym#(options[:as] ? "#{options[:as]}_#{name}" : name).to_sym
       @singular=(options[:singular] || @plural.to_s.singularize).to_sym
@@ -12,7 +13,9 @@ module Lolita
       @path=(options[:path] || "lolita").to_s
       @module=options[:module] 
       mod=@module ? nil :  "lolita/"
-      @controllers=Hash.new{|h,k| h[k]="#{mod}#{k}" }
+      @controllers=Hash.new{|h,k|
+        h[k]="#{mod}#{k}" 
+      }
     end
     #
     # lolita/posts/new => lolita/crud/new :class=>Post

data/lib/lolita/modules.rb

@@ -1,20 +1,6 @@
-Lolita.add_module :rest, :route=>true, :path=>File.expand_path(File.join(__FILE__,'..','modules'))
-Lolita.default_module=:rest
+require "lolita/modules/rest"
+
+Lolita.default_route = :rest
 
 
-#Lolita.add_module :pictures
-# Lolita.use(:blogs)
-# Lolita.use(:threads)
-# Lolita.use :lolita-devise-admins
-# require 'lolita-devise-users'
-# /lolita/admins
-# /lolita/admin/1/edit
-#Lolita.add_module :statistic, :route=>true
-# lolita/questions/statistic => lolita/statistic/index
-# lolita_modules :statistic
-# Lolita.mapping[:posts].to.lolita.modules.each do |m|
-#   lolita_rest
-#   lolita_statistic -> lolita/questions/statistic
-#   lolita_gallery -> lolita/questions/add_image
-#Lolita.mount :blog, :route=>true # lolita/blog
 

data/lib/lolita/rails/all.rb

@@ -0,0 +1,3 @@
+require 'lolita/mapping'
+require 'lolita/rails'
+require 'lolita/modules'

data/lib/lolita/rails/routes.rb

@@ -5,13 +5,14 @@ module ActionDispatch::Routing
     # Every module, that is used with lolita and has routes, need to have
     # <code>resource method</code>, for example, lolita_rest, that should be added
     # to ActionDispatch::Routing::Mapper class, as a *protected* method.
-    # Module can automaticliy add resource route or live it to user.
+    # Module can automaticliy add resource route or allow user to do it.
     # ====Example
-    #     Lolita.add_module :admins
+    #     Lolita.add_module Lolita::Gallery,:route=>:gallery
     #     # in route.rb
-    #     lolita_for :admins
-    #     # if admins have route added, than new route will point to these module controller
+    #     lolita_for :galleries
+    #     # lolita_for try to call :lolita_gallery in Mapper class
     def lolita_for *resources
+      #TODO refactor
       options = resources.extract_options!
 
       if as = options.delete(:as)
@@ -42,12 +43,15 @@ module ActionDispatch::Routing
             elsif target_class.respond_to?(:lolita) && target_class.instance_variable_get(:@lolita).nil?
                raise Lolita::NotInitialized, "Call lolita method in #{target_class}."
             else
-              route=Lolita::routes[mapping.name] || Lolita::routes[Lolita.default_module]
+              route=Lolita.routes[mapping.name] || Lolita.default_route
             end
             unless route
               raise Lolita::ModuleNotFound, "Module #{mapping.name.to_s.capitalize} not found! Add Lolita.use(:#{mapping.name}) to initializers/lolita.rb"
             end
             send(:"lolita_#{route}",mapping,mapping.controllers)
+            Lolita.conditional_routes(target_class).each do |route_name|
+              send(:"lolita_#{route_name}",mapping,mapping.controllers)
+            end
           end
         end
       }

data/lib/lolita/test/matchers.rb

@@ -0,0 +1,77 @@
+module Lolita
+  module Test
+    # Matchers that make easier to test Lolita and Lolita addons
+    module Matchers
+
+      class BeRoutable
+      
+        def matches?(actual)
+          @actual=actual
+          collect_routes
+          set_method_and_url
+          result=@routes.detect{|route| 
+            method_match(route) && @url.to_s.match(route[:path_info])
+          }
+          !!result
+        end
+
+        def failure_message
+          "expected #{@url.inspect}#{@method ? " with method #{@method.inspect}" : ""} to be routable"
+        end
+        def negative_failure_message
+          "expected #{@url.inspect}#{@method ? " with method #{@method.inspect}" : ""}  to not be routable"
+        end
+
+        private
+
+        def method_match(route)
+          if route[:request_method]
+            if @method
+              @method.to_s.upcase.match(route[:request_method])
+            else
+              false
+            end
+          else
+            true
+          end
+        end
+
+        def set_method_and_url
+          if @actual.is_a?(Hash)
+            @method,@url=@actual.keys.first,@actual.values.first
+          elsif @actual.is_a?(Array)
+            if @actual.size>=2
+              @method,@url=@actual[0],@actual[1]
+            elsif
+              @url=@actual.first
+            end
+          else
+            @url=@actual.to_s
+          end
+        end
+
+        def collect_routes
+          @routes=[]
+          all_applications.each do |application|
+            @routes+=application.routes.routes.map(&:conditions)
+          end
+        end
+
+        def all_applications
+          if defined?(Rails) && defined?(Rails::Application)
+            ObjectSpace.each_object(Rails::Application).select { |klass|
+             klass.class < Rails::Application 
+            }.map(&:class)
+          else
+            []
+          end
+        end
+      end
+
+       def be_routable
+        BeRoutable.new
+      end
+    end
+  end
+end
+