moonrope 1.0.0

data/lib/moonrope/eval_helpers.rb

@@ -0,0 +1,35 @@
+module Moonrope
+  module EvalHelpers
+    
+    #
+    # Raise an error.
+    #
+    # @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)
+      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)
+      else
+        raise Moonrope::Errors::RequestError, message
+      end
+    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.to_a.map do |result|
+        block.call(result)
+      end
+    end
+    
+  end
+end

data/lib/moonrope/helper.rb

@@ -0,0 +1,28 @@
+module Moonrope
+  class Helper
+    
+    # @return [Symbol] the name of the helper
+    attr_reader :name
+
+    # @return [Moonrope::Controller] the controller this helper belongs to
+    attr_reader :controller
+
+    # @return [Proc] the proc to execute
+    attr_reader :block
+    
+    
+    #
+    # Initialize a new helper
+    #
+    # @param name [Symbol] the name of the helper
+    # @param controller [Moonrope::Controller] the controller the helper belongs to
+    # @yield stores the block for use later
+    #
+    def initialize(name, controller, &block)
+      @name = name
+      @controller = controller
+      @block = block
+    end
+    
+  end
+end

data/lib/moonrope/param_set.rb

@@ -0,0 +1,44 @@
+module Moonrope
+  class ParamSet
+    
+    #
+    # Initialize a new ParamSet
+    #
+    # @param params [Hash or String] the initial params. If string, will be parsed through JSON.
+    #
+    def initialize(params = {})
+      @params = (params.is_a?(String) ? JSON.parse(params) : params) || {}
+      @defaults = {}
+    end
+
+    #
+    # Return the value for the given key 
+    #
+    # @param key [String] the key to lookup
+    # @return [Object] the value
+    #
+    def _value_for(key)
+      # Get the value from the params and defaults
+      value = (@params[key.to_s] || @defaults[key.to_s])
+      # Ensure that empty strings are actually nil.
+      value = nil if value.is_a?(String) && value.length == 0
+      # Return the value
+      value
+    end
+    
+    alias_method :[], :_value_for
+    alias_method :method_missing, :_value_for
+    
+    #
+    # Set the defaults for the param set
+    #
+    # @param defaults [Hash]
+    # @return [void]
+    def _defaults=(defaults)
+      if defaults.is_a?(Hash)
+        @defaults = defaults
+      end
+    end
+    
+  end
+end

data/lib/moonrope/rack_middleware.rb

@@ -0,0 +1,73 @@
+module Moonrope
+  class RackMiddleware
+    
+    #
+    # Initialize a new Moonrope::Rack server
+    #
+    # @param app [Object] the next Rack application in the stack
+    # @param base [Moonrope::Base] the base API to serve
+    # @param options [Hash] a hash of options
+    # 
+    #
+    def initialize(app, base, options = {})
+      @app = app
+      @base = base
+      @options = options
+    end
+    
+    #
+    # Make a new request
+    #
+    # @param env [Hash] a rack environment hash
+    # @return [Array] a rack triplet
+    #
+    def call(env)
+      if env['PATH_INFO'] =~ Moonrope::Request::PATH_REGEX
+        
+        if @options[:reload_on_each_request]
+          @base.load
+        end
+        
+        #
+        # Create a new request object
+        #
+        request = @base.request(env, $1)
+        
+        #
+        # Check the request is valid
+        #
+        unless request.valid?
+          return [400, {}, ["Invalid API Request. Must provide a version, controller & action as /api/v1/controller/action."]]
+        end
+
+        global_headers = {}
+        global_headers['Content-Type'] = 'application/json'
+        
+        #
+        # Execute the request
+        #
+        begin
+          result = request.execute
+          json = result.to_json
+          global_headers['Content-Length'] = json.bytesize.to_s
+          [200, global_headers.merge(result.headers), [result.to_json]]
+        rescue JSON::ParserError => e
+          [400, global_headers, [{:status => 'invalid-json', :details => e.message}.to_json]]
+        rescue => e
+          Moonrope.logger.info e.class
+          Moonrope.logger.info e.message
+          Moonrope.logger.info e.backtrace.join("\n")
+          [500, global_headers, [{:status => 'internal-server-error'}.to_json]]
+        end
+
+      else
+        if @app && @app.respond_to?(:call)
+          @app.call(env)
+        else
+          [404, {}, ["Non-API request"]]
+        end
+      end
+    end
+    
+  end
+end

data/lib/moonrope/railtie.rb

@@ -0,0 +1,30 @@
+module Moonrope
+  class Railtie < Rails::Railtie
+    
+    initializer 'moonrope.initialize' do |app|
+      
+      # Initialize a new moonrope base from the API defined in
+      # $RAILS_ROOT/app/api directory.
+      moonrope_directory = Rails.root.join('api')
+      if File.directory?(moonrope_directory)
+        app.config.moonrope = Moonrope::Base.load(moonrope_directory)
+      else
+        $stderr.puts "Moonrope is installed but there is no API directory at ROOT/app/api."
+        next
+      end
+      
+      # Set the logger
+      Moonrope.logger = Rails.logger
+      
+      # Insert the Moonrope middleware into the application's middleware
+      # stack (at the bottom).
+      app.middleware.use(
+        Moonrope::RackMiddleware,
+        app.config.moonrope,
+        :reload_on_each_request => !app.config.cache_classes
+      )
+      
+    end
+    
+  end
+end

data/lib/moonrope/request.rb

@@ -0,0 +1,165 @@
+module Moonrope
+  class Request
+    
+    # The path which will be intercepted by the Rack middleware
+    # and that all reuqest will arrive on.
+    PATH_REGEX = /\A\/api\/([\w\/\-\.]+)?/
+    
+    # @return [Hash] the rack environment
+    attr_reader :env
+    # @return [String] the name of the controller which was requested
+    attr_reader :controller_name
+    # @return [String] the name of the action which was requested
+    attr_reader :action_name
+    # @return [Object] the authenticated user
+    attr_reader :authenticated_user
+    
+    #
+    # Initialize a new Moonrope::Request
+    #
+    # @param base [Moonrope::Base]
+    # @param env [Hash] a rack environment has
+    # @param path [String] the reqested path (after the /api/ prefix)
+    #
+    def initialize(base, env, path = nil)
+      @base = base
+      @env = env
+      if path.nil? && env['PATH_INFO'] =~ PATH_REGEX
+        path = $1
+      end
+      @version, @controller_name, @action_name = path ? path.split("/") : [nil, nil, nil]
+    end
+    
+    #
+    # Return the requested API version from the request
+    #
+    # @return [Integer]
+    #
+    def version
+      version = @version.to_s.gsub(/[^0-9]/, '').to_i
+      version = 1 if version == 0
+      version
+    end
+    
+    #
+    # Return whether or not this request is valid and can continue?
+    #
+    # @return [Boolean]
+    #
+    def valid?
+      !!(version > 0 && [controller_name, action_name].all? { |c| c =~ /\A[\w\-\.]+\z/} && controller && action)
+    end
+    
+    #
+    # Return the controller object for the request
+    # 
+    # @return [Moonrope::Controller]
+    #
+    def controller
+      @controller ||= @base.controller(controller_name.to_sym)
+    end
+    
+    #
+    # Return the action object for the request
+    #
+    # return [Moonrope::Action]
+    #
+    def action
+      @action ||= controller.actions[action_name.to_sym]
+    end
+    
+    #
+    # Execute the appropriate action for the request after running
+    # the various authentication checks.
+    #
+    # @return [Moonrope::ActionResult]
+    #
+    def execute
+      eval_env = EvalEnvironment.new(@base, self)
+      if @base.authenticator
+        begin
+          @authenticated_user = eval_env.instance_eval(&@base.authenticator)
+          # If we are authenticated, check whether the action permits access to 
+          # this user, if not raise an error.
+          if authenticated?
+            unless action.check_access(eval_env) == true
+              raise Moonrope::Errors::AccessDenied, "Access to #{controller.name}/#{action.name} is not permitted."
+            end
+          end
+        rescue Moonrope::Errors::RequestError => e
+          @authenticated_user ||= false # set authenticated user to false if they don't exist
+          result = Moonrope::ActionResult.new(self)
+          result.status = e.status
+          result.data = e.data
+          return result
+        end
+      end
+      action.execute(eval_env)
+    end
+    
+    #
+    # Return all user supplier parameters
+    #
+    # @return [Moonrope::ParamSet]
+    #
+    def params
+      @params ||= Moonrope::ParamSet.new(rack_request.params['params'])
+    end
+    
+    #
+    # Return all HTTP headers from the request
+    #
+    # @return [Rack::Utils::HeaderHash]
+    #
+    def headers
+      @headers ||= self.class.extract_http_request_headers(@env)
+    end
+    
+    #
+    # Is this request to the API anonymous?
+    #
+    # @return [Boolean]
+    #
+    def anonymous?
+      authenticated_user.nil?
+    end
+    
+    #
+    # Is this request to the API authenticated?
+    #
+    # @return [Boolean]
+    #
+    def authenticated?
+      !(authenticated_user.nil? || authenticated_user == false)
+    end
+    
+    private
+    
+    #
+    # Return/create a rack request object for use internally
+    #
+    # @return [Rack::Request]
+    #
+    def rack_request
+      @rack_request ||= ::Rack::Request.new(@env)
+    end
+    
+    #
+    # Extract headers from the rack env
+    #
+    # @return [Rack::Utils::HeaderHash]
+    #
+    def self.extract_http_request_headers(env)
+      env.reject do |k, v|
+        !(/^HTTP_[A-Z_]+$/ === k) || v.nil?
+      end.map do |k, v|
+        [k.sub(/^HTTP_/, "").gsub("_", "-"), v]
+      end.inject(::Rack::Utils::HeaderHash.new) do |hash, k_v|
+        k, v = k_v
+        hash[k] = v
+        hash
+      end
+    end
+    
+  end
+end

data/lib/moonrope/structure.rb

@@ -0,0 +1,83 @@
+module Moonrope
+  class Structure
+    
+    # @return [Symbol] the name of the structure
+    attr_accessor :name
+    
+    # @return [Proc] the basic data block
+    attr_accessor :basic
+    
+    # @return [Proc] the full data block
+    attr_accessor :full
+    
+    # @return [Moonrope::DSL::StructureDSL] the DSL
+    attr_reader :dsl
+    
+    # @return [Hash] all expansions for the structure
+    attr_reader :expansions
+    
+    # @return [Array] all restrictions for the structure
+    attr_reader :restrictions
+    
+    # @return [Moonrope::Base] the base API
+    attr_reader :base
+    
+    #
+    # Initialize a new structure
+    #
+    # @param base [Moonrope::Base]
+    # @param name [Symbol]
+    # @yield instance evals the contents within the structure DSL
+    def initialize(base, name, &block)
+      @base = base
+      @name = name
+      @expansions = {}
+      @restrictions = []
+      @dsl = Moonrope::DSL::StructureDSL.new(self)
+      @dsl.instance_eval(&block) if block_given?
+    end
+    
+    #
+    # Return a hash for this struture
+    #
+    # @param object [Object] the object
+    # @param options [Hash] additional options
+    # @return [Hash]
+    #
+    def hash(object, options = {})
+      # Set up an environment for 
+      environment = EvalEnvironment.new(base, options[:request], :o => object)
+
+      # Always get a basic hash to work from
+      hash = environment.instance_eval(&self.basic)
+      
+      # Enhance with the full hash if requested
+      if options[:full]
+        if self.full.is_a?(Proc)
+          full_hash = environment.instance_eval(&self.full)
+          hash.merge!(full_hash)
+        end
+        
+        # Add restrictions
+        if environment.auth
+          @restrictions.each do |restriction|
+            next unless environment.instance_eval(&restriction.condition) == true
+            hash.merge!(environment.instance_eval(&restriction.data))
+          end
+        end
+      end
+      
+      # Add expansions
+      if options[:expansions]
+        expansions.each do |name, expansion|
+          next if options[:expansions].is_a?(Array) && !options[:expansions].include?(name.to_sym)
+          hash.merge!(name => environment.instance_eval(&expansion))
+        end
+      end
+      
+      # Return the hash
+      hash
+    end
+    
+  end
+end