moonrope 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 89677af83c79db9270d024635bb4a4cefc8131f6
+  data.tar.gz: 0a4002afcef30a933974d0090c501f276f0bd13d
+SHA512:
+  metadata.gz: 8e4a4fc0d9bd542697910e6c82e72faa41debf0cf2f6497267ab036d681bd28ca9dddd0079bbf0c5e868bca224e6728e46ce398bf7ae3c65e3809ed10b66e7fe
+  data.tar.gz: d974dffc746c61c3a5f5543ca21f22849c82020fe324e90a1e549479b6dcac9a1f096cef8f7a3f7d7b5455819df0db931ca40498e73ceeae9d3a4db7e33dec50

data/Rakefile

@@ -0,0 +1,5 @@
+task :default do
+  $LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+  $LOAD_PATH.unshift(File.expand_path('../test', __FILE__))
+  require 'test_helper'
+end

data/lib/moonrope.rb

@@ -0,0 +1,37 @@
+require 'json'
+require 'logger'
+
+require 'moonrope/action'
+require 'moonrope/action_result'
+require 'moonrope/base'
+require 'moonrope/before_action'
+require 'moonrope/controller'
+require 'moonrope/dsl/base_dsl'
+require 'moonrope/dsl/action_dsl'
+require 'moonrope/dsl/controller_dsl'
+require 'moonrope/dsl/structure_dsl'
+require 'moonrope/dsl/structure_restriction_dsl'
+
+require 'moonrope/errors'
+require 'moonrope/eval_helpers'
+require 'moonrope/eval_environment'
+require 'moonrope/helper'
+require 'moonrope/param_set'
+require 'moonrope/rack_middleware'
+require 'moonrope/request'
+require 'moonrope/structure'
+require 'moonrope/version'
+
+require 'moonrope/railtie' if defined?(Rails)
+
+module Moonrope
+  
+  class << self
+    attr_accessor :logger
+    
+    def logger
+      @logger ||= Logger.new(STDOUT)
+    end
+  end
+    
+end

data/lib/moonrope/action.rb

@@ -0,0 +1,163 @@
+module Moonrope
+  class Action
+    
+    # @return [Moonrope::Controller] the associated controller
+    attr_reader :controller
+    
+    # @return [Symbol] the name of the action
+    attr_reader :name
+    
+    # @return [Moonrope::DSL::Action] the action's DSL
+    attr_reader :dsl
+    
+    # @return [Hash] the params available for the action
+    attr_reader :params
+    
+    # @return [String] the description of the action
+    attr_accessor :description
+    
+    # @return [Proc] the access check condition for the action
+    attr_accessor :access
+    
+    # @return [Proc] the action for the action
+    attr_accessor :action
+    
+    #
+    # Initialize a new action
+    #
+    # @param controller [Moonrope::Controller] the controller this action belongs to
+    # @param name [Symbol] the name of the action
+    # @yield allows the action to be configured via Moonrope::DSL::ActionDSL
+    #
+    def initialize(controller, name, &block)
+      @controller = controller
+      @name = name
+      @params = {}
+      @dsl = Moonrope::DSL::ActionDSL.new(self)
+      @dsl.instance_eval(&block) if block_given?
+    end
+    
+    #
+    # Return a hash of all params for this action which are 
+    #
+    # @return [Hash] hash with field names as keys with default values
+    #
+    def default_params
+      @params.inject({}) do |h,(k,v)|
+        h[k.to_s] = v[:default] if v[:default]
+        h
+      end
+    end
+    
+    #
+    # Executes the action and returns a ActionResult object with the result
+    # of the action.
+    #
+    # @param request [Moonrope::Request or Moonrope::EvalEnvironment] 
+    # @return [Moonrope::ActionResult]
+    #
+    def execute(request = nil)
+      if request.is_a?(EvalEnvironment)
+        eval_environment = request
+      else
+        eval_environment = EvalEnvironment.new(@controller.base, request)
+      end
+      
+      #
+      # Set this actions default parameters in the eval environment so that
+      # it has access to them.
+      #
+      eval_environment.default_params = self.default_params
+      
+      #
+      # Set the current action to the eval environment so it knows what action
+      # invoked this.
+      #
+      eval_environment.action = self
+      
+      begin
+        #
+        # Validate the parameters
+        #
+        self.validate_parameters(eval_environment.params)
+        
+        start_time = Time.now
+        
+        # Run before filters
+        controller.before_actions_for(name).each do |action|
+          eval_environment.instance_eval(&action.block)
+        end
+        
+        # Run the actual action
+        response = eval_environment.instance_eval(&action)
+        
+        # Calculate the length of time this request takes
+        time_to_run = Time.now - start_time
+        
+        # Prepare a action result
+        result = ActionResult.new(self)
+        result.data     = response
+        result.status   = 'success'
+        result.time     = time_to_run.round(2)
+        result.flags    = eval_environment.flags
+        result.headers  = eval_environment.headers
+        
+        # Return the result object
+        result
+        
+      rescue Moonrope::Errors::RequestError => e
+        result = ActionResult.new(self)
+        result.status = e.status
+        result.data = e.data
+        result
+      end
+    end
+    
+    #
+    # Check whether the authenticated user has access to this request.
+    # Accepts a Request or an EvalEnvironment.
+    #
+    # @param request [Moonrope::Request or Moonrope::EvalEnvironment]
+    # @return [Boolean]
+    #
+    def check_access(request = nil)
+      if request.is_a?(EvalEnvironment)
+        eval_environment = request
+      else
+        eval_environment = EvalEnvironment.new(@controller.base, request)
+      end
+      
+      if eval_environment.auth && access.is_a?(Proc)
+        !!eval_environment.instance_eval(&access)
+      elsif @controller.base.default_access.is_a?(Proc)
+        !!eval_environment.instance_exec(self, &@controller.base.default_access)
+      else
+        false
+      end
+    end
+    
+    #
+    # Return whether or not the passed ParamSet is valid for this action
+    #
+    # @param param_set [Moonrope::ParamSet] the param set to check
+    # @return [Boolean]
+    #
+    def validate_parameters(param_set)
+      @params.each do |name, value|
+        if value[:required] && param_set[name].nil?
+          raise Moonrope::Errors::ParameterError, "`#{name}` parameter is required but is missing"
+        end
+        
+        if value[:regex] && param_set[name] && !(param_set[name].to_s =~ value[:regex])
+          raise Moonrope::Errors::ParameterError, "`#{name}` parameter is invalid"
+        end
+        
+        if value[:type] && param_set[name] && !param_set[name].is_a?(value[:type])
+          raise Moonrope::Errors::ParameterError, "`#{name}` should be a `#{value[:type]}` but is a `#{param_set[name].class}`"
+        end
+      end
+      true
+    end
+          
+  end
+end

data/lib/moonrope/action_result.rb

@@ -0,0 +1,63 @@
+module Moonrope
+  class ActionResult
+    
+    #
+    # Initialize a new result from a Moonrope::Action.
+    #
+    # @param action [Moonrope::Action] the action which originated this result
+    #
+    def initialize(action)
+      @action = action
+      @headers = {}
+      @time = nil
+      @flags = {}
+    end
+    
+    # @return [Object] the return value from the action
+    attr_accessor :data
+    
+    # @return [String] the status of the request
+    attr_accessor :status
+    
+    # @return [Hash] headers which have been set in the action
+    attr_accessor :headers
+    
+    # @return [Float] the length of time to process the action
+    attr_accessor :time
+    
+    # @return [Hash] flags which have been set in the action
+    attr_accessor :flags
+    
+    #
+    # Return a Hash representation of this ActionResult without the
+    # headers.
+    #
+    #   {
+    #     :status => 'success',
+    #     :time => 1.32,
+    #     :flags => {},
+    #     :data => {}
+    #   }
+    #
+    # @return [Hash]
+    #
+    def to_hash
+      {
+        :status => self.status,
+        :time => self.time,
+        :flags => self.flags,
+        :data => self.data
+      }
+    end
+    
+    #
+    # Return the ActionResult's hash with a JSON.
+    #
+    # @return [String]
+    #
+    def to_json
+      to_hash.to_json
+    end
+    
+  end
+end

data/lib/moonrope/base.rb

@@ -0,0 +1,130 @@
+module Moonrope
+  class Base
+    
+    #
+    # Load a set of Moonrope configuration files from a given 
+    # directory.
+    #
+    # @param path [String] the path to a directory containing Moonrope files
+    # @return [Moonrope::Base]
+    #
+    def self.load(path)
+      api = self.new
+      api.load(path)
+      api
+    end
+    
+    # @return [Array] the array of defined structures
+    attr_reader :structures
+    
+    # @return [Array] the array of defined controllers
+    attr_accessor :controllers
+    
+    # @return [Array] the array of defined helpers
+    attr_accessor :helpers
+    
+    # @return [Moonrope::DSL::BaseDSL] the base DSL
+    attr_accessor :dsl
+    
+    # @return [Proc] the authentictor
+    attr_accessor :authenticator
+    
+    # @return [Proc] the default access condition
+    attr_accessor :default_access
+    
+    # @return [String] the directory the base was loaded from (if relevant)
+    attr_accessor :loaded_from
+    
+    #
+    # Initialize a new instance of the Moonrope::Base
+    #
+    # @yield instance evals the contents within the Base DSL
+    #
+    def initialize(&block)
+      unload
+      @dsl = Moonrope::DSL::BaseDSL.new(self)
+      @dsl.instance_eval(&block) if block_given?
+    end
+    
+    #
+    # Reset the whole base to contain no data.
+    #
+    def unload
+      @structures = []
+      @controllers = []
+      @helpers = []
+      @authenticator = nil
+      @default_access = nil
+    end
+    
+    #
+    # Reload this whole base API from the path
+    #
+    def load(directory = nil)
+      directory = self.loaded_from if directory.nil?
+      if directory
+        unload
+        Dir["#{directory}/**/*.rb"].each do |filename|
+          self.dsl.instance_eval(File.read(filename), filename)
+        end
+        self.loaded_from = directory
+        self
+      else
+        raise Moonrope::Error, "Can't reload Moonrope::Base as it wasn't required from a directory"
+      end
+    end
+    
+    alias_method :reload, :load
+    
+    #
+    # Return a structure of the given name
+    #
+    # @param name [Symbol] the name of the structure
+    # @return [Moonrope::Structure]
+    #
+    def structure(name)
+      structures.select { |s| s.name == name }.first
+    end
+    
+    alias_method :[], :structure
+    
+    #
+    # Return a controller of the given name
+    #
+    # @param name [Symbol] the name of the controller
+    # @return [Moonrope::Controller]
+    #
+    def controller(name)
+      controllers.select { |a| a.name == name }.first
+    end
+    
+    alias_method :/, :controller
+    
+    #
+    # Create a new rack request for this API.
+    #
+    # @return [Moonrope::Request] a new request object
+    #
+    def request(*args)
+      Moonrope::Request.new(self, *args)
+    end
+    
+    #
+    # Return a helper for the given name and, potentially controller
+    #
+    # @param name [Symbol] the name of the helper
+    # @param controller [Moonrope::Controller] the controller scope
+    #
+    def helper(name, controller = nil)
+      if controller
+        matched_helpers = @helpers.select do |h|
+          h.name == name.to_sym && (h.controller.nil? || h.controller == controller)
+        end
+      else
+        matched_helpers = @helpers.select { |h| h.name == name.to_sym && h.controller.nil? }
+      end
+      matched_helpers.first
+    end
+    
+  end
+end

data/lib/moonrope/before_action.rb

@@ -0,0 +1,24 @@
+module Moonrope
+  class BeforeAction
+    
+    # @return [Array] the names of actions to execute this request on
+    attr_accessor :actions
+    
+    # @return [Proc] the block to execute in this action
+    attr_accessor :block
+    
+    # @return [Moonrope::Controller] the associated controller
+    attr_reader :controller
+    
+    #
+    # Initilize a new BeforeAction
+    #
+    # @param controller [Moonrope::Controller]
+    #
+    def initialize(controller)
+      @controller = controller
+      @actions = []
+    end
+    
+  end
+end

data/lib/moonrope/controller.rb

@@ -0,0 +1,49 @@
+module Moonrope
+  class Controller
+    
+    attr_accessor :name, :actions, :befores
+    attr_reader :base, :dsl
+    
+    #
+    # Initalize a new Moonrope::Controller
+    #
+    # @param base [Moonrope::Base] the base
+    # @param name [Symbol] the name of the controller
+    # @yield instance evals the contents within the ControllerDSL
+    #
+    def initialize(base, name, &block)
+      @base = base
+      @name = name
+      @actions = {}
+      @befores = []
+      @dsl = Moonrope::DSL::ControllerDSL.new(self)
+      @dsl.instance_eval(&block) if block_given?
+    end
+    
+    #
+    # Return an array of before actions which must be executed for
+    # the given action.
+    #
+    # @param action [Symbol] the name of the action to return
+    # @return [Array] an array of Moonrope::BeforeAction instances
+    #
+    def before_actions_for(action)
+      @befores.select do |b|
+        b.actions.empty? || b.actions.include?(action)
+      end
+    end
+    
+    #
+    # Lookup and return an action in this controller by name.
+    #
+    # @param action [Symbol] the name of the action
+    # @return [Moonrope::Action] the action
+    #
+    def action(action)
+      actions[action.to_sym]
+    end
+    
+    alias_method :/, :action
+    
+  end
+end