lolita 3.1.10 → 3.1.11

data/README.rdoc

@@ -1,99 +1,99 @@
-=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
-
-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
+
+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
+
+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/Rakefile

@@ -1,40 +1,40 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "lolita"
-  gem.homepage = "http://github.com/ithouse/lolita"
-  gem.license = "MIT"
-  gem.summary = %Q{Great Rails CMS.}
-  gem.description = %Q{Great Rails CMS, that turns your business logic into good-looking, fully functional workspace. }
-  gem.email = "support@ithouse.lv"
-  gem.authors = ["ITHouse (Latvia) and Arturs Meisters"]
-  # Include your dependencies below. Runtime dependencies are required when using your gem,
-  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
-  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
-  #  gem.add_development_dependency 'rspec', '> 1.2.3'
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-
-task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "lolita #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "lolita"
+  gem.homepage = "http://github.com/ithouse/lolita"
+  gem.license = "MIT"
+  gem.summary = %Q{Great Rails CMS.}
+  gem.description = %Q{Great Rails CMS, that turns your business logic into good-looking, fully functional workspace. }
+  gem.email = "support@ithouse.lv"
+  gem.authors = ["ITHouse (Latvia) and Arturs Meisters"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "lolita #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -1 +1 @@
-3.1.10
+3.1.11

data/app/controllers/lolita/info_controller.rb

@@ -1,41 +1,41 @@
-class Lolita::InfoController < ApplicationController
-  @@properties = []
-
-  def index
-    render :layout => false
-  end
-
-  def properties
-    if request.local?
-      render :inline => to_html
-    else
-      render :text => '<p>For security purposes, this information is only available to local requests.</p>', :status => :forbidden
-    end
-  end
-
-  private
-
-  def self.property(name, value = nil)
-    value ||= yield
-    @@properties << [name, value] if value
-    rescue Exception
-  end
-
-  def to_html
-    (table = '<table>').tap do
-      @@properties.each do |(name, value)|
-        table << %(<tr><td class="name">#{CGI.escapeHTML(name.to_s)}</td>)
-        formatted_value = if value.kind_of?(Array)
-              "<ul>" + value.map { |v| "<li>#{CGI.escapeHTML(v.to_s)}</li>" }.join + "</ul>"
-            else
-              CGI.escapeHTML(value.to_s)
-            end
-        table << %(<td class="value">#{formatted_value}</td></tr>)
-      end
-      table << '</table>'
-    end
-  end
-    
-  property 'Lolita version', "#{LOLITA_VERSION}"
-
-end
+class Lolita::InfoController < ApplicationController
+  @@properties = []
+
+  def index
+    render :layout => false
+  end
+
+  def properties
+    if request.local?
+      render :inline => to_html
+    else
+      render :text => '<p>For security purposes, this information is only available to local requests.</p>', :status => :forbidden
+    end
+  end
+
+  private
+
+  def self.property(name, value = nil)
+    value ||= yield
+    @@properties << [name, value] if value
+    rescue Exception
+  end
+
+  def to_html
+    (table = '<table>').tap do
+      @@properties.each do |(name, value)|
+        table << %(<tr><td class="name">#{CGI.escapeHTML(name.to_s)}</td>)
+        formatted_value = if value.kind_of?(Array)
+              "<ul>" + value.map { |v| "<li>#{CGI.escapeHTML(v.to_s)}</li>" }.join + "</ul>"
+            else
+              CGI.escapeHTML(value.to_s)
+            end
+        table << %(<td class="value">#{formatted_value}</td></tr>)
+      end
+      table << '</table>'
+    end
+  end
+    
+  property 'Lolita version', "#{LOLITA_VERSION}"
+
+end

data/app/controllers/lolita/rest_controller.rb

@@ -1,130 +1,130 @@
-class Lolita::RestController < ApplicationController
-  include Lolita::Controllers::UserHelpers
-  include Lolita::Controllers::InternalHelpers
-
-  include Lolita::Hooks
-  add_hook :before_new, :after_new, :before_create,:after_create,:before_edit,:after_edit
-  add_hook :before_update,:after_update,:before_destroy,:after_destroy,:before_index,:after_index
-  add_hook :before_build_resource, :after_build_resource
-  
-  before_filter :authenticate_lolita_user!
-  layout "lolita/application"
-  
-  def new
-    self.run(:before_new)
-    build_resource
-    show_form
-  end
-
-  def create
-    self.run(:before_create)
-    build_resource
-    save_and_redirect
-  end
-
-  def edit
-    self.run(:before_edit)
-    get_resource
-    show_form
-  end
-  
-  def update
-    self.run(:before_update)
-    get_resource
-    if self.resource
-      self.resource=resource_with_attributes(self.resource,resource_attributes)
-      save_and_redirect
-
-    end
-  end
-
-  def destroy
-    self.run(:before_destroy)
-    get_resource
-    if self.resource && self.resource.destroy
-      flash[:notice] = ::I18n.t "lolita.shared.destroy_notice"
-    else
-      flash[:alert] = ::I18n.t "lolita.shared.destroy_alert"
-    end
-    self.run(:after_destroy)
-    redirect_to lolita_resources_path
-  end
-
-  def index
-    self.run(:before_index)
-    respond_to do |format|
-      format.html do
-        build_response_for(:list,:page=>page)
-        show_index
-      end
-      format.json do
-        render :json=>page
-      end
-    end
-    self.run(:after_index)
-  end
-
-  private
-
-  def show_form
-    build_response_for(:tabs)
-    self.run(:"after_#{params[:action]}")
-    if request.xhr?
-      render "/lolita/rest/form", :layout => false
-    else
-      render "/lolita/rest/form"
-    end
-  end
-  
-  def show_index
-    render "/lolita/rest/index"
-  end
-  
-  def save_and_redirect
-    respond_to do |format|
-      if self.resource.save
-        self.resource.reload
-        format.html{ respond_html_200}
-        format.json{ respond_json_200}
-      else
-        format.html{ respond_html_400 }
-        format.json{ respond_json_400 }
-      end
-    end
-  end
-  
-  def respond_html_200
-    response.headers["Validation"] = 'true'
-    response.headers["Lolita-Notice"] = ::I18n.t "lolita.shared.save_notice"
-    show_form
-  end
-
-  def respond_html_400
-    response.headers["Validation"] = 'false'
-    response.headers["Lolita-Alert"] = ::I18n.t "lolita.shared.save_alert"
-    show_form
-  end
-
-  def respond_json_200
-    respond_json(200)
-  end
-
-  def respond_json_400
-    respond_json(400)
-  end
-
-  def respond_json(status)
-    self.run(:"after_#{params[:action]}")
-    render :status=>status, :json=>self.resource
-  end
-
-  def to_list
-    builder=build_response_for(:list,:page=>page)
-    render :index
-    #render_component *builder
-  end
-
-  def page
-    resource_class.lolita.list.paginate(params[:page], :params => params)
-  end
-end
+class Lolita::RestController < ApplicationController
+  include Lolita::Controllers::UserHelpers
+  include Lolita::Controllers::InternalHelpers
+
+  include Lolita::Hooks
+  add_hook :before_new, :after_new, :before_create,:after_create,:before_edit,:after_edit
+  add_hook :before_update,:after_update,:before_destroy,:after_destroy,:before_index,:after_index
+  add_hook :before_build_resource, :after_build_resource
+  
+  before_filter :authenticate_lolita_user!
+  layout "lolita/application"
+  
+  def new
+    self.run(:before_new)
+    build_resource
+    show_form
+  end
+
+  def create
+    self.run(:before_create)
+    build_resource
+    save_and_redirect
+  end
+
+  def edit
+    self.run(:before_edit)
+    get_resource
+    show_form
+  end
+  
+  def update
+    self.run(:before_update)
+    get_resource
+    if self.resource
+      self.resource=resource_with_attributes(self.resource,resource_attributes)
+      save_and_redirect
+
+    end
+  end
+
+  def destroy
+    self.run(:before_destroy)
+    get_resource
+    if self.resource && self.resource.destroy
+      flash[:notice] = ::I18n.t "lolita.shared.destroy_notice"
+    else
+      flash[:alert] = ::I18n.t "lolita.shared.destroy_alert"
+    end
+    self.run(:after_destroy)
+    redirect_to lolita_resources_path
+  end
+
+  def index
+    self.run(:before_index)
+    respond_to do |format|
+      format.html do
+        build_response_for(:list,:page=>page)
+        show_index
+      end
+      format.json do
+        render :json=>page
+      end
+    end
+    self.run(:after_index)
+  end
+
+  private
+
+  def show_form
+    build_response_for(:tabs)
+    self.run(:"after_#{params[:action]}")
+    if request.xhr?
+      render "/lolita/rest/form", :layout => false
+    else
+      render "/lolita/rest/form"
+    end
+  end
+  
+  def show_index
+    render "/lolita/rest/index"
+  end
+  
+  def save_and_redirect
+    respond_to do |format|
+      if self.resource.save
+        self.resource.reload
+        format.html{ respond_html_200}
+        format.json{ respond_json_200}
+      else
+        format.html{ respond_html_400 }
+        format.json{ respond_json_400 }
+      end
+    end
+  end
+  
+  def respond_html_200
+    response.headers["Validation"] = 'true'
+    response.headers["Lolita-Notice"] = ::I18n.t "lolita.shared.save_notice"
+    show_form
+  end
+
+  def respond_html_400
+    response.headers["Validation"] = 'false'
+    response.headers["Lolita-Alert"] = ::I18n.t "lolita.shared.save_alert"
+    show_form
+  end
+
+  def respond_json_200
+    respond_json(200)
+  end
+
+  def respond_json_400
+    respond_json(400)
+  end
+
+  def respond_json(status)
+    self.run(:"after_#{params[:action]}")
+    render :status=>status, :json=>self.resource
+  end
+
+  def to_list
+    builder=build_response_for(:list,:page=>page)
+    render :index
+    #render_component *builder
+  end
+
+  def page
+    resource_class.lolita.list.paginate(params[:page], :params => params)
+  end
+end