populate-me 0.0.33 → 0.1.0

data/lib/populate_me/mongo.rb

@@ -1,3 +1,98 @@
-# encoding: utf-8
-require "populate_me/ext"
-require 'populate_me/mongo/plug'
+require 'populate_me/document'
+require 'mongo'
+
+module PopulateMe
+
+  class MissingMongoDBError < StandardError; end
+
+  class Mongo < Document
+
+    class << self
+
+      def inherited sub 
+        super
+        sub.set :collection_name, WebUtils.dasherize_class_name(sub.name)
+      end
+
+      def collection
+        raise MissingMongoDBError, "Document class #{self.name} does not have a Mongo database." if settings.db.nil?
+        settings.db[settings.collection_name]
+      end
+
+      def set_id_field
+        field :_id, {type: :id}
+      end
+
+      def sort_by f, direction=1
+        direction = 1 if direction==:asc
+        direction = -1 if direction==:desc
+        if f.is_a?(Hash)
+          @current_sort = f
+        elsif f.is_a?(Array)
+          @current_sort = f.inject({}) do |h,pair| 
+            h.store(pair[0], pair[1])
+            h
+          end
+        else
+          raise(ArgumentError) unless [1,-1].include? direction
+          raise(ArgumentError) unless self.new.respond_to? f
+          @current_sort = {f => direction}
+        end
+        self
+      end
+
+      def id_string_key
+        (self.fields.keys[0]||'_id').to_s
+      end
+
+      def set_indexes f, ids=[]
+        requests = ids.each_with_index.inject([]) do |list, (id, i)|
+          list << {update_one: 
+            {
+              filter: {self.id_string_key=>id}, 
+              update: {'$set'=>{f=>i}}
+            }
+          }
+        end
+        collection.bulk_write requests
+      end
+
+      def admin_get theid
+        theid = BSON::ObjectId.from_string(theid) if BSON::ObjectId.legal?(theid)
+        self.cast{ collection.find({id_string_key => theid}).first }
+      end
+      alias_method :[], :admin_get
+
+      def admin_find o={}
+        query = o.delete(:query) || {}
+        o[:sort] ||= @current_sort
+        self.cast{ collection.find(query, o) }
+      end
+
+    end
+
+    attr_accessor :_id
+
+    def id; @_id; end
+    def id= value; @_id = value; end
+
+    def perform_create
+      result = self.class.collection.insert_one(self.to_h)
+      if result.ok? and self.id.nil?
+        self.id = result.inserted_id
+      end
+      self.id
+    end
+
+    def perform_update
+      self.class.collection.update_one({'_id'=> self.id}, self.to_h)
+      self.id
+    end
+
+    def perform_delete
+      self.class.collection.delete_one({'_id'=> self.id})
+    end
+    
+  end
+end
+

data/lib/populate_me/variation.rb

@@ -0,0 +1,34 @@
+module PopulateMe
+
+  class Variation < Struct.new :name, :ext, :job
+        
+    # Simple class to deal with variations of an attachment
+    # Mainly variation of images using ImageMagick
+    # but it could be anything else like creating the pdf version
+    # of a text file
+
+    def initialize name, ext, job_as_proc=nil, &job_as_block
+      super name, ext, job_as_proc||job_as_block
+    end
+
+    class << self
+
+      def new_image_magick_job name, ext, convert_string, options={}
+        o = {
+          strip: true, progressive: true,
+        }.merge(options)
+        defaults = ""
+        defaults << "-strip " if o[:strip]
+        defaults << "-interlace Plane " if o[:progressive] and [:jpg,:jpeg].include?(ext.to_sym)
+        job = lambda{ |src,dst|
+          Kernel.system "convert \"#{src}\" #{defaults}#{convert_string} \"#{dst}\""
+        }
+        self.new name, ext, job
+      end
+
+    end
+
+  end
+
+end
+

data/lib/populate_me/version.rb

@@ -0,0 +1,4 @@
+module PopulateMe
+  VERSION = '0.1.0'
+end
+

data/populate-me.gemspec

@@ -1,24 +1,32 @@
+require File.join(File.dirname(__FILE__), 'lib/populate_me/version')
+
 Gem::Specification.new do |s| 
+
+  s.authors = ["Mickael Riga"]
+  s.email = ["mig@mypeplum.com"]
+  s.homepage = "https://github.com/mig-hub/populate-me"
+  s.licenses = ['MIT']
+
   s.name = 'populate-me'
-  s.version = '0.0.33'
+  s.version = PopulateMe::VERSION
+  s.summary = "PopulateMe is an admin system for web applications."
+  s.description = "PopulateMe is an admin system for managing structured content of web applications. It is built on top of the Sinatra framework, but can be used along any framework using Rack."
+
   s.platform = Gem::Platform::RUBY
-  s.summary = "ALPHA !!! Populate Me is relatively complete but simple CMS"
-  s.description = "ALPHA !!! Populate Me is relatively complete but simple CMS. It includes a Rack middleware for putting in your Rack stack, and a bespoke MongoDB ODM. But Populate Me is not really finished yet."
   s.files = `git ls-files`.split("\n").sort
-  s.require_path = './lib'
-  s.author = "Mickael Riga"
-  s.email = "mig@mypeplum.com"
-  s.homepage = "https://github.com/mig-hub/populate-me"
-  s.licenses = ['MIT']
+  s.test_files = s.files.grep(/^test\//)
+  s.require_paths = ['lib']
 
-  s.add_dependency 'rack-golem', '~> 0'
+  s.add_dependency 'web-utils', '~> 0'
+  s.add_dependency 'sinatra', '~> 1.0'
   s.add_dependency 'json', '~> 2.1'
-  s.add_dependency 'mongo', '~> 2.0'
 
   s.add_development_dependency 'bundler', '~> 1.13'
-  s.add_development_dependency 'bacon', '~> 1.2'
+  s.add_development_dependency 'minitest', '~> 5.8'
   s.add_development_dependency 'rack-test', '~> 0.6'
+  s.add_development_dependency 'rack-cerberus', '~> 1.0'
+  s.add_development_dependency 'mongo', '~> 2.0'
   s.add_development_dependency 'racksh', '~> 1.0'
-
+  s.add_development_dependency 'rake', '~> 10.1'
 end
 

data/test/helper.rb

@@ -0,0 +1,37 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'minitest/autorun'
+require 'rack/test'
+
+module Minitest::Assertions
+  def assert_json response
+    assert response.content_type=="application/json", "Expected #{response.inspect} to be a JSON response"
+  end
+  def assert_for_view json, view_name, title=nil
+    assert json['template']==view_name, "Expected #{json.inspect} to have 'template' set to '#{view_name}'"
+    unless title.nil?
+      assert json['page_title']==title, "Expected #{json.inspect} to have 'page_title' set to '#{title}'"
+    end
+  end
+
+  def assert_receive obj, meth, retval=nil, args=[] 
+    mocked_meth = Minitest::Mock.new
+    mocked_meth.expect(:call, retval, args)
+    obj.stub meth, mocked_meth do
+      yield
+    end
+    assert mocked_meth.verify, "Expected #{obj.inspect} to receive :#{meth}"
+  end
+  def refute_receive obj, meth
+    proof = nil
+    obj.stub meth, proc{proof = :received} do
+      yield
+      assert(proof!=:received, "Expected #{obj.inspect} not to receive :#{meth}")
+    end
+  end
+end
+
+class Minitest::Spec
+  include Rack::Test::Methods
+end
+

data/test/test_admin.rb

@@ -0,0 +1,161 @@
+require 'helper'
+require 'populate_me/admin'
+
+class Admin < PopulateMe::Admin
+  enable :sessions
+  set :menu, [
+    ['Home Details', '/admin/form/home-details/0'],
+    ['Project Page', [
+      ['Project Page Intro', '/admin/form/project-page-intro/0'],
+      ['Projects', '/admin/list/project'],
+      ['Checks', [
+        ['Check 1', '/check/1'],
+        ['Check 2', '/check/2']
+      ]]
+    ]]
+  ]
+end
+
+class AdminWithCerberusPass < Admin
+  def self.cerberus_pass
+    '123'
+  end
+end
+
+class AdminCerberusNotAvailable < AdminWithCerberusPass
+  def self.cerberus_available?
+    false
+  end
+end
+
+class AdminCerberusDisabled < AdminWithCerberusPass
+  disable :cerberus
+end
+
+describe PopulateMe::Admin do
+
+  parallelize_me!
+
+  let(:app) { ::Admin.new }
+
+  let(:settings) { app.settings }
+
+  let(:json) { JSON.parse(last_response.body) }
+
+  describe 'Settings' do
+    it 'Sets paths based on the subclass file path' do
+      assert_equal __FILE__, settings.app_file
+    end
+    it 'Has a default value for the page title tag' do
+      assert_equal 'Populate Me', settings.meta_title
+    end
+    it 'Has a default index_path' do
+      assert_equal '/menu', settings.index_path
+    end
+    it 'Has cerberus enabled by default' do
+      assert settings.cerberus?
+    end
+    describe 'when ENV CERBERUS_PASS is not set' do
+      it 'Does not have cerberus_active' do
+        refute settings.cerberus_active
+      end
+    end
+    describe 'when ENV CERBERUS_PASS is set' do
+      let(:app) { AdminWithCerberusPass.new }
+      it 'Has cerberus_active' do
+        assert settings.cerberus_active
+      end
+    end
+    describe 'when ENV CERBERUS_PASS is set but gem not loaded' do
+      let(:app) { AdminCerberusNotAvailable.new }
+      it 'Does not have cerberus_active' do
+        refute settings.cerberus_active
+      end
+    end
+    describe 'when ENV CERBERUS_PASS is set but cerberus is disabled' do
+      let(:app) { AdminCerberusDisabled.new }
+      it 'Does not have cerberus_active' do
+        refute settings.cerberus_active
+      end
+    end
+    describe 'when Cerberus is active' do
+      let(:app) { AdminWithCerberusPass.new }
+      it 'Sets logout_path to /logout' do
+        assert_equal '/logout', settings.logout_path
+      end
+    end
+    describe 'when Cerberus is not active' do
+      it 'Sets logout_path to false' do
+        refute settings.logout_path
+      end
+    end
+  end
+
+  describe 'Middlewares' do
+
+    it 'Has API middleware mounted on /api' do
+      get '/api'
+      assert_predicate last_response, :ok?
+      assert_json last_response
+      assert json['success']
+    end
+
+    it 'Has assets available on /__assets__' do
+      get('/__assets__/css/main.css')
+      assert_predicate last_response, :ok?
+      assert_equal 'text/css', last_response.content_type
+    end
+
+    describe 'when cerberus is active' do
+      let(:app) { AdminWithCerberusPass.new }
+      it 'Uses Cerberus for authentication' do
+        get '/'
+        assert_equal 401, last_response.status
+      end
+    end
+    describe 'when cerberus is inactive' do
+      it 'Does not use Cerberus' do
+        get '/'
+        assert_predicate last_response, :ok?
+      end
+    end
+
+  end
+
+  describe 'Handlers' do
+
+    describe '/menu' do
+
+      describe 'when url is root' do
+        it 'Returns the correct info' do
+          get '/menu'
+          assert_predicate last_response, :ok?
+          assert_json last_response
+          assert_for_view json, 'template_menu', 'Menu'
+          assert_equal 2, json['items'].size
+          expected_h = {
+            'title'=> 'Home Details', 'href'=> '/admin/form/home-details/0'
+          }
+          assert_equal expected_h, json['items'][0]
+        end
+      end
+      describe 'when url is nested' do
+        it 'Returns the correct info' do
+          get '/menu/project-page/checks' 
+          assert_predicate last_response, :ok?
+          assert_json last_response
+          assert_for_view json, 'template_menu', 'Checks'
+          assert_equal 2, json['items'].size
+          expected_h = {
+            'title'=> 'Check 1', 'href'=> '/check/1'
+          }
+          assert_equal expected_h, json['items'][0]
+        end
+      end
+
+    end
+
+  end
+
+end
+

data/test/test_api.rb

@@ -0,0 +1,246 @@
+require 'helper'
+
+require 'populate_me/document'
+class Band < PopulateMe::Document
+  attr_accessor :name, :awsome, :position
+  def members; @members ||= []; end
+  def validate
+    error_on(:name,"WTF") if self.name=='ZZ Top'
+  end
+end
+class Band::Member < PopulateMe::Document
+  attr_accessor :name
+end
+
+require 'populate_me/api'
+
+describe 'PopulateMe::API' do
+
+  # This middleware has the CRUD interface for
+  # managing documents through a JSON-based API
+  #
+  # The API needs the Document class to implement these methods:
+  # - Class.admin_get
+  #   - Needs to be able to accept the ID as a string
+  #   - The class is responsible for conversion
+  #   - So a mix of different classes of IDs is not possible
+  # - instance.to_h
+  # - instance.save
+  # - instance.delete
+
+  parallelize_me!
+
+  let(:app) {
+    PopulateMe::API.new
+  }
+
+  let(:json) {
+    JSON.parse(last_response.body)
+  }
+
+  def assert_not_found
+    assert_json last_response
+    assert_equal 404, last_response.status
+    assert_equal 'pass', last_response.headers['X-Cascade']
+    refute json['success']
+    assert_equal 'Not Found', json['message']
+  end
+  
+  def assert_successful_creation
+    assert_json last_response
+    assert_equal 201, last_response.status
+    assert json['success']
+    assert_equal 'Created Successfully', json['message']
+  end
+
+  def assert_successful_sorting
+    assert_json last_response
+    assert_predicate last_response, :ok?
+    assert json['success']
+    assert_equal 'Sorted Successfully', json['message']
+  end
+
+  def assert_invalid_instance
+    assert_json last_response
+    assert_equal 400, last_response.status
+    refute json['success']
+    assert_equal 'Invalid Document', json['message']
+  end
+
+  def assert_successful_instance
+    assert_json last_response
+    assert_predicate last_response, :ok?
+    assert json['success']
+  end
+
+  def assert_successful_update
+    assert_json last_response
+    assert_predicate last_response, :ok?
+    assert json['success']
+    assert_equal 'Updated Successfully', json['message']
+  end
+
+  def assert_successful_deletion
+    assert_json last_response
+    assert_predicate last_response, :ok?
+    assert json['success']
+    assert_equal 'Deleted Successfully', json['message']
+  end
+
+  describe 'GET /version' do
+    it 'Returns the PopulateMe version' do
+      get('/version')
+      assert_json last_response
+      assert_predicate last_response, :ok?
+      assert json['success']
+      assert_equal PopulateMe::VERSION, json['version']
+    end
+  end
+
+  describe 'POST /:model' do
+
+    it 'Creates successfully' do
+      post('/band', {data: {id: 'neurosis', name: 'Neurosis'}})
+      assert_successful_creation
+      assert_equal 'Neurosis', json['data']['name']
+    end
+
+    it 'Typecasts before creating' do
+      post('/band', {data: {name: 'Arcade Fire', awsome: 'true'}})
+      assert_successful_creation
+      assert json['data']['awsome']
+    end
+
+    it 'Can create a doc even if no data is sent' do
+      post '/band'
+      assert_successful_creation
+    end
+
+    it 'Fails if the doc is invalid' do
+      post('/band', {data: {id: 'invalid_doc_post', name: 'ZZ Top'}})
+      assert_invalid_instance
+      assert_equal({'name'=>['WTF']}, json['data'])
+      assert_nil Band.admin_get('invalid_doc_post')
+    end
+
+    it 'Redirects if destination is given' do
+      post '/band', {'_destination'=>'http://example.org/anywhere'}
+      assert_equal 302, last_response.status
+      assert_equal 'http://example.org/anywhere', last_response.header['Location']
+    end
+
+  end
+
+  describe 'PUT /:model' do
+
+    it 'Can set indexes for sorting' do
+      post('/band', {data: {id: 'sortable1', name: 'Sortable 1'}})
+      post('/band', {data: {id: 'sortable2', name: 'Sortable 2'}})
+      post('/band', {data: {id: 'sortable3', name: 'Sortable 3'}})
+      put '/band', {
+        'action'=>'sort',
+        'field'=>'position',
+        'ids'=> ['sortable2','sortable3','sortable1']
+      }
+      assert_successful_sorting
+      assert_equal 0, Band.admin_get('sortable2').position
+      assert_equal 1, Band.admin_get('sortable3').position
+      assert_equal 2, Band.admin_get('sortable1').position
+    end
+
+    it 'Redirects after sorting if destination is given' do
+      post('/band', {data: {id: 'redirectsortable1', name: 'Redirect Sortable 1'}})
+      post('/band', {data: {id: 'redirectsortable2', name: 'Redirect Sortable 2'}})
+      post('/band', {data: {id: 'redirectsortable3', name: 'Redirect Sortable 3'}})
+      put '/band', {
+        'action'=>'sort',
+        'field'=>'position',
+        'ids'=> ['redirectsortable2','redirectsortable3','redirectsortable1'],
+        '_destination'=>'http://example.org/anywhere'
+      }
+      assert_equal 302, last_response.status
+      assert_equal 'http://example.org/anywhere', last_response.header['Location']
+    end
+
+  end
+
+  describe 'GET /:model/:id' do
+    it 'Sends a not-found when the model is not a class' do
+      get('/wizz/42')
+      assert_not_found
+    end
+    it 'Sends not-found when the model is a class but not a model' do
+      get('/string/42')
+      assert_not_found
+    end
+    it 'Sends not-found when the id is not provided' do
+      get('/band/')
+      assert_not_found
+    end
+    it 'Sends not-found when the instance does not exist' do
+      get('/band/666')
+      assert_not_found
+    end
+    it 'Sends the instance if it exists' do
+      post('/band', {data: {id: 'sendable', name: 'Morphine'}})
+      get('/band/sendable')
+      assert_successful_instance
+      assert_equal Band.admin_get('sendable').to_h, json['data']
+    end
+  end
+
+  describe 'PUT /:model/:id' do
+    it 'Sends not-found if the instance does not exist' do
+      put('/band/666')
+      assert_not_found
+    end
+    it 'Fails if the document is invalid' do
+      post('/band', {data: {id: 'invalid_doc_put', name: 'Valid here'}})
+      put('/band/invalid_doc_put', {data: {name: 'ZZ Top'}})
+      assert_invalid_instance
+      assert_equal({'name'=>['WTF']}, json['data'])
+      refute_equal 'ZZ Top', Band.admin_get('invalid_doc_put').name
+    end
+    it 'Updates documents' do
+      post('/band', {data: {id: 'updatable', name: 'Updatable'}})
+      put('/band/updatable', {data: {awsome: 'yes'}})
+      assert_successful_update
+      obj = Band.admin_get('updatable')
+      assert_equal 'yes', obj.awsome
+      assert_equal 'Updatable', obj.name
+    end
+    # it 'Updates nested documents' do
+    #   obj = Band.admin_get('3')
+    #   put('/band/3', {data: {members: [
+    #     {id: obj.members[0].id, _class: 'Band::Member', name: 'Joey Ramone'},
+    #     {id: obj.members[1].id, _class: 'Band::Member'},
+    #   ]}})
+    #   assert_successful_update
+    #   obj = Band.admin_get('3')
+    #   assert_equal 'yes', obj.awsome
+    #   assert_equal 'The Ramones', obj.name
+    #   assert_equal 2, obj.members.size
+    #   assert_equal 'Joey Ramone', obj.members[0].name
+    #   assert_equal 'Deedee Ramone', obj.members[1].name
+    # end
+  end
+
+  describe 'DELETE /:model/:id' do
+    it 'Sends not-found if the instance does not exist' do
+      delete('/band/666')
+      assert_not_found
+    end
+    it 'Returns a deletion response when the instance exists' do
+      post('/band', {data: {id: 'deletable', name: '1D'}})
+      delete('/band/deletable')
+      assert_successful_deletion
+      assert_instance_of Hash, json['data']
+    end
+    it 'Redirects if destination is given' do
+      delete('/band/2', {'_destination'=>'http://example.org/anywhere'})
+      assert_equal 302, last_response.status
+      assert_equal 'http://example.org/anywhere', last_response.header['Location']
+    end
+  end
+end
+