strum 0.0.21

data/lib/strum/commands/resource/service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "strum/commands/mixin/app_check"
+require "strum/commands/mixin/names"
+require "strum/commands/mixin/fields"
+
+module Strum::Commands::Resource
+  # Strum generate sub command
+  # `strum generate service`
+  class Service < Thor::Group
+    include Thor::Actions
+    include Strum::Commands::Mixin::AppCheck
+    include Strum::Commands::Mixin::Names
+    include Strum::Commands::Mixin::Fields
+
+    argument :name
+    class_option :crud, type: :boolean, aliases: ["-c"]
+    class_option :fields, type: :array, default: []
+
+    def self.source_root
+      File.expand_path("../../templates", __dir__)
+    end
+
+    def pre_check
+      raise StrumGenerateError, "This is not Strum application" unless strum?
+    end
+
+    def create_service_files
+      options[:crud] ? crud_service : basic_service
+    end
+
+    private
+
+      def basic_service
+        directory("service", File.expand_path(namespace_path, "services"))
+      end
+
+      def crud_service
+        directory("service_crud", File.expand_path(namespace_path, "services"))
+      end
+  end
+end

data/lib/strum/service.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "dry/matcher"
+
+module Strum
+  # Module
+  module Service
+    class Failure < StandardError; end
+
+    StrumMatcher = Dry::Matcher.new(
+      success: Dry::Matcher::Case.new(
+        match: lambda do |value, *pattern|
+          value[0] && (pattern.any? ? pattern.include?(value[1]) : true)
+        end,
+        resolve: ->(value) { value.last }
+      ),
+      failure: Dry::Matcher::Case.new(
+        match: lambda do |value, *pattern|
+          !value[0] && (pattern.any? ? pattern.include?(value[1]) : true)
+        end,
+        resolve: ->(value) { value.last }
+      )
+    )
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    # Internal: Interactor class methods.
+    module ClassMethods
+      def call(input = {}, &block)
+        strum = new(input)
+        strum.audit
+        strum.call if strum.valid?
+        strum.valid? ? valid_result(strum, &block) : invalid_result(strum, &block)
+      end
+
+      private
+
+        def valid_result(strum, &block)
+          return strum.output || strum.outputs unless block_given?
+          return StrumMatcher.call([true, strum.output], &block) if strum.output
+
+          StrumMatcher.call([true, *strum.outputs.keys, strum.outputs], &block)
+        end
+
+        def invalid_result(strum, &block)
+          return nil unless block_given?
+
+          StrumMatcher.call([false, *strum.errors.values, strum.errors], &block)
+        end
+    end
+
+    attr_reader :output, :outputs
+
+    # Instance methods
+    def initialize(input)
+      self.strum_errors = {}
+      self.outputs = {}
+      raise Failure, "'input' must be a Hash" unless input.is_a?(Hash)
+
+      self.input = input.transform_keys do |key|
+        key_to_sym(key)
+      end
+    end
+
+    def call
+      raise Failure, "call method must be implemented"
+    end
+
+    def audit; end
+
+    def valid?
+      strum_errors.empty?
+    end
+
+    def errors
+      strum_errors
+    end
+
+    protected
+
+      attr_accessor :input, :strum_errors
+      attr_writer :output, :outputs
+
+      def add_error(field, value)
+        if field.is_a?(Array)
+          field.each do |key|
+            value.is_a?(Array) ? value.each { |v| add_error(key, v) } : add_error(key, value)
+            add_error(key, value.is_a?(Array) ? value.first : value)
+          end
+        else
+          strum_errors[field] ||= []
+          strum_errors[field] = strum_errors[field] + Array(value)
+        end
+      end
+
+      def add_errors(errors)
+        errors.each { |field, value| add_error(field, value) }
+      end
+
+      def required(*keys)
+        keys.each { |key| add_error(key, :field_must_exist) unless input[key] }
+      end
+
+    private
+
+      def key_to_sym(key)
+        key.to_sym
+      rescue StandardError
+        key
+      end
+  end
+end

data/lib/strum/sub_command_base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Strum
+  # SubCommand Base class
+  class SubCommandBase < Thor
+    def self.banner(command, _namespace = nil, _subcommand = false)
+      "#{basename} #{subcommand_prefix} #{command.usage}"
+    end
+
+    def self.subcommand_prefix
+      name.gsub(/.*::/, "")
+          .gsub(/^[A-Z]/) { |match| match[0].downcase }
+          .gsub(/[A-Z]/) { |match| "-#{match[0].downcase}" }
+    end
+  end
+end

data/lib/strum/tasks/sequel.rake

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+namespace :sequel do # rubocop:disable Metrics/BlockLength
+  require "sequel"
+  Sequel.extension :migration
+
+  def postgres_cmd
+    postgres_db = Sequel.connect(adapter: "postgres",
+                                 host: ENV.fetch("DATABASE_HOST", "localhost"),
+                                 database: "postgres",
+                                 user: ENV.fetch("DATABASE_USER", "postgres"),
+                                 password: ENV.fetch("DATABASE_PASSWORD", nil))
+    yield(postgres_db)
+    postgres_db.disconnect
+  end
+
+  desc "Drop database"
+  task :drop do
+    postgres_cmd do |db|
+      db.execute "DROP DATABASE IF EXISTS \"#{ENV.fetch('DATABASE_NAME')}\""
+      puts "Database #{ENV.fetch('DATABASE_NAME')} dropped"
+    end
+  end
+
+  desc "Create database"
+  task :create do
+    postgres_cmd do |db|
+      db.execute "CREATE DATABASE \"#{ENV.fetch('DATABASE_NAME')}\""
+      puts "Database #{ENV.fetch('DATABASE_NAME')} created"
+    end
+  end
+
+  desc "Reset database"
+  task :reset do
+    postgres_cmd do |db|
+      db.execute "DROP DATABASE IF EXISTS \"#{ENV.fetch('DATABASE_NAME')}\""
+      db.execute "CREATE DATABASE \"#{ENV.fetch('DATABASE_NAME')}\""
+      puts "Database #{ENV.fetch('DATABASE_NAME')} recreated"
+    end
+    Rake::Task["sequel:migrate"].execute
+  end
+
+  desc "Prints current schema version"
+  task :version do
+    require "config/sequel"
+    version = if DB.tables.include?(:schema_migrations) && DB[:schema_migrations].count.positive?
+                DB[:schema_migrations].order(:filename).last[:filename]
+              end || 0
+
+    puts "Current schema version: #{version}"
+  end
+
+  desc "Migrate database"
+  task :migrate, [:version] do |_t, args|
+    require "config/sequel"
+    require "logger"
+    Sequel.extension :migration
+    DB.loggers << Logger.new($stdout) if DB.loggers.empty?
+    Sequel::TimestampMigrator.apply(DB, File.join(ENV["STRUM_ROOT"], "db/migrations"), args.version)
+  end
+
+  desc "Rollback database"
+  task :rollback do
+    require "config/sequel"
+    Rake::Task["sequel:version"].execute
+    if DB[:schema_migrations].count > 1
+      prev_version = DB[:schema_migrations]
+                     .order(Sequel.desc(:filename))
+                     .limit(2)
+                     .all
+                     .last[:filename]
+      target = prev_version.split("_").first.to_i
+    end
+
+    Rake::Task["sequel:migrate"].invoke(target || 0)
+    Rake::Task["sequel:version"].execute
+  end
+
+  desc "Annotate Sequel models"
+  task "annotate" do
+    ENV["RACK_ENV"] = "development"
+    require File.join(ENV["STRUM_ROOT"], "config", "models.rb")
+    DB.loggers.clear
+    require "sequel/annotate"
+    Sequel::Annotate.annotate(Dir[File.join(ENV["STRUM_ROOT"], "models/*.rb")])
+  end
+end

data/lib/strum/templates/app/blank/.env.local.tt

@@ -0,0 +1,6 @@
+VIRTUAL_HOST=lvh.me
+REDIS_URL=redis://127.0.0.1:6379
+<% if sequel? %>
+DATABASE_NAME=<%= "#{app_name}_development" %>
+DATABASE_USER=postgres
+<% end %>

data/lib/strum/templates/app/blank/.env.test.tt

@@ -0,0 +1,4 @@
+<% if sequel? %>
+DATABASE_NAME=<%= "#{app_name}_test" %>
+DATABASE_USER=postgres
+<% end %>

data/lib/strum/templates/app/blank/.gitignore

@@ -0,0 +1,26 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+.byebug_history
+
+# Editor directories and files
+.idea
+.vscode
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw*
+

data/lib/strum/templates/app/blank/.rubocop.yml

@@ -0,0 +1,28 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+# Use Ruby >= 1.9 syntax for hashes. Prefer { a: :b } over { :a => :b }.
+Style/HashSyntax:
+  Enabled: true
+
+# Method definitions after `private` or `protected` isolated calls need one
+# extra level of indentation.
+Layout/IndentationConsistency:
+  Enabled: true
+#  EnforcedStyle: rails
+
+# Two spaces, no tabs (for indentation).
+Layout/IndentationWidth:
+  Enabled: true
+
+# Check quotes usage according to lint rule below.
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Metrics/LineLength:
+  Max: 120
+  IgnoredPatterns: ['\A#']
+
+Style/Semicolon:
+  AllowAsExpressionSeparator: true

data/lib/strum/templates/app/blank/Dockerfile

@@ -0,0 +1,15 @@
+FROM registry.gitlab.com/qpard/ruby:latest as builder
+
+WORKDIR /usr/src/app
+ENV RACK_ENV production
+RUN apk add curl-dev ruby-dev build-base tzdata postgresql-dev
+COPY Gemfile* ./
+RUN bundle install --without development test
+
+FROM registry.gitlab.com/qpard/ruby:latest AS runtime
+WORKDIR /usr/src/app
+ENV RACK_ENV production
+
+RUN apk add tzdata postgresql-dev
+COPY --from=builder /usr/local/bundle /usr/local/bundle
+COPY . ./

data/lib/strum/templates/app/blank/Gemfile.tt

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# framework
+<% if rabbit? -%>
+gem "bunny", ">= 2.14.1"
+<% end -%>
+<% if json? -%>
+gem "fast_jsonapi"
+<% end -%>
+gem "puma", "~> 4.2.0"
+<% if cors? -%>
+gem "rack-cors"
+<% end -%>
+gem "rack-unreloader", "~> 1.7"
+gem "rake", "~> 13"
+<% if redis? -%>
+gem "redis-objects"
+<% end -%>
+gem "roda", "~> 3.24"
+<% if sequel? -%>
+
+# database
+gem "pg", "~> 1.1.4"
+gem "sequel", "~> 5.24"
+gem "sequel_pg", "~> 1.12"
+<% end -%>
+
+# Strum framework
+gem "strum", "~> 0.0.19"
+
+group :development do
+  # A Ruby code quality reporter
+  gem "rubycritic", require: false
+
+  # A Ruby static code analyzer and formatter,
+  # based on the community Ruby style guide. https://docs.rubocop.org
+  gem "rubocop", "~> 0.62.0", require: false
+
+  gem "roda-route_list"
+end
+
+group :test do
+<% if sequel? -%>
+  gem "database_cleaner"
+<% end -%>
+  gem "email_spec"
+  gem "json_spec"
+end
+
+group :development, :test do
+  # Call "byebug" anywhere in the code
+  # to stop execution and get a debugger console
+  gem "byebug", platforms: %i[mri mingw x64_mingw]
+  gem "factory_bot"
+  gem "rspec"
+  gem "rspec_junit_formatter"
+
+  gem "debase", "~> 0.2.4"
+  gem "ruby-debug-ide", "~> 0.7.0"
+<% if sequel? -%>
+  gem "sequel-annotate"
+<% end -%>
+
+  # A Ruby gem to load environment variables from `.env`.
+  gem "dotenv"
+end

data/lib/strum/templates/app/blank/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "./config/env"
+require "strum"
+
+spec = Gem::Specification.find_by_name "strum"
+rakefile = "#{spec.gem_dir}/lib/strum/Rakefile"
+load rakefile

data/lib/strum/templates/app/blank/bin/console.tt

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "irb"
+require "logger"
+require "./config/env"
+unless defined?(Unreloader)
+  require "rack/unreloader"
+  Unreloader = Rack::Unreloader.new(subclasses: %w[Sequel::Model], logger: Logger.new($stdout), reload: true) { <%= app_class_name %> }
+end
+<% if sequel? %>
+require "config/sequel"
+Unreloader.require('models'){|f| Sequel::Model.send(:camelize, File.basename(f).sub(/\.rb\z/, ''))}
+<% end %>
+IRB.start

data/lib/strum/templates/app/blank/config/app.rb.tt

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+<% if sequel? -%>
+require "config/sequel"
+require "config/models"
+
+<% end -%>
+require "roda"
+<% if json? -%>
+require "fast_jsonapi"
+<% end -%>
+require "strum"
+<% if cors? -%>
+require "rack/cors"
+<% end -%>
+<% if rabbit? -%>
+require "bunny"
+<% end -%>
+<% if redis? -%>
+require "redis/objects"
+<% end -%>
+
+unless defined?(Unreloader)
+  require "rack/unreloader"
+  Unreloader = Rack::Unreloader.new(reload: false)
+end
+
+Unreloader.require("services")
+<% if json? -%>
+Unreloader.require("serializers")
+<% end -%>
+
+# Main <%= app_class_name %> route class
+class <%= app_class_name %> < Roda
+  opts[:root] = ENV["STRUM_ROOT"]
+  plugin :all_verbs
+  plugin :symbol_status
+  plugin :json, content_type: "application/vnd.api+json"
+  plugin :json_parser
+<% if cors? %>
+  # Rack Middleware for handling Cross-Origin Resource Sharing (CORS), which makes cross-origin AJAX possible.
+  # https://github.com/cyu/rack-cors#rack-configuration
+  use Rack::Cors do
+    allow do
+      origins "*"
+      resource "*", headers: :any, methods: %i[get post options]
+    end
+  end
+<% end %>
+  plugin :hash_routes
+  Unreloader.require("routes")
+
+  route(&:hash_routes)
+
+  # for more details usage
+  # route do |req|
+  #   req.public
+  #   req.hash_routes
+  # end
+end

data/lib/strum/templates/app/blank/config/env.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path("..", __dir__), File.expand_path("../lib", __dir__))
+
+ENV["RACK_ENV"] ||= "development"
+
+unless ENV["RACK_ENV"] == "production"
+  require "dotenv"
+  Dotenv.load(".env.#{ENV['RACK_ENV'].downcase}", ".env.local")
+end
+
+ENV["STRUM_ROOT"] = File.expand_path("..", __dir__)

data/lib/strum/templates/app/blank/config.ru.tt

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "./config/env"
+
+dev = ENV["RACK_ENV"] == "development"
+
+if dev
+  require "logger"
+  logger = Logger.new($stdout)
+end
+
+require "rack/unreloader"
+Unreloader = Rack::Unreloader.new(subclasses: %w[Roda Sequel::Model],
+                                  logger: logger,
+                                  reload: dev) { <%= app_class_name %> }
+
+Unreloader.require("config/app.rb") { "<%= app_class_name %>" }
+run(dev ? Unreloader : <%= app_class_name %>.freeze.app)

data/lib/strum/templates/app/sequel/config/models.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "sequel/model"
+require "config/sequel.rb"
+
+Sequel::Model.plugin(:auto_validations)
+Sequel::Model.plugin(:constraint_validations)
+Sequel::Model.plugin(:subclasses)
+Sequel::Model.cache_associations = false if ENV["RACK_ENV"] == "development"
+
+unless defined?(Unreloader)
+  require "rack/unreloader"
+  Unreloader = Rack::Unreloader.new(reload: false)
+end
+
+Unreloader.require("models") do |f|
+  Sequel::Model.send(:camelize, File.basename(f).sub(/\.rb\z/, ""))
+end

data/lib/strum/templates/app/sequel/config/sequel.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "sequel"
+
+DB = Sequel.connect adapter: "postgres",
+                    host: ENV.delete("DATABASE_HOST") || "localhost",
+                    database: ENV.delete("DATABASE_NAME"),
+                    user: ENV.delete("DATABASE_USER"),
+                    password: ENV.delete("DATABASE_PASSWORD")
+DB.extension(:pg_array, :pg_json)

data/lib/strum/templates/app/sequel/db/migrations/001_setup.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    DB.extension(:constraint_validations)
+    DB.extension(:pg_array)
+    DB.extension(:pg_json)
+    DB.create_constraint_validations_table
+    extension :date_arithmetic
+    run "CREATE EXTENSION IF NOT EXISTS citext;"
+  end
+
+  down do
+    DB.extension(:constraint_validations)
+    DB.drop_constraint_validations_table
+  end
+end

data/lib/strum/templates/migration/%migration_filename%.rb.tt

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+<%- if model? -%>
+  change do
+    extension(:constraint_validations)
+    create_table(:<%= table_name %>) do
+      primary_key :id
+      # code here ...
+    end
+  end
+<%- else -%>
+  change do
+    primary_key :id
+    # code here...
+  end
+
+  # or use up/down
+  # up do
+  #   # up here...
+  # end
+  #
+  # down do
+  #   # down here...
+  # end
+<%- end -%>
+end

data/lib/strum/templates/model/%resource_filename%.rb.tt

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+<%- namespace_names.each_with_index do |c,i| -%>
+<%= '  ' * i %>module <%= c %>
+<%- end -%>
+<%= ident %># Strum service
+<%= ident %># You model description here...
+<%= ident %>class <%= resource_class_name -%> < Sequel::Model
+<%= ident %>end
+<%- (namespace_names.size - 1).downto(0) do |i| -%>
+<%= '  ' * i %>end
+<%- end -%>

data/lib/strum/templates/route/%resource_filename%.rb.tt

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Branch route /<%= name %>
+class <%= app_class_name %>
+  hash_branch "<%= route_name %>" do |req|
+    # req.on do
+    # end
+  end
+end