souls 0.51.1 → 0.52.2

data/lib/souls/api/generate/policy.rb

@@ -1,7 +1,7 @@
 module Souls
-  module Api::Generate
-    ## Generate Policy
-    def self.policy(class_name: "user")
+  class Generate < Thor
+    desc "policy [CLASS_NAME]", "Generate Policy File Template"
+    def policy(class_name)
       dir_name = "./app/policies"
       FileUtils.mkdir_p(dir_name) unless Dir.exist?(dir_name)
       file_path = "#{dir_name}/#{class_name.singularize}_policy.rb"
@@ -44,8 +44,8 @@ module Souls
       end
       puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
       file_path
-    rescue StandardError => e
-      raise(StandardError, e)
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
     end
   end
 end

data/lib/souls/api/generate/query.rb

@@ -1,65 +1,65 @@
 module Souls
-  module Api::Generate
-    ## Generate Query / Queries
-    class << self
-      def create_queries(class_name: "user")
-        file_path = "./app/graphql/queries/#{class_name.pluralize}.rb"
-        return "Query already exist! #{file_path}" if File.exist?(file_path)
+  class Generate < Thor
+    desc "query [CLASS_NAME]", "Generate GraphQL Query from schema.rb"
+    def query(class_name)
+      file_dir = "./app/graphql/queries/"
+      FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
+      singularized_class_name = class_name.singularize
+      create_query(class_name: singularized_class_name)
+      create_queries(class_name: singularized_class_name)
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+
+    private
+
+    def create_queries(class_name: "user")
+      file_path = "./app/graphql/queries/#{class_name.pluralize}.rb"
+      return "Query already exist! #{file_path}" if File.exist?(file_path)
 
-        File.open(file_path, "w") do |f|
-          f.write(<<~TEXT)
-            module Queries
-              class #{class_name.camelize.pluralize} < Queries::BaseQuery
-                type [Types::#{class_name.camelize}Type], null: false
+      File.open(file_path, "w") do |f|
+        f.write(<<~TEXT)
+          module Queries
+            class #{class_name.camelize.pluralize} < Queries::BaseQuery
+              type [Types::#{class_name.camelize}Type], null: false
 
-                def resolve
-                  ::#{class_name.camelize}.all
-                rescue StandardError => error
-                  GraphQL::ExecutionError.new error
-                end
+              def resolve
+                ::#{class_name.camelize}.all
+              rescue StandardError => error
+                GraphQL::ExecutionError.new error
               end
             end
-          TEXT
-        end
-        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
-        file_path
-      rescue StandardError => e
-        raise(StandardError, e)
+          end
+        TEXT
       end
+      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      file_path
+    rescue StandardError => e
+      raise(StandardError, e)
+    end
 
-      def create_query(class_name: "user")
-        file_path = "./app/graphql/queries/#{class_name}.rb"
-        return "Query already exist! #{file_path}" if File.exist?(file_path)
+    def create_query(class_name: "user")
+      file_path = "./app/graphql/queries/#{class_name}.rb"
+      return "Query already exist! #{file_path}" if File.exist?(file_path)
 
-        File.open(file_path, "w") do |f|
-          f.write(<<~TEXT)
-            module Queries
-              class #{class_name.camelize} < Queries::BaseQuery
-                type Types::#{class_name.camelize}Type, null: false
-                argument :id, String, required: true
+      File.open(file_path, "w") do |f|
+        f.write(<<~TEXT)
+          module Queries
+            class #{class_name.camelize} < Queries::BaseQuery
+              type Types::#{class_name.camelize}Type, null: false
+              argument :id, String, required: true
 
-                def resolve **args
-                  _, data_id = SoulsApiSchema.from_global_id args[:id]
-                  ::#{class_name.camelize}.find(data_id)
-                rescue StandardError => error
-                  GraphQL::ExecutionError.new error
-                end
+              def resolve **args
+                _, data_id = SoulsApiSchema.from_global_id args[:id]
+                ::#{class_name.camelize}.find(data_id)
+              rescue StandardError => error
+                GraphQL::ExecutionError.new error
               end
             end
-          TEXT
-          puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
-          file_path
-        rescue StandardError => e
-          raise(StandardError, e)
-        end
-      end
-
-      def query(class_name: "user")
-        file_dir = "./app/graphql/queries/"
-        FileUtils.mkdir_p(file_dir) unless Dir.exist?(file_dir)
-        singularized_class_name = class_name.singularize
-        create_query(class_name: singularized_class_name)
-        create_queries(class_name: singularized_class_name)
+          end
+        TEXT
+        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+        file_path
       rescue StandardError => e
         raise(StandardError, e)
       end

data/lib/souls/api/generate/resolver.rb

@@ -1,63 +1,80 @@
 module Souls
-  module Api::Generate
-    ## Generate Resolver
-    class << self
-      def resolver_head(class_name: "user")
-        FileUtils.mkdir_p("./app/graphql/resolvers") unless Dir.exist?("./app/graphql/resolvers")
-        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-        @relation_params = []
-        File.open(file_path, "w") do |f|
-          f.write(<<~TEXT)
-            module Resolvers
-              class #{class_name.camelize}Search < Base
-                include SearchObject.module(:graphql)
-                scope { ::#{class_name.camelize}.all }
-                type Types::#{class_name.camelize}Type.connection_type, null: false
-                description "Search #{class_name.camelize}"
+  class Generate < Thor
+    desc "resolver [CLASS_NAME]", "Generate GraphQL Resolver from schema.rb"
+    def resolver(class_name)
+      singularized_class_name = class_name.singularize.underscore
+      file_path = "./app/graphql/resolvers/#{singularized_class_name}_search.rb"
+      raise(StandardError, "Resolver already exist! #{file_path}") if File.exist?(file_path)
 
-                class #{class_name.camelize}Filter < ::Types::BaseInputObject
-                  argument :OR, [self], required: false
-          TEXT
-        end
+      resolver_head(class_name: singularized_class_name)
+      resolver_params(class_name: singularized_class_name)
+      resolver_after_params(class_name: singularized_class_name)
+      resolver_before_end(class_name: singularized_class_name)
+      resolver_end(class_name: singularized_class_name)
+      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+
+    private
+
+    def resolver_head(class_name: "user")
+      FileUtils.mkdir_p("./app/graphql/resolvers") unless Dir.exist?("./app/graphql/resolvers")
+      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+      @relation_params = []
+      File.open(file_path, "w") do |f|
+        f.write(<<~TEXT)
+          module Resolvers
+            class #{class_name.camelize}Search < Base
+              include SearchObject.module(:graphql)
+              scope { ::#{class_name.camelize}.all }
+              type Types::#{class_name.camelize}Type.connection_type, null: false
+              description "Search #{class_name.camelize}"
+
+              class #{class_name.camelize}Filter < ::Types::BaseInputObject
+                argument :OR, [self], required: false
+        TEXT
       end
+    end
 
-      def resolver_params(class_name: "user")
-        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-        path = "./db/schema.rb"
-        @on = false
-        @user_exist = false
-        @relation_params = []
-        File.open(file_path, "a") do |new_line|
-          File.open(path, "r") do |f|
-            f.each_line.with_index do |line, _i|
-              if @on
-                break if line.include?("t.index") || line.strip == "end"
+    def resolver_params(class_name: "user")
+      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+      path = "./db/schema.rb"
+      @on = false
+      @user_exist = false
+      @relation_params = []
+      File.open(file_path, "a") do |new_line|
+        File.open(path, "r") do |f|
+          f.each_line.with_index do |line, _i|
+            if @on
+              break if line.include?("t.index") || line.strip == "end"
 
-                field = "[String]" if line.include?("array: true")
-                type, name = Souls.get_type_and_name(line)
-                field ||= Souls.type_check(type)
-                case name
-                when "user_id"
-                  @user_exist = true
-                when /$*_id\z/
-                  @relation_params << name
-                  new_line.write("      argument :#{name}, String, required: false\n")
-                when "created_at", "updated_at"
-                  next
-                else
-                  new_line.write("      argument :#{name}, #{field}, required: false\n")
-                end
+              field = "[String]" if line.include?("array: true")
+              type, name = Souls.get_type_and_name(line)
+              field ||= Souls.type_check(type)
+              case name
+              when "user_id"
+                @user_exist = true
+              when /$*_id\z/
+                @relation_params << name
+                new_line.write("      argument :#{name}, String, required: false\n")
+              when "created_at", "updated_at"
+                next
+              else
+                new_line.write("      argument :#{name}, #{field}, required: false\n")
               end
-              @on = true if Souls.table_check(line: line, class_name: class_name)
             end
+            @on = true if Souls.table_check(line: line, class_name: class_name)
           end
         end
       end
+    end
 
-      def resolver_after_params(class_name: "user")
-        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-        File.open(file_path, "a") do |f|
-          f.write(<<-TEXT)
+    def resolver_after_params(class_name: "user")
+      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+      File.open(file_path, "a") do |f|
+        f.write(<<-TEXT)
         argument :start_date, String, required: false
         argument :end_date, String, required: false
       end
@@ -73,86 +90,69 @@ module Souls
 
       def normalize_filters(value, branches = [])
         scope = ::#{class_name.camelize}.all
-          TEXT
-        end
+        TEXT
       end
+    end
 
-      def resolver_before_end(class_name: "user")
-        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-        path = "./db/schema.rb"
-        @on = false
-        @user_exist = false
-        @relation_params = []
-        File.open(file_path, "a") do |new_line|
-          File.open(path, "r") do |f|
-            f.each_line.with_index do |line, _i|
-              if @on
-                break if line.include?("t.index") || line.strip == "end"
+    def resolver_before_end(class_name: "user")
+      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+      path = "./db/schema.rb"
+      @on = false
+      @user_exist = false
+      @relation_params = []
+      File.open(file_path, "a") do |new_line|
+        File.open(path, "r") do |f|
+          f.each_line.with_index do |line, _i|
+            if @on
+              break if line.include?("t.index") || line.strip == "end"
 
-                type, name = Souls.get_type_and_name(line)
-                if line.include?("array: true")
-                  new_line.write(
-                    "      scope = scope.where(\"#{name} @> ARRAY[?]::text[]\", value[:#{name}]) if value[:#{name}]\n"
-                  )
-                  next
-                end
-                case name
-                when "user_id"
-                  @user_exist = true
-                when /$*_id\z/
-                  @relation_params << name
-                  new_line.write(
-                    "      scope = scope.where(#{name}: decode_global_key(value[:#{name}])) if value[:#{name}]\n"
-                  )
-                when "created_at", "updated_at"
-                  next
+              type, name = Souls.get_type_and_name(line)
+              if line.include?("array: true")
+                new_line.write(
+                  "      scope = scope.where(\"#{name} @> ARRAY[?]::text[]\", value[:#{name}]) if value[:#{name}]\n"
+                )
+                next
+              end
+              case name
+              when "user_id"
+                @user_exist = true
+              when /$*_id\z/
+                @relation_params << name
+                new_line.write(
+                  "      scope = scope.where(#{name}: decode_global_key(value[:#{name}])) if value[:#{name}]\n"
+                )
+              when "created_at", "updated_at"
+                next
+              else
+                case type
+                when "boolean"
+                  new_line.write("      scope = scope.where(#{name}: value[:#{name}]) unless value[:#{name}].nil?\n")
                 else
-                  case type
-                  when "boolean"
-                    new_line.write("      scope = scope.where(#{name}: value[:#{name}]) unless value[:#{name}].nil?\n")
-                  else
-                    new_line.write("      scope = scope.where(#{name}: value[:#{name}]) if value[:#{name}]\n")
-                  end
+                  new_line.write("      scope = scope.where(#{name}: value[:#{name}]) if value[:#{name}]\n")
                 end
               end
-              @on = true if Souls.table_check(line: line, class_name: class_name)
             end
+            @on = true if Souls.table_check(line: line, class_name: class_name)
           end
         end
       end
+    end
 
-      def resolver_end(class_name: "user")
-        file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
-        File.open(file_path, "a") do |f|
-          f.write(<<~TEXT)
-                  scope = scope.where("created_at >= ?", value[:start_date]) if value[:start_date]
-                  scope = scope.where("created_at <= ?", value[:end_date]) if value[:end_date]
-                  branches << scope
-                  value[:OR].inject(branches) { |s, v| normalize_filters(v, s) } if value[:OR].present?
-                  branches
-                end
+    def resolver_end(class_name: "user")
+      file_path = "./app/graphql/resolvers/#{class_name.singularize}_search.rb"
+      File.open(file_path, "a") do |f|
+        f.write(<<~TEXT)
+                scope = scope.where("created_at >= ?", value[:start_date]) if value[:start_date]
+                scope = scope.where("created_at <= ?", value[:end_date]) if value[:end_date]
+                branches << scope
+                value[:OR].inject(branches) { |s, v| normalize_filters(v, s) } if value[:OR].present?
+                branches
               end
             end
-          TEXT
-        end
-        file_path
-      end
-
-      def resolver(class_name: "user")
-        singularized_class_name = class_name.singularize.underscore
-        file_path = "./app/graphql/resolvers/#{singularized_class_name}_search.rb"
-        raise(StandardError, "Resolver already exist! #{file_path}") if File.exist?(file_path)
-
-        resolver_head(class_name: singularized_class_name)
-        resolver_params(class_name: singularized_class_name)
-        resolver_after_params(class_name: singularized_class_name)
-        resolver_before_end(class_name: singularized_class_name)
-        resolver_end(class_name: singularized_class_name)
-        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
-        file_path
-      rescue StandardError => e
-        raise(StandardError, e)
+          end
+        TEXT
       end
+      file_path
     end
   end
 end

data/lib/souls/api/generate/rspec_factory.rb

@@ -1,67 +1,67 @@
 module Souls
-  module Api::Generate
-    ## Generate Rspec Factory
-    class << self
-      def rspec_factory_head(class_name: "user")
-        file_path = "./spec/factories/#{class_name.pluralize}.rb"
-        FileUtils.mkdir_p("./spec/factories/") unless Dir.exist?("./spec/factories/")
-        File.open(file_path, "w") do |f|
-          f.write(<<~TEXT)
-            FactoryBot.define do
-              factory :#{class_name} do
-          TEXT
-        end
+  class Generate < Thor
+    desc "rspec_factory [CLASS_NAME]", "Generate Rspec Factory Test from schema.rb"
+    def rspec_factory(class_name)
+      file_path = "./spec/factories/#{class_name.pluralize}.rb"
+      return "RspecFactory already exist! #{file_path}" if File.exist?(file_path)
+
+      singularized_class_name = class_name.singularize
+      rspec_factory_head(class_name: singularized_class_name)
+      rspec_factory_params(class_name: singularized_class_name)
+      rspec_factory_end(class_name: singularized_class_name)
+      puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
+      file_path
+    rescue Thor::Error => e
+      raise(Thor::Error, e)
+    end
+
+    private
+
+    def rspec_factory_head(class_name: "user")
+      file_path = "./spec/factories/#{class_name.pluralize}.rb"
+      FileUtils.mkdir_p("./spec/factories/") unless Dir.exist?("./spec/factories/")
+      File.open(file_path, "w") do |f|
+        f.write(<<~TEXT)
+          FactoryBot.define do
+            factory :#{class_name} do
+        TEXT
       end
+    end
 
-      def rspec_factory_params(class_name: "user")
-        file_path = "./spec/factories/#{class_name.pluralize}.rb"
-        path = "./db/schema.rb"
-        @on = false
-        File.open(file_path, "a") do |new_line|
-          File.open(path, "r") do |f|
-            f.each_line.with_index do |line, _i|
-              if @on
-                new_line.write("\n" && break) if line.include?("t.index") || line.strip == "end"
-                field = '["tag1", "tag2", "tag3"]' if line.include?("array: true")
-                type, name = line.split(",")[0].gsub("\"", "").scan(/((?<=t\.).+(?=\s)) (.+)/)[0]
-                field ||= Souls.get_test_type(type)
-                if type == "bigint" && name.include?("_id")
-                  id_name = name.gsub("_id", "")
-                  new_line.write("    association :#{id_name}, factory: :#{id_name}\n")
-                else
-                  new_line.write("    #{name} { #{field} }\n")
-                end
+    def rspec_factory_params(class_name: "user")
+      file_path = "./spec/factories/#{class_name.pluralize}.rb"
+      path = "./db/schema.rb"
+      @on = false
+      File.open(file_path, "a") do |new_line|
+        File.open(path, "r") do |f|
+          f.each_line.with_index do |line, _i|
+            if @on
+              new_line.write("\n" && break) if line.include?("t.index") || line.strip == "end"
+              field = '["tag1", "tag2", "tag3"]' if line.include?("array: true")
+              type, name = line.split(",")[0].gsub("\"", "").scan(/((?<=t\.).+(?=\s)) (.+)/)[0]
+              field ||= Souls.get_test_type(type)
+              if type == "bigint" && name.include?("_id")
+                id_name = name.gsub("_id", "")
+                new_line.write("    association :#{id_name}, factory: :#{id_name}\n")
+              else
+                new_line.write("    #{name} { #{field} }\n")
               end
-              @on = true if Souls.table_check(line: line, class_name: class_name)
             end
+            @on = true if Souls.table_check(line: line, class_name: class_name)
           end
         end
       end
+    end
 
-      def rspec_factory_end(class_name: "user")
-        file_path = "./spec/factories/#{class_name.pluralize}.rb"
-        File.open(file_path, "a") do |f|
-          f.write(<<~TEXT)
-              end
+    def rspec_factory_end(class_name: "user")
+      file_path = "./spec/factories/#{class_name.pluralize}.rb"
+      File.open(file_path, "a") do |f|
+        f.write(<<~TEXT)
             end
-          TEXT
-        end
-        file_path
-      end
-
-      def rspec_factory(class_name: "user")
-        file_path = "./spec/factories/#{class_name.pluralize}.rb"
-        return "RspecFactory already exist! #{file_path}" if File.exist?(file_path)
-
-        singularized_class_name = class_name.singularize
-        rspec_factory_head(class_name: singularized_class_name)
-        rspec_factory_params(class_name: singularized_class_name)
-        rspec_factory_end(class_name: singularized_class_name)
-        puts(Paint % ["Created file! : %{white_text}", :green, { white_text: [file_path.to_s, :white] }])
-        file_path
-      rescue StandardError => e
-        raise(StandardError, e)
+          end
+        TEXT
       end
+      file_path
     end
   end
 end