ditty 0.7.1 → 0.10.1

data/lib/ditty/services/email.rb

@@ -11,6 +11,8 @@ module Ditty
       class << self
         include ActiveSupport::Inflector
 
+        attr_writer :config
+
         def config!
           cfg = config
           Mail.defaults do
@@ -18,27 +20,35 @@ module Ditty
           end
         end
 
-        def deliver(email, to = nil, options = {})
+        def generate(email, to = nil, options = {})
           config!
           options[:to] ||= to unless to.nil?
+          options[:from] ||= config[:from] unless config[:from].nil?
           email = from_symbol(email, options) if email.is_a? Symbol
-          email.deliver!
+          email
+        end
+
+        def deliver(email, to = nil, options = {})
+          generate(email, to, options).deliver!
         end
 
         private
 
-        def config
-          default.merge Ditty::Services::Settings.values(:email) || {}
-        end
+          def config
+            @config ||= default.merge ::Ditty::Services::Settings.values(:email) || {}
+          end
 
-        def default
-          { delivery_method: :logger, logger: Ditty::Services::Logger.instance }
-        end
+          def default
+            {
+              delivery_method: :logger,
+              logger: ::Ditty::Services::Logger
+            }
+          end
 
-        def from_symbol(email, options)
-          require "ditty/emails/#{email}"
-          constantize("Ditty::Emails::#{classify(email)}").new(options)
-        end
+          def from_symbol(email, options)
+            require "ditty/emails/#{email}"
+            constantize("Ditty::Emails::#{classify(email)}").new(options)
+          end
       end
     end
   end

data/lib/ditty/services/logger.rb

@@ -20,6 +20,7 @@ module Ditty
       def initialize
         @loggers = []
         return if config[:loggers].blank?
+
         config[:loggers].each do |values|
           klass = values[:class].constantize
           opts = tr(values[:options]) || nil
@@ -29,30 +30,46 @@ module Ditty
         end
       end
 
+      # TODO: REfac this so that you can log something like ES to a separate logger
+
       def method_missing(method, *args, &block)
         loggers.each { |logger| logger.send(method, *args, &block) }
       end
 
       def respond_to_missing?(method, _include_private = false)
-        loggers.any? { |logger| logger.respond_to?(method) }
+        return true if loggers.any? { |logger| logger.respond_to?(method) }
+
+        super
       end
 
       private
 
-      def config
-        default.merge Ditty::Services::Settings.values(:logger) || {}
-      end
+        def config
+          default.merge ::Ditty::Services::Settings.values(:logger) || {}
+        end
 
-      def tr(val)
-        {
-          '$stdout' => $stdout,
-          '$stderr' => $stderr
-        }[val] || val
-      end
+        def tr(val)
+          {
+            '$stdout' => $stdout,
+            '$stderr' => $stderr
+          }[val] || val
+        end
 
-      def default
-        { loggers: [{ name: 'default', class: 'Logger' }] }
-      end
+        def default
+          { loggers: [{ name: 'default', class: 'Logger' }] }
+        end
+
+        class << self
+          def method_missing(method, *args, &block)
+            instance.send(method, *args, &block)
+          end
+
+          def respond_to_missing?(method, _include_private)
+            return true if instance.respond_to?(method)
+
+            super
+          end
+        end
     end
   end
 end

data/lib/ditty/services/pagination_wrapper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ditty
   module Services
     class PaginationWrapper
@@ -8,18 +10,18 @@ module Ditty
       end
 
       def last_page?
-        if list.respond_to? :'last_page?'
+        if list.respond_to? :last_page?
           list.last_page?
         else
-          list.current_page == list.total_pages
+          list.next_page.nil?
         end
       end
 
       def first_page?
-        if list.respond_to? :'first_page?'
+        if list.respond_to? :first_page?
           list.first_page?
         else
-          list.current_page == 0
+          list.previous_page.nil?
         end
       end
 
@@ -62,7 +64,9 @@ module Ditty
       end
 
       def respond_to_missing?(method, _include_private = false)
-        list.respond_to? method
+        return true if list.respond_to?(method)
+
+        super
       end
 
       def current_page_record_range

data/lib/ditty/services/settings.rb

@@ -16,22 +16,30 @@ module Ditty
     # in separate files will be used in preference of those in the `settings.yml`
     # file.
     module Settings
-      CONFIG_FOLDER = './config'.freeze
-      CONFIG_FILE = "#{CONFIG_FOLDER}/settings.yml".freeze
+      CONFIG_FOLDER = './config'
+      CONFIG_FILE = "#{CONFIG_FOLDER}/settings.yml"
 
       class << self
         def [](key)
-          values(key.to_sym)
+          keys = key.to_s.split('.').map(&:to_sym)
+          from = values
+          if keys.count > 1 && scope?(keys.first)
+            from = values(keys.first)
+            keys = keys[1..]
+            key = keys.join('.')
+          end
+          key = key.to_sym if key.respond_to?(:to_sym)
+          from[key] || from.dig(*keys)
         end
 
         def values(scope = :settings)
           @values ||= begin
             v = Hash.new do |h, k|
               h[k] = if File.file?("#{CONFIG_FOLDER}/#{k}.yml")
-                       read("#{CONFIG_FOLDER}/#{k}.yml")
-                     elsif k != :settings && h[:settings].key?(k)
-                       h[:settings][k]
-                     end
+                read("#{CONFIG_FOLDER}/#{k}.yml")
+              elsif k != :settings && h[:settings].key?(k)
+                h[:settings][k]
+              end
               h[k]
             end
             v[:settings] = File.file?(CONFIG_FILE) ? read(CONFIG_FILE) : {}
@@ -40,6 +48,10 @@ module Ditty
           @values[scope]
         end
 
+        def scope?(name)
+          @values.key?(name.to_sym) || File.file?("#{CONFIG_FOLDER}/#{name}.yml")
+        end
+
         attr_writer :values
 
         def read(filename)

data/lib/ditty/tasks/ditty.rake

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+namespace :ditty do
+  desc 'Run the ditty console'
+  task :console do
+    require 'irb'
+    ARGV.clear
+    IRB.start
+  end
+
+  desc 'Prepare Ditty'
+  task prep: ['generate_tokens', 'prep:folders', 'prep:public', 'prep:migrations']
+
+  desc 'Generate the needed tokens'
+  task :generate_tokens do
+    puts 'Generating the Ditty tokens'
+    require 'securerandom'
+    File.write('.session_secret', SecureRandom.random_bytes(40)) unless File.file?('.session_secret')
+    File.write('.token_secret', SecureRandom.random_bytes(40)) unless File.file?('.token_secret')
+  end
+
+  desc 'Seed the Ditty database'
+  task :seed do
+    puts 'Seeding the Ditty database'
+    require 'ditty/seed'
+  end
+
+  desc 'Dump the Ditty DB Schema'
+  task :dump_schema do
+    Ditty::Components.components.each do |_name, comp|
+      comp.load if comp.respond_to?(:load)
+    end.compact
+    DB.dump_schema_cache('./config/schema.dump')
+  end
+
+  namespace :prep do
+    desc 'Check that the required Ditty folders are present'
+    task :folders do
+      puts 'Prepare the Ditty folders'
+      Dir.mkdir 'pids' unless File.exist?('pids')
+      Dir.mkdir 'logs' unless File.exist?('logs')
+    end
+
+    desc 'Check that the public folder is present and populated'
+    task :public do
+      puts 'Preparing the Ditty public folder'
+      Dir.mkdir 'public' unless File.exist?('public')
+      ::Ditty::Components.public_folder.each do |path|
+        puts "Checking #{path}"
+        path = "#{path}/."
+        FileUtils.cp_r path, 'public' unless File.expand_path(path).eql? File.expand_path('public')
+      end
+    end
+
+    desc 'Check that the migrations folder is present and populated'
+    task :migrations do
+      puts 'Preparing the Ditty migrations folder'
+      Dir.mkdir 'migrations' unless File.exist?('migrations')
+      ::Ditty::Components.migrations.each do |path|
+        path = "#{path}/."
+        FileUtils.cp_r path, 'migrations' unless File.expand_path(path).eql? File.expand_path('migrations')
+      end
+      puts 'Migrations added:'
+      Dir.foreach('migrations').sort.each { |x| puts x if File.file?("migrations/#{x}") && x[-3..] == '.rb' }
+    end
+  end
+
+  desc 'Migrate Ditty database to latest version'
+  task migrate: ['prep:migrations'] do
+    puts 'Running the Ditty migrations'
+    Rake::Task['ditty:migrate:up'].invoke
+  end
+
+  namespace :migrate do
+    require 'logger'
+
+    folder = 'migrations'
+
+    desc 'Check if the migration is current'
+    task :check do
+      ::DB.loggers << Logger.new($stdout) if ::DB.loggers.count.zero?
+      puts '** [ditty] Running Ditty Sequel Migrations check'
+      ::Sequel.extension :migration
+      begin
+        ::Sequel::Migrator.check_current(::DB, folder)
+        puts '** [ditty] Sequel Migrations up to date'
+      rescue Sequel::Migrator::Error => _e
+        raise 'Sequel Migrations NOT up to date'
+      end
+    end
+
+    desc 'Migrate Ditty database to the specified version'
+    task :run, [:version] do |_t, args|
+      ::DB.loggers << Logger.new($stdout) if ::DB.loggers.count.zero?
+      raise 'No version specified' unless args[:version]
+
+      puts "** [ditty] Running Ditty Migrations to #{args[:version]}"
+      ::Sequel.extension :migration
+      ::Sequel::Migrator.run(::DB, folder, target: args[:version].to_i)
+    end
+
+    desc 'Migrate Ditty database to latest version'
+    task :up do
+      ::DB.loggers << Logger.new($stdout) if ::DB.loggers.count.zero?
+      puts '** [ditty] Running Ditty Migrations up'
+      ::Sequel.extension :migration
+      ::Sequel::Migrator.apply(::DB, folder)
+    end
+
+    desc 'Remove the whole Ditty database. You WILL lose data'
+    task :down do
+      ::DB.loggers << Logger.new($stdout) if ::DB.loggers.count.zero?
+      puts '** [ditty] Running Ditty Migrations down'
+      ::Sequel.extension :migration
+      ::Sequel::Migrator.apply(::DB, folder, 0)
+    end
+
+    desc 'Reset the Ditty database. You WILL lose data'
+    task :bounce do
+      ::DB.loggers << Logger.new($stdout) if ::DB.loggers.count.zero?
+      puts '** [ditty] Running Ditty Migrations bounce'
+      ::Sequel.extension :migration
+      ::Sequel::Migrator.apply(::DB, folder, 0)
+      ::Sequel::Migrator.apply(::DB, folder)
+    end
+  end
+end

data/lib/ditty/tasks/omniauth-ldap.rake

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+namespace :ditty do
+  namespace :ldap do
+    desc 'Check the LDAP settings'
+    task :check do
+      settings = ::Ditty::Services::Settings[:authentication][:ldap][:arguments].first
+      ldap = Net::LDAP.new host: settings[:host], port: settings[:port]
+      ldap.authenticate settings[:bind_dn], settings[:password] if settings[:bind_dn]
+      raise 'Could not bind to LDAP server' unless ldap.bind
+
+      puts 'LDAP Binding Successful'
+    end
+
+    desc 'Add the AD / LDAP Groups to Ditty as Roles'
+    task :populate_groups, [:filter] do |_task, args|
+      puts 'Adding AD / LDAP Groups to Ditty as Roles'
+      require 'ditty/services/settings'
+      require 'ditty/models/role'
+
+      settings = ::Ditty::Services::Settings[:authentication][:ldap][:arguments].first
+      ldap = Net::LDAP.new host: settings[:host], port: settings[:port]
+      ldap.authenticate settings[:bind_dn], settings[:password] if settings[:bind_dn]
+      if ldap.bind
+        group_filter = Net::LDAP::Filter.construct(settings[:group_filter]) unless settings[:group_filter].blank?
+        group_filter ||= Net::LDAP::Filter.eq('ObjectClass', 'Group')
+        if args[:filter]
+          search_filter = Net::LDAP::Filter.eq(*args[:filter].split(':', 2))
+          filter = Net::LDAP::Filter.join(group_filter, search_filter)
+        else
+          filter = group_filter
+        end
+        ldap.search(base: settings[:base], filter: filter).each do |group|
+          Ditty::Role.find_or_create(name: group.name) do |role|
+            puts "Adding #{role.name}"
+          end
+        end
+      else
+        puts 'Could not connect to LDAP Server'
+      end
+    end
+  end
+end

data/lib/ditty/templates/.gitignore

@@ -0,0 +1,5 @@
+.token_secret
+.session_secret
+gems
+logs/*
+migrations

data/lib/ditty/templates/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/lib/ditty/templates/.rubocop.yml

@@ -0,0 +1,7 @@
+require:
+  - rubocop-rspec
+  - rubocop-performance
+  - rubocop-thread_safety
+  - rubocop-sequel
+  - ditty/rubocop
+

data/lib/ditty/templates/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'dotenv/load'
+
+require 'rake'
+require 'ditty'
+require 'ditty/db' if ENV['DATABASE_URL']
+require 'ditty/memcached' if ENV['MEMCACHED_URL']
+
+require './application'
+
+Ditty::Components.tasks

data/lib/ditty/templates/application.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+libdir = File.expand_path("#{File.dirname(__FILE__)}/lib")
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require 'ditty/components/ditty'
+Ditty.component :ditty
+
+# Enable DB Caching
+require 'ditty/memcached' if ENV['MEMCACHED_URL']
+
+# Load more components here

data/lib/ditty/templates/config.ru

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'dotenv/load'
+
+# Last Gasp Effort to catch the error
+require 'ditty/middleware/error_catchall'
+use ::Ditty::Middleware::ErrorCatchall if ENV['APP_ENV'] == 'production'
+
+require 'rack/static'
+use Rack::Static, urls: ['/favicon.ico', '/js/', '/images/', '/css/'], root: 'public'
+
+# Session
+use Rack::Session::Cookie,
+    key: '_Ditty_session',
+    path: '/',
+    # :secure=>!TEST_MODE, # Uncomment if only allowing https:// access
+    secret: File.read('.session_secret')
+
+require './application'
+require 'ditty/services/authentication'
+use OmniAuth::Builder do
+  ::Ditty::Services::Authentication.providers.each do |prov|
+    provider prov, *::Ditty::Services::Authentication.config[prov][:arguments]
+  end
+end
+
+map '/' do
+  use Rack::Static, root: 'public', urls: ['/css', '/images', '/js'], header_rules: [
+    [:all, { 'Cache-Control' => 'public, max-age=31536000' }]
+  ]
+  require 'ditty/middleware/accept_extension'
+  use Ditty::Middleware::AcceptExtension
+  require 'rack/content_type'
+  use Rack::ContentType
+
+  run Rack::URLMap.new ::Ditty::Components.routes
+end