backframe 0.0.49 → 1.0.0

data/lib/backframe/activerecord/acts_as_percent.rb

@@ -1,46 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module ActsAsPercent
-
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def acts_as_percent(entity)
-
-        class_eval <<-EOV
-
-          after_initialize :uncast_percent_#{entity}, :if => Proc.new { |c| c.#{entity}.present? }
-          before_save :cast_percent_#{entity}, :if => Proc.new { |c| c.#{entity}.present? }
-          after_save :uncast_percent_#{entity}, :if => Proc.new { |c| c.#{entity}.present? }
-
-          def raw_#{entity}
-            self.#{entity} / 100.00
-          end
-
-          private
-
-          def uncast_percent_#{entity}
-            self.#{entity} = self.#{entity} * 100.00
-          end
-
-          def cast_percent_#{entity}
-            self.#{entity} = self.#{entity} / 100.00
-          end
-
-        EOV
-
-      end
-
-    end
-
-  end
-end
-
-
-

data/lib/backframe/activerecord/acts_as_phone.rb

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-require 'phony'
-
-module Backframe
-  module ActsAsPhone
-
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def acts_as_phone(entity)
-
-        class_eval <<-EOV
-
-          after_initialize :uncast_phone_#{entity}, :if => Proc.new { |c| !c.new_record? && c.#{entity}.present? }
-          before_save :cast_phone_#{entity}, :if => Proc.new { |c| c.#{entity}.present? }
-          after_save :uncast_phone_#{entity}, :if => Proc.new { |c| c.#{entity}.present? }
-
-          validate :validates_phone_#{entity}, :if => Proc.new { |c| c.#{entity}.present? }
-
-          private
-
-          def uncast_phone_#{entity}
-            self.#{entity} = self.#{entity}[0]+'-'+self.#{entity}[1,3]+'-'+self.#{entity}[4,3]+'-'+self.#{entity}[7,4]
-          end
-
-          def cast_phone_#{entity}
-            self.#{entity} = #{entity}_to_international(self.#{entity})
-          end
-
-          def validates_phone_#{entity}
-            testvalue = #{entity}_to_international(self.#{entity})
-            if !Phony.plausible?(testvalue)
-              self.errors.add(:#{entity}, 'invalid #{entity} number')
-            end
-          end
-
-          def #{entity}_to_international(value)
-            newvalue = value.gsub('(', '').gsub(')', '').gsub('.', '').gsub('-', '').gsub(' ', '')
-            newvalue = (newvalue.length == 10) ? '1'+value : value
-            Phony.normalize(newvalue)
-          end
-
-        EOV
-
-      end
-
-    end
-
-  end
-end
-
-
-

data/lib/backframe/activerecord/acts_as_user.rb

@@ -1,101 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module ActsAsUser
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def acts_as_user(*args)
-        arguments = args[0] || {}
-
-        reset = arguments[:reset] || 'Backframe::Reset'
-        activation = arguments[:activation] || 'Backframe::Activation'
-
-        attr_accessor :password, :change_password, :set_password, :old_password, :new_password, :confirm_password, :confirm_email
-
-        has_many :activations, :class_name => activation, :dependent => :destroy, :as => :user
-        has_many :resets, :class_name => reset, :dependent => :destroy, :as => :user
-
-        after_validation :set_new_password, :if => Proc.new { |u| u.new_password.present? }
-        after_create :activate
-
-        validates_presence_of :first_name, :last_name, :email
-        validate :validate_password, :if => Proc.new { |u| u.change_password.present? || u.set_password.present? }
-
-        class_eval <<-EOV
-          def full_name
-            self.first_name+' '+self.last_name
-          end
-
-          def rfc822
-            self.full_name+' <'+self.email+'>'
-          end
-
-          def locked_out?
-            self.signin_locked_at.present? && self.signin_locked_at > Time.now.ago(5.minutes)
-          end
-
-          def signin(status)
-            if status == :success
-              self.signin_locked_at = nil
-              self.signin_attempts = 0
-            elsif status == :failed
-              self.signin_attempts += 1
-              if self.signin_attempts >= 5
-                self.signin_attempts = 0
-                self.signin_locked_at = Time.now
-              end
-            end
-            self.save
-          end
-
-          def authenticate(password)
-            self.password_hash == BCrypt::Engine.hash_secret(password, self.password_salt)
-          end
-
-          def password=(password)
-            @password = password
-            self.password_salt = BCrypt::Engine.generate_salt
-            self.password_hash = BCrypt::Engine.hash_secret(password, self.password_salt)
-          end
-
-          def password
-            @password
-          end
-
-          def validate_password
-            if self.change_password && self.old_password.blank?
-              return self.errors.add(:old_password, I18n.t('activerecord.errors.messages.blank'))
-            elsif self.change_password && !authenticate(self.old_password)
-              return self.errors.add(:old_password, I18n.t(:user_invalid_old_password))
-            elsif self.new_password.blank? || self.confirm_password.blank?
-              return self.errors.add(:new_password, I18n.t(:user_unconfirmed_password))
-            elsif self.confirm_password != self.new_password
-              return self.errors.add(:new_password, I18n.t(:user_unmatching_passwords))
-            end
-          end
-
-          def set_new_password
-            self.password = self.new_password
-          end
-
-          def activate
-            self.activations.create
-          end
-
-          def reset
-            self.resets.create
-          end
-
-        EOV
-
-      end
-
-    end
-  end
-end

data/lib/backframe/activerecord/default_values.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module DefaultValues
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def default_values(*args)
-
-        arguments = args[0] || {}
-
-        after_initialize :set_default_values, :if => Proc.new { |o| o.new_record? }
-
-        class_eval <<-EOV
-
-          def set_default_values
-            self.attributes = #{arguments.symbolize_keys.to_s}
-          end
-
-        EOV
-
-
-      end
-
-    end
-  end
-end

data/lib/backframe/activerecord/filter_sort.rb

@@ -1,79 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module FilterSort
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def filter_query(relation, filters, fields)
-        if filters.key?(:q)
-          conditions = []
-          params = []
-          fields.each do |field|
-            column = (field.match(/.*\..*/)) ? field : "\"#{self.table_name}\".\"#{field}\""
-            conditions << "LOWER(#{column}::VARCHAR) LIKE ?"
-            params << '%'+filters[:q].downcase+'%'
-          end
-          args = params.unshift(conditions.join(' OR '))
-          relation = relation.where(args)
-        end
-        relation
-      end
-
-      def filter_range(relation, filters, start_date, end_date = nil)
-        end_date ||= start_date
-        if filters.key?(:start_date) && filters.key?(:end_date)
-          relation = relation.where("\"#{self.table_name}\".\"#{start_date}\" <= ? AND \"#{self.table_name}\".\"#{end_date}\" >= ?", filters[:end_date], filters[:start_date])
-        end
-        relation
-      end
-
-      def filter_boolean(relation, filters, field)
-        if filters.key?(field)
-          relation = relation.where("\"#{self.table_name}\".\"#{field}\" = ?", true) if ["1","true"].include?(filters[field].to_s)
-          relation = relation.where("\"#{self.table_name}\".\"#{field}\" = ?", false) if ["0","false"].include?(filters[field].to_s)
-        end
-        relation
-      end
-
-      def filter_status(relation, filters, field, value)
-        if filters.key?(value)
-          relation = relation.where("\"#{self.table_name}\".\"#{field}\" = ?", value) if ["1","true"].include?(filters[value].to_s)
-          relation = relation.where("\"#{self.table_name}\".\"#{field}\" != ?", value) if ["0","false"].include?(filters[value].to_s)
-        end
-        relation
-      end
-
-      def sort(relation, key = nil, order = nil)
-        self._sort(relation, key, order, 'created_at', 'desc', [self])
-      end
-
-      def _sort(relation, key, order, default_key = 'created_at', default_order = 'desc', included = nil)
-        sortfields = {}
-        sortjoins = {}
-        self.columns.each do |column|
-          sortfields[column.name] = "\"#{self.table_name}\".\"#{column.name}\""
-        end
-        model_table = self.table_name
-        associations = self.reflect_on_all_associations(:belongs_to)
-        associations.each do |association|
-          if !(association.options.key?(:polymorphic) && association.options[:polymorphic])
-            association_name = association.name
-            association_table = association.class_name.constantize.table_name
-            association_foreign_key = association.foreign_key
-            sortjoins["#{association.name}"] = "LEFT OUTER JOIN \"#{association_table}\" #{association_name} ON (\"#{association_name}\".\"id\" = \"#{model_table}\".\"#{association_foreign_key}\")"
-            association.class_name.constantize.columns.each do |column|
-              sortfields["#{association_name}.#{column.name}"] = "\"#{association_name}\".\"#{column.name}\""
-            end
-          end
-        end
-        key = (key.present? && sortfields.has_key?(key)) ? key : default_key
-        order = (order.present?) ? order : default_order
-        if parts = key.match(/(\w*)\.(\w*)/)
-          relation = relation.joins(sortjoins[parts[1]])
-        end
-        relation.order("#{sortfields[key]} #{order}")
-      end
-    end
-  end
-end

data/lib/backframe/activerecord/migration.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  module Migration
-    extend ActiveSupport::Concern
-
-    def self.included(base)
-      base.send :extend, ClassMethods
-    end
-
-    module ClassMethods
-
-      def add_foreign_key_index(from, to, column)
-        add_foreign_key(from, to, :column => column)
-        add_index(from, column)
-      end
-
-      def remove_foreign_key_index(from, column)
-        add_index(from, column)
-        add_foreign_key(from, :column => column)
-      end
-
-    end
-  end
-end

data/lib/backframe/image_cache/image_cache.rb

@@ -1,45 +0,0 @@
-require 'backframe/image_cache/lib/asset'
-require 'backframe/image_cache/lib/cache'
-require 'backframe/image_cache/lib/conversions'
-
-module Backframe
-
-  module ImageCache
-
-    class Base
-
-      def asset(filepath, conversions)
-        Backframe::ImageCache::Asset.new(filepath, conversions).process
-      end
-
-      def cached(filepath, conversions)
-        Backframe::ImageCache::Cache.new(filepath, conversions).process
-      end
-
-      def path(filepath, conversions)
-        string = Backframe::ImageCache::Conversions.new(conversions).to_s
-        filekey = filepath || 'default.jpg'
-        "/imagecache/#{string}/#{filekey}"
-      end
-
-      def url(filepath, conversions)
-        Rails.application.config.root_url + path(filepath, conversions)
-      end
-
-      def http_url(filepath, conversions)
-        url(filepath, conversions).gsub('https', 'http')
-      end
-
-      def cdn_url(filepath, conversions)
-        Rails.application.config.cdn_url + path(filepath, conversions)
-      end
-
-      def http_cdn_url(filepath, conversions)
-        cdn_url(filepath, conversions).gsub('https', 'http')
-      end
-
-    end
-
-  end
-
-end

data/lib/backframe/image_cache/lib/asset.rb

@@ -1,109 +0,0 @@
-require 'stringio'
-
-module Backframe
-
-  module ImageCache
-
-    class Asset
-      
-      def initialize(filepath, conversions)
-        @filepath = filepath
-        @conversions = conversions
-      end
-
-      def process
-        normalized = Backframe::ImageCache::Conversions.new(conversions)
-        if filepath.present?
-          fullpath = fullpath(filepath)
-          content_type = content_type(filepath)
-          data = download(fullpath)
-          oriented = auto_orient(data)
-          command = expand(normalized)
-          converted = execute(oriented, command)
-        else
-          converted = default_asset
-        end
-        compressed = compress(converted)
-        OpenStruct.new({ :success => true, :data => compressed, :content_type => content_type })
-      end
-
-      private
-
-        attr_reader :filepath, :conversions
-
-        def fullpath(path)
-          File.exist?("#{Rails.root}/public/#{path}") ? "#{Rails.root}/public/#{path}" : "#{Rails.application.config.cdn_url}/#{path}"
-        end
-
-        def download(path)
-          open(path).read
-        end
-
-        def auto_orient(data)
-          execute(data, '-auto-orient')
-        end
-
-        def content_type(filepath)
-          ext = extension(filepath)
-          "image/#{ext}"
-        end
-
-        def extension(filepath)
-          filepath.match(/.*\.([a-z]*)$/)[1]
-        end
-
-        def expand(conversions)
-          command = []
-          conversions.to_a.each do |conversion|
-            if conversion.key?(:fit)
-              width = conversion[:fit][:width] * conversion[:density]
-              height = conversion[:fit][:height] * conversion[:density]
-              command << "-resize \"#{width}x#{height}^\" -gravity center -crop '#{width}x#{height}+0+0'"
-            elsif conversion.key?(:height)
-              height = conversion[:height] * conversion[:density]
-              command << "-resize \"x#{height}\""
-            elsif conversion.key?(:width)
-              width = conversion[:width] * conversion[:density]
-              command << "-resize \"#{width}\""
-            elsif conversion.key?(:crop)
-              command << "-crop '#{parts[1]}x#{parts[2]}+#{parts[3]}+#{parts[4]}'"
-            end
-          end
-          command.join(' ')
-        end
-
-        def default_asset
-          path = "#{Rails.root}/tmp/canvas.png"
-          command = "convert 10x10 canvas:#EEEEEE #{conversions} '#{path}'"
-          Rails.logger.debug(command)
-          output = `#{command}`
-          IO.read(path)
-        end
-
-        #################### UTILITIES ####################
-
-        def tmpfile(data)
-          filename = SecureRandom.hex(32).to_s.upcase[0,8]
-          tmpfile = Tempfile.new(filename, :encoding => 'ascii-8bit')
-          tmpfile.write(data)
-          tmpfile.close if tmpfile && !tmpfile.closed?
-          tmpfile
-        end
-
-        def execute(data, command)
-          tmpfile = tmpfile(data)
-          command = "convert '#{tmpfile.path}' #{command} '#{tmpfile.path}'"
-          Rails.logger.debug(command)
-          output = `#{command}`
-          IO.read(tmpfile.path)
-        end
-
-        def compress(data)
-          ActiveSupport::Gzip.compress(data)
-        end
-
-    end
-
-  end
-
-end