moonrope 1.3.3 → 2.0.2

data/lib/moonrope/dsl/authenticator_dsl.rb

@@ -0,0 +1,35 @@
+module Moonrope
+  module DSL
+    class AuthenticatorDSL
+
+      def initialize(authenticator)
+        @authenticator = authenticator
+      end
+
+      def friendly_name(value)
+        @authenticator.friendly_name = value
+      end
+
+      def description(value)
+        @authenticator.description = value
+      end
+
+      def header(name, description = nil, options = {})
+        @authenticator.headers[name] = options.merge(:name => name, :description => description)
+      end
+
+      def error(name, description = nil, options = {})
+        @authenticator.errors[name] = options.merge(:name => name, :description => description)
+      end
+
+      def lookup(&block)
+        @authenticator.lookup = block
+      end
+
+      def rule(name, error_code, description = nil, &block)
+        @authenticator.rules[name] = {:name => name, :error_code => error_code, :description => description, :block => block}
+      end
+
+    end
+  end
+end

data/lib/moonrope/dsl/base_dsl.rb

@@ -1,3 +1,7 @@
+require 'moonrope/structure'
+require 'moonrope/controller'
+require 'moonrope/authenticator'
+
 module Moonrope
   module DSL
     class BaseDSL
@@ -47,24 +51,6 @@ module Moonrope
         controller
       end
 
-      #
-      # Set the authenticator for the API.
-      #
-      # @yield stores the block as the authenticator
-      #
-      def authenticator(&block)
-        @base.authenticator = block
-      end
-
-      #
-      # Set the default access check block.
-      #
-      # @yield stores the block as the access check
-      #
-      def default_access(value = nil, &block)
-        @base.default_access = block_given? ? block : value
-      end
-
       #
       # Define a new helper in the global namespace
       #
@@ -81,6 +67,23 @@ module Moonrope
         helper_instance
       end
 
+      #
+      # Define a new authenticator
+      #
+      def authenticator(name, &block)
+        authenticator = Moonrope::Authenticator.new(name)
+        dsl = Moonrope::DSL::AuthenticatorDSL.new(authenticator)
+        dsl.instance_eval(&block) if block_given?
+        @base.authenticators[name] = authenticator
+      end
+
+      #
+      # Define a new global shared action
+      #
+      def shared_action(name, &block)
+        @base.shared_actions[name] = block
+      end
+
     end
   end
 end

data/lib/moonrope/dsl/controller_dsl.rb

@@ -1,3 +1,6 @@
+require 'moonrope/action'
+require 'moonrope/before_action'
+
 module Moonrope
   module DSL
     class ControllerDSL
@@ -14,6 +17,31 @@ module Moonrope
       # @return [Moonrope::Controller] the associated controller
       attr_reader :controller
 
+      #
+      # Stop this controller frmo being documented
+      #
+      def no_doc!
+        @controller.doc = false
+      end
+
+      #
+      # Set the friendly name for the controller
+      #
+      # @param name [String]
+      #
+      def friendly_name(string)
+        @controller.friendly_name = string
+      end
+
+      #
+      # Set the description for the controller
+      #
+      # @param description [String]
+      #
+      def description(description)
+        @controller.description = description
+      end
+
       #
       # Defines a new action within the controller.
       #
@@ -28,6 +56,29 @@ module Moonrope
         action
       end
 
+      #
+      # Set the name of the authenticator to use for all actions in this controller
+      #
+      # @param name [Symbol]
+      #
+      def authenticator(name)
+        @controller.authenticator = name
+      end
+
+      #
+      # Set the name of the access rule to use for all actions in this controller
+      #
+      # @param name [Symbol]
+      #
+      def access_rule(name)
+        if name.is_a?(Hash)
+          authenticator name.first[0]
+          access_rule name.first[1]
+        else
+          @controller.access_rule = name
+        end
+      end
+
       #
       # Defines a new before action within the controller.
       #
@@ -43,14 +94,6 @@ module Moonrope
         before_action
       end
 
-      #
-      # Defines the access required for controller methods which do not
-      # define their own access.
-      #
-      def access(value = nil, &block)
-        @controller.access = block_given? ? block : value
-      end
-
       #
       # Defines a new helper for this controller.
       #
@@ -61,9 +104,17 @@ module Moonrope
         if @controller.base.helper(name, @controller)
           raise Moonrope::Errors::HelperAlreadyDefined, "Helper has already been defined with name `#{name}`"
         end
-
         @controller.base.helpers << Moonrope::Helper.new(name, @controller, options, &block)
       end
+
+      #
+      # Define a shared action which can be used by any action
+      #
+      # @param name[Symbol] the name of the shared action
+      #
+      def shared_action(name, &block)
+        @controller.shared_actions[name] = block
+      end
     end
   end
 end

data/lib/moonrope/dsl/filterable_dsl.rb

@@ -0,0 +1,27 @@
+module Moonrope
+  module DSL
+    class FilterableDSL
+
+      def initialize(action)
+        @action = action
+      end
+
+      def attribute(name, options = {}, &block)
+        if options[:type] == Integer || options[:type] == Float
+          # Numbers
+          options[:operators] ||= [:eq, :not_eq, :gt, :gte, :lt, :lte, :in, :not_in]
+        elsif options[:type] == String
+          # Strings
+          options[:operators] ||= [:eq, :not_eq, :starts_with, :ends_with, :in, :not_in]
+        elsif options[:type] == :timestamp
+          # Times
+          options[:operators] ||= [:eq, :not_eq, :gt, :gte, :lt, :lte]
+        else
+          # Everything else
+          options[:operators] ||= [:eq, :not_eq]
+        end
+        @action.filters[name] = options.merge(:name => name, :block => block)
+      end
+    end
+  end
+end

data/lib/moonrope/dsl/structure_dsl.rb

@@ -1,3 +1,5 @@
+require 'moonrope/structure_attribute'
+
 module Moonrope
   module DSL
     class StructureDSL
@@ -26,6 +28,10 @@ module Moonrope
         @conditions = []
       end
 
+      def no_doc!
+        @structure.doc = false
+      end
+
       def scope(options = {}, &block)
         scope_dsl = self.class.new(@structure)
         scope_dsl.options = options
@@ -35,12 +41,21 @@ module Moonrope
       def group(name, &block)
         scope_dsl = self.class.new(@structure)
         scope_dsl.groups = [@groups, name].flatten
+        scope_dsl.conditions = @conditions
         scope_dsl.instance_eval(&block)
       end
 
-      def condition(condition, &block)
+      def condition(condition, description = nil, &block)
         scope_dsl = self.class.new(@structure)
+        if condition.is_a?(Hash) && condition.size == 1
+          condition = {:authenticator => condition.first[0], :access_rule => condition.first[1]}
+        elsif condition.is_a?(Symbol)
+          condition = {:authenticator => :default, :access_rule => condition}
+        else
+          condition = {:block => condition, :description => description}
+        end
         scope_dsl.conditions = [@conditions, condition].flatten
+        scope_dsl.groups = @groups
         scope_dsl.instance_eval(&block)
       end
 
@@ -61,6 +76,8 @@ module Moonrope
         attribute.source_attribute  = options[:source_attribute]
         attribute.value             = options[:value]
         attribute.example           = options[:eg] || options[:example]
+        attribute.doc               = options[:doc]
+        attribute.mutation          = options[:mutation]
         attribute.groups            = @groups
         attribute.conditions        = @conditions
         @structure.attributes[type] << attribute
@@ -84,7 +101,16 @@ module Moonrope
 
       def expansion(name, *args, &block)
         if block_given?
-          @structure.expansions[name] = block
+          if args[0].is_a?(String)
+            attrs = args[1] || {}
+            attrs[:description] = args[0]
+          elsif args[0].is_a?(Hash)
+            attrs = atrs[0]
+          else
+            attrs = {}
+          end
+
+          @structure.expansions[name] = attrs.merge({:block => block, :conditions => @conditions})
         else
           attribute(:expansion, name, *args)
         end

data/lib/moonrope/errors.rb

@@ -5,6 +5,9 @@ module Moonrope
     end
 
     class HelperAlreadyDefined < Error; end
+    class MissingAuthenticator < Error; end
+    class MissingAccessRule < Error; end
+    class InvalidSharedAction < Error; end
 
     class RequestError < Error
       attr_reader :options
@@ -22,6 +25,16 @@ module Moonrope
       end
     end
 
+    class StructuredError < RequestError
+      def status
+        "error"
+      end
+
+      def data
+        @options
+      end
+    end
+
     class AccessDenied < RequestError
       def status
         'access-denied'

data/lib/moonrope/eval_environment.rb

@@ -1,7 +1,11 @@
+require 'moonrope/eval_helpers'
+require 'moonrope/eval_helpers/filter_helper'
+
 module Moonrope
   class EvalEnvironment
 
     include Moonrope::EvalHelpers
+    include Moonrope::EvalHelpers::FilterHelper
 
     # @return [Moonrope::Base] the base object
     attr_reader :base
@@ -28,9 +32,10 @@ module Moonrope
     # @param request [Moonrope::Request]
     # @param accessors [Hash] additional variables which can be made available
     #
-    def initialize(base, request, accessors = {})
+    def initialize(base, request, action = nil, accessors = {})
       @base = base
       @request = request
+      @action = action
       @accessors = accessors
       @default_params = {}
       reset
@@ -46,8 +51,8 @@ module Moonrope
     #
     # @return [Object] the authenticated object
     #
-    def auth
-      request ? request.authenticated_user : nil
+    def identity
+      request ? request.identity : nil
     end
 
     #
@@ -143,6 +148,54 @@ module Moonrope
         raise Moonrope::Errors::Error, "No structure found named '#{structure_name}'"
       end
 
+      if options.delete(:return)
+        if options.empty? && action && action.returns && action.returns[:structure_opts].is_a?(Hash)
+          options = action.returns[:structure_opts]
+        end
+      end
+
+      if request
+        if options[:paramable]
+          if options[:paramable].is_a?(Hash)
+            options[:expansions] = options[:paramable][:expansions]
+            options[:full] = options[:paramable][:full]
+          end
+
+          if options[:paramable] == true || options[:paramable].is_a?(Hash) && options[:paramable].has_key?(:expansions)
+            if request.params["_expansions"].is_a?(Array)
+              options[:expansions] = request.params["_expansions"].map(&:to_sym)
+              if options[:paramable].is_a?(Hash) && options[:paramable][:expansions].is_a?(Array)
+                whitelist = options[:paramable][:expansions]
+                options[:expansions].reject! { |e| !whitelist.include?(e) }
+              end
+            end
+
+            if request.params["_expansions"] == true
+              if options[:paramable].is_a?(Hash)
+                if options[:paramable][:expansions].is_a?(Array)
+                  options[:expansions] = options[:paramable][:expansions]
+                elsif options[:paramable].has_key?(:expansions)
+                  options[:expansions] = true
+                end
+              else
+                options[:expansions] = true
+              end
+            end
+
+            if request.params["_expansions"] == false
+              options[:expansions] = nil
+            end
+
+          end
+
+          if request.params.has?("_full")
+            if options[:paramable] == true || (options[:paramable].is_a?(Hash) && options[:paramable].has_key?(:full))
+              options[:full] = !!request.params["_full"]
+            end
+          end
+        end
+      end
+
       structure.hash(object, options.merge(:request => @request))
     end
 
@@ -169,5 +222,31 @@ module Moonrope
       self.structure_for(structure_name).is_a?(Moonrope::Structure)
     end
 
+    #
+    # Copy the list of parameters onto the given objectr
+    #
+    def copy_params_to(object, *params_to_copy)
+      if params_to_copy.first.is_a?(Hash)
+        options = params_to_copy.shift
+        if options[:from]
+          all_params = action.params.select { |_,p| p[:from_shared_action].include?(options[:from]) }
+          params_to_copy = params_to_copy + all_params.keys
+        end
+      end
+      params_to_copy.each do |param_name|
+        if param_definition = action.params[param_name]
+          if params.has?(param_name)
+            if param_definition[:apply]
+              instance_exec(object, params[param_name], &param_definition[:apply])
+            elsif object.respond_to?("#{param_name}=")
+              object.send("#{param_name}=", params[param_name])
+            end
+          end
+        else
+          raise Moonrope::Errors::Error, "Attempted to copy parameter #{parameter} to object but no definition exists"
+        end
+      end
+    end
+
   end
 end

data/lib/moonrope/eval_helpers.rb

@@ -7,29 +7,68 @@ module Moonrope
     # @param type [Symbol] the type of error to raise
     # @param message [String, Hash or Array] options to pass with the error (usually a message)
     #
-    def error(type, message)
+    def error(type, code_or_message = nil, message = nil)
       case type
-      when :not_found           then raise(Moonrope::Errors::NotFound, message)
-      when :access_denied       then raise(Moonrope::Errors::AccessDenied, message)
-      when :validation_error    then raise(Moonrope::Errors::ValidationError, message)
-      when :parameter_error     then raise(Moonrope::Errors::ParameterError, message)
+      when :not_found           then raise(Moonrope::Errors::NotFound, code_or_message)
+      when :access_denied       then raise(Moonrope::Errors::AccessDenied, code_or_message)
+      when :validation_error    then raise(Moonrope::Errors::ValidationError, code_or_message)
+      when :parameter_error     then raise(Moonrope::Errors::ParameterError, code_or_message)
+      when :structured_error    then structured_error(code_or_message, message)
       else
-        raise Moonrope::Errors::RequestError, message
+        if type.is_a?(String)
+          if code_or_message.is_a?(Hash)
+            structured_error(type, nil, code_or_message)
+          else
+            structured_error(type, code_or_message, message.is_a?(Hash) ? message : {})
+          end
+        else
+          raise Moonrope::Errors::RequestError, code_or_message
+        end
       end
     end
 
+    #
+    # Raises a structured error.
+    #
+    # @param code [String] the code to return
+    # @param message [String] explantory text to return
+    # @param additional [Hash] additional data to return with the error
+    #
+    def structured_error(code, message, additional = {})
+      if action
+        if action.authenticator_to_use.is_a?(Moonrope::Authenticator)
+          errors = action.authenticator_to_use.errors.merge(action.errors)
+        else
+          errors = action.errors
+        end
+        if error = errors[code]
+          message = error[:description].gsub(/\{(\w+)\}/) { additional[$1.to_sym] }
+        end
+      end
+      raise Moonrope::Errors::StructuredError, {:code => code, :message => message}.merge(additional)
+    end
+
     #
     # Return paginated information
     #
     def paginate(collection, max_per_page = 60, &block)
       per_page = params.per_page || 30
       per_page = max_per_page if per_page < 1 || per_page > max_per_page
-      paginated_results = collection.page(params.page).per(per_page)
-      set_flag :paginated, {:page => params.page, :per_page => per_page, :total_pages => paginated_results.total_pages, :total_records => paginated_results.total_count}
+      paginated_results = collection.page(params.page || 1).per(per_page)
+      set_flag :paginated, {:page => params.page || 1, :per_page => per_page, :total_pages => paginated_results.total_pages, :total_records => paginated_results.total_count}
       paginated_results.to_a.map do |result|
         block.call(result)
       end
     end
 
+    #
+    # Return information sorted by appropriate values from parameters
+    #
+    def sort(collection, &block)
+      collection = collection.order(params.sort_by => params.order)
+      set_flag :sorted, {:by => params.sort_by, :order => params.order}
+      block.call(collection)
+    end
+
   end
 end