shaf 0.8.0 → 1.0.0

data/lib/shaf/spec/http_method_utils.rb

@@ -3,10 +3,18 @@ module Shaf
     module HttpUtils
       include ::Rack::Test::Methods
 
-      [:get, :put, :patch, :post, :delete, :options, :head, :link, :unlink].each do |m|
-        define_method m do |*args|
+      %i[get put patch post delete options head link unlink].each do |m|
+        define_method m do |uri, payload = nil, options = {}|
           set_headers
-          super(*args)
+
+          if payload
+            payload = JSON.generate(payload) if payload.respond_to? :to_h
+            options['CONTENT_TYPE'] ||= 'application/json'
+            super(uri, payload, options)
+          else
+            super(uri, options)
+          end
+
           set_payload parse_response(last_response.body)
         end
       end

data/lib/shaf/spec/integration_spec.rb

@@ -6,14 +6,14 @@ module Shaf
       include PayloadUtils
       include HttpUtils
 
-      register_spec_type self do |desc, args|
-        next unless args && args.is_a?(Hash)
+      register_spec_type self do |_desc, args|
+        next unless args&.is_a?(Hash)
         args[:type]&.to_s == 'integration'
       end
 
       def set_headers
         if defined?(@__integration_test_auth_token) && @__integration_test_auth_token
-          header 'X-AUTH-TOKEN', @__integration_test_auth_token
+          header Settings.auth_token_header, @__integration_test_auth_token
         end
       end
 
@@ -25,7 +25,7 @@ module Shaf
       end
 
       def app
-        App.instance
+        App.app
       end
 
       def follow_rel(rel, method: nil)

data/lib/shaf/spec/serializer_spec.rb

@@ -11,7 +11,7 @@ module Shaf
         args[:type]&.to_s == 'serializer'
       end
 
-      def serialize(resource, current_user:)
+      def serialize(resource, current_user: nil)
         serializer = __serializer || HALPresenter
         set_payload serializer.to_hal(resource, current_user: current_user)
       end

data/lib/shaf/upgrade/manifest.rb

@@ -14,23 +14,48 @@ module Shaf
         @files[:regexp] = build_patterns(params[:substitutes])
       end
 
-      def patch_for(file)
-        files[:patch].select { |_, pattern| file =~ pattern }.keys
+      def patches
+        files[:patch]
       end
 
-      def regexp_for(file)
-        files[:regexp].select { |_, pattern| file =~ pattern }.keys
+      def additions
+        files[:add]
+      end
+
+      def removals
+        files[:drop]
+      end
+
+      def regexps
+        files[:regexp]
+      end
+
+      def patches_for(file)
+        patches.select { |_, pattern| file =~ pattern }.keys
+      end
+
+      def regexps_for(file)
+        regexps.select { |_, pattern| file =~ pattern }.keys
       end
 
       def drop?(file)
-        files[:drop].any? { |pattern| file =~ pattern }
+        removals.any? { |pattern| file =~ pattern }
       end
 
       def stats
-        "Add: #{files[:add].size}, " \
-          "Del: #{files[:drop].size}, " \
-          "Patch: #{files[:patch].size}, " \
-          "Regexp: #{files[:regexp].size}"
+        {
+          additions: additions.size,
+          removals: removals.size,
+          patches: patches.size,
+          regexps: regexps.size
+        }
+      end
+
+      def stats_str
+        "Add: #{additions.size}, " \
+          "Del: #{removals.size}, " \
+          "Patch: #{patches.size}, " \
+          "Regexp: #{regexps.size}"
       end
 
       private

data/lib/shaf/upgrade/package.rb

@@ -77,15 +77,15 @@ module Shaf
 
       def apply(dir = nil)
         apply_patches(dir)
-        apply_additions
         apply_drops(dir)
+        apply_additions
         apply_substitutes(dir)
       end
 
       def to_s
         str = "Shaf::Upgrade::Package for version #{@version}"
         return str if @manifest.nil?
-        "#{str} (#{@manifest.stats})"
+        "#{str} (#{@manifest.stats_str})"
       end
 
       private
@@ -143,8 +143,8 @@ module Shaf
       end
 
       def apply_patches(dir = nil)
-        files_in(dir).all? do |file|
-          @manifest.patch_for(file).all? do |name|
+        files_in(dir).each do |file|
+          @manifest.patches_for(file).each do |name|
             patch = @files[name]
             apply_patch(file, patch)
           end
@@ -152,35 +152,40 @@ module Shaf
       end
 
       def apply_patch(file, patch)
-        success = nil
-        Open3.popen3('patch', file, '-r', '-') do |i, o, e, t|
+        Open3.popen3('patch', file) do |i, o, e, t|
           i.write patch
           i.close
           puts o.read
           err = e.read
           puts err unless err.empty?
-          success = t.value.success?
+          next if t.value.success?
+          STDERR.puts "Failed to apply patch for: #{file}\n"
         end
-        success
       end
 
       def apply_additions
-        @manifest.files[:add].each do |chksum, filename|
+        puts '' unless @manifest.additions.empty?
+        @manifest.additions.each do |chksum, filename|
           content = @files[chksum]
           FileUtils.mkdir_p File.dirname(filename)
+          puts "adding file: #{filename}"
           File.open(filename, 'w') { |file| file.write(content) }
         end
       end
 
       def apply_drops(dir = nil)
+        puts '' unless @manifest.removals.empty?
         files_in(dir).map do |file|
-          File.unlink(file) if @manifest.drop?(file)
+          next unless @manifest.drop?(file)
+          puts "removing file: #{file}"
+          File.unlink(file)
         end
       end
 
       def apply_substitutes(dir = nil)
+        puts '' unless @manifest.regexps.empty?
         files_in(dir).all? do |file|
-          @manifest.regexp_for(file).all? do |name|
+          @manifest.regexps_for(file).all? do |name|
             params = symbolize_keys(YAML.safe_load(@files[name]))
             apply_substitute(file, params)
           end
@@ -188,18 +193,22 @@ module Shaf
       end
 
       def apply_substitute(file, params)
-        pattern = params[:pattern] or return
-        replacement = params[:replace] or return
+        return unless params[:pattern] && params[:replace]
+
+        pattern = Regexp.new(params[:pattern])
+        replacement = params[:replace]
+
         tmp = Tempfile.open do |new_file|
           File.readlines(file).each do |line|
-            new_file << line.sub(Regexp.new(pattern), replacement)
+            new_file << line.gsub(pattern, replacement)
           end
           new_file
         end
+
         FileUtils.mv(tmp.path, file)
       end
 
-      # Refactor this when support for ruby < 2.5 is dropped
+      # Refactor this when support for ruby 2.4 is dropped
       def symbolize_keys(hash)
         hash.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
       end

data/lib/shaf/utils.rb

@@ -1,39 +1,49 @@
+# frozen_string_literal: true
+
+require 'forwardable'
 require 'shaf/version'
 
 module Shaf
   module Utils
+    extend Forwardable
+
     class ProjectRootNotFound < StandardError; end
 
     SHAF_VERSION_FILE = '.shaf'.freeze
 
-    # FIXME!!!
-    def self.pluralize(noun)
-      noun + 's' # FIXME!!
-    end
+    class << self
+      def model_name(name)
+        name.capitalize.gsub(/[_-](\w)/) { $1.upcase }
+      end
 
-    def self.model_name(name)
-      name.capitalize.gsub(/[_-](\w)/) { $1.upcase }
-    end
+      def gem_root
+        File.expand_path('../..', __dir__)
+      end
 
-    def self.gem_root
-      File.expand_path('../../..', __FILE__)
-    end
+      # FIXME!!!
+      def pluralize(noun)
+        return pluralize(noun.to_s).to_sym if noun.is_a? Symbol
+        noun + 's'
+      end
 
-    # FIXME!!!
-    def self.singularize(noun)
-      return singularize(noun.to_s).to_sym if noun.is_a? Symbol
-      return noun unless noun.end_with? 's'
-      noun[0..-2]
-    end
+      # FIXME!!!
+      def singularize(noun)
+        return singularize(noun.to_s).to_sym if noun.is_a? Symbol
+        return noun unless noun.end_with? 's'
+        noun[0..-2]
+      end
 
-    def pluralize(noun)
-      Utils::pluralize(noun)
-    end
+      def symbolize(str)
+        :"#{str}"
+      end
 
-    def gem_root
-      self.class.gem_root
+      def symbol_string(str)
+        symbolize(str).inspect
+      end
     end
 
+    def_delegators Utils, :pluralize, :singularize, :symbolize, :symbol_string, :gem_root
+
     def project_root
       return @project_root if defined? @project_root
       dir = Dir.pwd

data/lib/shaf/version.rb

@@ -1,3 +1,3 @@
 module Shaf
-  VERSION = "0.8.0"
+  VERSION = "1.0.0"
 end

data/templates/Rakefile

@@ -10,3 +10,30 @@ Shaf::ApiDocTask.new do |api_doc|
   api_doc.html_output_dir = File.join(Shaf::Settings.public_folder, "doc")
   api_doc.yaml_output_dir = Shaf::Settings.documents_dir || "doc/api"
 end
+
+namespace :test do
+  Shaf::TestTask.new(:integration) do |t|
+    t.pattern = "spec/integration/**/*_spec.rb"
+  end
+
+  Shaf::TestTask.new(:models) do |t|
+    t.pattern = "spec/models/**/*_spec.rb"
+  end
+
+  Shaf::TestTask.new(:serializers) do |t|
+    t.pattern = "spec/serializers/**/*_spec.rb"
+  end
+
+  Shaf::TestTask.new(:lib) do |t|
+    t.pattern = "spec/lib/**/*_spec.rb"
+  end
+
+  Shaf::TestTask.new(:all) do |t|
+    t.pattern = [
+      "spec/lib/**/*_spec.rb",
+      "spec/models/**/*_spec.rb",
+      "spec/serializers/**/*_spec.rb",
+      "spec/integration/**/*_spec.rb"
+    ]
+  end
+end

data/templates/api/controllers/base_controller.rb

@@ -7,20 +7,22 @@ class BaseController < Sinatra::Base
     enable :logging
     enable :method_override
     mime_type :hal, 'application/hal+json'
-    set :views, VIEWS_DIR
+    set :views, Shaf::Settings.views_folder
     set :static, !production?
-    set :public_folder, ASSETS_DIR
+    set :public_folder, Shaf::Settings.public_folder
     disable :dump_errors
     set :show_exceptions, :after_handler
     enable :current_user
-    set :auth_token_header, AUTH_TOKEN_HEADER
+    set :auth_token_header, Shaf::Settings.auth_token_header
   end
 
   use Rack::Deflater
 
+  Shaf::Router.mount(self, default: true)
+
   def self.inherited(controller)
     super
-    Shaf::App.use controller
+    Shaf::Router.mount controller
   end
 
   def self.log
@@ -39,16 +41,19 @@ class BaseController < Sinatra::Base
     log.debug "Payload: #{payload || 'empty'}"
   end
 
+  not_found do
+    err = NotFoundError.new "Resource \"#{request.path_info}\" does not exist"
+    respond_with(err, status: err.http_status)
+  end
+
   error StandardError do
     err = env['sinatra.error']
     log.error err.message
-    err.backtrace.each(&log.method(:error))
+    Array(err.backtrace).each(&log.method(:error))
 
     api_error = to_api_error(err)
 
-    respond_with api_error,
-      status: api_error.http_status,
-      serializer: ErrorSerializer
+    respond_with(api_error, status: api_error.http_status)
   end
 
   def to_api_error(err)

data/templates/api/serializers/error_serializer.rb

@@ -1,11 +1,13 @@
 require 'serializers/base_serializer'
 
 class ErrorSerializer < BaseSerializer
-
   model Shaf::Errors::ServerError
 
   attribute :title
   attribute :code
   attribute :message
 
+  link :profile do
+    Shaf::Settings.error_profile_uri
+  end
 end

data/templates/api/serializers/form_serializer.rb

@@ -9,37 +9,32 @@ class FormSerializer < BaseSerializer
     (options[:method] || resource&.method || 'POST').to_s.upcase
   end
 
-  attribute :name do
-    options[:name] || resource&.name
-  end
-
-  attribute :title do
-    options[:title] || resource&.title
-  end
-
-  attribute :href do
-    options[:href] || resource&.href
-  end
-
-  attribute :type do
-    options[:type] || resource&.type
+  %i[name title href type submit].each do |sym|
+    attribute sym do
+      options[sym] || resource&.public_send(sym)
+    end
   end
 
   link :self do
     options[:self_link] || resource&.self_link
   end
 
+  link :profile do
+    Shaf::Settings.form_profile_uri
+  end
+
   post_serialize do |hash|
     fields = resource&.fields
     break if fields.nil? || fields.empty?
     hash[:fields] = fields.map do |field|
       {
         name: field.name,
-        type: field.type,
-        label: field.label,
+        type: field.type
       }.tap do |f|
+        f[:title] = field.title if field.title
         f[:value] = field.value if field.has_value?
         f[:required] = true if field.required
+        f[:hidden] = true if field.hidden
       end
     end
   end

data/templates/api/serializers/validation_error_serializer.rb

@@ -0,0 +1,13 @@
+class ValidationErrorSerializer < BaseSerializer
+  model Shaf::Errors::ValidationError
+
+  attribute :title
+  attribute :code
+  attribute :fields do
+    resource.fields
+  end
+
+  link :profile do
+    Shaf::Settings.error_profile_uri
+  end
+end