lolita 3.0.3

data/lib/lolita/base_configuration.rb

@@ -0,0 +1,55 @@
+module Lolita
+  class BaseConfiguration
+  
+    attr_reader :scope, :modules, :routes, :controllers
+    attr_accessor :mappings,:default_module,:user_classes,:authentication
+
+    def initialize(scope)
+      @scope=scope
+      @mappings={}
+      @default_module=nil
+      @user_classes=[]
+      @modules=[]
+      @routes={}
+      @controllers={}
+    end
+
+    def use(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
+      config={
+        :route=>self.routes,
+        :controller=>self.controllers
+      }
+      config.each{|key,value|
+        next unless options[key]
+        new_value=options[key]==true ? name : options[key]
+        if value.is_a?(Hash)
+          value[name]=new_value
+        elsif !value.include?(new_value)
+          value << new_value
+        end
+      }
+
+      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
+
+  end
+end

data/lib/lolita/builder.rb

@@ -0,0 +1,69 @@
+module Lolita
+  # Any Lolita::Configuration class that should return visual information about itself
+  # can include Builder::Base, that provide default methods for _controllers_ to use.
+  # * #build method is used to render component for class instance.
+  # * #build_options is method that return specific options for builder, to pass to component,
+  #   such as :color,:postition etc.
+  # * #builder is setter/getter method for Lolita::Configuration, that accept Hash or Array or single
+  #   String or Symbol for buider.
+  #
+  module Builder
+
+    # Build response. Render component for current class with given options.
+    def build(options=nil)
+      builder_options=self.builder_options || {}
+      options=(options || {}).merge(builder_options)
+      builder_values=self.builder
+      return builder_values[:name],builder_values[:state],options
+    end
+
+    # Default options for class. This method should be overwritten.
+    def builder_options
+      {builder_name.to_sym=>self}
+    end
+
+    # Set or get builder for class.
+    # _Value_ can be
+    # * <tt>Hash</tt> where key <code>:name</code> is component name and <code>:state</code> is component state
+    # * <tt>Array or two args</tt> - first is used as _name_ and second as _state_.
+    # * <tt>String or Symbol (one arg)</tt> - is used as _name_.
+    # Default _name_ is Lolita::Configuration class name (example <code>:list</code>) and
+    # default state is <code>:display</code>
+    def builder(*value)
+      if value && !value.empty?
+        set_builder(*value)
+      else
+        unless @builder
+          @builder=default_builder
+        end
+        @builder
+      end
+    end
+
+    # Return default builder information.
+    def default_builder
+      {:name=>"lolita/#{builder_name}",:state=>default_build_state}
+    end
+    
+    private
+
+    def set_builder *value
+      if value[0].is_a?(Hash)
+        @builder=value[0]
+      elsif value.size>1
+        @builder={:name=>value[0],:state=>value[1]}
+      else
+        @builder={:name=>value[0],:state=>default_build_state}
+      end
+    end
+    
+    def default_build_state
+      :display
+    end
+    
+    def builder_name
+      self.class.to_s.split("::").last.downcase.to_sym
+    end
+    
+  end
+end

data/lib/lolita/configuration/base.rb

@@ -0,0 +1,76 @@
+# Every class that include Lolita::Configuration this module assign
+# #lolita and #lolita= methods. First one is for normal Lolita configuration
+# definition, and the other one made to assing Lolita to class as a Lolita::Configuration::Base
+# object. You may want to do that to change configuration or for testing purpose.
+module Lolita
+  module Configuration
+    # Lolita could be defined inside of any class that is supported by Lolita::Adapter, for now that is
+    # * ActiveRecord::Base
+    # * Mongoid::Document
+    # Main block can hold these methods:
+    # <tt>list</tt> - List definition, see Lolitia::Configuration::List
+    # <tt>tab</tt> - Tab definition, see Lolita::Configuration::Tab
+    # <tt>tabs</tt> - Tabs definition, see Lolita::Configuration::Tabs
+    class Base
+
+      attr_reader :dbi,:klass
+      @@generators=[:tabs,:list]
+      class << self
+        def add_generator(method)
+          @@generators<<method.to_sym
+        end
+      end
+      # When configuration is defined in class than you don't need to worry about
+      # creating new object, because Lolita itself create it for that class.
+      # New object is created like when you define it in class, but <i>parent_class</i>
+      # must be given.
+      # ====Example
+      #     class Person < ActiveRecord::Base
+      #        include Lolita::Configuration
+      #        lolita
+      #     end
+      #     Person.lolita.klass #=> Person
+      #     # Init Lolita by youself
+      #
+      #     class Person < ActiveRecord::Base
+      #       include Lolita::Configuration
+      #     end
+      #     Person.lolita=Lolita::Configuration::Base.new(Person)
+      #     Person.lolita.klass #=> Person
+      def initialize(orm_class,&block)
+        @klass=orm_class
+        @dbi=Lolita::DBI::Base.new(orm_class)
+        block_given? ? self.instance_eval(&block) : self.generate!
+      end
+
+
+      # Create list variable for ::Base class and create lazy object of Lolita::LazyLoader.
+      # See Lolita::Configuration::List for more information.
+      def list &block
+        Lolita::LazyLoader.lazy_load(self,:@list,Lolita::Configuration::List,@dbi,&block)
+      end
+
+      # Create collection of Lolita::Configuration::Tab, loading lazy.
+      # See Lolita::Configuration::Tabs for details.
+      def tabs &block
+        Lolita::LazyLoader.lazy_load(self, :@tabs,Lolita::Configuration::Tabs,@dbi,&block)
+      end
+
+      # Shortcut for Lolita::Configuration::Tabs <<.
+      # Tabs should not be defined in lolita block to create onew or more Lolita::Configuration::Tab
+      # See Lolita::Configuration::Tab for details of defination.
+      def tab *args, &block
+        self.tabs<<Lolita::Configuration::Tab.new(@dbi,*args,&block)
+      end
+      
+      # Call all supported instance metods to set needed variables and initialize object with them.
+      def generate!
+        @@generators.each{|generator|
+          self.send(generator)
+        }
+      end
+      
+    end
+  end
+end
+

data/lib/lolita/configuration/column.rb

@@ -0,0 +1,86 @@
+module Lolita
+  module Configuration
+    class Column 
+
+      MAX_TEXT_SIZE=20
+      DEFAULT_DATE_FORMAT="%Y-%m-%d"
+      DEFAULT_TIME_FORMAT="%H:%M:%S"
+      lolita_accessor :name,:title,:type,:options,:format
+      
+      def initialize(*args,&block)
+        self.set_attributes(*args)
+        self.instance_eval(&block) if block_given?
+        validate
+        set_default_values
+      end
+      
+      #
+      #  column do
+      #    name "UID"
+      #    format do(values)
+      #      values.first+values.last
+      #    end
+      #  end
+      # <%= column.with_format([@post.id,@post.user_id])%>
+      def with_format(value) #TODO test
+        if @format
+          @format.call(value)
+        else
+          format_from_type(value)
+        end
+      end
+
+      def format_from_type(value) #TODO test
+        if value
+          case self.type.to_s.downcase
+          when "string"
+            value
+          when "integer"
+            value
+          when "text"
+            new_value=value.to_s.gsub(/<\/?[^>]*>/, "").strip
+            if new_value.size>MAX_TEXT_SIZE
+              "#{new_value.slice(0..MAX_TEXT_SIZE)}..."
+            else
+              new_value
+            end
+          when "datetime"
+            value.strftime("#{DEFAULT_DATE_FORMAT} #{DEFAULT_TIME_FORMAT}")
+          when "date"
+            value.strftime(DEFAULT_DATE_FORMAT)
+          when "time"
+            value.strftime(DEFAULT_TIME_FORMAT)
+          else
+            value.to_s
+          end
+        else
+          ""
+        end
+      end
+      
+      def set_attributes(*args)
+        if !args.empty?
+          if args[0].is_a?(Hash)
+            args[0].each{|m,value|
+              self.send("#{m}=".to_sym,value)
+            }
+          elsif args[0].is_a?(Symbol) || args[0].is_a?(String)
+            self.name=args[0].to_s
+          else
+            raise ArgumentError.new("Lolita::Configuration::Column arguments must be Hash or Symbol or String instead of #{args[0].class}")
+          end
+        end
+      end
+      
+      private
+      
+      def set_default_values
+        @title||=@name.to_s.humanize
+      end
+      
+      def validate
+        raise ArgumentError.new("Column must have name.") unless self.name
+      end
+    end
+  end
+end

data/lib/lolita/configuration/columns.rb

@@ -0,0 +1,65 @@
+module Lolita
+  module Configuration
+    class Columns
+
+      include Enumerable
+      include ObservedArray
+      
+      attr_accessor :list
+      attr_reader :dbi
+      
+      def initialize(list,dbi=nil)
+        @list=list
+        @dbi=dbi || list.dbi
+        @columns=[]
+      end
+      
+      def each
+        @columns.each_with_index{|column,index|
+          if column.is_a?(Lolita::Configuration::Column)
+            yield column
+          else
+            raise "Any column must be Lolita::Configuratin::Column object instead of #{column.class}."
+          end
+        }
+      end
+
+      def generate!
+        @columns.clear
+        @dbi.fields.each_with_index{|field,index|
+          @columns[index]=Lolita::Configuration::Column.new(field)
+        }
+      end
+
+      def add attributes={},&block
+        if block_given?
+          @columns<<build_element(&block)
+        else
+          @columns<<build_element(attributes)
+        end
+        self
+      end
+
+      private
+
+      def collection_variable
+        @columns
+      end
+      
+      def build_element(column=nil,&block)
+        if column.is_a?(Lolita::Configuration::Column)
+          column
+        elsif column.is_a?(Proc)
+          Lolita::Configuration::Column.new(&column)
+        elsif block_given?
+          Lolita::Configuration::Column.new(&block)
+        elsif [Symbol,String,Hash].include?(column.class)
+          Lolita::Configuration::Column.new(column)
+        else
+          raise ArgumentError.new("Column can not be defined with #{column.class}.")
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita/configuration/field.rb

@@ -0,0 +1,169 @@
+module Lolita
+  module Configuration
+    # Lolita::Configuration::Field is class that allow to configure fields.
+    # To change behaviour of field you can use these attributes
+    # * <tt>name</tt> - field name, used to set or get value from related ORM object
+    # * <tt>type</tt> - can change the way field is shown and how data is formated
+    # * <tt>field_set</tt> - define field set that field belongs to. See Lolita::Configuration::FieldSet
+    # * <tt>nested_in</tt> - define field for different Lolita::DBI instance, than given. This is used
+    #   to create nested fields in one form for related models. Like user and profile, where in user
+    #   form there are fields from profile that can be manipulated when user is changed or created.
+    # * <tt>optinos</tt> - specific options for different type of fields, see Lolita::Configuration::FieldExtensions for details
+    # * <tt>html_options</tt> - used to change field HTML output,like class or style etc.
+    # 
+    # To define field in ORM class through lolita configuration block
+    # ====Example
+    #     lolita do
+    #       tab do
+    #         field :email
+    #         field :user_id, :type=>"string"
+    #         field :body do
+    #            title "Full text" 
+    #            html_options :class=>"full_text"
+    #         end
+    #       end
+    #     end
+    class Field
+
+      lolita_accessor :name,:title,:field_set,:nested_for,:options, :html_options,:record
+      attr_reader :dbi,:nested_in,:association_type
+      
+      def initialize dbi, *args, &block
+        @dbi=dbi
+        self.set_attributes(*args)
+        self.instance_eval(&block) if block_given?
+        set_default_values
+        validate
+      end
+
+      def type(value=nil)
+        @type=value if value
+        add_extension unless @extension_added
+        @type
+      end
+
+      def type=(value)
+        @type=value
+        add_extension unless @extension_added
+      end
+      
+      def value value=nil, &block
+        self.send(:value=,value,&block) if value || block_given?
+        unless @value
+          self.record_value
+        else
+          if @value.is_a?(Proc)
+            @value.call(self)
+          else
+            @value
+          end
+        end
+      end
+
+      def value=(value=nil,&block)
+        if block_given?
+          @value=block
+        else
+          @value=value
+        end
+      end
+
+      def name=(value)
+        @name=value.to_sym
+      end
+
+      def type_name
+        self.type.to_s.downcase
+      end
+
+      def nested_in=(dbi)
+        unless self.dbi.associations_class_names.include?(dbi.klass.to_s)
+          raise Lolita::ReferenceError, "There is no association between #{self.dbi.klass} and #{dbi.klass}"
+        end
+        raise ArgumentError, "Field can be nested only in Lolita::DBI::Base object." unless dbi.is_a?(Lolita::DBI::Base)
+        @nested_in=dbi
+      end
+      
+      def nested?
+        !self.nested_in.nil?
+      end
+
+      def nested_in?(dbi_or_class)
+        if dbi_or_class.is_a?(Lolita::DBI::Base)
+          self.nested_in && self.nested_in.klass==dbi_or_class.klass
+        else
+          self.nested_in && self.nested_in.klass==dbi_or_class
+        end
+      end
+      
+      def set_attributes(*args)
+        if args
+          attributes=args.extract_options!
+          self.name=args.first if args.first
+          attributes.each{|attr,value|
+            self.send(:"#{attr}=",value)
+          }
+        end
+      end
+
+      # TODO is this useable
+      def record_value #TODO test
+        if self.record
+          self.record.send(self.name.to_sym)
+        else
+          nil
+        end
+      end
+
+      private
+
+      def add_extension #TODO test
+        @extension_added=true
+        set_association
+        refactor_type
+        set_association_type
+        self.extend("Lolita::Configuration::FieldExtensions::#{@type.camelize}".constantize) rescue nil
+      end
+
+      
+      def set_association #TODO test
+        assoc_name=@name.to_s.gsub(/_id$/,"")
+        @association=@dbi.reflect_on_association(assoc_name.to_sym) ||
+          @dbi.reflect_on_association(assoc_name.pluralize.to_sym)
+      end
+      
+      def refactor_type #TODO test
+        @type=if @association
+          "collection"
+        elsif [:created_at,:updated_at,:type].include?(@name)
+          "disabled"
+        else
+          @type
+        end
+      end
+
+      def set_association_type #TODO test
+        if @association
+          @association_type=@dbi.association_macro(@association)
+        end
+      end
+
+      def set_default_values
+        self.title||=self.name.to_s.capitalize
+        self.type||="string"
+        self.options||={}
+      end
+
+      def validate
+        unless self.name
+          raise Lolita::FieldNameError, "Field must have name."
+        end
+        #FIXME need this validation
+        #        if !@value && !@dbi.klass.instance_methods.include?(self.name.to_s)
+        #          raise Lolita::FieldNameError, "#{@dbi.klass} must respond to #{self.name} method."
+        #        end
+      end
+     
+    end
+  end
+end