lolita 3.2.0.rc.7 → 3.2.0.rc.9

data/lib/generators/lolita/uninstall_generator.rb

@@ -0,0 +1,76 @@
+module Lolita
+  module Generators
+    class UninstallGenerator < Rails::Generators::Base
+      ROUTE_NAME = "lolita_for"
+      INCLUDE_MODULE = "Lolita::Configuration"
+      MODEL_METHOD = "lolita"
+
+      desc "Uninstall Lolita and remove all dependencies"
+
+      def ask_to_continue
+        #ask("Do you want to remove initializer, clear routes and remove Lolita from models? [y]es/[n]o")
+      end
+      # Remove lolita initializer file
+      def remove_initializer
+        if File.exist?(Rails.root + "config/initializers/lolita.rb")
+          remove_file "config/initializers/lolita.rb"
+        end
+      end
+
+      # Remove all not-commented lines that begins with lolita_for
+      def clear_routes
+        gsub_file File.join(Rails.root,"config","routes.rb"), /^\s*#{ROUTE_NAME}.*/ do |match|
+          match.clear
+          match
+        end
+      end
+
+      # Remove configuration include line and lolita block or single lolita method call.
+      # Block will be removed correctly if it starts with _do_ and ends with _end_. 
+      def clear_models
+        Dir[File.join(Rails.root,"app","models","*.rb")].each do |file_name|
+          matched = false
+          gsub_file file_name, /^\s*include\s+#{INCLUDE_MODULE}.*/ do |match|
+            matched = true
+            match.clear
+            match
+          end
+          if matched
+            new_lines = []
+            File.open(file_name,"r") do |file|
+              do_count = nil
+              file.each_line do |line|
+                if do_count.nil?
+                  if line.match(/^(\s*)lolita\s+(do)?/)
+                    if $2 == "do"
+                      do_count = 1
+                    else
+                      do_count = 0
+                    end
+                  else
+                    new_lines << line
+                  end
+                elsif do_count > 0
+                  if line.match(/(^|\s+)do(\s+|$)/)
+                    do_count +=1
+                  elsif line.match(/(^|\s+)end(\s+|$)/)
+                    do_count -=1
+                  end
+                else
+                  new_lines << line
+                end
+              end
+            end
+            File.open(file_name,"w") do |file|
+              new_lines.each do |line|
+                file.puts(line)
+              end
+            end
+
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita.rb

@@ -1,208 +1,142 @@
 
-$:<<File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
-LOLITA_VERSION=File.read(File.expand_path("../../VERSION",__FILE__)).gsub(/[^.\w]/,"")
-FRAMEWORK = if defined?(Rails)
-  " with Rails #{::Rails::VERSION::STRING}"
-end
-puts "=> Lolita #{LOLITA_VERSION} starting#{FRAMEWORK}"
-
-require "rubygems"
-require 'abstract'
-
-require 'active_support'
-require 'active_support/core_ext/numeric/time'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/concern'
-require 'active_support/callbacks'
-require 'active_support/dependencies'
-require 'active_support/inflector'
-
-
-require 'lolita/errors'
-require "lolita/hooks"
-# Require all ruby extensions
-Dir["#{File.dirname(__FILE__)}/lolita/ruby_ext/**/*.*"].each do |path|
-  require path
-end
+require 'lolita/version'
 
 module Lolita
-  include Lolita::Hooks
-  add_hook :before_setup, :after_setup, :after_routes_loaded,:before_routes_loaded
-  
-  autoload(:LazyLoader,'lolita/lazy_loader')
-  autoload(:VERSION,'lolita/version')
-  autoload(:ObservedArray,'lolita/observed_array')
-  autoload(:Builder,'lolita/builder')
-  autoload(:ControllerAdditions,'lolita/controller_additions')
-  module Builder
-    autoload(:Custom, 'lolita/builder')
-  end
 
-  module SystemConfiguration
-    autoload :Base, 'lolita/system_configuration/base'
-    autoload :Application, 'lolita/system_configuration/application'
-  end
+  CONFIGURATIONS = {}
+  DEFAULT_CONFIGURATION_NAME = :default
 
-  module Adapter
-    autoload :FieldHelper, 'lolita/adapter/field_helper'
-    autoload :AbstractAdapter, 'lolita/adapter/abstract_adapter'
-    autoload :ActiveRecord, 'lolita/adapter/active_record'
-    autoload :Mongoid, 'lolita/adapter/mongoid'
+  def self.configuration name = nil
+    name ||= DEFAULT_CONFIGURATION_NAME
+    CONFIGURATIONS[name] ||= Lolita::SystemConfiguration::Base.new(name)
+    CONFIGURATIONS[name]
   end
 
-  module DBI
-    autoload :Base, 'lolita/dbi/base'
+  def self.setup
+    self.run(:before_setup)
+    yield configuration
+    self.run(:after_setup)
   end
   
-  module Hooks
-    autoload :NamedHook, "lolita/hooks/named_hook"
+  def self.root
+    @@root||=File.expand_path("#{__FILE__}/../..")
   end
- 
-  # Keep all configuration classes and modules, that is used to configure classes with lolita.
-  module Configuration
-
-    autoload :Base, 'lolita/configuration/base'
-    autoload :Column, 'lolita/configuration/column'
-    autoload :Columns, 'lolita/configuration/columns'
-    autoload :Fields, 'lolita/configuration/fields'
-    autoload :FieldSet, 'lolita/configuration/field_set'
-    autoload :List, 'lolita/configuration/list'
-    autoload :Tabs, 'lolita/configuration/tabs'
-    autoload :Filter, 'lolita/configuration/filter'
-    autoload :NestedForm, 'lolita/configuration/nested_form'
-    autoload :Search, 'lolita/configuration/search'
-
-    # Module contains classes that is used to create specific type class based on given arguments.
-    module Factory
-      autoload :Field, "lolita/configuration/factory/field"
-      autoload :Tab, "lolita/configuration/factory/tab"
-    end
-
-    # Contains all supported field types. Class name is Lolita::Configuration::Field::[FieldType]
-    module Field
-      autoload :Base,'lolita/configuration/field'
-      Dir["#{File.dirname(__FILE__)}/lolita/configuration/field/**/*.*"].each do |path|
-        base_name=File.basename(path,".rb")
-        autoload :"#{base_name.camelize}", "lolita/configuration/field/#{base_name}"
-      end
-    end
 
-    module Tab
-      autoload :Base, 'lolita/configuration/tab'
-      ["tab"].each do |type|
-        Dir["#{File.dirname(__FILE__)}/lolita/configuration/#{type}/**/*.*"].each do |path|
-          base_name=File.basename(path,".rb")
-          autoload :"#{base_name.camelize}", "lolita/configuration/#{type}/#{base_name}"
-        end
-      end
-    end
-    
-    def self.included(base)
-      base.class_eval do
-        include Lolita::Hooks
-        add_hook :after_lolita_loaded
-
-        extend ClassMethods
-        def lolita
-          self.class.lolita
-        end
-      end
-    end
-
-    module ClassMethods
-      def lolita(&block)
-        Lolita::LazyLoader.lazy_load(self,:@lolita,Lolita::Configuration::Base,self,&block)
-      end
-      
-      def lolita=(value)
-        if value.is_a?(Lolita::Configuration::Base)
-          @lolita=value
-        else
-          raise ArgumentError.new("Only Lolita::Configuration::Base is acceptable.")
+  def self.app_root
+    @@app_root||=File.join(File.expand_path("#{__FILE__}/../.."),"app")
+  end
+  
+  def self.method_missing method_name, *args, &block
+    self.class_eval <<-LOLITA_SETUP,__FILE__,__LINE__+1
+      class << self
+        def #{method_name}(*args,&block)
+          configuration.send(:#{method_name},*args,&block)
         end
       end
-    end
+    LOLITA_SETUP
+    configuration.send(method_name,*args,&block)
   end
 
-  module Test
-    autoload :Matchers, 'lolita/test/matchers'
-  end
+  def self.load!
+    load_frameworks!
+    load_dependencies!
+    load_base!
+
+    self.send(:include, Lolita::Hooks)
+    self.send(:add_hook, :before_setup, :after_setup, :after_routes_loaded,:before_routes_loaded)
+
   
-  module Controllers
-    autoload :InternalHelpers, 'lolita/controllers/internal_helpers'
-    autoload :UserHelpers, 'lolita/controllers/user_helpers'
-    autoload :UrlHelpers, 'lolita/controllers/url_helpers'
-    autoload :ComponentHelpers, 'lolita/controllers/component_helpers'
-    autoload :AuthorizationHelpers, 'lolita/controllers/authorization_helpers'
+    if rails?
+      load_rails!
+    end
+    load_modules!
   end
 
-  module Navigation
-    autoload :Tree, "lolita/navigation/tree"
-    autoload :Branch, "lolita/navigation/branch"
+  def self.load_frameworks!
+    frameworks.each do |framework|
+      begin
+        require framework 
+        puts " => Loading Lolita #{version} with #{framework}"
+      rescue Execption => e
+        raise "Can't load #{framework}. Check you Gemfile."
+      end
+    end
   end
 
-  module Support
-    autoload :Formatter, 'lolita/support/formatter'
-    class Formatter
-      autoload :Rails, 'lolita/support/formatter/rails'
+  def self.frameworks
+    frameworks = []
+    if rails?
+      frameworks << "rails"
+    end
+    frameworks
+  end
+
+  def self.load_dependencies!
+    require 'abstract'
+    require 'observer'
+    require 'ostruct'
+    require "base64"
+    require 'active_support'
+    require 'active_support/core_ext/numeric/time'
+    require 'active_support/core_ext/date_time/conversions'
+    require 'active_support/concern'
+    require 'active_support/callbacks'
+    require 'active_support/dependencies'
+    require 'active_support/inflector'
+  end
+
+  def self.load_base!
+    Dir["#{File.dirname(__FILE__)}/lolita/ruby_ext/**/*.*"].each do |path|
+      require path
     end
+    require 'lolita/errors'
+    require 'lolita/utils'
+    require 'lolita/hooks'
+    require 'lolita/mapping'
+    require 'lolita/hooks/named_hook'
+    require 'lolita/system_configuration/base'
+    require 'lolita/system_configuration/application'
+    require 'lolita/extensions/extensions'
   end
 
-  module Search
-    autoload :Simple, 'lolita/search/simple'
-  end
+  def self.load_modules!
+    require 'lolita/base'
+    require 'lolita/orm'
+    require 'lolita/configuration'
+    require 'lolita/helpers'
+    require 'lolita/processors/request_processor'
+    require 'lolita/navigation/tree'
+    require 'lolita/navigation/branch'
 
-  @@scopes={}
+    require 'lolita/test/matchers'
+    require 'lolita/support/formatter'
+    require 'lolita/support/formatter/rails'
 
-  def self.scope name=nil
-    name||=scope_name
-    @@scopes[name]||=Lolita::SystemConfiguration::Base.new(name)
-    @@scopes[name]
+    require 'lolita/search/simple'
+    require 'lolita/components/base'
+    require 'lolita/components/configuration/column_component'
   end
 
-  def self.setup
-    self.run(:before_setup)
-    yield scope
-    self.run(:after_setup)
+  def self.load_rails!
+    require 'kaminari'
+    require 'tinymce-rails'
+    require 'jquery-rails'
+    require 'lolita/rails/railtie'
+    require 'lolita/rails/engine'
   end
 
-  def self.scope_name
-    :default
-  end
-  
-  def self.root
-    @@root||=File.expand_path("#{__FILE__}/../..")
+  def self.version
+    Lolita::Version::STRING
   end
 
-  def self.app_root
-    @@app_root||=File.join(File.expand_path("#{__FILE__}/../.."),"app")
-  end
-  
-  def self.method_missing method_name, *args, &block
-    self.class_eval <<-LOLITA_SETUP,__FILE__,__LINE__+1
-      class << self
-        def #{method_name}(*args,&block)
-          scope.send(:#{method_name},*args,&block)
-        end
-      end
-    LOLITA_SETUP
-    scope.send(method_name,*args,&block)
+  def self.rails?
+    defined?(::Rails)
   end
 
   def self.rails3?
     defined?(::Rails) && ::Rails::VERSION::MAJOR == 3
   end
-
-  module Generators
-    autoload :FileHelper, File.join(Lolita.root,"lib","generators","helpers","file_helper")
-  end
-  
 end
 
-if Lolita.rails3?
-  require "base64"
-  require 'kaminari'
-  require 'tinymce-rails'
-  require 'jquery-rails'
-  require 'lolita/rails/all'
-end
+
+Lolita.load!

data/lib/lolita/adapter/abstract_adapter.rb

@@ -9,6 +9,7 @@ module Lolita
       abstract_method 'name',:reflect_on_association,:field_by_name,:field_by_association
       abstract_method 'id',:find_by_id
       abstract_method 'query', :search
+      abstract_method 'access_modes_for', :record
     end
   end
 end

data/lib/lolita/adapter/active_record.rb

@@ -23,14 +23,30 @@ module Lolita
           @association.send(method,*args,&block)
         end
 
-        def key
-          if @association.macro == :belongs_to 
-            @association.foreign_key
+        def key # maybe this isn't neccessery any more
+          if @association.macro == :has_and_belongs_to_many || through?
+            association_key
           else
-            @association.association_foreign_key
+            @association.foreign_key
           end 
         end
 
+        def association_key
+          @association.association_foreign_key
+        end
+
+        def foreign_key
+          @association.foreign_key
+        end
+
+        def through
+          @association.options[:through]
+        end
+
+        def through?
+          @association.options.has_key?(:through)
+        end
+
         def polymorphic?
           @association.options[:polymorphic]
         end
@@ -61,20 +77,6 @@ module Lolita
         @associations
       end
 
-      # Return all association class names
-      def associations_class_names
-        self.associations.map{|name,association|
-          association.class_name
-        }
-      end
-
-      # Detect if class reflect on association by name
-      def reflect_on_association(name)
-        if orm_association = klass.reflect_on_association(name)
-          Association.new(orm_association,self)
-        end
-      end
-
       # Each field from ORM is changed to this class instance.
       class Field
         include Lolita::Adapter::FieldHelper
@@ -141,6 +143,8 @@ module Lolita
         end
       end # end of field
 
+      include Lolita::Adapter::CommonHelper
+
       def fields
         @fields||=self.klass.columns.collect{|column|
           Field.new(column,self)
@@ -163,43 +167,6 @@ module Lolita
         end
       end
 
-      def find_by_id(id)
-        self.klass.unscoped.find_by_id(id)
-      end
-
-      # This method is used to paginate, main reason is for list and for index action. 
-      # Method accepts three arguments
-      # <tt>page</tt> - page that should be shown (integer)
-      # <tt>per</tt> - how many records there should be in page
-      # <tt>options</tt> - Hash with optional information. 
-      # By default, Lolita::Configuration::List passes request, with current request information.
-      # Also it passes <i>:pagination_method</i> that is used to detect if there is special method(-s) in model
-      # that should be used for creating page.
-      def paginate(page,per,options ={})
-        scope = nil
-        if options[:pagination_method]
-          if options[:pagination_method].respond_to?(:each)
-            options[:pagination_method].each do |method_name|
-              options[:previous_scope] = scope
-              if new_scope = pagination_scope_from_klass(method_name,page,per,options)
-                scope = scope ? scope.merge(new_scope) : new_scope
-              end
-            end
-          else
-            scope = pagination_scope_from_klass(options[:pagination_method],page,per,options)
-          end
-          scope
-        else
-          klass.unscoped.page(page).per(per)
-        end
-      end
-
-      def pagination_scope_from_klass(method_name,page,per,options)
-        if klass.respond_to?(method_name)
-          klass.send(method_name,page,per,options)
-        end
-      end
-
       def search(query, options = {})
         #TODO raise error or warn when there are lot of records and no index on field
         unless query.blank?