shaf 0.1.0.beta

data/lib/shaf/command/generate.rb

@@ -0,0 +1,19 @@
+require 'shaf/generator'
+
+module Shaf
+  module Command
+    class Generate < Base
+
+      identifier %r(\Ag(en(erate)?)?\Z)
+      usage Generator::Factory.usage.flatten.sort
+
+      def call
+        in_project_root do
+          Generator::Factory.create(*args).call
+        end
+      rescue StandardError => e
+        raise Command::ArgumentError, e.message
+      end
+    end
+  end
+end

data/lib/shaf/command/new.rb

@@ -0,0 +1,79 @@
+require 'fileutils'
+require 'yaml'
+require 'erb'
+require 'shaf/version'
+
+module Shaf
+  module Command
+    class New < Base
+
+      identifier %r(\An(ew)?\Z)
+      usage 'new PROJECT_NAME'
+
+      def call
+        @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
+          copy_templates
+          create_gemfile
+          create_shaf_version_file
+          create_ruby_version_file
+        end
+      end
+
+      def create_dir(name)
+        return if Dir.exist? name
+        FileUtils.mkdir_p(name)
+      rescue SystemCallError
+        exit_with_error("Failed to create directory #{name}", 2)
+      end
+
+      def create_gemfile
+        template_file = File.expand_path('../templates/Gemfile.erb', __FILE__)
+        content = File.read(template_file)
+        File.write "Gemfile",
+          ERB.new(content, 0, '%-<>').result
+      end
+
+      def copy_templates
+        template_files.each do |template|
+          copy_template(template)
+        end
+      end
+
+      def create_shaf_version_file
+        File.write '.shaf',
+          YAML.dump({'version' => Shaf::VERSION})
+      end
+
+      def create_ruby_version_file
+        File.write '.ruby-version', RUBY_VERSION
+      end
+
+      def copy_template(template)
+        target = target_for(template)
+        create_dir File.dirname(target)
+        FileUtils.cp(template, target)
+      end
+
+      def template_dir
+        File.expand_path('../../../../templates', __FILE__)
+      end
+
+      def template_files
+        Dir["#{template_dir}/**/{*,.*}"].reject do |file|
+          File.directory?(file)
+        end
+      end
+
+      def target_for(template)
+        template.sub("#{template_dir}/", "")
+      end
+    end
+  end
+end

data/lib/shaf/command/server.rb

@@ -0,0 +1,15 @@
+module Shaf
+  module Command
+    class Server < Base
+
+      identifier %r(\As(erver)?\Z)
+      usage 'server'
+
+      def call
+        bootstrap
+        App.instance.run!
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# A sample Gemfile
+source "https://rubygems.org"
+ruby '<%= RUBY_VERSION %>'
+
+gem 'shaf'
+gem 'sinatra', require: 'sinatra/base'
+gem 'rake'
+gem 'thin'
+gem 'sequel'
+gem 'sequel'
+gem 'sinatra-sequel'
+gem 'bcrypt'
+gem 'hal_presenter'
+gem 'redcarpet'
+
+group :production, :development do
+  gem 'pg'
+end
+
+group :development, :test do
+  gem 'sqlite3'
+end
+
+group :test do
+  gem 'minitest'
+  gem 'minitest-hooks'
+  gem 'rack-test'
+end
+

data/lib/shaf/doc_model.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+
+module Shaf
+  class DocModel
+    class << self
+      def find(name)
+        @@docs ||= {}
+        @@docs[name] ||= load(name)
+        new(name) if @@docs[name]
+      end
+
+      def find!(name)
+        find(name) or raise(Errors::NotFoundError, "No documentation for #{name}")
+      end
+
+      private
+
+      def load(name)
+        file = File.join(Settings.documents_dir, "#{name}.yml")
+        return YAML.load(File.read(file)) if File.exist? file
+      end
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def to_s
+      return "#{@name} not found" unless @@docs[@name]
+      JSON.pretty_generate(@@docs[@name])
+    end
+
+    def attribute(attr)
+      attr_doc = @@docs.dig(@name, 'attributes', attr.to_s)
+      return attr_doc if attr_doc
+      raise Errors::NotFoundError,
+        "No documentation for #{@name} attribute '#{attr}'"
+    end
+
+    def link(rel)
+      link_doc = @@docs.dig(@name, 'links', rel.to_s)
+      return link_doc if link_doc
+      raise Errors::NotFoundError,
+        "No documentation for #{@name} link relation '#{rel}'"
+    end
+
+    def embedded(name)
+      embed_doc = @@docs.dig(@name, 'embeds', name.to_s)
+      return embed_doc if embed_doc
+      raise Errors::NotFoundError,
+        "No documentation for #{@name} embedded '#{name}'"
+    end
+  end
+end

data/lib/shaf/errors.rb

@@ -0,0 +1,77 @@
+module Shaf
+  module Errors
+    class ServerError < StandardError
+      attr_reader :code, :title
+
+      def http_status
+        500
+      end
+
+      def initialize(msg = "Unknown error", code: nil, title: nil)
+        super(msg)
+        @code = code || "UNKNOWN_ERROR"
+        @title = title || "Something bad happend"
+      end
+    end
+
+    class BadRequestError < ServerError
+      def http_status
+        400
+      end
+
+      def initialize(msg = nil)
+        msg ||= "The request cannot be understood"
+        super(msg, code: "INVALID_REQUEST", title: "Invalid request")
+      end
+    end
+
+    class UnauthorizedError < ServerError
+      def http_status
+        401
+      end
+
+      def initialize(msg = nil)
+        msg ||= "User is not authorized"
+        super(msg, code: "UNAUTHORIZED", title: "Unauthorized user")
+      end
+    end
+
+    class ForbiddenError < ServerError
+      def http_status
+        403
+      end
+
+      def initialize(msg = nil)
+        msg ||= "User is not allowed to perform this action"
+        super(msg, code: "FORBIDDEN", title: "User not allowed")
+      end
+    end
+
+    class NotFoundError < ServerError
+      attr_reader :clazz, :id
+
+      def http_status
+        404
+      end
+
+      def initialize(msg = nil, clazz: nil, id: nil)
+        @clazz = clazz
+        @id = id
+        msg ||= "#{clazz ? "#{clazz.to_s} r" : "R"}esource with id #{id} does not exist"
+        super(msg, code: "RESOURCE_NOT_FOUND", title: "Resource not found")
+      end
+    end
+
+    class UnsupportedMediaTypeError < ServerError
+      def http_status
+        415
+      end
+
+      def initialize(msg = nil, request: nil)
+        content_type = request&.env["CONTENT_TYPE"]
+        msg = "Unsupported Media Type#{content_type ? ": #{content_type}" : ""}"
+        super(msg, code: "UNSUPPORTED_MEDIA_TYPE", title: "Unsupported media type")
+      end
+    end
+  end
+end

data/lib/shaf/extensions.rb

@@ -0,0 +1,11 @@
+require 'shaf/extensions/resource_uris'
+require 'shaf/extensions/authorize'
+
+module Shaf
+  def self.extensions
+    [
+      ResourceUris,
+      Authorize,
+    ]
+  end
+end

data/lib/shaf/extensions/authorize.rb

@@ -0,0 +1,42 @@
+require 'sinatra/base'
+
+module Shaf
+
+  module Authorize
+    class NoPolicyError < StandardError; end
+    class PolicyViolationError < StandardError; end
+
+    attr_reader :policy_class
+
+    def authorize_with(policy_class)
+      @policy_class = policy_class
+    end
+
+    def self.registered(app)
+      app.helpers Helpers
+    end
+  end
+
+  module Helpers
+    def policy(resource)
+      return @policy if @policy
+      user = current_user if respond_to? :current_user
+      @policy = self.class.policy_class&.new(user, resource)
+    end
+
+    def authorize(action, resource = nil)
+      policy(resource) or raise Authorize::NoPolicyError
+      @policy.public_send method_for(action)
+    end
+
+    def authorize!(action, resource = nil)
+      authorize(action, resource) or raise Authorize::PolicyViolationError
+    end
+
+    def method_for(action)
+      return action if action.to_s.end_with? '?'
+      "#{action}?".to_sym
+    end
+  end
+
+end

data/lib/shaf/extensions/resource_uris.rb

@@ -0,0 +1,153 @@
+require 'sinatra/base'
+
+module Shaf
+  module ResourceUris
+    def resource_uris_for(*args)
+      CreateUriMethods.new(*args).call
+      include UriHelper
+    end
+
+    def register_uri(name, uri)
+      if UriHelper.respond_to? MethodBuilder.method_name(name)
+        raise "resource uri #{name} can't be registered. Method already exist!"
+      end
+      method_string = MethodBuilder.as_string(name, uri)
+      UriHelperMethods.eval_method(method_string)
+    end
+  end
+
+  Sinatra.register ResourceUris
+
+  module UriHelperMethods
+    def self.register(name, &block)
+      define_method(name, &block)
+    end
+
+    def self.eval_method(str)
+      class_eval str
+    end
+  end
+
+  module UriHelper
+    extend UriHelperMethods
+    include UriHelperMethods
+  end
+
+  # This class register uri helper methods like:
+  # books_uri             => /books
+  # book_uri(book)        => /books/5
+  # new_book_uri          => /books
+  # edit_book_uri(book)   => /books/5/edit
+  #
+  class CreateUriMethods
+    def initialize(name, base: nil, plural_name: nil)
+      @name = name.to_s
+      @base = base&.sub(%r(/\Z), '') || ''
+      @plural_name = plural_name&.to_s || name.to_s + 's'
+    end
+
+    def call
+      if plural_name == name
+        register_resource_uri_by_arg
+      else
+        register_resources_uri
+        register_resource_uri
+      end
+      register_new_resource_uri
+      register_edit_resource_uri
+    end
+
+    private
+
+    attr_reader :name, :base, :plural_name
+
+    def register_resources_uri
+      uri = "#{base}/#{plural_name}"
+      UriHelperMethods.register "#{plural_name}_uri" do
+        uri.dup.freeze
+      end
+    end
+
+    def register_resource_uri
+      uri = "#{base}/#{plural_name}"
+      UriHelperMethods.register "#{name}_uri" do |resrc|
+        id = resrc.is_a?(Integer) ? resrc : resrc&.id
+        "#{uri}/#{id}".freeze unless id.nil?
+      end
+    end
+
+    # If a resource has the same singular and plural names, then this method
+    # should be used. It will return the resource uri when a resource is given
+    # as argument and the resources uri when no arguments are provided.
+    def register_resource_uri_by_arg
+      uri = "#{base}/#{plural_name}"
+      UriHelperMethods.register "#{plural_name}_uri" do |resrc = nil|
+        if resrc.nil?
+          uri.dup.freeze
+        else
+          id = resrc.is_a?(Integer) ? resrc : resrc&.id
+          "#{uri}/#{id}".freeze unless id.nil?
+        end
+      end
+    end
+
+    def register_new_resource_uri
+      uri = "#{base}/#{plural_name}/form"
+      UriHelperMethods.register "new_#{name}_uri" do
+        uri.dup.freeze
+      end
+    end
+
+    def register_edit_resource_uri
+      uri = "#{base}/#{plural_name}"
+      UriHelperMethods.register "edit_#{name}_uri" do |resrc|
+        id = resrc.is_a?(Integer) ? resrc : resrc&.id
+        "#{uri}/#{id}/edit".freeze unless id.nil?
+      end
+    end
+  end
+
+  module MethodBuilder
+    class << self
+      def method_name(name)
+        "#{name}_uri"
+      end
+
+      def signature(name, uri)
+        args = extract_symbols(uri)
+        s = method_name(name)
+        s << "(#{args.join(', ')})" unless args.empty?
+        s
+      end
+
+      def as_string(name, uri)
+        signature = signature(name, uri)
+        <<~EOM
+      def #{signature}
+        \"#{interpolated_uri_string(uri)}\".freeze
+      end
+        EOM
+      end
+
+      private
+
+      def extract_symbols(uri)
+        uri.split('/').grep(/:.*/).map { |t| t[1..-1] }.map(&:to_sym)
+      end
+
+      def interpolated_uri_string(uri)
+        return uri if uri.split('/').empty?
+
+        segments = uri.split('/').map do |segment|
+          if segment.start_with? ':'
+            str = segment[1..-1]
+            "\#{#{str}.respond_to?(#{segment}) ? #{str}.#{str} : #{str}}"
+          else
+            segment
+          end
+        end
+        segments.join('/')
+      end
+    end
+  end
+end