freeberry 0.2.5

data/lib/freeberry/controllers/helper_tools.rb

@@ -0,0 +1,171 @@
+module Freeberry
+  module Controllers
+    module HelperTools
+      
+      def title(content)
+	      content_for(:title) { content } unless content.blank?
+      end
+
+      def javascript(*args)
+	      content_for(:head) { javascript_include_tag(*args) }
+      end
+
+      def stylesheet(*args)
+        content_for(:head) { stylesheet_link_tag(*args) }
+      end
+
+      def description(content)
+        content_for(:description) { tag(:meta, :content=>content, :name=>"description") } unless content.blank?
+      end
+
+      def keywords(content)
+        content_for(:keywords) { tag(:meta, :content=>content, :name=>"keywords") } unless content.blank?
+      end
+      
+      def page_title
+        h([@page_title, I18n.t("page.title")].compact.join(' – '))
+      end
+      
+      def page_keywords
+        h([@page_keywords, I18n.t("page.meta_keywords")].compact.join(' '))
+      end
+      
+      def page_description
+        h([@page_description, I18n.t("page.meta_description")].compact.join(', '))
+      end
+
+      def anchor_to(name, options={})
+        return if name.blank?
+        options[:name] = name
+        
+        content_tag(:a, '', options)
+      end
+
+      def link_by_href(name, options={})
+        link_to name, name, options
+      end
+
+      def link_to_unless_current_span(name, options = {}, html_options = {}, &block)
+        link_to_unless_span current_page?(options), name, options, html_options, &block
+      end
+
+      def link_to_unless_span(condition, name, options = {}, html_options = {}, &block)
+        if condition
+          if block_given?
+	          block.arity <= 1 ? yield(name) : yield(name, options, html_options)
+          else
+           content_tag(:span, name, html_options)
+          end
+        else
+          link_to(name, options, html_options)
+        end
+      end
+
+      def link_to_unless_current_tag(name, options = {}, html_options = {}, &block)
+        link_to_unless_tag current_page?(options), name, options, html_options, &block
+      end
+
+      def link_to_if_tag(condition, name, options = {}, html_options = {}, &block)
+        tag_name = html_options.delete(:tag) || :span
+        if condition
+          link_to(name, options, html_options)
+        else
+          if block_given?
+	          block.arity <= 1 ? yield(name) : yield(name, options, html_options)
+          else
+           content_tag(tag_name, name, html_options)
+          end
+        end
+      end	
+
+      def link_to_unless_tag(condition, name, options = {}, html_options = {}, &block)
+        tag_name = html_options.delete(:tag) || :span
+        unless condition
+          link_to(name, options, html_options)
+        else
+          if block_given?
+	          block.arity <= 1 ? yield(name) : yield(name, options, html_options)
+          else
+           content_tag(tag_name, name, html_options)
+          end
+        end
+      end	
+
+      def link_to_remote_if(condition, name, options = {}, html_options = nil)
+        return name unless condition
+        link_to_function(name, remote_function(options), html_options || options.delete(:html))
+      end
+
+      def submit_image(name, src, options={})
+        html_options = options.dup.symbolize_keys
+        
+        html_options[:name] = name
+        html_options[:src] = src
+        html_options[:type] ||= 'image'
+        
+        tag(:input, html_options)
+      end
+
+      def submit_image_to_remote(name, value, options = {})
+        options[:with] ||= 'Form.serialize(this.form)'
+        
+        html_options = options.delete(:html) || {}
+        html_options[:name] = name
+        html_options[:type] ||= 'button'
+
+        onclick = html_options.delete(:onclick) || remote_function(options)
+
+        tag(:input, html_options.merge(:value => name, :onclick => onclick))
+      end
+
+      def locale_image_tag(source, options = {})
+        source = "#{I18n.locale}/#{source}"
+        image_tag(source, options)
+      end
+
+      # swf_object
+      def swf_object(swf, id, width, height, flash_version, options = {})
+        options.symbolize_keys!
+        
+        params = options.delete(:params) || {}
+        attributes = options.delete(:attributes) || {}
+        flashvars = options.delete(:flashvars) || {}
+        
+        attributes[:classid] ||= "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"
+        attributes[:id] ||= id
+        attributes[:name] ||= id
+        
+        output_buffer = ActiveSupport::SafeBuffer.new
+        
+        if options[:create_div]
+          output_buffer << content_tag(:div, 
+            "This website requires <a href='http://www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash&promoid=BIOW' target='_blank'>Flash player</a> #{flash_version} or higher.",
+            :id => id)
+        end
+        
+        js = []
+        
+        js << "var params = {#{params.to_a.map{|item| "#{item[0]}:'#{item[1]}'" }.join(',')}};"
+        js << "var attributes = {#{attributes.to_a.map{|item| "#{item[0]}:'#{item[1]}'" }.join(',')}};"
+        js << "var flashvars = {#{flashvars.to_a.map{|item| "#{item[0]}:'#{item[1]}'" }.join(',')}};"
+
+        js << "swfobject.embedSWF('#{swf}', '#{id}', '#{width}', '#{height}', '#{flash_version}', '/swf/expressInstall.swf', flashvars, params, attributes);"
+
+        output_buffer << javascript_tag(js.join)
+        
+        output_buffer
+      end
+
+      def encode_email(email_address, options = {})
+        email_address = email_address.to_s
+        string = ''
+
+        "document.write('#{email_address}');".each_byte do |c|
+           string << sprintf("%%%x", c)
+         end
+         
+        "<script type=\"#{Mime::JS}\">eval(decodeURIComponent('#{string}'))</script>"
+      end
+    end
+  end
+end

data/lib/freeberry/core_ext.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].sort.each do |path|
+  require "freeberry/core_ext/#{File.basename(path, '.rb')}"
+end

data/lib/freeberry/core_ext/array.rb

@@ -0,0 +1,22 @@
+require 'enumerator'
+
+class Array
+  def chunk(pieces)
+    q, r = length.divmod(pieces)
+    (0..pieces).map { |i| i * q + [r, i].min }.enum_cons(2) \
+    .map { |a, b| slice(a...b) }
+  end
+  
+  def shuffle
+    sort_by { rand }
+  end
+
+  def shuffle!
+    self.replace shuffle
+  end
+  
+  def random
+    idx = Kernel.rand(size)
+    at(idx)
+  end
+end

data/lib/freeberry/core_ext/i18n.rb

@@ -0,0 +1,21 @@
+require 'ostruct'
+
+module I18n
+  def self.name_for_locale(locale)
+    begin
+      I18n.backend.translate(locale, :name, :scope => [:language])
+    rescue I18n::MissingTranslationData
+      locale.to_s
+    end
+  end
+  
+  def self.all_available_locales
+    records = []
+    
+    available_locales.each do |locale|
+      records << OpenStruct.new(:code => locale.to_s.downcase, :title => name_for_locale(locale))
+    end
+    
+    records.sort_by(&:title)
+  end
+end

data/lib/freeberry/core_ext/string.rb

@@ -0,0 +1,28 @@
+class String
+  def is_int?
+    self =~ /^[-+]?[0-9]*$/
+  end
+  
+	def no_html
+		str = self.dup
+		str.gsub!(/<\/?[^>]*>/, '')
+		str.strip!
+		str.gsub!('&nbsp;', '')
+		str
+	end
+	
+	def words_count
+		frequencies = Hash.new(0)  
+		downcase.scan(/(\w+([-'.]\w+)*)/) { |word, ignore| frequencies[word] += 1 }
+		return frequencies
+	end
+	
+	def parameterize(sep = '-')
+	  value = Freeberry::Transliteration.transliterate(self)
+    ActiveSupport::Inflector.parameterize(value, sep)
+  end
+	
+	def self.randomize(length = 8)
+	  Array.new(length) { (rand(122-97) + 97).chr }.join
+	end
+end

data/lib/freeberry/header_tools.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Freeberry
+  module HeaderTools
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      def self.extended(base)
+        base.has_one :header, :as=>:headerable, :dependent=>:destroy
+        base.after_update :save_header
+      
+        base.send :include, InstanceMethods
+      end
+    end
+    
+    module InstanceMethods
+      def page_header=(value)
+        h = self.header || self.build_header
+        h.attributes = value
+      end
+    
+      private
+      
+        def save_header
+          self.header.save(:validate => false) unless self.header.nil?
+        end
+    end
+  end
+end

data/lib/freeberry/model_filter.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+module Freeberry
+  class ModelFilter
+    attr_accessor :klass
+    
+    attr_accessor :attributes, :columns
+    
+    attr_accessor :order_by, :order_column, :order_type
+    
+    attr_accessor :conditions
+    
+    def initialize(klass, options={})
+      options.symbolize_keys!
+      
+      @klass = klass
+      
+      @columns = options[:columns]
+      @columns ||= klass.respond_to?(:column_names) ? @klass.column_names : []
+      
+      @attributes = options[:attributes] || {}
+      @raw_values = {}
+    end
+    
+    def filter(options = {})
+      order = options.delete(:order)
+      where = options.delete(:conditions)
+      
+      {
+        :order => (self.order_by || order || "id DESC"),
+        :conditions => (self.conditions || where)
+      }.merge(options)
+    end
+    
+    def next_order_type
+      return if @order_type.blank?
+      
+      @order_type == 'desc' ? 'asc' : 'desc'
+    end
+    
+    def update_attributes(params = {})
+      return if params.nil? || params.keys.empty?
+      
+      options = params.symbolize_keys
+      
+      @raw_values = extract_values(options)
+      @conditions = extract_conditions(options)
+      @order_by = extract_order(options)
+    end
+    
+    def method_missing(method, *args, &block)
+      match_data = method.to_s.match(/^(.+)_before_type_cast$/)
+      method_name = (match_data ? match_data[1] : method).to_sym
+      
+      if @attributes.include?(method_name)
+        @raw_values[method_name]
+      else
+        super
+      end
+    end
+    
+    def respond_to?(method_name)
+      return true if @attributes.include?(method_name.to_sym)
+      super
+    end
+    
+    private
+      
+      def normalize_value(attribute, value)
+        column = @klass.columns_hash[attribute.to_s]
+        
+        case column.type
+          when :string then value.to_s
+          when :integer then value.to_s.blank? ? nil : value.to_i
+          when :float then value.to_s.blank? ? nil : value.to_f
+          else value
+        end
+      end
+      
+      def extract_order(options={})
+        options.symbolize_keys!
+        
+        ocolumn = options.delete(:order_column)
+        otype = options.delete(:order_type)
+        
+        unless ocolumn.blank?
+          @order_column = ocolumn.to_s.strip.downcase.to_s
+          @order_column = nil unless @columns.include?(@order_column)
+        end
+
+        unless @order_column.blank?
+          @order_type = otype.to_s.strip.downcase unless otype.blank?
+          @order_type = nil unless ['desc', 'asc'].include?(@order_type)
+          @order_type ||= 'desc'
+          
+          real_column = @order_column.to_s
+          
+          if @klass.respond_to?(:translated_columns) && @klass.translated_columns.include?(real_column)
+            locale = (I18n.locale.to_s == 'uk' ? 'ua' : 'ru')
+            real_column = "#{@order_column}_#{locale}"
+          end
+          
+          "#{@klass.quoted_table_name}.#{real_column} #{@order_type}"
+        end
+      end
+      
+      def extract_values(options={})
+        values = {}
+        
+        options.each do |k, v|
+          key = k.to_sym
+          values[key] = normalize_value(k, v) if @attributes.include?(key)
+        end
+        
+        values
+      end
+      
+      def extract_conditions(options={})
+        c_names = []
+        c_values = []
+        
+        @raw_values.each do |k, v|
+          next if v.blank?
+          
+          arr = extract_method(k, v)
+          
+          c_names << arr.first
+          c_values << arr.last
+        end
+        
+        [c_names.join(' AND ')] + c_values
+      end
+      
+      def extract_method(attribute, value)
+        column = @klass.columns_hash[attribute.to_s]
+        
+        case column.type
+          when :string, :text then
+            x = "#{@klass.quoted_table_name}.#{attribute} LIKE ?"
+            y = value.nil? ? nil : "#{value}%"
+          when :boolean then
+            x = "#{@klass.quoted_table_name}.#{attribute} = ?"
+            y = (value && value.to_i == 1) ? 1 : 0
+          when :integer, :float then
+            x = "#{@klass.quoted_table_name}.#{attribute} = ?"
+            y = value.nil? ? nil : value.to_i
+        end
+        
+        [x, y]
+      end
+  end
+end

data/lib/freeberry/models/asset.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    module Asset
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            belongs_to :user
+            belongs_to :assetable, :polymorphic => true
+    
+            before_validation :make_content_type
+            before_create :read_dimensions, :parameterize_file_name
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def url(*args)
+          data.url(*args)
+        end
+        
+        def filename
+          data_file_name
+        end
+        
+        def content_type
+          data_content_type
+        end
+        
+        def size
+          data_file_size
+        end
+        
+        def path
+          data.path
+        end
+        
+        def styles
+          data.styles
+        end
+        
+        def format_created_at
+          I18n.l(self.created_at, :format=>"%d.%m.%Y %H:%M")
+        end
+        
+        def to_xml(options = {})
+          builder = options[:builder] ||= Nokogiri::XML::Builder.new(options)
+
+          builder.send(self.type.to_s.downcase) do |xml|
+            xml.id_ self.id
+            xml.filename self.filename
+            xml.size self.size
+            xml.path self.url
+            
+            xml.styles do
+              self.styles.each do |style|
+                xml.send(style.first, self.url(style.first))
+              end
+            end unless self.styles.empty?
+          end
+          
+          builder.to_xml
+        end
+        
+        def has_dimensions?
+          self.respond_to?(:width) && self.respond_to?(:height)
+        end
+        
+        def image?
+          ["image/jpeg", "image/tiff", "image/png", "image/gif", "image/bmp"].include?(self.data_content_type)
+        end
+        
+        def geometry
+          @geometry ||= Paperclip::Geometry.from_file(data.to_file)
+          @geometry
+        end
+        
+        protected
+        
+          def read_dimensions
+            if image? && has_dimensions?
+              self.width = geometry.width
+              self.height = geometry.height
+            end
+          end
+          
+          def parameterize_file_name
+            unless data_file_name.blank?
+              extension = File.extname(data_file_name).downcase
+              filename = File.basename(data_file_name, extension).downcase.parameterize
+                      
+              self.data.instance_write(:file_name, [filename, extension].join)
+            end
+          end
+          
+          def make_content_type
+            if data_content_type == "application/octet-stream"
+              content_types = MIME::Types.type_for(filename)
+              self.data_content_type = content_types.first.to_s unless content_types.empty?
+            end
+          end
+      end
+    end
+  end
+end