joshua 0.2.2 → 0.2.4

data/lib/joshua/error.rb

@@ -1,61 +0,0 @@
-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

@@ -1,216 +0,0 @@
-class Joshua
-  ANNOTATIONS   ||= {}
-  OPTS            = {}
-  PLUGINS         = {}
-  DOCUMENTED      = []
-
-  class << self
-    @@params = Params::Define.new
-
-    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_generic :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_generic :detail, data
-      else
-        set :opts, :detail, data
-      end
-    end
-
-    # method in available for GET requests as well
-    def gettable
-      if @method_type
-        @@params.add_generic :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_generic :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
-
-    # here we capture member & collection metods
-    def method_added name
-      return if name.to_s.start_with?('_api_')
-      return unless @method_type
-
-      set @method_type, name, @@params.fetch_and_clear_opts
-
-      alias_method "_api_#{@method_type}_#{name}", name
-      remove_method name
-    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

@@ -1,53 +0,0 @@
-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_generic 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

@@ -1,56 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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