haveapi 0.3.2 → 0.4.0

data/lib/haveapi/api.rb

@@ -33,22 +33,31 @@ module HaveAPI
   # Return list of resources for version +v+.
   def self.get_version_resources(module_name, v)
     filter_resources(module_name) do |r|
-      r.version.is_a?(Array) ? r.version.include?(v) : (r.version == v || r.version == :all)
+      r_v = r.version || implicit_version
+
+      if r_v.is_a?(Array)
+        r_v.include?(v)
+
+      else
+        r_v == v || r_v == :all
+      end
     end
   end
 
   # Return a list of all API versions.
-  def self.get_versions(module_name)
+  def self.versions(module_name)
     ret = []
 
     resources(module_name) do |r|
       ret << r.version unless ret.include?(r.version)
     end
 
+    ret.compact!
+    ret << implicit_version if ret.empty? && implicit_version
     ret
   end
 
-  def self.set_module_name(name)
+  def self.module_name=(name)
     @module_name = name
   end
 
@@ -56,11 +65,19 @@ module HaveAPI
     @module_name
   end
 
-  def self.set_default_authenticate(chain)
+  def self.implicit_version=(v)
+    @implicit_version = v
+  end
+
+  def self.implicit_version
+    @implicit_version
+  end
+
+  def self.default_authenticate=(chain)
     @default_auth = chain
   end
 
   def self.default_authenticate
-    @default_auth
+    @default_auth || []
   end
 end

data/lib/haveapi/common.rb

@@ -31,6 +31,13 @@ module HaveAPI
           subclass.custom_attrs << attr
         end
       end
+
+      def check_build(msg)
+        yield
+      
+      rescue => e
+        raise BuildError.new(msg, e)
+      end
     end
 
     has_attr :obj_type

data/lib/haveapi/exceptions.rb

@@ -0,0 +1,7 @@
+require 'nesty'
+
+module HaveAPI
+  class BuildError < StandardError
+    include Nesty::NestedError
+  end
+end

data/lib/haveapi/hooks.rb

@@ -46,18 +46,29 @@ module HaveAPI
   module Hooks
     # Register a hook defined by +klass+ with +name+.
     # +klass+ is an instance of Class, that is class name, not it's instance.
-    def self.register_hook(klass, name)
+    # +opts+ is a hash and can have following keys:
+    #   - desc - why this hook exists, when it's called
+    #   - context - the context in which given blocks are called
+    #   - args - hash of block arguments
+    #   - initial - hash of initial values
+    #   - ret - hash of return values
+    def self.register_hook(klass, name, opts = {})
       classified = hook_classify(klass)
+      opts[:listeners] = []
 
       @hooks ||= {}
       @hooks[classified] ||= {}
-      @hooks[classified][name] = []
+      @hooks[classified][name] = opts
+    end
+
+    def self.hooks
+      @hooks
     end
 
     # Connect class hook defined in +klass+ with +name+ to +block+.
     # +klass+ is a class name.
     def self.connect_hook(klass, name, &block)
-      @hooks[hook_classify(klass)][name] << block
+      @hooks[hook_classify(klass)][name][:listeners] << block
     end
 
     # Connect instance hook from instance +klass+ with +name+ to +block+.
@@ -66,11 +77,11 @@ module HaveAPI
         @hooks[klass] = {}
 
         @hooks[klass.class].each do |k, v|
-          @hooks[klass][k] = []
+          @hooks[klass][k] = {listeners: []}
         end
       end
 
-      @hooks[klass][name] << block
+      @hooks[klass][name][:listeners] << block
     end
 
     # Call all blocks that are connected to hook in +klass+ with +name+.
@@ -92,7 +103,7 @@ module HaveAPI
 
       catch(:stop) do
         return initial unless @hooks[classified]
-        hooks = @hooks[classified][name]
+        hooks = @hooks[classified][name][:listeners]
         return initial unless hooks
 
         hooks.each do |hook|
@@ -122,8 +133,8 @@ module HaveAPI
   module Hookable
     module ClassMethods
       # Register a hook named +name+.
-      def has_hook(name)
-        Hooks.register_hook(self.to_s, name)
+      def has_hook(name, opts = {})
+        Hooks.register_hook(self.to_s, name, opts)
       end
 
       # Connect +block+ to registered hook with +name+.

data/lib/haveapi/model_adapters/active_record.rb

@@ -285,55 +285,94 @@ END
         end
       end
 
-      handle ::ActiveRecord::Validations::PresenceValidator do |v|
-        validator({present: true})
-      end
-
-      handle ::ActiveModel::Validations::AbsenceValidator do |v|
-        validator({absent: true})
-      end
+      # Presence validator may have different meaning for model and controller.
+      # The attribute may be filled by other means than by controller and it is
+      # wrong to assume that the parameter must ALWAYS be sent by the client.
+      # Usually it would be needed only for Create and perhaps Update actions.
+      #
+      # handle ::ActiveRecord::Validations::PresenceValidator do |v|
+      #   opts = { empty: false }
+      #   opts[:message] = v.options[:message] if v.options[:message]
+      # 
+      #   validator(HaveAPI::Validators::Presence, :present, opts)
+      # end
 
       handle ::ActiveModel::Validations::ExclusionValidator do |v|
-        validator(v.options)
+        opts = {
+            values: v.options[:in].map { |v| v }
+        }
+        opts[:message] = v.options[:message] if v.options[:message]
+
+        validator(:exclude, opts)
       end
 
       handle ::ActiveModel::Validations::FormatValidator do |v|
-        validator({format: {with_source: v.options[:with].source}.update(v.options)})
+        opts = {
+            rx: v.options[:with]
+        }
+        opts[:message] = v.options[:message] if v.options[:message]
+
+        validator(:format, opts)
       end
 
       handle ::ActiveModel::Validations::InclusionValidator do |v|
-        validator(v.options)
+        opts = {
+            values: v.options[:in].map { |v| v }
+        }
+        opts[:message] = v.options[:message] if v.options[:message]
+
+        validator(:include, opts)
       end
 
       handle ::ActiveModel::Validations::LengthValidator do |v|
-        validator(v.options)
+        opts = {}
+        opts[:min] = v.options[:minimum] if v.options[:minimum]
+        opts[:max] = v.options[:maximum] if v.options[:maximum]
+        opts[:equals] = v.options[:is] if v.options[:is]
+        opts[:message] = v.options[:message] if v.options[:message]
+
+        validator(:length, opts) unless opts.empty?
       end
 
       handle ::ActiveModel::Validations::NumericalityValidator do |v|
-        validator(v.options)
-      end
+        opts = {}
+        
+        opts[:min] = v.options[:greater_than] + 1 if v.options[:greater_than]
+        opts[:min] = v.options[:greater_than_or_equal_to] if v.options[:greater_than_or_equal_to]
+        
+        if v.options[:equal_to]
+          validator(accept: v.options[:equal_to])
+          next
+        end
+        
+        opts[:max] = v.options[:less_than] - 1 if v.options[:less_than]
+        opts[:max] = v.options[:less_than_or_equal_to] if v.options[:less_than_or_equal_to]
+
+        opts[:odd] = true if v.options[:odd]
+        opts[:even] = true if v.options[:even]
+
+        opts[:message] = v.options[:message] if v.options[:message]
 
-      handle ::ActiveRecord::Validations::UniquenessValidator do |v|
-        validator(v.options)
+        validator(:number, opts) unless opts.empty?
       end
 
       def initialize(params)
         @params = params
       end
 
-      def validator_for(param, v)
+      def validator_for(param, key, opts)
         @params.each do |p|
           next unless p.is_a?(::HaveAPI::Parameters::Param)
 
           if p.db_name == param
-            p.add_validator(v)
+            p.add_validator(key, opts)
             break
           end
         end
       end
 
-      def validator(v)
-        validator_for(@attr, v)
+      def validator(key, opts)
+        validator_for(@attr, key, opts)
       end
 
       def translate(v)

data/lib/haveapi/output_formatter.rb

@@ -32,8 +32,8 @@ module HaveAPI
       @formatter.nil? ? false : true
     end
 
-    def format(status, response, message = nil, errors = nil)
-      @formatter.format(header(status, response, message, errors))
+    def format(status, response, message = nil, errors = nil, version: true)
+      @formatter.format(header(status, response, message, errors, version))
     end
 
     def error(msg)
@@ -45,13 +45,16 @@ module HaveAPI
     end
 
     protected
-    def header(status, response, message = nil, errors = nil)
-      {
+    def header(status, response, message = nil, errors = nil, version)
+      ret = {}
+      ret[:version] = HaveAPI::PROTOCOL_VERSION if version
+      ret.update({
           status: status,
           response: response,
           message: message,
           errors: errors
-      }
+      })
+      ret
     end
   end
 end

data/lib/haveapi/output_formatters/json.rb

@@ -3,7 +3,12 @@ module HaveAPI::OutputFormatters
     handle 'application/json'
 
     def format(response)
-      JSON.pretty_generate(response)
+      if ENV['RACK_ENV'] == 'development'
+        JSON.pretty_generate(response)
+
+      else
+        JSON.generate(response)
+      end
     end
   end
 end

data/lib/haveapi/params/param.rb

@@ -1,22 +1,22 @@
 module HaveAPI::Parameters
   class Param
+    ATTRIBUTES = %i(label desc type db_name default fill clean)
+
     attr_reader :name, :label, :desc, :type, :default
 
-    def initialize(name, required: nil, label: nil, desc: nil, type: nil,
-                   choices: nil, db_name: nil, default: :_nil, fill: false,
-                   clean: nil)
-      @required = required
+    def initialize(name, args = {})
       @name = name
-      @label = label || name.to_s.capitalize
-      @desc = desc
-      @type = type
-      @choices = choices
-      @db_name = db_name
-      @default = default
-      @fill = fill
+      @label = args.delete(:label) || name.to_s.capitalize
       @layout = :custom
-      @validators = {}
-      @clean = clean
+
+      ATTRIBUTES.each do |attr|
+        instance_variable_set("@#{attr}", args.delete(attr))
+      end
+
+      @type ||= String
+
+      @validators = HaveAPI::ValidatorChain.new(args) unless args.empty?
+      fail "unused arguments #{args}" unless args.empty?
     end
 
     def db_name
@@ -24,7 +24,7 @@ module HaveAPI::Parameters
     end
 
     def required?
-      @required
+      @validators ? @validators.required? : false
     end
 
     def optional?
@@ -35,33 +35,36 @@ module HaveAPI::Parameters
       @fill
     end
 
-    def add_validator(v)
-      @validators.update(v)
-    end
-
-    def validators
-      @validators
-    end
-
     def describe(context)
       {
           required: required?,
           label: @label,
           description: @desc,
           type: @type ? @type.to_s : String.to_s,
-          choices: @choices,
-          validators: @validators,
+          validators: @validators ? @validators.describe : {},
           default: @default
       }
     end
 
+    def add_validator(k, v)
+      @validators ||= HaveAPI::ValidatorChain.new({})
+      @validators.add_or_replace(k, v)
+    end
+
     def patch(attrs)
-      attrs.each { |k, v| instance_variable_set("@#{k}", v) }
+      attrs.each do |k, v|
+        if ATTRIBUTES.include?(k)
+          instance_variable_set("@#{k}", v)
+
+        else
+          add_validator(k, v)
+        end
+      end
     end
 
     def clean(raw)
       return instance_exec(raw, &@clean) if @clean
-
+      
       val = if raw.nil?
         @default
 
@@ -86,22 +89,13 @@ module HaveAPI::Parameters
         raw
       end
 
-      if @choices
-        if @choices.is_a?(Array)
-          unless @choices.include?(val) || @choices.include?(val.to_s.to_sym)
-            raise HaveAPI::ValidationError.new("invalid choice '#{raw}'")
-          end
-
-        elsif @choices.is_a?(Hash)
-          unless @choices.has_key?(val) || @choices.has_key?(val.to_s.to_sym)
-            raise HaveAPI::ValidationError.new("invalid choice '#{raw}'")
-          end
-        end
-      end
-
       val
     end
 
+    def validate(v, params)
+      @validators ? @validators.validate(v, params) : true
+    end
+
     def format_output(v)
       if @type == ::Datetime && v.is_a?(Time)
         v.iso8601

data/lib/haveapi/params/resource.rb

@@ -37,6 +37,10 @@ module HaveAPI::Parameters
       @resource::Show
     end
 
+    def show_index
+      @resource::Index
+    end
+
     def describe(context)
       val_url = context.url_for(
           @resource::Show,
@@ -71,6 +75,18 @@ module HaveAPI::Parameters
       }
     end
 
+    def validate_build_output
+      %i(value_id value_label).each do |name|
+        v = instance_variable_get("@#{name}")
+
+        [show_action, show_index].each do |klass|
+          next unless klass.instance_variable_get('@output')[v].nil?
+
+          fail "association to '#{@resource}': value_label '#{v}' is not an output parameter of '#{klass}'"
+        end
+      end
+    end
+
     def patch(attrs)
       attrs.each { |k, v| instance_variable_set("@#{k}", v) }
     end
@@ -81,6 +97,10 @@ module HaveAPI::Parameters
       ).input_clean(@resource.model, raw, @extra)
     end
 
+    def validate(v, params)
+      true
+    end
+
     def format_output(v)
       v
     end

data/lib/haveapi/params.rb

@@ -187,6 +187,14 @@ module HaveAPI
       ret
     end
 
+    def validate_build
+      m = :"validate_build_#{@direction}"
+
+      @params.each do |p|
+        p.send(m) if p.respond_to?(m)
+      end
+    end
+
     # First step of validation. Check if input is in correct namespace
     # and has a correct layout.
     def check_layout(params)
@@ -207,14 +215,15 @@ module HaveAPI
     # convert params to correct data types, set default values if necessary.
     def validate(params)
       errors = {}
-
+     
       layout_aware(params) do |input|
+        # First run - coerce values to correct types
         @params.each do |p|
           if p.required? && input[p.name].nil?
             errors[p.name] = ['required parameter missing']
             next
           end
-
+          
           unless input.has_key?(p.name)
             input[p.name] = p.default if p.respond_to?(:fill?) && p.fill?
             next
@@ -228,11 +237,24 @@ module HaveAPI
             errors[p.name] << e.message
             next
           end
-
+          
           input[p.name] = cleaned if cleaned != :_nil
         end
-      end
+        
+        # Second run - validate parameters
+        @params.each do |p|
+          next if errors.has_key?(p.name)
+          next if input[p.name].nil?
 
+          res = p.validate(input[p.name], input)
+          
+          unless res === true
+            errors[p.name] ||= []
+            errors[p.name].concat(res)
+          end
+        end
+      end
+      
       unless errors.empty?
         raise ValidationError.new('input parameters not valid', errors)
       end

data/lib/haveapi/resource.rb

@@ -25,13 +25,8 @@ module HaveAPI
       constants.select do |c|
         obj = const_get(c)
 
-        begin
-          if obj.obj_type == :action
-            yield obj
-          end
-
-        rescue NoMethodError
-          next
+        if obj.respond_to?(:obj_type) && obj.obj_type == :action
+          yield obj
         end
       end
     end