lipsiadmin 2.9

data/lib/data_base/attachment/thumbnail.rb

@@ -0,0 +1,72 @@
+module Lipsiadmin
+  module Attachment
+    # Handles thumbnailing images that are uploaded.
+    class Thumbnail < Processor
+
+      attr_accessor :current_geometry, :target_geometry, :format, :whiny, :convert_options
+
+      # Creates a Thumbnail object set to work on the +file+ given. It
+      # will attempt to transform the image into one defined by +target_geometry+
+      # which is a "WxH"-style string. +format+ will be inferred from the +file+
+      # unless specified. Thumbnail creation will raise no errors unless
+      # +whiny+ is true (which it is, by default. If +convert_options+ is
+      # set, the options will be appended to the convert command upon image conversion 
+      def initialize(file, options = {})
+        super
+        geometry          = options[:geometry]
+        @file             = file
+        @crop             = geometry[-1,1] == '#'
+        @target_geometry  = Geometry.parse geometry
+        @current_geometry = Geometry.from_file @file
+        @convert_options  = options[:convert_options]
+        @whiny            = options[:whiny].nil? ? true : options[:whiny]
+        @format           = options[:format]
+
+        @current_format   = File.extname(@file.path)
+        @basename         = File.basename(@file.path, @current_format)
+      end
+
+      # Returns true if the +target_geometry+ is meant to crop.
+      def crop?
+        @crop
+      end
+
+      # Returns true if the image is meant to make use of additional convert options.
+      def convert_options?
+        not @convert_options.blank?
+      end
+
+      # Performs the conversion of the +file+ into a thumbnail. Returns the Tempfile
+      # that contains the new image.
+      def make
+        src = @file
+        dst = Tempfile.new([@basename, @format].compact.join("."))
+        dst.binmode
+
+        command = <<-end_command
+          "#{ File.expand_path(src.path) }[0]"
+          #{ transformation_command }
+          "#{ File.expand_path(dst.path) }"
+        end_command
+
+        begin
+          success = Attachment.run("convert", command.gsub(/\s+/, " "))
+        rescue AttachmentCommandLineError
+          raise AttachmentError, "There was an error processing the thumbnail for #{@basename}" if @whiny
+        end
+
+        dst
+      end
+
+      # Returns the command ImageMagick's +convert+ needs to transform the image
+      # into the thumbnail.
+      def transformation_command
+        scale, crop = @current_geometry.transformation_to(@target_geometry, crop?)
+        trans = "-resize \"#{scale}\""
+        trans << " -crop \"#{crop}\" +repage" if crop
+        trans << " #{convert_options}" if convert_options?
+        trans
+      end
+    end
+  end
+end

data/lib/data_base/attachment/upfile.rb

@@ -0,0 +1,45 @@
+module Lipsiadmin
+  module Attachment
+    # The Upfile module is a convenience module for adding uploaded-file-type methods
+    # to the +File+ class. Useful for testing.
+    #   user.avatar = File.new("test/test_avatar.jpg")
+    module Upfile
+
+      # Infer the MIME-type of the file from the extension.
+      def content_type
+        type = (self.path.match(/\.(\w+)$/)[1] rescue "octet-stream").downcase
+        case type
+        when %r"jpe?g"                 then "image/jpeg"
+        when %r"tiff?"                 then "image/tiff"
+        when %r"png", "gif", "bmp"     then "image/#{type}"
+        when "txt"                     then "text/plain"
+        when %r"html?"                 then "text/html"
+        when "csv", "xml", "css", "js" then "text/#{type}"
+        else "application/x-#{type}"
+        end
+      end
+
+      # Returns the file's normal name.
+      def original_filename
+        File.basename(self.path)
+      end
+
+      # Returns the size of the file.
+      def size
+        File.size(self)
+      end
+    end
+  end
+
+  if defined? StringIO
+    class StringIO#:nodoc:
+      attr_accessor :original_filename, :content_type
+      def original_filename
+        @original_filename ||= "stringio.txt"
+      end
+      def content_type
+        @content_type ||= "text/plain"
+      end
+    end
+  end
+end

data/lib/data_base/attachment_table.rb

@@ -0,0 +1,142 @@
+module Lipsiadmin
+  module DataBase
+    # This is the table that handle the attachments. 
+    # You can define some global info like:
+    # 
+    #   attachment_styles :thumb, "128x128"
+    # 
+    # In this way all models that use <tt>has_one_attachment</tt> or 
+    # <tt>has_many_attachments</tt> handle a default style called *thumb*
+    # 
+    # Remember that any model that use <tt>has_one_attachment</tt> or 
+    # <tt>has_many_attachments</tt> can override/add styles/validations etc...
+    # 
+    class AttachmentTable < ActiveRecord::Base
+      
+      def self.inherited(subclass)#:nodoc:
+        super
+        subclass.write_inheritable_attribute(:attachment_definitions, {}) if subclass.attachment_definitions.nil?
+        subclass.attachment_definitions[subclass.name] = {:validations => {}}.merge(Lipsiadmin::Attachment.options)
+        subclass.extend(ClassMethods)
+      end
+      
+      set_table_name "attachments"
+      
+      belongs_to :attacher, :polymorphic => true
+      after_save :save_attached_files
+      before_destroy :destroy_attached_files
+      define_callbacks :before_post_process, :after_post_process
+      define_callbacks :"before_attached_post_process", :"after_attached_post_process"
+      
+      #validates_presence_of :filename
+      
+      # Returns the url of the attachment, optionally you can pass the style like url(:thumb)
+      def url(style=nil)
+        file.to_s(style)
+      end
+      
+      # Returns a <tt>Lipsiadmin::Attachment::Attach</tt> instance
+      def file
+        @_file ||= Lipsiadmin::Attachment::Attach.new(:attached, self, attachment_definitions)
+      end
+      
+      # Assign a <tt>Lipsiadmin::Attachment::Attach</tt> instance to the current file
+      def file=(tempfile)
+        file.assign(tempfile)
+      end
+      
+      # Returns true if the file exist
+      def file?
+        file.exist?
+      end
+      
+      def attachment_definitions=(options)#:nodoc:
+        attachment_definitions.merge!(options.symbolize_keys)
+      end
+      
+      # This is the custom instance attachment_definition
+      def attachment_definitions#:nodoc:
+        @instance_attachment_definitions ||= self.class.attachment_definitions[self.class.name].clone
+        return @instance_attachment_definitions
+      end
+      
+      validates_each(:file) do |record, attr, value|
+        attachment = record.file
+        attachment.send(:flush_errors) unless attachment.valid?
+      end
+      
+      # Perform <tt>file</tt>.save
+      def save_attached_files
+        logger.info("[Attachment] Saving attachments.")
+        file.save
+      end
+      
+      # Perform <tt>file</tt>.destroy
+      def destroy_attached_files
+        logger.info("[Attachment] Deleting attachments.")
+        file.queue_existing_for_delete
+        file.flush_deletes
+      end
+    end
+    
+    module ClassMethods#:nodoc:
+
+      def attachment_url(url)
+        attachment_attachment_url_for(self.name, url)
+      end
+
+      def attachment_default_url(url)
+        attachment_default_url_for(self.name, url)
+      end
+      
+      def attachment_path(path)
+        attachment_path_for(self.name, path)
+      end
+          
+      def attachment_styles(name, styles)
+        attachment_styles_for(self.name, name, styles)
+      end
+      
+      def attachment_default_style(default_style)
+        attachment_default_style_for(self.name, default_style)
+      end
+
+      def attachment_whiny(whiny_thumbnails)
+        attachment_whiny_for(self.name, whiny_thumbnails)
+      end
+
+      def attachment_storage(storage)
+        attachment_storage_for(self.name, storage)
+      end
+      
+      def attachment_convert_options(name, convert_options)
+        attachment_convert_options_for(self.name, name, convert_options)
+      end
+      
+      def attachment_background(background)
+        attachment_background_for(self.name, background)
+      end
+      
+      def attachment_processors(processors)
+        attachment_processors_for(self.name, processors)
+      end
+
+      def validates_attachment_size(options = {})
+        validates_attachment_size_for(self.name, options)
+      end
+
+      def validates_attachment_thumbnails(options = {})
+        validates_attachment_thumbnails_for(self.name, options)
+      end
+
+      def validates_attachment_presence(options = {})
+        validates_attachment_presence_for(self.name, options)
+      end
+
+      def validates_attachment_content_type(options = {})
+        validates_attachment_content_type_for(self.name, options)
+      end
+    end
+    
+  end
+end

data/lib/data_base/translate_attributes.rb

@@ -0,0 +1,30 @@
+module Lipsiadmin
+  module DataBase
+    # With this method we can translate define and automatically translate columns for 
+    # the current rails locale.
+    # 
+    # Defining some columns like these:
+    # 
+    #   m.col :string, :name_it, :name_en, :name_cz
+    #   m.col :text, :description_it, :description_en, :description_cz
+    #   
+    # we can call
+    #   
+    #   myinstance.name
+    # 
+    # or
+    # 
+    #   puts myinstance.description
+    #   
+    # Lipsiadmin look for name_#{I18n.locale}
+    # 
+    module TranslateAttributes
+      # Define <tt>method missing</tt> to intercept calls to non-localized methods (eg. +name+ instead of +name_cz+)
+      def method_missing(method_name, *arguments)
+        # puts "Trying to send '#{method_name}_#{I18n.locale}' to #{self.class}" # uncomment for easy debugging in script/console
+        return self.send(:"#{method_name}_#{I18n.locale}") if self.respond_to?(:"#{method_name}_#{I18n.locale}")
+        super
+      end
+    end
+  end
+end

data/lib/data_base/utility_scopes.rb

@@ -0,0 +1,40 @@
+module Lipsiadmin
+  module DataBase
+    # This Module provides named scope for:
+    # 
+    # - Search records in a extjs way (but can reusable)
+    # - Paginate records in a extjs way (but can be reusable)
+    # - Add association to the model (used for search in dependents tables)
+    # 
+    #   Examples:
+    #   
+    #     invoices = current_account.store.invoices.with(:order).search(params)
+    #     invoices_count = invoices.size
+    #     invoices_paginated = invoices.paginate(params)
+    # 
+    module UtilityScopes
+      def self.included(base)#:nodoc:
+        base.class_eval do 
+          named_scope :search, lambda { |params|
+            order = params[:sort].blank? && params[:dir].blank? ? nil : "#{params[:sort]} #{params[:dir]}"
+            conditions = nil
+
+            if !params[:query].blank? && !params[:fields].blank?
+              filters = params[:fields].split(",").collect { |f| "#{f} LIKE ?" }.compact
+              conditions = [filters.join(" OR ")].concat((1..filters.size).collect { "%#{params[:query]}%" })
+            end
+
+            { :conditions => conditions }
+          }
+
+          named_scope :paginate, lambda { |params|
+            order = params[:sort].blank? && params[:dir].blank? ? nil : "#{params[:sort]} #{params[:dir]}"
+            { :order => order, :limit => params[:limit], :offset => params[:start] }
+          }
+
+          named_scope :with, lambda { |*associations| { :include => associations } }
+        end
+      end
+    end
+  end
+end

data/lib/data_base/without_table.rb

@@ -0,0 +1,62 @@
+module Lipsiadmin
+  module DataBase
+    # This class create a *fake* table that can be usefull if you need for example
+    # perform validations. Take a look to this test case:
+    # 
+    #   Examples:
+    # 
+    #     class Contact < Lipsiadmin::DataBase::WithoutTable
+    #       column :name, :string
+    #       column :company, :string
+    #       column :telephone, :string
+    #       column :email, :string
+    #       column :message, :text
+    #     
+    #       validates_presence_of :name, :message
+    #       validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+    #     end
+    # 
+    # Now we need to validate a contact, and if the validations is okey send an email or if not raise errors
+    # 
+    #   @contact = Contact.new(params[:contact])
+    #   if @contact.valid? 
+    #     Notifier.deliver_support_request(@contact)
+    #   else
+    #     flash[:notice] = "There are some problems"
+    #     render :action => :support_request
+    #   end
+    # 
+    class WithoutTable < ActiveRecord::Base
+      self.abstract_class = true
+
+      def create_or_update#:nodoc:
+        errors.empty?
+      end
+
+      class << self
+        def inherited(klass)#:nodoc:
+          columns_hash.each do |name, column|
+            klass.columns << column unless klass.column_names.include(name)
+          end
+        end
+        
+        # Returns columns for this *fake* table
+        def columns()
+          @columns ||= []
+        end
+        
+        # Define columns for a this *fake* table
+        def column(name, sql_type = nil, default = nil, null = true)
+          columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
+          reset_column_information
+        end
+        
+        # Resets all the cached information about columns, which will cause them to be reloaded on the next request.
+        def reset_column_information
+          generated_methods.each { |name| undef_method(name) }
+          @column_names = @columns_hash = @content_columns = @dynamic_methods_hash = @generated_methods = nil
+        end
+      end
+    end
+  end
+end

data/lib/generator.rb

@@ -0,0 +1,114 @@
+require 'rails_generator'
+require 'rails_generator/commands'
+require 'find'
+
+module Lipsiadmin#:nodoc:
+  module Generator#:nodoc:
+
+    module Lookup#:nodoc:
+      def self.included(base)
+        base.class_eval do
+          alias_method_chain :use_component_sources!, :lipsiadmin
+        end
+      end
+      
+      # Append my sources
+      def use_component_sources_with_lipsiadmin!
+        use_component_sources_without_lipsiadmin!
+        sources << Rails::Generator::PathSource.new(:lipsiadmin, "#{File.dirname(__FILE__)}/../lipsiadmin_generators")
+      end
+
+    end
+  end
+end
+
+module Lipsiadmin#:nodoc:
+  module Generator#:nodoc:
+    module Commands#:nodoc:
+
+      module Base#:nodoc:
+        PROTECTED_DIRS = ["app/controllers/",
+                          "app/views/",
+                          "config/",
+                          "app/helpers/",
+                          "app/models/",
+                          "config/",
+                          "lib/",
+                          "app/views/layouts/",
+                          "public/images/",
+                          "public/javascripts/",
+                          "public/stylesheet/"]
+        
+        def with_source_in(path)
+          root = source_path(path)
+          Find.find(root) do |f|
+            Find.prune if File.basename(f) == ".svn"
+            Find.prune if File.basename(f) == ".DS_Store"
+            full_path = f[(source_root.length)..-1]
+            rel_path = f[(root.length)..-1]
+            yield full_path, rel_path
+          end
+        end
+
+        def create_all(relative_source, relative_destination)
+          directories = []
+          with_source_in(relative_source) do |full, rel|
+            if File.directory?(source_path(full))
+              directory File.join(relative_destination, rel)
+              directories << File.join(relative_destination, rel)
+            else
+              file full, File.join(relative_destination, rel)
+            end
+          end
+          # Need to do this for remove all directories
+          directories.each { |d| directory(d) unless PROTECTED_DIRS.include?(d) }
+        end
+        
+        private
+          def render_template_part(template_options)
+            # Getting Sandbox to evaluate part template in it
+            part_binding = template_options[:sandbox].call.sandbox_binding
+            part_rel_path = template_options[:insert]
+            part_path = source_path(part_rel_path)
+
+            # Render inner template within Sandbox binding
+            rendered_part = ERB.new(File.readlines(part_path).join, nil, '-').result(part_binding)
+          end
+      end
+
+      module Destroy#:nodoc:
+        include Base
+
+        def append(relative_destination, text, sentinel=nil)
+          path = destination_path(relative_destination)
+          logger.append relative_destination
+          content = File.read(path)
+          if content.include?(text)
+            text = content.gsub(text+"\n", "")
+            File.open(path, 'wb') {|f| f.write(text) }
+          end
+        end
+      end # Module Create
+      
+      module Create#:nodoc:
+        include Base
+
+        def append(relative_destination, text, sentinel=nil)
+          path = destination_path(relative_destination)
+          logger.append relative_destination
+          content = File.read(path)
+          unless content.include?(text)
+            text = sentinel.blank? ? (content + "\n" + text + "\n") : content.gsub(sentinel, sentinel+"\n"+text)
+            File.open(path, 'wb') {|f| f.write(text) }
+          end
+        end
+      end # Module Create
+    end # Module Commands
+  end # Module Utils
+end # Module Backend
+
+# For Backend Generators
+Rails::Generator::Commands::Create.send(:include, Lipsiadmin::Generator::Commands::Create)
+Rails::Generator::Commands::Destroy.send(:include, Lipsiadmin::Generator::Commands::Destroy)
+Rails::Generator::Lookup::ClassMethods.send(:include, Lipsiadmin::Generator::Lookup)
+Rails::Generator::Base.send(:include, Rails::Generator::Lookup)