shaf 1.6.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd5e02da6f878d5f9e0ef2e4d3adb641e9ea34362c943cff5a9e94d93ffaad26
-  data.tar.gz: 565dd3872f4b46a48955b94ebbb6324472ec6293bf1f7ead551a55fdc5bd4d4a
+  metadata.gz: aa31b5bc9a9cc80cc5b34c5a3f6101eb17ebf8166bd1a6ae46f0008709c3fa0f
+  data.tar.gz: d4fc21aa271c30bb3e52bbc65571917beb0b16029e7ee764fc8705a5d4197ca8
 SHA512:
-  metadata.gz: 129bf19d6c7ff6ff0f1df840078fbba5df8e47045e69a5b3a3e40ebdc2680f46ad36dc3c4660f8dd8ba5187368fa3b0ecdb503b0575def9f1403ed0d6e743935
-  data.tar.gz: c4fa82f52be8f910f40cebe13b0c5df52239a780788d7d083bc6f969cbfb02c9d72a4aa1fa1e2dce6cc23013be92e9d0eaacc849beaf9e05decacc34ccb9ed3d
+  metadata.gz: 6820ebc741c7392a44a767d1be674394fb307c3e937997c0428dea3663fd57faa3ab9ff6700dedda76e522650373997413b4a5b256198d9646c4741a91ae33d7
+  data.tar.gz: 9315cdd74263a2ae7b39f8a5960267aff7b61c498e0d95ca00559f61a3756f53f84f62b946bb24d8d818d901133cc537ef4402a0b3e201ae34f52b201015f72c

data/lib/shaf/alps/attribute_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Shaf
+  module ALPS
+    class AttributeSerializer
+      attr_reader :attribute
+
+      def self.call(arg)
+        new(arg).to_hash
+      end
+
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      def to_hash
+        {
+          id: attribute.id,
+          type: 'semantic',
+        }.merge(optional_properties)
+      end
+
+      private
+
+      def optional_properties
+        descriptors = serialized_descriptors
+        hash = {}
+        hash[:href] = attribute.href if attribute.href
+        hash[:doc] = { value: attribute.doc } if attribute.doc
+        hash[:name] = attribute.name.to_s if attribute.name
+        hash[:descriptor] = descriptors unless descriptors.empty?
+        hash
+      end
+
+      def serialized_descriptors
+        descriptors = attribute.attributes.map { |attr| self.class.call(attr) }
+        descriptors += attribute.relations.map { |rel| RelationSerializer.call(rel) }
+      end
+    end
+  end
+end

data/lib/shaf/alps/json_serializer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'shaf/alps/attribute_serializer'
+require 'shaf/alps/relation_serializer'
+
+module Shaf
+  module ALPS
+    class JsonSerializer
+      ALPS_VERSION = '1.0'
+
+      def self.call(profile)
+        new(profile).to_hash
+      end
+
+      attr_reader :profile
+
+      def initialize(profile)
+        @profile = profile
+      end
+
+      def to_hash
+        {
+          alps: {
+            version: ALPS_VERSION,
+            doc: profile.doc,
+            descriptor: descriptors,
+          }.compact
+        }
+      end
+
+      private
+
+      def descriptors
+        attribute_descriptors + relation_descriptors
+      end
+
+      def attribute_descriptors
+        profile.attributes.map do |desc|
+          AttributeSerializer.call(desc)
+        end
+      end
+
+      def relation_descriptors
+        profile.relations.map do |desc|
+          RelationSerializer.call(desc)
+        end
+      end
+    end
+  end
+end

data/lib/shaf/alps/relation_serializer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Shaf
+  module ALPS
+    class RelationSerializer
+      SAFE_METHODS = ['GET', 'HEAD', 'OPTIONS']
+      IDEMPOTENT_METHODS = ['PUT', 'PATCH', 'DELETE']
+      UNSAFE_METHODS = ['POST']
+
+      attr_reader :rel
+
+      def self.call(arg)
+        new(arg).to_hash
+      end
+
+      def initialize(rel)
+        @rel = rel
+      end
+
+      def to_hash
+        {
+          id: rel.id,
+          type: type,
+        }.merge(optional_properties)
+      end
+
+      private
+
+      def optional_properties
+        descriptors = serialized_descriptors
+        hash = {}
+        hash[:href] = rel.href if rel.href
+        hash[:doc] = { value: rel.doc } if rel.doc
+        hash[:name] = rel.name.to_s if rel.name
+        hash[:rt] = rel.content_type if rel.content_type
+        hash[:descriptor] = descriptors unless descriptors.empty?
+        hash[:ext] = extension if extension
+        hash
+      end
+
+      def type
+        methods = rel.http_methods
+        if methods.all? { |m| SAFE_METHODS.include? m }
+          'safe'
+        elsif methods.all? { |m| (SAFE_METHODS + IDEMPOTENT_METHODS).include? m }
+          'idempotent'
+        else
+          'unsafe'
+        end
+      end
+
+      def extension
+        methods = rel.http_methods
+        return unless methods
+
+        [
+          {
+            id: :http_method,
+            href: 'https://gist.github.com/sammyhenningsson/2103d839eb79a7baf8854bfb96bda7ae',
+            value: methods,
+          }
+        ]
+      end
+
+      def serialized_descriptors
+        rel.attributes.map { |attr| AttributeSerializer.call(attr) }
+      end
+    end
+  end
+end

data/lib/shaf/app.rb

@@ -1,19 +1,44 @@
-require 'shaf/middleware'
+require 'sinatra'
 
 module Shaf
   class App
     class << self
+      # Either call `Shaf::App.run!`
       def run!
-        app.run!
+        instance.run!
       end
 
-      def app
-        Sinatra.new.tap do |app|
-          app.set :port, Settings.port || 3000
-          app.use Middleware::RequestId
-          app.use Router
+      # Or `run Shaf::App` (in config.ru)
+      def call(*args)
+        instance.call(*args)
+      end
+
+      def instance
+        # This works since Sinatra includes Sinatra::Delegator into
+        # Rack::Builder, which means that Rack::Builder#set will be delegated
+        # to Sinatra::Application
+        @instance ||= Rack::Builder.new(app) do
+          set :port, Settings.port || 3000
+        end
+      end
+
+      def use(middleware, *args, **kwargs, &block)
+        if args.empty? && kwargs.empty?
+          instance.use middleware, &block
+        elsif kwargs.empty?
+          instance.use middleware, *args, &block
+        elsif args.empty?
+          instance.use middleware, **kwargs, &block
+        else
+          instance.use middleware, *args, **kwargs, &block
         end
       end
+
+      private
+
+      def app
+        Router.new
+      end
     end
   end
 end

data/lib/shaf/authenticator/base.rb

@@ -0,0 +1,161 @@
+require 'shaf/authenticator/challenge'
+require 'shaf/authenticator/parameter'
+require 'shaf/errors'
+
+module Shaf
+  module Authenticator
+    class Base
+      class MissingParametersError < Error
+        def initialize(authenticator, *args)
+          super("Missing required parameters: [#{args.join(', ')}] for #{authenticator}")
+        end
+      end
+
+      class InvalidParameterError < Error
+        def initialize(authenticator, *args)
+          str = args.map { |key, value| "#{key}: #{value}" }.join(', ')
+          super("Invalid parameters for #{authenticator}: #{str}")
+        end
+      end
+
+      class WrongCredentialsReturnTypeError < Error
+        def initialize(authenticator, clazz)
+          super <<~ERR
+            #{authenticator}.credentials return an instance of #{clazz}
+              It must return an instance of Hash.
+              Location: #{authenticator.method(:credentials).source_location})
+          ERR
+        end
+      end
+
+      class << self
+        def inherited(child)
+          Authenticator.register(child)
+        end
+
+        def scheme(scheme = nil)
+          if scheme
+            @scheme = scheme.to_s
+          elsif @scheme
+            @scheme
+          else
+            raise Error, "#{self} must specify a scheme!"
+          end
+        end
+
+        def scheme?(str)
+          return false unless scheme
+
+          str.to_s.downcase == scheme.downcase
+        end
+
+        def param(name, required: true, default: nil, values: nil)
+          params[name.to_sym] = Parameter.new(
+            name,
+            required: required,
+            default: default,
+            values: values
+          )
+        end
+
+        def restricted(**parameters, &block)
+          validate! parameters
+          add_defaults! parameters
+          challenges << Challenge.new(scheme, **parameters, &block)
+        end
+
+        def challenges_for(realm)
+          challenges.select do |challenge|
+            challenge.realm? realm
+          end
+        end
+
+        def user(request, realm: nil)
+          auth = authorization(request)
+          cred = credentials(auth, request) || {}
+          raise WrongCredentialsReturnTypeError.new(self, cred.class) unless cred.kind_of? Hash
+
+          return if cred.compact.empty?
+
+          challenges_for(realm).each do |challenge|
+            user = challenge.test(**cred)
+            return user if user
+          end
+
+          nil
+        end
+
+        def params
+          @params ||= superclass.respond_to?(:params) ? superclass.params.dup : {}
+        end
+
+        protected
+
+        # Subclasses should implement this method. The return value should be and array
+        # that will get passed as block arguments to the block passed to #restricted
+        def credentials(authorization, request); end
+
+        private
+
+        def challenges
+          @challenges ||= []
+        end
+
+        def validate!(parameters)
+          validate_required(parameters)
+          validate_params(parameters)
+        end
+
+        def validate_required(parameters)
+          errors = []
+
+          required_params.each do |param|
+            next if parameters.key? param.name
+            next if param.default
+            errors << param.name
+          end
+
+          raise MissingParametersError.new(self, *errors) unless errors.empty?
+        end
+
+        def validate_params(parameters)
+          errors = []
+
+          parameters.each do |key, value|
+            if params.key? key
+              errors << [key, value] unless params[key].valid? value
+            else
+              logger.warn "Unsupported authenticator parameter " \
+                          "for #{self}: #{key} = \"#{value}\""
+              parameters.delete(key)
+            end
+          end
+
+          raise InvalidParameterError.new(self, *errors) unless errors.empty?
+        end
+
+        def logger
+          Shaf.logger
+        end
+
+        def add_defaults!(parameters)
+          params.each do |key, param|
+            next unless param.default
+            parameters[key] ||= param.default
+          end
+        end
+
+        def required_params
+          params.values.select(&:required?)
+        end
+
+        def authorization(request)
+          return unless request.authorization
+
+          request.authorization.sub(/^#{scheme} /i, '')
+        end
+      end
+    end
+  end
+end
+

data/lib/shaf/authenticator/basic_auth.rb

@@ -0,0 +1,25 @@
+module Shaf
+  module Authenticator
+    class BasicAuth < Base
+      scheme 'Basic'
+
+      param :realm
+      param :charset, required: false, values: ["UTF-8"]
+
+      def self.credentials(authorization, _request)
+        return unless authorization
+
+        decoded = String(authorization.unpack("m*").first)
+        return {} if decoded.empty?
+
+        user, password = decoded.split(/:/, 2)
+                                .map { |str| str unless String(str).empty? }
+
+        {
+          user: user,
+          password: password
+        }
+      end
+    end
+  end
+end

data/lib/shaf/authenticator/challenge.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Shaf
+  module Authenticator
+    class Challenge
+      attr_reader :scheme, :parameters, :realm
+
+      def initialize(scheme, **parameters, &block)
+        @scheme = scheme
+        @realm = parameters.delete(:realm)&.to_s
+        @parameters = parameters
+        define_singleton_method(:test, &block)
+      end
+
+      def to_s
+        "#{scheme} #{parameter_string}"
+      end
+
+      def realm?(arg)
+        realm&.to_s == arg&.to_s
+      end
+
+      private
+
+      def parameter_string
+        params = {}
+        params[:realm] = realm if realm
+        params.merge(parameters).map { |k,v| %Q(#{k}="#{v}") }.join(', ')
+      end
+    end
+  end
+end

data/lib/shaf/authenticator/parameter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Shaf
+  module Authenticator
+    class Parameter
+      attr_reader :name, :default, :values
+
+      def initialize(name, required: true, default: nil, values: nil)
+        @name = name
+        @required = required
+        @default = default
+        @values = values&.map(&:downcase)
+      end
+
+      def required?
+        @required
+      end
+
+      def optional?
+        !required?
+      end
+
+      def valid?(value)
+        return optional? if value.nil?
+        return true unless values
+
+        values.include?(value.downcase)
+      end
+    end
+  end
+end

data/lib/shaf/authenticator/request.rb

@@ -0,0 +1,17 @@
+require 'rack/auth/abstract/request'
+
+module Shaf
+  module Authenticator
+    class Request < Rack::Auth::AbstractRequest
+      attr_reader :env
+
+      def valid?
+        !String(authorization).strip.empty?
+      end
+
+      def authorization
+        env[authorization_key]
+      end
+    end
+  end
+end

data/lib/shaf/authenticator.rb

@@ -0,0 +1,56 @@
+require 'set'
+require 'digest'
+require 'shaf/authenticator/request'
+
+module Shaf
+  module Authenticator
+    class << self
+      def register(authenticator)
+        authenticators << authenticator
+      end
+
+      def unregister(authenticator)
+        authenticators.delete_if { |auth| auth == authenticator }
+      end
+
+      def challenges_for(realm: nil)
+        authenticators.each_with_object([]) do |authenticator, challenges|
+          challenges.concat Array(authenticator.challenges_for(realm))
+        end
+      end
+
+      def user(env, realm: nil)
+        request = Request.new(env)
+        return unless request.provided?
+
+        authenticator = authenticator_for(request)
+        authenticator&.user(request, realm: realm)
+      end
+
+      private
+
+      def authenticators
+        @authenticators ||= Set.new
+      end
+
+      def authenticator_for(request)
+        scheme = request.scheme
+        authenticator = authenticators.find { |auth| auth.scheme? scheme }
+
+        logger.warn(
+          "Client tried to authenticate with an unsupported " \
+          "authentication scheme: #{scheme}"
+        ) unless authenticator
+
+        authenticator
+      end
+
+      def logger
+        Shaf.logger
+      end
+    end
+  end
+end
+
+require 'shaf/authenticator/base'
+require 'shaf/authenticator/basic_auth'

data/lib/shaf/command/base.rb

@@ -23,6 +23,10 @@ module Shaf
           @usage = str || block
         end
 
+        def identified_by
+          @identifiers
+        end
+
         def exit_with_error(msg, status)
           STDERR.puts msg
           exit status

data/lib/shaf/command/console.rb

@@ -4,7 +4,7 @@ module Shaf
   module Command
     class Console < Base
 
-      identifier %r(\Ac(onsole)?\Z)
+      identifier %r(\Ac(\b|onsole)\Z)
       usage 'console'
 
       def call

data/lib/shaf/command/generate.rb

@@ -1,10 +1,11 @@
+require 'file_transactions'
 require 'shaf/generator'
 
 module Shaf
   module Command
     class Generate < Base
 
-      identifier %r(\Ag(en(erate)?)?\Z)
+      identifier %r(\Ag(\b|en(\b|erate))\Z)
       usage Generator::Factory.usage.flatten.sort
 
       def self.options(parser, options)
@@ -19,7 +20,9 @@ module Shaf
 
       def call
         in_project_root do
-          Generator::Factory.create(*args, **options).call
+          FileTransactions.transaction do
+            Generator::Factory.create(*args, **options).call
+          end
         end
       rescue StandardError => e
         raise Command::ArgumentError, e.message

data/lib/shaf/command/new.rb

@@ -10,21 +10,26 @@ module Shaf
       usage 'new PROJECT_NAME'
 
       def call
-        @project_name = args.first
-        if @project_name.nil? || @project_name.empty?
+        self.project_name = args.first
+        if project_name.nil? || project_name.empty?
           raise ArgumentError,
             "Please provide a project name when using command 'new'!"
         end
 
-        create_dir @project_name
-        Dir.chdir(@project_name) do
+        create_dir project_name
+        Dir.chdir(project_name) do
           copy_templates
           create_gemfile
+          create_settings_file
           write_shaf_version
           create_ruby_version_file
         end
       end
 
+      private
+
+      attr_accessor :project_name
+
       def create_dir(name)
         return if Dir.exist? name
         FileUtils.mkdir_p(name)
@@ -38,9 +43,21 @@ module Shaf
         File.write "Gemfile", erb(content)
       end
 
-      def erb(content)
-        return ERB.new(content, 0, '%-<>').result if RUBY_VERSION < "2.6.0"
-        ERB.new(content, trim_mode: '-<>').result
+      def create_settings_file
+        settings_file = 'config/settings.yml'
+        template_file = File.expand_path("../templates/#{settings_file}.erb", __FILE__)
+        content = File.read(template_file)
+        locals = {
+          project_name: project_name.capitalize,
+          default_port: "<%= ENV.fetch('PORT', 3000) %>"
+        }
+        File.write settings_file,
+                   erb(content, locals)
+      end
+
+      def erb(content, locals = {})
+        return ERB.new(content, 0, '%-<>').result_with_hash(locals) if RUBY_VERSION < "2.6.0"
+        ERB.new(content, trim_mode: '-<>').result_with_hash(locals)
       end
 
       def copy_templates

data/lib/shaf/command/server.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'rack'
 
 module Shaf
   module Command
@@ -16,7 +17,10 @@ module Shaf
       def call
         Settings.port = options[:port] if options[:port]
         bootstrap
-        App.run!
+        Rack::Server.start(
+          app: App,
+          Port: Settings.port
+        )
       end
     end
   end

data/lib/shaf/command/templates/Gemfile.erb

@@ -11,6 +11,7 @@ gem 'sinatra-sequel'
 gem 'bcrypt'
 gem 'hal_presenter'
 gem 'redcarpet'
+gem 'yard'
 
 group :production, :development do
   gem 'pg'