moonrope 1.0.0

data/lib/moonrope/dsl/action_dsl.rb

@@ -0,0 +1,70 @@
+module Moonrope
+  module DSL
+    class ActionDSL
+      
+      # 
+      # Initialize a new ActionDSL
+      #
+      # @param action [Moonrope::Action]
+      #
+      def initialize(action)
+        @action = action
+      end
+      
+      # 
+      # Set the description for the action
+      #
+      #   description "Returns all users which are configured"
+      #
+      # @param value [String]
+      # @return [void]
+      #
+      def description(value)
+        @action.description = value
+      end
+      
+      #
+      # Add a new param to the action's param set.
+      #
+      #   param :page, "The page number", :default => 2
+      #
+      # @param name [Symbol] the name of the param
+      # @param description [String] a description of the action
+      # @param options [Hash] a hash of additional options
+      # @return [void]
+      #
+      def param(name, description, options = {})
+        @action.params[name] = options.merge(:description => description)
+      end
+      
+      #
+      # Set the access condition for the action.
+      #
+      #   access do
+      #     auth.is_a?(User)
+      #   end
+      #
+      # @yield the contents of the yield will be saved as the access condition
+      # @return [void]
+      #
+      def access(value = nil, &block)
+        @action.access = block_given? ? block : value
+      end
+    
+      #
+      # Set the action to execute when this action is invoked.
+      #
+      #   action do
+      #     # Do something here and return a JSON-able value
+      #   end
+      #
+      # @yield the contents of the yield will be saved as the action
+      # @return [void]
+      # 
+      def action(&block)
+        @action.action = block
+      end
+    
+    end
+  end
+end

data/lib/moonrope/dsl/base_dsl.rb

@@ -0,0 +1,74 @@
+module Moonrope
+  module DSL
+    class BaseDSL
+      
+      #
+      # Initiaize a new BaseDSL
+      #
+      # @param base [Moonrope::Base]
+      #
+      def initialize(base)
+        @base = base
+      end
+    
+      #
+      # Define a new structure
+      #
+      # @param name [Symbol] the name of the structure
+      # @yield instance evals the block within the StructureDSL
+      #
+      def structure(name, &block)
+        structure = Moonrope::Structure.new(@base, name)
+        structure.dsl.instance_eval(&block) if block_given?
+        @base.structures << structure
+      end
+    
+      #
+      # Define a new controller or append values to an existing
+      # controller if it has already been defined.
+      #
+      # @param name [Symbol] the name of the controller
+      # @yield instance evals the block within the ControllerDSL
+      #
+      def controller(name, &block)
+        existing = @base.controllers.select { |a| a.name == name }.first
+        if existing
+          controller = existing
+        else
+          controller = Moonrope::Controller.new(@base, name)
+        end
+        controller.dsl.instance_eval(&block) if block_given?
+        @base.controllers << 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(&block)
+        @base.default_access = block
+      end
+      
+      #
+      # Define a new helper in the global namespace
+      #
+      # @param name [Symbol] the name of the helper
+      # @yield stores the block to execute for the helper
+      #
+      def helper(name, &block)
+        @base.helpers << Moonrope::Helper.new(name, nil, &block)
+      end
+      
+    end
+  end
+end

data/lib/moonrope/dsl/controller_dsl.rb

@@ -0,0 +1,57 @@
+module Moonrope
+  module DSL
+    class ControllerDSL
+      
+      #
+      # Initialize a new ControllerDSL
+      #
+      # @param controller [Moonrope::Controller]
+      #
+      def initialize(controller)
+        @controller = controller
+      end
+      
+      # @return [Moonrope::Controller] the associated controller
+      attr_reader :controller
+      
+      #
+      # Defines a new action within the controller.
+      #
+      # @param name [Symbol]
+      # @yield instance evals the block within the ActionDSL
+      # @return [Moonrope::Action] the new action instance
+      #
+      def action(name, &block)
+        action = Moonrope::Action.new(@controller, name)
+        action.dsl.instance_eval(&block) if block_given?
+        @controller.actions[name] = action
+        action
+      end
+      
+      #
+      # Defines a new before action within the controller.
+      #
+      # @param actions [Symbol] the names of the actions to apply to (none for all)
+      # @yield stores the block as the block to be executed 
+      # @return [Moonrope::BeforeAction]
+      #
+      def before(*actions, &block)
+        before_action = Moonrope::BeforeAction.new(@controller)
+        before_action.block = block
+        before_action.actions = actions
+        @controller.befores << before_action
+        before_action
+      end
+      
+      #
+      # Defines a new helper for this controller.
+      #
+      # @param name [Symbol] the name of the helper
+      # @yield stores the block to execute for the helper
+      #
+      def helper(name, &block)
+        @controller.base.helpers << Moonrope::Helper.new(name, @controller, &block)
+      end
+    end
+  end
+end

data/lib/moonrope/dsl/structure_dsl.rb

@@ -0,0 +1,63 @@
+module Moonrope
+  module DSL
+    class StructureDSL
+      
+      #
+      # Initialize a new StructureDSL
+      #
+      # @param structure [Moonrope::Structure]
+      #
+      def initialize(structure)
+        @structure = structure
+      end
+      
+      # @return [Moonrope::Structure] the associated structure
+      attr_reader :structure
+    
+      #
+      # Set the basic variables for the structure.
+      #
+      # @yield stores the contents of the block for the basic data
+      # @return [void]
+      #
+      def basic(&block)
+        structure.basic = block
+      end
+
+      #
+      # Set the full variables for the structure.
+      #
+      # @yield stores the contents of the block for the full data
+      # @return [void]
+      #
+      def full(&block)
+        structure.full = block
+      end
+    
+      #
+      # Add a new expansion.
+      #
+      # @param name [Symbol] the name of the expansion
+      # @yield sets the block to execute for the expansion if requested
+      # @return [void]
+      #
+      def expansion(name, &block)
+        structure.expansions[name] = block
+      end
+    
+      #
+      # Add a new restricted block.
+      #
+      # @yield instance evals the block within RestrictionDSL
+      # @return [Moonrope::DSL::RestrictionDSL]
+      #
+      def restricted(&block)
+        dsl = Moonrope::DSL::StructureRestrictionDSL.new
+        dsl.instance_eval(&block)
+        structure.restrictions << dsl
+        dsl
+      end
+    
+    end
+  end
+end

data/lib/moonrope/dsl/structure_restriction_dsl.rb

@@ -0,0 +1,27 @@
+module Moonrope
+  module DSL
+    class StructureRestrictionDSL
+      
+      #
+      # Set or get the data block for the restriction
+      #
+      # @yield stores the contents of the block as the data
+      # @return [Proc]
+      #
+      def data(&block)
+        block_given? ? @data = block : @data
+      end
+
+      #
+      # Set or get the condition block for the restriction
+      #
+      # @yield stores the contents of the block as the condition
+      # @return [Proc]
+      #
+      def condition(&block)
+        block_given? ? @condition = block : @condition
+      end
+      
+    end
+  end
+end

data/lib/moonrope/errors.rb

@@ -0,0 +1,48 @@
+module Moonrope
+  module Errors
+    
+    class Error < StandardError
+    end
+    
+    class RequestError < Error
+      attr_reader :options
+      
+      def initialize(options)
+        @options = options
+      end
+      
+      def data
+        {:message => @options}
+      end
+    end
+    
+    class AccessDenied < RequestError
+      def status
+        'access-denied'
+      end
+    end
+    
+    class NotFound < RequestError
+      def status
+        'not-found'
+      end
+    end
+    
+    class ValidationError < RequestError
+      def status
+        'validation-error'
+      end
+      
+      def data
+        {:errors => @options}
+      end
+    end
+    
+    class ParameterError < RequestError
+      def status
+        'parameter-error'
+      end
+    end
+    
+  end
+end

data/lib/moonrope/eval_environment.rb

@@ -0,0 +1,141 @@
+module Moonrope
+  class EvalEnvironment
+    
+    include Moonrope::EvalHelpers
+    
+    # @return [Moonrope::Base] the base object
+    attr_reader :base
+    
+    # @return [Moonrope::Request] the associated request
+    attr_reader :request
+    
+    # @return [Hash] the headers
+    attr_reader :headers
+    
+    # @return [Hash] the flags
+    attr_reader :flags
+    
+    # @return [Hash] the default params to be merged with request params
+    attr_accessor :default_params
+    
+    # @return [Moonrope::Action] the action which invoked this environment
+    attr_accessor :action
+    
+    #
+    # Initialize a new EvalEnvironment
+    #
+    # @param base [Moonrope::Base]
+    # @param request [Moonrope::Request]
+    # @param accessors [Hash] additional variables which can be made available
+    #
+    def initialize(base, request, accessors = {})
+      @base = base
+      @request = request
+      @accessors = accessors
+      @default_params = {}
+      reset
+    end
+    
+    #
+    # @return [Integer] the requested API version
+    #
+    def version
+      request ? request.version : 1
+    end
+    
+    #
+    # @return [Object] the authenticated object
+    #
+    def auth
+      request ? request.authenticated_user : nil
+    end
+    
+    #
+    # @return [Hash] all parameters sent for this request including defaults
+    #
+    def params
+      @params ||= begin
+        params = request ? request.params : ParamSet.new
+        params._defaults = @default_params
+        params
+      end
+    end
+    
+    #
+    # Set a header which should be returned to the client.
+    #
+    # @param name [String] the key
+    # @param value [String] the value
+    # @return [void]
+    #
+    def set_header(name, value)
+      @headers[name.to_s] = value
+    end
+    
+    #
+    # Set a flag which should be returned to the client.
+    #
+    # @param name [Symbol] the key
+    # @param value [String] the value
+    # @return [void]
+    #
+    def set_flag(name, value)
+      @flags[name] = value
+    end
+    
+    # 
+    # Clear all flags & headers from this environment.
+    # 
+    # @return [void]
+    #
+    def reset
+      @flags = {}
+      @headers = {}
+    end
+    
+    #
+    # Attempts to find an return an accessor from the has
+    #
+    # @param name [Symbol] the name of the method
+    # @param value [void] unused/wnated
+    # @return [Object]
+    #
+    def method_missing(name, *args)
+      if @accessors.keys.include?(name.to_sym)
+        @accessors[name.to_sym]
+      elsif helper = @base.helper(name.to_sym, action ? action.controller : nil)
+        instance_exec(*args, &helper.block)
+      else
+        super
+      end
+    end
+    
+    #
+    # Generate a new structure from the core DSL for the given
+    # object and return a hash or nil if the structure doesn't 
+    # exist.
+    #
+    # @param structure [Moonrope::Structure or Symbol] the structure to be used
+    # @param object [Object] the object to pass through the structure
+    # @param options [Hash] options to pass to the strucutre hash generator
+    #
+    def structure(structure, object, options = {})
+      if object
+        structure = case structure
+        when Symbol, String       then @base.structure(structure.to_sym)
+        when Moonrope::Structure  then structure
+        else
+          raise Moonrope::Errors::Error, "Invalid structure '#{structure}'"
+        end
+        if structure
+          structure.hash(object, options.merge(:request => @request))
+        else
+          raise Moonrope::Errors::Error, "No structure found named '#{structure}'"
+        end
+      else
+        nil
+      end
+    end
+    
+  end
+end