lolita 3.1.18 → 3.2.0.rc1

data/README.rdoc

@@ -1,100 +0,0 @@
-=Lolita
-
-Great Rails CMS, that turns your business logic into good-looking, fully functional workspace.
-==Demo
-See the demo page at Demo[http://lolita-demo.ithouse.lv]
-
-==Installation
-
-First install Lolita gem
-  sudo gem install lolita
-
-Then go to your rails project and 
- rails g lolita:install
-
-That will create initializer and copy all assets.
-Also it will call <em>install</em> on all added modules to lolita. 
-So if you in Gemfile have following
-  gem "lolita"
-  gem "lolita-file-upload"
-It will also call <i>lolita_file_upload:install</i>.
-==Usage
- 
-To make your model use Lolita do like this
-  class Post < ActiveRecord::Base
-    include Lolita::Configuration
-    lolita
-  end
-Then in routes.rb file make resources accessable for lolita with  
-  lolita_for :posts
-This will make routes like
-  /lolita/posts
-  /lolita/posts/1/edit
-  /lolita/posts/new
-Or open /lolita and it will redirect to first available resource list view.
-
-For more detailed usage read Usage[https://github.com/ithouse/lolita/wiki/Usage] at wiki.
-
-===Add authorization to Lolita
-
-Easiest way to add authentication is with Devise. First install Devise as gem, than add it to your project.
-Make Devise model, lets say, User. After that add these lines in <i>/config/initializers/lolita.rb</i>
-  config.user_classes << User
-  config.authentication = :authenticate_user!
-This will make before each Lolita requests call before filter, that than will call <em>authenticate_user!</em>
-that is Devise method for authenticating user. Without it Lolita will be acessable for everyone.
-You can also add any other authentication method like
-  config.authentication = :authenticate_admin
-And than put this method for common use in <em>ApplicationController</em> or in some other place that is accessable
-to all controllers.
-===Using newer version of Lolita
-
-If you decide to use some newer version, you most likely should copy new assets to your project. 
-This can be done with
-  rails g lolita:assets
-===Using hooks
-
-Lolita define hooks for RestController and for components.
-====RestController hooks
-
-There are two kind of hooks for all actions - <em>before_[action name]</em> and <em>after_[action name]</em>.
-Define callbacks for those hooks outside of controller. This will call User#log_action each time when #destroy 
-action is requested.
-   Lolita::RestController.before_destroy do
-      User.log_action("Going to delete #{params[:id]}") 
-   end
-Also you can define callbacks in your controllers that extend Lolita::RestController. This will call #set_default_params
-each time #new action is requested.
-   class PostController < Lolita::RestController
-      before_new :set_default_params
-
-      private
-
-      def set_default_params
-        params[:post][:title]="-Your title goes here-"
-      end
-  end
-====Component hooks
-
-Components have three hooks - <em>before</em>, <em>after</em> and <em>around</em>.
-Component hooks are different from controller hooks with names. Each component has it's own name, that is used to
-call component, like
-  render_component :"lolita/configuration/list/display"
-  #same as
-  render_component :"lolita/configuration/list", :display
-and this name is used to add callback for component. As components is not related to specific class, then there
-are only one way to define callback for them.
-  Lolita::Hooks.component(:"/lolita/configuration/list/display").before do
-    "<div>My Custom text</div>"
-  end
-That what are inside of blocks depends on place where you define callback if it is in <i>.rb</i> file, than you
-should put HTML in quotes, if in <i>.erb</i> and similar files then there is no need for that. Also blocks with 
-Ruby code only return last line, so you should probably define HTML as shown in previous example.
-For <b>around</b> callback if you pass block, then original content will be replaced with that, but if you want
-to let original content inside of your block content than it is done like this with #let_content method.
-  Lolita::Hooks.component(:"/lolita/configuration/list/display").around do
-    "<div style='color:red'>#{let_content}</div>"
-  end
-==License
-
-Lolita is under MIT license. See LICENSE.txt[https://github.com/ithouse/lolita/blob/master/LICENSE.txt]

data/app/controllers/lolita/field_data_controller.rb

@@ -1,36 +0,0 @@
-class Lolita::FieldDataController < ApplicationController
-  include Lolita::Controllers::UserHelpers
-
-  before_filter :authenticate_lolita_user!
-  before_filter :find_field, :except => [:autocomplete_field]
-
-  def array_polymorphic
-    klass = params[:class].camelize.constantize
-    data_collection = @field.polymorphic_association_values(:klass => klass)
-    @id = params[:id].to_s.to_i
-    @collection = [[]]+data_collection
-    render_component(*@field.build(:state => :options_for_select, :collection => @collection, :id => @id))
-  end
-
-  def find_field
-    @field = params[:field_class].camelize.constantize.lolita.tabs.fields.detect{|field|
-      field.name.to_s == params[:name].to_s
-    }
-  end
-
-	def autocomplete_field
-    klass = params[:field_class].camelize.constantize
-    field = klass.lolita.tabs.fields.detect{|field| field.name.to_s == params[:field_name]}
-    data = if field
-      (field.search || field.create_search(true)).run(params[:term],request).map do |record|
-        {
-          :id => record.id,
-          :value => record.send(field.current_text_method(field.association.klass)),
-          :name => "#{params[:field_class].downcase}[#{params[:field_name].singularize}_ids][]",
-          :delete_link => I18n.t("lolita.shared.delete")
-        }
-      end
-    end
-    render :json => data || {}
-	end
-end

data/app/views/components/lolita/configuration/field/array/autocomplete/_display.html.haml

@@ -1,11 +0,0 @@
-- ids_method = field.name.to_s.match(/_ids$/) ? field.name : "#{field.name.to_s.singularize}_ids"
-
-.autocomplete-container
-  = hidden_field_tag "#{resource_name}[#{ids_method}][]",""
-  = text_field_tag :"autocomplete-#{resource_name}", nil, :"data-autocomplete-url" => autocomplete_field_path(:field_class => tab_form.object.class.to_s, :field_name => field.name)
-  %ul
-    - resource.persisted? && resource.send(field.name).each do |element|
-      %li
-        = element.send(element.class.lolita.tabs.first.fields.first.name.to_sym)
-        = link_to I18n.t("lolita.shared.delete").downcase, nil
-        = hidden_field_tag "#{resource_name}[#{ids_method}][]", element.id

data/app/views/components/lolita/configuration/field/array/checkbox/_display.html.haml

@@ -1,8 +0,0 @@
-- ids_method = field.name.to_s.match(/_ids$/) ? field.name : "#{field.name.to_s.singularize}_ids"
-= hidden_field_tag "#{resource_name}[#{ids_method}][]",""
-- field.view_values(self).each do |value|
-  - editors = resource.send(:"#{ids_method}")
-  .habtm-container
-    = label_tag "#{resource_name}_#{field.name}_#{value.last}",value.first, :class => "habtm-label"
-    = check_box_tag "#{resource_name}[#{ids_method}][]", value.last, resource.send("#{ids_method}").include?(value.last), :id => "#{resource_name}_#{field.name}_#{value.last}", :class => "habtm-checkbox"
-.clear

data/app/views/components/lolita/configuration/field/array/polymorphic/_display.html.haml

@@ -1,6 +0,0 @@
-- record = tab_form.object
-- type_name = field.association.name.to_s + "_type"
-- id_name = field.association.name.to_s + "_id"
-
-= tab_form.select(type_name,field.polymorphic_classes, {:include_blank => true},{:"data-polymorphic-url" => array_field_data_collector_path(:name => field.name, :field_class => record.class.to_s, :class => "klass", :id =>record.send(id_name) || 0) })
-= tab_form.select(id_name, field.polymorphic_association_values(:record => record))

data/app/views/components/lolita/configuration/field/array/polymorphic/_options_for_select.html.haml

@@ -1 +0,0 @@
-= options_for_select(collection,id)

data/app/views/components/lolita/configuration/search/_display.html.haml

@@ -1,2 +0,0 @@
-= form_tag lolita_resources_path(), :method => :get, :class => "search" do 
-  %input{:type => "text", :name => "q", :value => params[:q], :placeholder => t("lolita.search")}

data/app/views/components/lolita/shared/_save_button.html.erb

@@ -1,6 +0,0 @@
- <div class="save black">
-  <div class="last-save">
-    <%= resource.updated_at.strftime("#{t("lolita.tabs.last_save")}: %m/%d/%Y %H:%M ") if resource.respond_to?(:updated_at) && resource.updated_at %>
-  </div>
-  <button class="save-all"><%=::I18n.t("lolita.tabs.save")%></button>
-</div>

data/lib/generators/lolita/assets_generator.rb

@@ -1,19 +0,0 @@
-require 'generators/helpers/file_helper'
-module Lolita
-  module Generators
-    class AssetsGenerator < Rails::Generators::Base
-      include Lolita::Generators::FileHelper
-      desc "Copy all from lolita public directory to project public directory."
-      def copy_all
-        copy_dir("public")
-      end      
-
-       def call_modules
-        Lolita.modules.each do |module_name|
-          command="#{module_name.to_s.underscore.gsub("/","_")}:assets" 
-          invoke command rescue nil
-        end
-      end
-    end
-  end
-end

data/lib/lolita/configuration/factory.rb

@@ -1,56 +0,0 @@
-module Lolita
-  module Configuration
-    module Factory
-      
-      def temp_object?
-        @create_temp_object||=false
-        @create_temp_object
-      end
-
-      def add(dbi,*args,&block)
-        @create_temp_object=true
-        name =  nil
-        if self == Lolita::Configuration::Tab
-          if args && args.first
-            name = args.first
-          else
-            raise ArgumentError, "Define tab with type."
-          end
-        else
-          begin
-            temp_object=self.const_get(:Base).new(dbi,*args,&block)
-            name =temp_object.type
-          rescue Exception => e
-            raise e
-          ensure
-            @create_temp_object=false
-          end
-        end
-        factory(name).new(dbi,*args,&block)
-      end
-
-
-      protected
-
-      def factory(name)
-        begin
-          self.const_get(:"#{to_class(name)}")
-        rescue NameError
-          error_class=Lolita::ConfigurationClassNotFound
-          raise error_class, "Can't find #{self}::#{to_class(name)}. Should be in /configuration/#{factory_name}/#{name}.rb"
-        end
-      end
-
-      def to_class(name)
-        name.to_s.downcase.gsub(/_id$/, "").gsub(/(^\w|_\w)/) do |m|
-          m.gsub("_","").upcase
-        end
-      end
-
-      def factory_name
-        @factory_name||=self.to_s.split("::").last.downcase
-        @factory_name
-      end
-    end
-  end
-end

data/lib/lolita/configuration/helper.rb

@@ -1,24 +0,0 @@
-module Lolita
-  module Configuration
-    module Helper
-      class << self
-        # Return true if field name matches one of these:
-        # * created_at, updated_at, type
-        # * ends with _id, but there is no association that uses that field as foreign_key
-        # * there are uploader with that name
-        def tehnical_field?(db_field,dbi)
-          name = db_field[:name].to_s
-          if name.match(/^created_at|updated_at|type$/)
-            true
-          elsif name.match(/_id$/)
-            # FIXME move this to dbi association proxy
-            key_method = dbi.adapter_name == :active_record ? :association_foreign_key : :key
-            !dbi.associations.values.detect{|assoc| assoc.send(key_method) == name}
-          elsif dbi.klass.respond_to?(:uploaders)
-            dbi.klass.uploaders.keys.include?(name.to_sym)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lolita/configuration/page.rb

@@ -1,126 +0,0 @@
-module Lolita
-  module Configuration
-    class Page
-
-      # page options is used to define specific options for pagination like :joins or :conditions
-      lolita_accessor :page_options
-      attr_writer :per_page
-      def initialize(dbi, list=nil)
-        @dbi=dbi
-        @list = list
-        @sort_columns=[]
-      end
-
-      # Records per page (also block setter)
-      def per_page(value=nil)
-        if value
-          @per_page=value
-          self
-        else
-          @per_page
-        end
-      end
-
-      # Define new sort column with ascending sort direction
-      def asc(column)
-        @sort_columns<<[column.to_sym,:asc]
-        self
-      end
-
-      # Define new sort columns with descending sort direction
-      def desc(column)
-        @sort_columns<<[column.to_sym,:desc]
-        self
-      end
-
-      # Return all sort columns.
-      # Each column is an Array where first element is column name and second is direction
-      # ====Example
-      #     page=Lolita::Configuration::Page.new(@dbi)
-      #     page.asc(:created_at)
-      #     page.sort_columns #=> [[:created_at,:asc]]
-      def sort_columns
-        @sort_columns
-      end
-
-      # Paginate
-      # Options:
-      # * <tt>:per_page</tt> - record count per page, default uses list.per_page
-      # * <tt>:page</tt> - what page to show
-      # * <tt>:sort_columns</tt> - sort columns for page. See #sort_columns
-      # * <tt>:asc</tt> - column to sort in ascending direction
-      #     list.paginate(1,:asc=>:created_at)
-      # * <tt>:desc</tt> - column to sort in descending direction
-      #
-      # ====Example
-      #     list.paginate(1)
-      #     list.paginate
-      #     list.paginate(:per_page=>2,:page=>1)
-      def paginate *args
-        options=args ? args.extract_options! : {}
-        hold=options.delete(:hold)
-        @params=options.delete(:params)
-        set_values_from_options(options)
-        options[:page]||=((args && args.first) || 1)
-        options[:per_page]||=@per_page || 10
-        @last_options=options
-        @last_options[:sort]=self.sort_columns unless self.sort_columns.empty?
-        unless hold
-          get_page()
-        end
-      end
-
-      def get_page()
-        @page=@dbi.filter(filter_conditions).paginate((@page_options||{}).merge(@last_options))
-      end
-      
-      # Return last paginated page
-      # ====Example
-      #     list.paginate(2)
-      #     # call page to avoid another call to db
-      #     list.page
-      def last_page
-        @page
-      end
-
-      private
-
-      # returns filter conditions as Hash for get_page()
-      def filter_conditions
-        if @params
-          conditions = {}
-          @params.each_pair do |k,v|
-            if k.to_s =~ /^f_([a-z0-9_\-]+)$/ && !v.to_s.strip.blank?
-              conditions[$1.to_sym] = v
-            end
-          end
-          conditions
-        else
-          {}
-        end
-      end
-
-      def allowed_options
-        [:sort_columns,:asc,:desc]
-      end
-
-      def set_values_from_options(options)
-        allowed_options.each{|meth|
-          if options.has_key?(meth)
-            self.send(meth,options.delete(meth))
-          end
-        }
-        parse_params
-      end
-
-      def parse_params
-        if @params
-          if @params.has_key?(:sc)
-            self.send((@params[:sd] || :asc).to_sym,@params[:sc])
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/lolita/configuration/search.rb

@@ -1,91 +0,0 @@
-module Lolita
-  module Configuration
-    # Proxy class for search. It supports two methods #with and #run.
-    # By default with method accepts method name or nothing and creates Lolita::Search::Simple instance
-    # that will be used to run search on current dbi. 
-    # By default search run against all content fields, but when _:fields_ options is passed it search in
-    # those fields only. 
-    # ==== Example
-    #     class Post < ActiveRecord::Base
-    #       include Lolita::Configuration
-    #       lolita do
-    #         list do
-    #           search :fields => [:name]
-    #         end
-    #       end
-    #     end
-    # #with method also accepts class or instance of some class, that will be used to run search.
-    # That class should have #run method that accepts query and request. 
-    # ====Example
-    #     class MyCustomSearch
-    #       def initialize(dbi)
-    #         @dbi = dbi
-    #       end
-    #   
-    #       def run(query,request = nil)
-    #         @dbi.klass.where(:my_field => query)
-    #       end
-    #     end
-    # Also you can put your search method in model. For more see Lolita::Search::Simple
-    # ====Example
-    #     class Post < ActiveRecord::Base
-    #       include Lolita::Configuration
-    #       lolita do
-    #         list do
-    #           search :my_custom_search
-    #         end
-    #       end
-    #       
-    #       def self.my_custom_search(query,request)
-    #         self.where(:title => query, :user_id => request.params[:user_id])
-    #       end
-    #     end    
-    class Search
-      include Lolita::Builder
-      attr_reader :dbi
-      attr_writer :with, :fields
-
-      def initialize dbi, *args, &block
-        @dbi = dbi
-        set_attributes(args ? args.extract_options! : {})
-        instance_eval(&block) if block_given?
-        @with ||= args[0]!=true && args[0] ? args[0] : nil 
-      end
-
-      def with(value = nil)
-        @with = value if value
-        if !@with || [String,Symbol].include?(@with.class)
-          @with = Lolita::Search::Simple.new(dbi,@with, :fields => @fields)
-        elsif @with.class == Class
-          initialize_arity = @with.instance_method(:initialize).arity
-          @with = if initialize_arity < 0 || initialize_arity > 1
-            @with.new(dbi,:fields => @fields)
-          else
-            @with.new(dbi)
-          end
-        end
-        @with
-      end
-
-      def run(query,request = nil)
-        if self.with.method(:run).arity < 0 || self.with.method(:run).arity > 1
-          self.with.run(query,request)
-        else
-          self.with.run(query)
-        end
-      end
-
-      private
-
-      def set_attributes options
-        if options.respond_to?(:each)
-          options.each do |method_name, value| 
-            self.send(:"#{method_name}=",value)
-          end
-        end
-      end
-
-    end
-
-  end
-end