lolita 3.3.7 → 3.3.8

data/app/controllers/lolita/field_data_controller.rb~

@@ -1,40 +0,0 @@
-class Lolita::FieldDataController < ApplicationController
-  include Lolita::Controllers::AuthenticationHelpers
-
-  before_filter :find_field, :except => [:autocomplete_field]
-
-  def array_polymorphic
-    klass = params[:class].camelize.constantize
-    authorization_proxy.authorize!(:read,klass)
-    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 autocomplete_field
-    klass = params[:field_class].camelize.constantize
-    authorization_proxy.authorize!(:read,klass)
-    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].underscore}[#{params[:field_name].singularize}_ids][]",
-          :delete_link => I18n.t("lolita.shared.delete").to_s.downcase
-        }
-      end
-    end
-    render :json => data || {}
-	end
-
-  private
-
-  def find_field
-    @field = params[:field_class].camelize.constantize.lolita.tabs.fields.detect{|field|
-      field.name.to_s == params[:name].to_s
-    }
-  end
-
-end

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

@@ -1,16 +0,0 @@
-.autocomplete-container.zzz
-
-  - if field.association.macro == :one
-    = self.current_form.hidden_field field.association.key
-    = render_component *field.build(:state => "input", :with_value => true)
-  - else
-         zzz
-    - ids_method = field.name.to_s.match(/_ids$/) ? field.name : "#{field.name.to_s.singularize}_ids"
-    = hidden_field_tag "#{resource_name}[#{ids_method}][]",""
-    = render_component *field.build(:state => "input")
-    %ul
-      - resource && resource.persisted? && resource.send(field.name).each do |record|
-        %li
-          = record.send(field.current_text_method(field.association.klass))
-          = link_to I18n.t("lolita.shared.delete").downcase, nil
-           = hidden_field_tag "#{resource_name}[#{ids_method}][]", record.id

data/app/views/components/lolita/configuration/filter/_display.html.haml~

@@ -1,9 +0,0 @@
-- if filter
-  = form_for filter.resource(params), :as => :filter, :html => {:class => "filter"}, :method => :get, :url => request.path do |f|
-    - current_form(f) do 
-      - filter.fields.each do |field|
-        .field
-          = render_component "lolita/configuration/field", :label, :field => field
-          = render_component *field.build(:resource => current_form.object)
-
-    %button{:type => "submit"}= ::I18n.t "lolita.filter.apply_button"

data/lib/lolita/configuration/filter.rb~

@@ -1,122 +0,0 @@
-# coding: utf-8
-module Lolita
-  module Configuration
-    # Lolita::Configuration::Filter is for filtering data in list view.
-    # By now it supports these field types:
-    # - Array
-    # - Boolean
-    #  
-    # To use it, call "filter" method in list block, filter method accepts field names
-    # as arguments. You can pass block and configure each field. Field configuration is just like in tab configuration.
-    #
-    # === Examples
-    #    
-    #    # this will build country select field and is_deleted checkbox
-    #    list do
-    #      filter :country, :is_deleted
-    #    end
-    #
-    #    # For example you have text field "status" with values opened,closed,rejected
-    #    list do
-    #      filter do
-    #        field :status, :array, :values=> %w(open closed rejected)
-    #        field :is_deleted, :title => "Deleted"
-    #      end
-    #    end
-    #
-    class Filter
-      include Lolita::Builder
-      attr_reader :dbi
-
-      def initialize(dbi,*args,&block)
-        @dbi = dbi
-        @fields=Lolita::Configuration::Fields.new
-        set_attributes(*args)
-        self.instance_eval(&block) if block_given?
-      end
-
-      def field *args, &block
-        field=Lolita::Configuration::Factory::Field.create(self.dbi,*args,&block)
-        field
-        @fields<<field
-        field
-      end
-
-      # Set all fields in tab. Accept <code>fields</code> as Array.
-      # Each array element can be Lolita::Configuration::Field object or
-      # Hash, that will be passed to #field method.
-      def fields=(fields)
-        if fields.is_a?(Array)
-          fields.each{|field_attr|
-            if field_attr.is_a?(Lolita::Configuration::Field)
-              @fields<<field_attr
-            else
-              self.field(field_attr)
-            end
-          }
-        end
-      end
-
-      def fields(*args, &block)
-        if args && args.any? || block_given?
-          args.each do |field_name|
-            f = field(field_name)
-            f.instance_eval(&block) if block_given?
-          end
-        end
-        @fields
-      end
-
-      # Used to set attributes if block not given.
-      def set_attributes(*args)
-        if args && args[0]
-          if args[0].is_a?(Hash)
-            args[0].each{|m,value|
-              self.send("#{m}=".to_sym,value)
-            }
-          else
-            fields *args            
-          end
-        end
-      end
-
-      def html_option_for_select field
-        {
-          :include_blank => ::I18n.t('lolita.filter.include_blank_by_title', :title => field.title)
-        }
-      end
-
-      def update method_name, list, request
-        filter_params = request && request.params && request.params[:filter]
-        page_criteria = if method_name == :paginate && self.search && filter_params
-          search_criteria = self.search.run(nil,request)
-          page_criteria = if search_criteria.respond_to?(:where)
-            list.page_criteria.merge(search_criteria)
-          elsif search_criteria.nil?
-            list.page_criteria
-          else
-            search_criteria
-          end
-        else
-          list.page_criteria.merge(self.dbi.filter(filter_params || {}))
-        end
-        list.instance_variable_set(:@page_criteria,page_criteria)
-      end
-
-      def search *args, &block
-        if args && args.any? || block_given?
-          @search = Lolita::Configuration::Search.new(self.dbi,*args, &block)
-        else
-          @search
-        end
-      end
-
-      def resource(params)
-	if klass = fields.any? ? fields.first.dbi.klass : nil
-	  klass.new(params[klass.to_s.underscore.to_sym]).extend(Module.new{def persisted?; true; end})
-	end
-      end
-      
-    end
-  end
-end

data/lib/lolita/controllers/internal_helpers.rb~

@@ -1,75 +0,0 @@
-module Lolita
-  module Controllers
-
-    module InternalHelpers
-
-      def include_application_assets
-        result = ""
-        Lolita.application.assets.each do |asset_name|
-          if asset_name.match(/\.js(\.|$)/)
-            result << javascript_include_tag(asset_name)
-          elsif asset_name.match(/\.css(\.|$)/)
-            result << stylesheet_link_tag(asset_name)
-          end
-        end
-        raw(result)
-      end
-
-      def resource
-        instance_variable_get(:"@#{resource_name}")
-      end
-      
-      def resource_name
-        lolita_mapping.class_name.underscore.to_sym
-      end
-      
-      def resource_class
-        lolita_mapping.to
-      end
-      
-      def lolita_mapping(new_mapping = nil)
-        @lolita_mapping ||= request.env["lolita.mapping"]
-      end
-
-      def current_form=(form)
-        @current_form = form
-      end
-
-      def current_form(temp_form = nil)
-        if block_given?
-          old_form = @current_form
-          @current_form = temp_form
-          content = yield
-          @current_form = old_form
-        end
-        @current_form
-      end
-
-      def use_mapping(new_mapping)
-        if block_given? 
-          begin
-            @old_mapping = lolita_mapping
-            @lolita_mapping = new_mapping
-            yield
-          ensure
-            @lolita_mapping = @old_mapping
-            @old_mapping = nil
-          end
-        end
-      end
-
-      protected
-
-      def is_lolita_resource?
-        raise ActionController::UnknownAction unless lolita_mapping
-        true
-      end
-
-      def resource=(new_resource)
-        instance_variable_set(:"@#{resource_name}",new_resource)
-      end
-
-    end
-
-  end
-end

data/lib/lolita/version.rb~

@@ -1,30 +0,0 @@
-module Lolita
-  module Version
-    MAJOR = 3
-    MINOR = 3
-    PATCH = 6
-    BUILD = nil
-
-    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
-
-    def self.to_s
-      STRING
-    end
-
-    def self.major
-      MAJOR
-    end
-
-    def self.minor
-      MINOR
-    end
-
-    def self.patch
-      PATCH
-    end
-
-    def self.build
-      BUILD
-    end
-  end
-end

data/spec/configuration/filter_spec.rb~

@@ -1,167 +0,0 @@
-require 'spec_helper'
-
-describe Lolita::Configuration::Filter do
-
-  let(:dbi){Lolita::DBI::Base.new(Post)}
-
-  it "should create new filter with block" do
-    Lolita::Configuration::Filter.new(dbi) do
-    end
-  end
-
-  it "should create new filter without block" do
-    Lolita::Configuration::Filter.new(dbi)
-  end
-
-  it "should give fields as arguments" do
-    list=Lolita::Configuration::List.new(dbi)
-    list.filter :name, :is_public
-    list.filter.fields.size.should == 2
-  end
-
-  it "should add some fields" do
-    filter=Lolita::Configuration::Filter.new(dbi) do
-      fields :name, :is_public, :not_public
-    end
-    filter.fields.size.should == 3
-  end
-
-  it "should add some field with block" do
-    filter=Lolita::Configuration::Filter.new(dbi) do
-      field :name do
-        type :integer
-      end
-    end
-    filter.fields.first.type.should == "integer"
-  end
-
-  it "should add some fields with block" do
-    filter=Lolita::Configuration::Filter.new(dbi) do
-      fields :name, :is_public do
-        type :integer
-      end
-      field :created_at, :time
-    end
-    filter.fields.size.should == 3
-    filter.fields[0].type.should == "integer"
-    filter.fields[1].type.should == "integer"
-    filter.fields[2].type.should == "time"
-  end
-
-  it "should filter results for boolean" do
-    Fabricate(:post, :is_public => true)
-    Fabricate(:post, :is_public => true)
-    Fabricate(:post, :is_public => false)
-
-    filter=Lolita::Configuration::Filter.new(dbi) do
-      field :is_public
-    end
-
-    dbi.filter(:is_public => 1).size.should == 2
-    dbi.filter(:is_public => 0).size.should == 1
-  end
-
-  it "should filter results for belongs_to" do
-    c1 = Fabricate(:category, :name => "Linux")
-    c2 = Fabricate(:category, :name => "Android")
-    p1=Fabricate(:post, :category => c1)
-    p2=Fabricate(:post, :category => c1)
-    p3=Fabricate(:post, :category => c2)
-
-    filter=Lolita::Configuration::Filter.new(dbi) do
-      field :tags
-    end
-    dbi.filter(:category_id => c1.id).size.should == 2
-    dbi.filter(:category_id => c2.id).size.should == 1
-  end
-
-  it "should filter results for has_and_belongs_to_many" do
-    tag1 = Fabricate(:tag, :name => "Linux")
-    tag2 = Fabricate(:tag, :name => "Android")
-    p1=Fabricate(:post, :tags => [tag1,tag2])
-    p2=Fabricate(:post, :tags => [tag1,tag2])
-    p3=Fabricate(:post, :tags => [tag1])
-
-    filter=Lolita::Configuration::Filter.new(dbi) do
-      field :tags
-    end
-    dbi.filter(:tag_ids => tag1.id).size.should == 3
-    dbi.filter(:tag_ids => tag2.id).size.should == 2
-  end
-
-  describe "Filtering list" do
-    let(:list){ Lolita::Configuration::List}
-
-    it "should filter with default filters" do
-      tags = %w(Android Linux Windows).map{|name| Fabricate(:tag, :name => name )}
-      3.times {|i| Fabricate(:post,:tags => [tags[i]])}
-
-      list_conf = list.new(dbi) do
-        filter do
-          field :tags
-        end
-      end
-      list_conf.paginate(1).should have(3).items
-      request = Object.new
-      request.class_eval do
-        def params
-          {:filter => {:tag_ids => Tag.where(:name => 'Android').first.id}}
-        end
-      end
-      list_conf.paginate(1,request).should have(1).items
-    end
-    
-    it "should filter with custom search" do
-      tags = %w(Android Linux Windows).map{|name| Fabricate(:tag, :name => name )}
-      3.times {|i| Fabricate(:post,:tags => [tags[i]])}
-      Post.class_eval do
-        def self.custom_filter query,request
-          where(:tag_ids.in => Tag.where(:name.in => ['Android','Linux']).map(&:id))
-        end
-      end
-      list_conf = list.new(dbi) do
-        filter do
-          field :tags
-          search :custom_filter
-        end
-      end
-      list_conf.paginate(1).should have(3).items
-      request = Object.new
-      request.class_eval do
-        def params
-          {:filter => {:tag_ids => Tag.where(:name => 'Android').first.id}}
-        end
-      end
-      list_conf.paginate(1,request).should have(2).items
-    end
-  end
-
-  describe "#resource" do
-    let(:filter){ Lolita::Configuration::Filter.new(dbi, :name ) }
-    let(:params){ {} }
-    subject do
-      tags = %w(Android Linux Windows).map{|name| Fabricate(:tag, :name => name )}
-      filter.resource(params)
-    end
-
-    context "reflections" do
-      let(:params){ {:post => {"tag_ids"=>["", Tag.where(:name => 'Android').first.id]}} }
-      let(:filter){ Lolita::Configuration::Filter.new(dbi, :tag ) }
-      it "recognizes" do
-	subject.tags.should have(1).item
-      end
-    end
-
-    context "simple attributes" do
-      let(:params){ {:post => {"title" => "MyName" }} }
-      let(:filter){ Lolita::Configuration::Filter.new(dbi, :title ) }
-      it "recognizes" do
-	subject.title.should eq("MyName")
-      end
-    end
-
-    it "should be persisted" do
-      subject.should be_persisted
-    end
-  end
-end