joshua 0.1.0

data/lib/joshua/error.rb

@@ -0,0 +1,61 @@
+class Joshua
+  class Error < StandardError
+  end
+
+  RESCUE_FROM  = {}
+
+  class << self
+    # rescue_from CustomError do ...
+    # for unhandled
+    # rescue_from :all do
+    #   api.error 500, 'Error happens'
+    # end
+    # define handled error code and description
+    # error :not_found, 'Document not found'
+    # error 404, 'Document not found'
+    # in api methods
+    # error 404
+    # error :not_found
+    def rescue_from klass, desc=nil, &block
+      RESCUE_FROM[klass] = desc || block
+    end
+
+    # show and render single error in class error format
+    # usually when API class not found
+    def error text
+      out = Response.new nil
+      out.error text
+      out.render
+    end
+
+    def error_print error
+      return if ENV['RACK_ENV'] == 'test'
+
+      puts
+      puts 'Joshua error dump'.red
+      puts '---'
+      puts '%s: %s' % [error.class, error.message]
+      puts '---'
+      puts error.backtrace
+      puts '---'
+    end
+  end
+
+  ###
+
+  def error desc
+    if err = RESCUE_FROM[desc]
+      if err.is_a?(Proc)
+        err.call
+      else
+        response.error desc, err
+        desc = err
+      end
+
+      return
+    end
+
+    raise Joshua::Error, desc
+  end
+
+end

data/lib/joshua/opts.rb

@@ -0,0 +1,204 @@
+class Joshua
+  PARAMS        ||= Params::Define.new
+  ANNOTATIONS   ||= {}
+  OPTS            = {}
+  PLUGINS         = {}
+  DOCUMENTED      = []
+
+  class << self
+    def base what
+      set :opts, :base, what
+    end
+
+    # if you want to make API DOC public use "documented"
+    def documented
+      if self == Joshua
+        DOCUMENTED.map(&:to_s).sort.map(&:constantize)
+      else
+        DOCUMENTED.push self unless DOCUMENTED.include?(self)
+      end
+    end
+
+    def api_path
+      to_s.underscore.sub(/_api$/, '')
+    end
+
+    # define method annotations
+    # annotation :unsecure! do
+    #   @is_unsecure = true
+    # end
+    # unsecure!
+    # def login
+    #   ...
+    def annotation name, &block
+      ANNOTATIONS[name] = block
+      self.define_singleton_method name do |*args|
+        PARAMS.__add_annotation name, args
+      end
+    end
+
+    # /api/companies/1/show
+    def member &block
+      @method_type = :member
+      class_exec &block
+      @method_type = nil
+    end
+
+    # /api/companies/list?countrty_id=1
+    def collection &block
+      @method_type = :collection
+      class_exec &block
+      @method_type = nil
+    end
+
+    # There are multiple ways to create params
+    # params :name, String, req: true
+    # params.name!, String
+    # params do
+    #   name String, required: true
+    #   name! String
+    # end
+    # params :label do |value, opts|
+    #   # validate is value a label, return coarced label
+    #   # or raise error with error
+    # end
+    def params *args, &block
+      if name = args.first
+        if block
+          # if argument is provided we create a validator
+          Params::Parse.define name, &block
+        else
+          only_in_api_methods!
+          PARAMS.send *args
+        end
+      elsif block
+        PARAMS.instance_eval &block
+      else
+        only_in_api_methods!
+        PARAMS
+      end
+    end
+
+    # api method icon
+    # you can find great icons at https://boxicons.com/ - export to svg
+    def icon data
+      if @method_type
+        raise ArgumentError.new('Icons cant be added on methods')
+      else
+        set :opts, :icon, data
+      end
+    end
+
+    # api method description
+    def desc data
+      if @method_type
+        PARAMS.__add :desc, data
+      else
+        set :opts, :desc, data
+      end
+    end
+
+    # api method detailed description
+    def detail data
+      return if data.to_s == ''
+
+      if @method_type
+        PARAMS.__add :detail, data
+      else
+        set :opts, :detail, data
+      end
+    end
+
+    # method in available for GET requests as well
+    def gettable
+      if @method_type
+        PARAMS.__add :gettable
+      else
+        raise ArgumentError.new('gettable can only be set on methods')
+      end
+    end
+
+    # allow methods without @api.bearer token set
+    def unsafe
+        if @method_type
+        PARAMS.__add :unsafe
+      else
+        raise ArgumentError.new('Only api methods can be unsafe')
+      end
+    end
+
+    # all api methods are secure (require bearer token)
+    def unsecure
+
+    end
+
+    # block execute before any public method or just some member or collection methods
+    def before &block
+      set_callback :before, block
+    end
+
+    # block execute after any public method or just some member or collection methods
+    # used to add meta tags to response
+    def after &block
+      set_callback :after, block
+    end
+
+    # simplified module include, masked as plugin
+    # Joshua.plugin :foo do ...
+    # Joshua.plugin :foo
+    def plugin name, &block
+      if block_given?
+        # if block given, define a plugin
+        PLUGINS[name] = block
+      else
+        # without a block execute it
+        blk = PLUGINS[name]
+        raise ArgumentError.new('Plugin :%s not defined' % name) unless blk
+        instance_exec &blk
+      end
+    end
+
+    def get *args
+      opts.dig *args
+    end
+
+    # dig all options for a current class
+    def opts
+      out = {}
+
+      # dig down the ancestors tree till Object class
+      ancestors.each do |klass|
+        break if klass == Object
+
+        # copy all member and collection method options
+        keys = (OPTS[klass.to_s] || {}).keys
+        keys.each do |type|
+          for k, v in (OPTS.dig(klass.to_s, type) || {})
+            out[type] ||= {}
+            out[type][k] ||= v
+          end
+        end
+      end
+
+      out
+    end
+
+    private
+
+    # generic opts set
+    # set :foo, :bar, :baz
+    def set *args
+      name, value   = args.pop(2)
+      args.unshift to_s
+      pointer = OPTS
+
+      for el in args
+        pointer[el] ||= {}
+        pointer = pointer[el]
+      end
+
+      pointer[name] = value
+    end
+  end
+end
+

data/lib/joshua/params/define.rb

@@ -0,0 +1,53 @@
+class Joshua
+  module Params
+    class Define
+      def initialize
+        @opts = { }
+      end
+
+      def method_missing name, *args
+        name = name.to_s
+
+        raise ArgumentError.new('! is not allowed in params') if name.include?('!')
+
+        type, opts = args
+
+        if type.is_a?(Hash)
+          opts = args.first
+          type = :string
+        end
+
+        type = :string if type.nil?
+
+        opts ||= {}
+        opts[:type] = type.to_s.dasherize.downcase.to_sym
+
+        opts[:required] = true if opts[:required].nil?
+        opts[:required] = false if name.sub! /\?$/, ''
+        opts[:required] = false if opts.delete(:optional)
+
+        opts.merge!(type: :boolean, default: false) if opts[:type] == :false
+        opts.merge!(type: :boolean, default: true) if opts[:type] == :true
+        opts[:required] = false if opts[:type] == :boolean
+
+        @opts[:params] ||= {}
+        @opts[:params][name.to_sym] = opts
+      end
+
+      def fetch_and_clear_opts
+        @opts
+          .dup
+          .tap { @opts = {} }
+      end
+
+      def __add name, value=true
+        @opts[name] = value
+      end
+
+      def __add_annotation name, data
+        @opts[:annotations] ||= {}
+        @opts[:annotations][name] = data
+      end
+    end
+  end
+end

data/lib/joshua/params/parse.rb

@@ -0,0 +1,56 @@
+class Joshua
+  module Params
+    class Parse
+      class << self
+        def define name, &block
+          define_method 'check_%s' % name do |value, opts|
+            block.call value, opts || {}
+          end
+        end
+      end
+
+      ###
+
+      # check :boolean, 'on'
+      def check type, value, opts={}
+        opts[:required] = true if opts.delete(:req)
+
+        if value.to_s == ''
+          if !opts[:default].nil?
+            opts[:default]
+          elsif opts[:required]
+            error 'Argument missing'
+          end
+        else
+          m = 'check_%s' % type
+          hard_error 'Unsupported paramter type: %s' % type unless respond_to?(m)
+
+          if opts[:array]
+            delimiter = opts[:array].is_a?(TrueClass) ? /\s*[,:;]\s*/ : opts[:array]
+
+            value = value.split(delimiter) unless value.is_a?(Array)
+            value.map { |_| check_send m, _, opts }
+          else
+            check_send m, value, opts
+          end
+        end
+      end
+
+      private
+
+      def check_send m, value, opts
+        send(m, value, opts).tap do |_|
+          error 'Value not in range of values' if opts[:values] && !opts[:values].include?(_)
+        end
+      end
+
+      def error desc
+        raise Joshua::Error, desc
+      end
+
+      def hard_error desc
+        raise StandardError, desc
+      end
+    end
+  end
+end

data/lib/joshua/params/types.rb

@@ -0,0 +1,152 @@
+require 'date'
+
+class Joshua
+  module Params
+    class Parse
+      # params.is_active :boolean, default: false
+      def check_boolean value, opts={}
+        return false unless value
+
+        if %w(true 1 on).include?(value.to_s)
+          true
+        elsif %w(false 0 off).include?(value.to_s)
+          false
+        else
+          error 'Unsupported boolean param value: %s' % value
+        end
+      end
+
+      def check_integer value, opts={}
+        value.to_i.tap do |test|
+          error localized(:not_integer) if test.to_s != value.to_s
+          error localized(:min_value) % opts[:min] if opts[:min] && test < opts[:min]
+          error localized(:max_value) % opts[:max] if opts[:max] && test > opts[:max]
+        end
+      end
+
+      def check_string value, opts={}
+        value
+          .to_s
+          .sub(/^\s+/, '')
+          .sub(/\s+$/, '')
+      end
+
+      def check_float value, opts={}
+        value =
+        if opts[:round]
+          value.to_f.round(opts[:round])
+        else
+          value.to_f
+        end
+
+        error localized(:min_value) % opts[:min] if opts[:min] && value < opts[:min]
+        error localized(:max_value) % opts[:max] if opts[:max] && value > opts[:max]
+
+        value
+      end
+
+      def check_date value, opts={}
+        date = DateTime.parse(value)
+        date = DateTime.new(date.year, date.month, date.day)
+
+        check_date_min_max date, opts
+      end
+
+      def check_date_time value, opts={}
+        date = DateTime.parse(value)
+        check_date_min_max date, opts
+      end
+
+      def check_hash value, opts={}
+        value = {} unless value.is_a?(Hash)
+
+        if opts[:allow]
+          for key in value.keys
+            value.delete(key) unless opts[:allow].include?(key)
+          end
+        end
+
+        value
+      end
+
+      def check_email email, opts={}
+        error localized(:email_min) unless email.to_s.length > 7
+        error localized(:email_missing) unless email.include?('@')
+        email.downcase
+      end
+
+      def check_url url
+        error localized(:url_start) unless url =~ /^https?:\/\/./
+        url
+      end
+
+      # geolocation point. google maps url will be automaticly converted
+      # https://www.google.com/maps/@51.5254742,-0.1057319,13z
+      def check_point value, opts={}
+        parts = value.split(/\s*,\s*/) unless parts.is_a?(Array)
+
+        error localized(:point_format) unless parts[1]
+
+        for part in parts
+          error localized(:point_format) unless part.include?('.')
+          error localized(:point_format) unless part.length > 5
+        end
+
+        parts.join(',')
+      end
+
+      def check_oib oib, opts={}
+        oib = oib.to_s
+
+        return false unless oib.match(/^[0-9]{11}$/)
+
+        control_sum = (0..9).inject(10) do |middle, position|
+          middle += oib.at(position).to_i
+          middle %= 10
+          middle = 10 if middle == 0
+          middle *= 2
+          middle %= 11
+        end
+
+        control_sum = 11 - control_sum
+        control_sum = 0 if control_sum == 10
+
+        if control_sum == oib.at(10).to_i
+          oib.to_i
+        else
+          error 'Wrong OIB'
+        end
+      end
+
+      private
+
+      def check_date_min_max value, opts={}
+        if min = opts[:min]
+          min = DateTime.parse(min)
+          error localized(:min_date) % min if min > value
+        end
+
+        if max = opts[:max]
+          max = DateTime.parse(max)
+          error localized(:max_date) % max if value > max
+        end
+
+        value
+      end
+
+      def localized error
+        locale =
+        if defined?(Lux)
+          Lux.current.locale.to_s
+        elsif defined?(I18n)
+          I18n.with_locale || I18n.locale
+        else
+          :en
+        end
+
+        pointer = ERRORS[locale.to_sym] || ERRORS[:en]
+        pointer[error]
+      end
+    end
+  end
+end