backframe 0.0.49 → 1.0.0

data/lib/backframe/image_cache/lib/cache.rb

@@ -1,67 +0,0 @@
-require 'stringio'
-
-module Backframe
-
-  module ImageCache
-
-    class Cache
-      
-      def initialize(filepath, conversions)
-        @filepath = filepath
-        @conversions = conversions
-      end
-
-      def process
-        begin
-          test(filepath, conversions)
-        rescue
-          test(nil, conversions)
-        end
-      end
-
-      def test(filepath, conversions)
-        filekey = filepath || 'default.jpg'
-        normalized = Backframe::ImageCache::Conversions.new(conversions)
-        key = "imagecache/#{normalized.to_s}/#{filekey}"
-        if !redis.get(key)
-          asset = Backframe::ImageCache::Asset.new(filepath, normalized).process
-          upload_to_s3(asset, key)
-          save_to_redis(key)
-        end
-        return OpenStruct.new(:success => true, :url => "#{Rails.application.config.cdn_url}/#{key}")
-      end
-
-      private
-
-        attr_reader :filepath, :conversions
-
-        def save_to_redis(key)
-          redis.set(key, true)
-          redis.expire(key, (7 * 24 * 60 * 60))
-        end
-
-        def upload_to_s3(asset, key)
-          headers = { :acl => 'public-read', :content_type => asset.content_type, :cache_control => 'max-age=315360000, no-transform, public', :content_encoding => 'gzip' }
-          bucket = s3.buckets[aws['bucket']]
-          bucket.objects.create(key, asset.data, headers)
-        end
-
-        def aws
-          @aws ||= YAML.load_file("#{Rails.root}/config/aws.yml")[Rails.env]
-        end
-
-        def s3
-          @s3 ||= AWS::S3.new(:access_key_id => aws['access_key_id'], :secret_access_key => aws['secret_access_key'])
-        end
-
-        def redis
-          return @redis if @redis.present?
-          config = YAML.load_file("#{Rails.root}/config/redis.yml")[Rails.env]
-          @redis = Redis.new(:host => config['host'], :port => config['port'], :db => config[:cache])
-        end
-
-    end
-
-  end
-
-end

data/lib/backframe/image_cache/lib/conversions.rb

@@ -1,132 +0,0 @@
-require 'stringio'
-
-module Backframe
-
-  module ImageCache
-
-    class Conversions
-      
-      def initialize(conversions)
-        @conversions = normalize_conversions(conversions)
-      end
-
-      def to_s
-        output = []
-        conversions.each do |conversion|
-          if conversion.key?(:fit)
-            output << "F#{conversion[:fit][:width]}X#{conversion[:fit][:height]}D#{conversion[:density]}"
-          elsif conversion.key?(:width)
-            output << "W#{conversion[:width]}D#{conversion[:density]}"
-          elsif conversion.key?(:height)
-            output << "H#{conversion[:height]}D#{conversion[:density]}"
-          elsif conversion.key?(:crop)
-            output << "C#{conversion[:crop][:width]}X#{conversion[:crop][:height]}X#{conversion[:crop][:x]}X#{conversion[:crop][:y]}D#{conversion[:density]}"
-          end
-        end
-        output.join("-")
-      end
-
-      def to_a
-        conversions
-      end
-
-      private
-
-        attr_reader :conversions
-
-        #################### CONVERSION HANDLING ####################
-
-        def normalize_conversions(conversions)
-          if conversions.is_a?(String)
-            return normalize_conversion_string(conversions)
-          elsif conversions.is_a?(Symbol)
-              return normalize_conversion_string(conversions.to_s)
-          elsif conversions.is_a?(Hash)
-            return normalize_conversion_array([conversions])
-          elsif conversions.is_a?(Array)
-            return normalize_conversion_array(conversions)
-          elsif conversions.is_a?(Backframe::ImageCache::Conversions)
-            return conversions.to_a
-          end
-        end
-
-      def normalize_conversion_string(string)
-        output = []
-        string.upcase.split("-").each do |part|
-          if part == 'PREVIEW'
-            output << { :width => 250, :density => 2 }
-          elsif part == 'TINY'
-            output << { :fit => { :width => 20, :height => 20 }, :density => 2 }
-          elsif part == 'SMALL'
-            output << { :fit => { :width => 40, :height => 40 }, :density => 2 }
-          elsif part == 'MEDIUM'
-            output << { :fit => { :width => 250, :height => 250 }, :density => 2 }
-          elsif matches = part.match(/^F(\d*)X(\d*)(D(\d*))?$/)
-            density = (matches[3]) ? matches[4] : 1
-            output << { :fit => { :width => matches[1].to_i, :height => matches[2].to_i }, :density => density.to_i }
-          elsif matches = part.match(/^W(\d*)(D(\d*))?$/)
-            density = (matches[2]) ? matches[3] : 1
-            output << { :width => matches[1].to_i, :density => density.to_i }
-          elsif matches = part.match(/^H(\d*)(D(\d*))?$/)
-            density = (matches[2]) ? matches[3] : 1
-            output << { :height => matches[1].to_i, :density => density.to_i }
-          elsif matches = part.match(/^C(\d*)X(\d*)X(\d*)X(\d*)(D(\d*))?$/)
-            density = (matches[4]) ? matches[5] : 1
-            output << { :crop => { :width => matches[1].to_i, :height => matches[2].to_i, :x => matches[3].to_i, :y => matches[4].to_i, :density => density.to_i } }
-          end
-        end
-        output
-      end
-
-      def normalize_conversion_array(array)
-        output = []
-        array.each do |conversion|
-          density = conversion[:density].to_i || 1
-          if conversion.key?(:preview)
-            output << { :width => 250, :density => density }
-          elsif conversion.key?(:tiny)
-            output << { :fit => { :width => 20, :height => 20 }, :density => density }
-          elsif conversion.key?(:small)
-            output << { :fit => { :width => 40, :height => 40 }, :density => density }
-          elsif conversion.key?(:medium)
-            output << { :fit => { :width => 250, :height => 250 }, :density => density }
-          elsif conversion.key?(:fit)
-            fit = (conversion[:fit].is_a?(String)) ? parse_geometry_string(conversion[:fit]) : parse_geometry_array(conversion[:fit])
-            output << { :fit => fit, :density => density }
-          elsif conversion.key?(:width)
-            output << { :width => conversion[:width].to_i, :density => density }
-          elsif conversion.key?(:height)
-            output << { :height => conversion[:height].to_i, :density => density }
-          elsif conversion.key?(:crop)
-            crop = (conversion[:crop].is_a?(String)) ? parse_geometry(conversion[:crop]) : parse_geometry_array(conversion[:crop])
-            output << { :crop => crop, :density => density }
-          end
-        end
-        output
-      end
-
-      def parse_geometry_string(string)
-        string = string.upcase
-        if matches = string.match(/^(\d*)X(\d*)$/)
-          { :width => matches[1].to_i, :height => matches[2].to_i }
-        elsif matches = string.match(/^(\d*)X(\d*)X(\d*)X(\d*)$/)
-          { :width => matches[1].to_i, :height => matches[2].to_i, :x => matches[3].to_i, :y => matches[4].to_i }
-        elsif matches = string.match(/^(\d*)X(\d*)\+(\d*)\+(\d*)$/)
-          { :width => matches[1].to_i, :height => matches[2].to_i, :x => matches[3].to_i, :y => matches[4].to_i }
-        end
-      end
-
-      def parse_geometry_array(array)
-        output = {}
-        output[:width] = array[:width].to_i if array.key?(:width)
-        output[:height] = array[:height].to_i if array.key?(:height)
-        output[:x] = array[:x].to_i if array.key?(:x)
-        output[:y] = array[:y].to_i if array.key?(:y)
-        output
-      end
-
-    end
-
-  end
-
-end

data/lib/backframe/models/activation.rb

@@ -1,60 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  class Activation < ActiveRecord::Base
-
-    liquid_methods :code, :url
-
-    belongs_to :user, :polymorphic => true
-
-    validates_presence_of :user, :token
-
-    after_initialize :init, :if => Proc.new { |o| o.new_record? }
-    after_create :enforce_uniqueness
-    after_commit :send_email
-
-    def claim
-      self.claimed_at = Time.zone.now
-      self.is_active = false
-      self.save
-      self.user.update_attributes(:is_active => true, :activated_at => Time.zone.now)
-    end
-
-    def expired?
-      !self.is_active
-    end
-
-    def url
-      return "#{Rails.application.config.root_url}/admin/activation/#{self.token}"   if self.user_type == 'Admin'
-      return "#{Rails.application.config.root_url}/account/activation/#{self.token}" if self.user_type == 'Customer'
-    end
-
-    private
-
-      def init
-        self.token ||= SecureRandom.hex(32).to_s.upcase[0,32]
-        self.is_active = true
-      end
-
-      def set_active
-        self.is_active = true
-      end
-
-      def enforce_uniqueness
-        self.user.activations.where('id != ?', self.id).update_all(:is_active => false)
-      end
-
-      def send_email
-        return if Rails.env.test?
-        if self.user_type == 'Admin'
-          ApplicationMailer.activation(self).deliver_now!
-        elsif self.user_type == 'Customer'
-          template = EmailTemplate.find_by(:code => 'account_activation')
-          email = EmailDelivery.new(:customer => self.user, :subject => template.subject, :body => template.body)
-          email.personalize(:customer => self.user, :activation => self)
-          email.save
-        end
-      end
-
-  end
-end

data/lib/backframe/models/activity.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  class Activity < ActiveRecord::Base
-
-    belongs_to :subject, :polymorphic => true
-    belongs_to :object1, :polymorphic => true
-    belongs_to :object2, :polymorphic => true
-    belongs_to :story
-
-    validates_presence_of :story, :subject
-
-    default_scope -> { includes(:subject,:object1,:object2,:story).order(:created_at => :desc) }
-
-    def text=(text)
-      self.story = Backframe::Story.find_or_initialize_by(:text => text)
-    end
-
-    def subject=(object)
-      self.subject_type = object.class.name
-      self.subject_text = object.activity_text
-      self.subject_id   = object.id
-    end
-
-    def object1=(object)
-      self.object1_type = object.class.name
-      self.object1_text = object.activity_text
-      self.object1_id   = object.id
-      object
-    end
-
-    def object2=(object)
-      self.object2_type = object.class.name
-      self.object2_text = object.activity_text
-      self.object2_id   = object.id
-      object
-    end
-
-  end
-end

data/lib/backframe/models/reset.rb

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  class Reset < ActiveRecord::Base
-
-    liquid_methods :code, :url
-
-    belongs_to :user, :polymorphic => true
-
-    validates_presence_of :user, :token
-
-    after_initialize :init, :if => Proc.new { |o| o.new_record? }
-    after_create :enforce_uniqueness
-    after_commit :send_email
-
-    def claim
-      self.claimed_at = Time.zone.now
-      self.is_active = false
-      self.save
-      self.user.update_attributes(:is_active => true, :activated_at => Time.zone.now)
-    end
-
-    def expired?
-      !self.is_active
-    end
-
-    def url
-      return "#{Rails.application.config.root_url}/admin/reset/#{self.token}"   if self.user_type == 'Admin'
-      return "#{Rails.application.config.root_url}/account/reset/#{self.token}" if self.user_type == 'Customer'
-    end
-
-    private
-
-      def init
-        self.token ||= SecureRandom.hex(32).to_s.upcase[0,32]
-        self.is_active = true
-      end
-
-      def set_active
-        self.is_active = true
-      end
-
-      def enforce_uniqueness
-        self.user.resets.where('id != ?', self.id).update_all(:is_active => false)
-      end
-
-      def send_email
-        if self.user_type == 'Admin'
-          ApplicationMailer.reset(self).deliver_now!
-        elsif self.user_type == 'Customer'
-          template = EmailTemplate.find_by(:code => 'password_reset')
-          email = EmailDelivery.new(:customer => self.user, :subject => template.subject, :body => template.body)
-          email.personalize(:customer => self.user, :reset => self)
-          email.save
-        end
-      end
-
-  end
-end

data/lib/backframe/models/story.rb

@@ -1,9 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  class Story < ActiveRecord::Base
-
-    has_many :activities
-
-  end
-end

data/lib/backframe/serializers/activity_serializer.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-module Backframe
-  class ActivitySerializer < ActiveModel::Serializer
-
-    cache :key => :object
-    attributes :id, :subject, :story, :object1, :object2, :created_at, :updated_at
-
-    def subject
-      if object.subject.present?
-        { :link => object.subject.activity_link, :photo => (object.subject.photo.present?) ? object.subject.photo.url(:small) : nil, :text => object.subject.full_name }
-      elsif object.subject_text.present?
-        { :text => object.subject_text }
-      else
-        nil
-      end
-    end
-
-    def story
-      object.story.text
-    end
-
-    def object1
-      if object.object1.present?
-        { :link => object.object1.activity_link, :entity => object.object1.activity_entity, :text => object.object1.activity_text }
-      elsif object.object1_text.present?
-        { :text => object.object1_text }
-      else
-        nil
-      end
-    end
-
-    def object2
-      if object.object2.present?
-        { :link => object.object2.activity_link, :entity => object.object2.activity_entity, :text => object.object2.activity_text }
-      elsif object.object2_text.present?
-        { :text => object.object2_text }
-      else
-        nil
-      end
-    end
-
-  end
-end

data/spec/backframe/acts_as_api_spec.rb

@@ -1,225 +0,0 @@
-require 'spec_helper'
-
-describe 'Backframe::ActsAsAPI', type: :controller do
-  controller do
-    include Backframe::ActsAsAPI
-    acts_as_api
-
-    def base_api_url
-      '/example'
-    end
-  end
-
-  describe 'error handlng' do
-    before { get :index }
-
-    context 'acts_as_resource not found' do
-      controller do
-        def index
-          raise ActiveRecord::RecordNotFound
-        end
-      end
-
-      it 'responds with 404 status' do
-        expect(response.status).to eq 404
-      end
-
-      it 'responds with JSON body' do
-        expect(json_response[:error][:status]).to eq 404
-        expect(json_response[:error][:message]).to be
-      end
-    end
-
-    context 'route not found' do
-      controller do
-        def index
-          raise ActionController::RoutingError, ''
-        end
-      end
-
-      it 'responds with 404 status' do
-        expect(response.status).to eq 404
-      end
-
-      it 'responds with JSON body' do
-        expect(json_response[:error][:status]).to eq 404
-        expect(json_response[:error][:message]).to be
-      end
-    end
-
-    context 'unauthenticated' do
-      controller do
-        def index
-          raise Backframe::Exceptions::Unauthenticated
-        end
-      end
-
-      it 'responds with 401 status' do
-        expect(response.status).to eq 401
-      end
-
-      it 'responds with JSON body' do
-        expect(json_response[:error][:status]).to eq 401
-        expect(json_response[:error][:message]).to be
-      end
-    end
-
-    context 'unauthorized' do
-      controller do
-        def index
-          raise Backframe::Exceptions::Unauthorized
-        end
-      end
-
-      it 'responds with 403 status' do
-        expect(response.status).to eq 403
-      end
-
-      it 'responds with JSON body' do
-        expect(json_response[:error][:status]).to eq 403
-        expect(json_response[:error][:message]).to be
-      end
-    end
-  end
-
-  describe 'headers' do
-    controller do
-      def index
-        render nothing: true
-      end
-    end
-
-    it 'responds with Last-Modified header' do
-      get :index
-
-      # FIXME: Use timecop here
-      expect(response.headers['Last-Modified']).to eq Time.now.httpdate
-    end
-  end
-
-  describe '#page' do
-    let!(:records) { create_list(:example, 10) }
-
-    controller do
-      def index
-        page(Example.all, nil)
-      end
-    end
-
-    it 'responds with 200 status' do
-      get :index, format: :json
-      expect(response.status).to eq 200
-    end
-
-    it 'responds with records' do
-      get :index, format: :json
-      expect(json_response[:records].length).to eq 10
-    end
-
-    it 'responds with links' do
-      get :index, format: :json
-      expect(json_response[:links]).to be
-      expect(json_response[:links][:self]).to eq '/example/anonymous.json?page=1'
-    end
-
-    context 'with pagination params' do
-      before { get :index, page: 2, per_page: 3, format: :json }
-
-      it 'serializes one page of records' do
-        expect(json_response[:records].length).to eq 3
-
-        serialized = serialize(Example.sort(Example)[3]).stringify_keys
-        expect(json_response[:records].first).to eq serialized
-      end
-
-      it 'includes pagination metadata' do
-        expect(json_response[:total_records]).to eq 10
-        expect(json_response[:total_pages]).to eq 4
-        expect(json_response[:current_page]).to eq 2
-      end
-    end
-
-    context 'without pagination params' do
-      before { get :index, format: :json }
-
-      it 'serializes all records' do
-        expect(json_response[:records].length).to eq 10
-
-        serialized = serialize(Example.sort(Example).first).stringify_keys
-        expect(json_response[:records].first).to eq serialized
-      end
-
-      it 'includes pagination metadata' do
-        expect(json_response[:total_records]).to eq 10
-        expect(json_response[:total_pages]).to eq 1
-        expect(json_response[:current_page]).to eq 1
-      end
-    end
-
-    context 'with sort params' do
-      controller do
-        def index
-          page(Example.all)
-        end
-      end
-
-      context 'with single param' do
-        before do
-          create_list(:example, 10)
-          get :index, sort: 'a', format: :json
-        end
-
-        it 'responds with records sorted ascending' do
-          values = json_response[:records].map { |record| record[:a] }
-          expect(values).to eq values.sort
-        end
-      end
-
-      context 'with negated param' do
-        before do
-          create_list(:example, 10)
-          get :index, sort: '-a', format: :json
-        end
-
-        it 'responds with records sorted descending' do
-          values = json_response[:records].map { |record| record[:a] }
-          expect(values).to eq values.sort.reverse
-        end
-      end
-
-      context 'with multiple params' do
-        before do
-          create_list(:example, 10, a: 'a')
-          create_list(:example, 10)
-          get :index, sort: 'a,b', format: :json
-        end
-
-        it 'responds with records sorted by both fields' do
-          values = json_response[:records].map { |record| [record[:a], record[:b]] }
-          expect(values).to eq values.sort
-        end
-      end
-    end
-
-    context 'with field params' do
-      let!(:records) { create_list(:example, 10) }
-
-      before { get :index, fields: 'a,b', format: :json }
-
-      it 'only responds with given fields' do
-        expect(json_response[:records].first).to eq serialize(Example.sort(Example).first, fields: [:a, :b]).stringify_keys
-      end
-    end
-
-    context 'with exclude ids params' do
-      let!(:records) { create_list(:example, 10) }
-      let(:exclude_ids) { records.take(5).map(&:id).join(',') }
-
-      before { get :index, exclude_ids: exclude_ids, format: :json }
-
-      it 'responds with unexcluded records' do
-        expect(json_response[:records].length).to eq 5
-      end
-    end
-  end
-end