ditty 0.7.1 → 0.10.1

data/lib/ditty/controllers/{users.rb → users_controller.rb}

@@ -1,23 +1,19 @@
 # frozen_string_literal: true
 
-require 'ditty/controllers/component'
+require 'ditty/controllers/component_controller'
 require 'ditty/models/user'
+require 'ditty/models/user_login_trait'
 require 'ditty/policies/user_policy'
 require 'ditty/models/identity'
 require 'ditty/policies/identity_policy'
 
 module Ditty
-  class Users < Ditty::Component
+  class UsersController < ::Ditty::ComponentController
     SEARCHABLE = %i[name surname email].freeze
 
     set model_class: User
     set track_actions: true
 
-    def find_template(views, name, engine, &block)
-      super(views, name, engine, &block) # Root
-      super(::Ditty::App.view_folder, name, engine, &block) # Ditty
-    end
-
     # New
     get '/new' do
       authorize settings.model_class, :create
@@ -32,8 +28,8 @@ module Ditty
 
       locals = { title: heading(:new) }
 
-      user_params = permitted_attributes(User, :create)
-      identity_params = permitted_attributes(Identity, :create)
+      user_params = permitted_parameters(User, :create)
+      identity_params = permitted_parameters(Identity, :create)
       user_params['email'] = identity_params['username']
       roles = user_params.delete('role_id')
 
@@ -42,25 +38,24 @@ module Ditty
 
       DB.transaction(isolation: :serializable) do
         begin
-          identity.save
+          identity.save_changes
         rescue Sequel::ValidationFailed
           raise unless request.accept? 'text/html'
+
           status 400
           locals = { title: heading(:new), entity: user, identity: identity }
           return haml(:"#{view_location}/new", locals: locals)
         end
-        user.save
+        user.save_changes
         user.add_identity identity
 
-        if roles
-          roles.each do |role_id|
-            user.add_role(role_id) unless user.roles.map(&:id).include? role_id.to_i
-          end
+        roles&.each do |role_id|
+          user.add_role(role_id) unless user.roles.map(&:id).include? role_id.to_i
         end
         user.check_roles
       end
 
-      broadcast(:component_create, target: self)
+      broadcast(:component_create, target: self, entity: user)
       create_response(user)
     end
 
@@ -70,10 +65,10 @@ module Ditty
       halt 404 unless entity
       authorize entity, :update
 
-      values = permitted_attributes(settings.model_class, :update)
+      values = permitted_parameters(settings.model_class, :update)
       roles  = values.delete('role_id')
       entity.set values
-      entity.save # Will trigger a Sequel::ValidationFailed exception if the model is incorrect
+      entity.save_changes # Will trigger a Sequel::ValidationFailed exception if the model is incorrect
 
       if roles
         entity.remove_all_roles
@@ -99,9 +94,10 @@ module Ditty
         return redirect back
       end
 
-      values = permitted_attributes(Identity, :create)
+      values = permitted_parameters(Identity, :create)
       identity.set values
-      if identity.valid? && identity.save
+      if identity.valid?
+        identity.save_changes
         broadcast(:identity_update_password, target: self)
         flash[:success] = 'Password Updated'
         redirect back
@@ -134,6 +130,7 @@ module Ditty
       halt 404 unless entity
       authorize entity, :read
 
+      flash[:redirect_to] = request.path
       haml :"#{view_location}/profile", locals: { entity: entity, identity: entity.identity.first, title: 'My Account' }
     end
   end

data/lib/ditty/db.rb

@@ -8,7 +8,7 @@ require 'active_support/core_ext/object/blank'
 pool_timeout = (ENV['DB_POOL_TIMEOUT'] || 5).to_i
 
 if defined? DB
-  Ditty::Services::Logger.instance.warn 'Database connection already set up'
+  ::Ditty::Services::Logger.warn 'Database connection already set up'
 elsif ENV['DATABASE_URL'].blank? == false
   # Delete DATABASE_URL from the environment, so it isn't accidently
   # passed to subprocesses.  DATABASE_URL may contain passwords.
@@ -18,12 +18,16 @@ elsif ENV['DATABASE_URL'].blank? == false
   )
 
   DB.sql_log_level = (ENV['SEQUEL_LOGGING_LEVEL'] || :debug).to_sym
-  DB.loggers << Ditty::Services::Logger.instance
+  DB.loggers << ::Ditty::Services::Logger if ENV['DB_DEBUG'].to_i == 1
   DB.extension(:pagination)
+  DB.extension(:schema_caching)
+  DB.load_schema_cache?('./config/schema.dump')
 
-  Sequel::Model.plugin :validation_helpers
-  Sequel::Model.plugin :update_or_create
+  Sequel::Model.plugin :auto_validations
+  Sequel::Model.plugin :string_stripper
   Sequel::Model.plugin :timestamps, update_on_create: true
+  Sequel::Model.plugin :update_or_create
+  Sequel::Model.plugin :validation_helpers
 else
-  Ditty::Services::Logger.instance.error 'No database connection set up'
+  ::Ditty::Services::Logger.error 'No database connection set up'
 end

data/lib/ditty/emails/base.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require 'haml'
-require 'ditty/components/app'
+require 'ditty/components/ditty'
 
 module Ditty
   module Emails
@@ -15,60 +17,72 @@ module Ditty
       def deliver!(to = nil, locals = {})
         options[:to] = to unless to.nil?
         @locals.merge!(locals)
-        %i[to from subject].each do |param|
-          mail.send(param, options[param]) if options[param]
+        %i[to from subject content_type].each do |param|
+          next unless options[param]
+
+          @locals[param] ||= options[param]
+          mail.send(param, options[param])
+        end
+        html = content
+        mail.html_part do
+          body html
         end
-        mail.body content
         mail.deliver!
       end
 
       def method_missing(method, *args, &block)
         return super unless respond_to_missing?(method)
+
         mail.send(method, *args, &block)
       end
 
       def respond_to_missing?(method, _include_private = false)
-        mail.respond_to? method
+        return true if mail.respond_to?(method)
+
+        super
       end
 
       private
 
-      def content
-        result = Haml::Engine.new(content_haml).render(Object.new, locals)
-        return result unless options[:layout]
-        Haml::Engine.new(layout_haml).render(Object.new, content: result)
-      end
+        def content
+          result = Haml::Engine.new(content_haml).render(Object.new, locals)
+          return result unless options[:layout]
 
-      def content_haml
-        read_template(options[:view])
-      end
+          Haml::Engine.new(layout_haml).render(Object.new, locals.merge(content: result))
+        end
 
-      def layout_haml
-        read_template("layouts/#{options[:layout]}") if options[:layout]
-      end
+        def content_haml
+          read_template(options[:view])
+        end
 
-      def read_template(template)
-        File.read(find_template("emails/#{template}"))
-      end
+        def layout_haml
+          read_template("layouts/#{options[:layout]}") if options[:layout]
+        end
 
-      def base_options
-        { subject: '(No Subject)', from: 'no-reply@ditty.io', view: :base }
-      end
+        def read_template(template)
+          File.read(find_template("emails/#{template}"))
+        end
 
-      def find_template(file)
-        template = File.expand_path("./views/#{file}.haml")
-        return template if File.file? template
-        template = File.expand_path("./#{file}.haml", App.view_folder)
-        return template if File.file? template
-        file
-      end
+        def base_options
+          { subject: '(No Subject)', from: 'no-reply@ditty.io', view: :base, content_type: 'text/html; charset=UTF-8' }
+        end
 
-      class << self
-        def deliver!(to = nil, options = {})
-          locals = options[:locals] || {}
-          new(options).deliver!(to, locals)
+        def find_template(file)
+          template = File.expand_path("./views/#{file}.haml")
+          return template if File.file? template
+
+          template = File.expand_path("./#{file}.haml", App.view_folder)
+          return template if File.file? template
+
+          file
+        end
+
+        class << self
+          def deliver!(to = nil, options = {})
+            locals = options[:locals] || {}
+            new(options).deliver!(to, locals)
+          end
         end
-      end
     end
   end
 end

data/lib/ditty/generators/crud_generator.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'thor/group'
+require 'active_support/inflector'
+
+module Ditty
+  module Generators
+    class CrudGenerator < Thor::Group
+      include Thor::Actions
+      attr_reader :namespace, :folder, :views_folder, :controller_name, :model_name, :policy_name # , :file_name
+
+      desc 'Create a CRUD Endpoint including the Model, Controller, Policy, Views and GraphQL Types'
+      argument :name, type: :string, desc: 'Name of the Model, eg. MyApp::User'
+
+      # --no-views make views optional
+      class_option :views, type: :boolean, default: true, desc: 'Generate views for controller'
+
+      def self.source_root
+        File.dirname(__FILE__)
+      end
+
+      def setup
+        @namespace       = name.deconstantize
+        @folder          = namespace.underscore
+        @model_name      = name.demodulize
+        @views_folder    = File.join('views', model_name.pluralize.underscore)
+        @controller_name = "#{model_name.pluralize}Controller"
+        @policy_name     = "#{model_name}Policy"
+      end
+
+      def create_model
+        filename = File.join("lib/#{folder}/models", "#{model_name.underscore}.rb")
+        template '../templates/model.rb.erb', filename
+      rescue StandardError => e
+        puts "Could not generate model for #{model_name}: #{e.message}"
+      end
+
+      def create_controller
+        filename = File.join("lib/#{folder}/controllers", "#{controller_name.underscore}.rb")
+        template '../templates/controller.rb.erb', filename
+        # TODO: Insert the route into the component file
+        # insert_into_file 'config.ru', "use #{class_name}\n", after: 'run ApplicationController\n'
+      rescue StandardError => e
+        puts "Could not generate controller for #{model_name}: #{e.message}"
+      end
+
+      def create_policy
+        filename = File.join("lib/#{folder}/policies", "#{policy_name.underscore}.rb")
+        template '../templates/policy.rb.erb', filename
+      rescue StandardError => e
+        puts "Could not generate policy for #{model_name}: #{e.message}"
+      end
+
+      def create_type
+        filename = File.join("lib/#{folder}/types", "#{model_name.underscore}_type.rb")
+        template '../templates/type.rb.erb', filename
+      rescue StandardError => e
+        puts "Could not generate type for #{model_name}: #{e.message}"
+      end
+
+      def create_views
+        return unless options[:views]
+
+        directory '../templates/views', views_folder
+      end
+
+      private
+
+        def meta_columns
+          %i[id guid slug created_at updated_at]
+        end
+
+        def columns
+          require "#{folder}/models/#{model_name.underscore}"
+          name.constantize.columns
+        rescue StandardError
+          []
+        end
+
+        def schema
+          require "#{folder}/models/#{model_name.underscore}"
+          name.constantize.db_schema
+        rescue StandardError
+          []
+        end
+
+        def many_to_ones
+          DB.foreign_key_list(model_name.underscore.pluralize)
+        end
+
+        def name_column(table)
+          candidates = DB.schema(table.to_sym).to_h.keys - DB.foreign_key_list(table.to_sym).map do |e|
+                                                             e[:columns]
+                                                           end.flatten
+          (candidates - meta_columns).first
+        end
+
+        def graphql_types
+          @graphql_types ||= Hash.new('String').merge(
+            integer: 'Integer',
+            boolean: 'Boolean',
+            datetime: 'GraphQL::Types::ISO8601DateTime'
+          )
+        end
+
+        def input_types
+          @input_types ||= Hash.new('text').merge(
+            integer: 'number',
+            datetime: 'date'
+          )
+        end
+    end
+  end
+end

data/lib/ditty/generators/migration_generator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'thor/group'
+require 'active_support/inflector'
+
+module Ditty
+  module Generators
+    class MigrationGenerator < Thor::Group
+      include Thor::Actions
+
+      attr_reader :namespace, :folder
+
+      desc 'Creates a new Sequel migration for the current project'
+      argument :name, type: :string, desc: 'Name of the migration'
+
+      def self.source_root
+        File.expand_path('../templates', __dir__)
+      end
+
+      def create_model
+        filename = File.join('migrations', "#{Time.now.strftime('%Y%m%d')}_#{name.underscore}.rb")
+        template '../templates/migration.rb.erb', filename
+      end
+    end
+  end
+end

data/lib/ditty/generators/project_generator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'thor/group'
+require 'active_support/inflector'
+
+module Ditty
+  module Generators
+    class ProjectGenerator < Thor::Group
+      include Thor::Actions
+
+      attr_reader :name, :namespace, :folder
+
+      desc 'Initialize a new Ditty project in the current folder'
+
+      def setup
+        @name      = File.basename(Dir.getwd)
+        @folder    = @name.underscore
+        @namespace = folder.classify
+        @name      = @name.titleize
+      end
+
+      def self.source_root
+        File.expand_path('../templates', __dir__)
+      end
+
+      def create_startup_files
+        directory 'logs'
+        directory 'pids'
+        directory 'public'
+        directory '../../../views', 'views'
+        copy_file '.gitignore', './.gitignore'
+        copy_file 'env.example', './.env'
+        copy_file '.rubocop.yml', './.rubocop.yml'
+        copy_file '.rspec', './.rspec'
+
+        template 'lib/project.rb.erb', "lib/#{folder}.rb"
+
+        copy_file 'application.rb', './application.rb'
+        copy_file 'config.ru', './config.ru'
+        copy_file 'Rakefile', './Rakefile'
+        copy_file 'sidekiq.rb', './config/sidekiq.rb'
+        copy_file 'sidekiq.yml', './config/sidekiq.yml'
+
+        copy_file 'spec_helper.rb', './specs/spec_helper.rb'
+        copy_file '../../../spec/support/api_shared_examples.rb', './specs/support/api_shared_examples.rb'
+        copy_file '../../../spec/support/crud_shared_examples.rb', './specs/support/crud_shared_examples.rb'
+
+        template 'settings.yml.erb', './config/settings.yml'
+      end
+    end
+  end
+end

data/lib/ditty/helpers/authentication.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 require 'ditty/models/user'
-require 'ditty/models/role'
-require 'ditty/models/identity'
 
 module Ditty
   module Helpers
     module Authentication
       def current_user
         return nil if current_user_id.nil?
+
         @current_user ||= User[current_user_id]
       end
 
@@ -19,8 +18,9 @@ module Ditty
       end
 
       def current_user_id
-        return env['rack.session']['user_id'] if env['rack.session']
-        env['omniauth.auth'].uid if env['omniauth.auth']
+        return env['rack.session']['user_id'] if env['rack.session'] && env['rack.session']['user_id']
+
+        env['omniauth.auth']&.uid
       end
 
       def authenticate
@@ -33,11 +33,12 @@ module Ditty
 
       def authenticate!
         raise NotAuthenticated unless authenticated?
+
         true
       end
 
       def logout
-        env['rack.session'].delete('user_id') unless env['rack.session'].nil?
+        env['rack.session']&.delete('user_id')
         env.delete('omniauth.auth')
       end
     end