moon 0.0.1

data/lib/moon/action/models/updater.rb

@@ -0,0 +1,36 @@
+
+# Uses the parameters in the context and tries to update the models.
+class Moon::Action::Models::Updater
+
+  def initialize(context)
+    @context = context
+  end
+
+  def perform
+    @context.models.each do |model_key, model|
+      Model.new(model, @context.parameters[model_key]).update
+    end
+    nil
+  end
+
+  # Model updater.
+  class Model
+
+    def initialize(model, parameters = { })
+      @model, @parameters = model, parameters
+    end
+
+    def update
+      @parameters.each do |key, value|
+        method_name = "#{key}=".to_sym
+        @model.send method_name, value if @model.respond_to?(method_name)
+      end
+    end
+
+  end
+
+  def self.perform(context)
+    new(context).perform
+  end
+
+end

data/lib/moon/action/rebuild_arrays.rb

@@ -0,0 +1,40 @@
+
+# Converts each hash with numeric keys { "0" => "one", "1" => "two" } into arrays [ "one", "two" ].
+class Moon::Action::RebuildArrays
+
+  def initialize(context)
+    @context = context
+  end
+
+  def perform
+    @context.parameters = self.class.rebuild_arrays @context.parameters
+    nil
+  end
+
+  private
+
+  def self.rebuild_arrays(parameters)
+    parameters.each do |key, value|
+      parameters[key] = rebuild_arrays value if value.is_a?(Hash)
+    end
+
+    if array_hash?(parameters)
+      array = [ ]
+      parameters.keys.map(&:to_i).sort.each do |index|
+        array << parameters[index.to_s]
+      end
+      array
+    else
+      parameters
+    end
+  end
+
+  def self.array_hash?(hash)
+    hash.size == hash.keys.select{ |key| key.to_s =~ /^\d+$/ }.size
+  end
+
+  def self.perform(context)
+    new(context).perform
+  end
+
+end

data/lib/moon/action/reference_object.rb

@@ -0,0 +1,35 @@
+
+# The action creates a reference to the given store object and stores it in the given model attribute.
+class Moon::Action::ReferenceObject
+
+  def initialize(options)
+    from, to = options.values_at :from, :to
+    @store_method, @store_key = from
+    @model_key, @model_attribute = to
+  end
+
+  def perform(context)
+    @context = context
+    fetch_object
+    create_reference
+    store_reference
+    nil
+  end
+
+  private
+
+  def fetch_object
+    store = @context.send @store_method.to_sym
+    @object = store[@store_key.to_sym]
+  end
+
+  def create_reference
+    @reference = GOM::Object.reference @object
+  end
+
+  def store_reference
+    model = @context.models[@model_key.to_sym]
+    model.send :"#{@model_attribute}=", @reference
+  end
+
+end

data/lib/moon/action/valid_models_required.rb

@@ -0,0 +1,21 @@
+
+# The action checks if every model in the context is valid.
+class Moon::Action::ValidModelsRequired
+
+  def self.perform(context)
+    validation_errors = validate_models context
+    validation_errors.empty? ? nil : Moon::Response::JSON::ValidationErrors.new(validation_errors)
+  end
+
+  private
+
+  def self.validate_models(context)
+    validation_errors = { }
+    context.models.each do |key, model|
+      validator = Moon::Validator[model.class].new model
+      validation_errors[key] = validator.messages unless validator.ok?
+    end
+    validation_errors
+  end
+
+end

data/lib/moon/application.rb

@@ -0,0 +1,33 @@
+
+# Main application class.
+class Moon::Application
+
+  autoload :Rack, File.join(File.dirname(__FILE__), "application", "rack")
+  autoload :Routes, File.join(File.dirname(__FILE__), "application", "routes")
+
+  # This error is raised if an action doesn't respond to :perform.
+  class InvalidActionError < StandardError; end
+
+  # This error is raised if a response doesn't respond to :status, :headers and :body.
+  class InvalidResponseError < StandardError; end
+
+  attr_reader :routes
+  attr_reader :rack
+
+  def initialize
+    @routes = Routes.new
+  end
+
+  def rack
+    @routes.rack.transponder
+  end
+
+  def environment
+    @rack.environment
+  end
+
+  def self.storage_name(environment)
+    environment == :test ? :dump : :main
+  end
+
+end

data/lib/moon/application/rack.rb

@@ -0,0 +1,104 @@
+require 'sinatra/base'
+
+# Adapter for Rack-up servers. Sinatra is used as helper.
+class Moon::Application::Rack
+
+  attr_reader :routes
+  attr_reader :transponder
+  attr_reader :environment
+
+  def initialize
+    initialize_transponder
+  end
+
+  def routes=(routes)
+    @routes = routes
+    map_routes
+  end
+
+  def call(*arguments)
+    @transponder.call *arguments
+  end
+
+  private
+
+  def initialize_transponder
+    @transponder = Class.new Sinatra::Base
+    @transponder.enable :sessions
+    @transponder.disable :show_exceptions
+    @transponder.set :public, "public"
+    @transponder.error do
+      error = request.env["sinatra.error"]
+      error.message + "\n" + error.backtrace.join("\n")
+    end
+    @environment = @transponder.environment
+  end
+
+  def map_routes
+    @routes.each do |route|
+      Route.new(@transponder, route).define
+    end
+  end
+
+  # Abstraction for a application route
+  class Route
+
+    attr_reader :response
+    attr_reader :rack_response
+
+    def initialize(transponder, route)
+      @transponder = transponder
+      @environment = @transponder.environment
+      @route = route
+    end
+
+    def http_method
+      @route[:http_method]
+    end
+
+    def path
+      @route[:path]
+    end
+
+    def actions
+      @route[:actions] || [ ]
+    end
+
+    def define
+      route = self
+      @transponder.send http_method, path do
+        route.handle session, params
+      end
+    end
+
+    def handle(session, params)
+      build_context session, params
+      perform_actions
+      build_rack_response
+      @rack_response
+    end
+
+    private
+
+    def build_context(session, params)
+      @context = Moon::Context.new session, params
+      @context.storage_name = Moon::Application.storage_name @environment
+    end
+
+    def perform_actions
+      actions.each do |action|
+        raise Moon::Application::InvalidActionError, "Actions must implement a :perform method!" unless action.respond_to?(:perform)
+        @response = action.perform @context
+        return if @response
+      end
+    end
+
+    def build_rack_response
+      raise Moon::Application::InvalidResponseError, "Responses must implement the :status, :headers and :body methods" unless
+        @response.respond_to?(:status) && @response.respond_to?(:headers) && @response.respond_to?(:body)
+      @rack_response = [ @response.status, @response.headers, @response.body ]
+    end
+
+  end
+
+end

data/lib/moon/application/routes.rb

@@ -0,0 +1,16 @@
+require 'configure'
+
+# Handler for the application routes.
+class Moon::Application::Routes
+
+  attr_reader :rack
+
+  def initialize
+    @rack = Moon::Application::Rack.new
+  end
+
+  def define(&block)
+    @rack.routes = [ Configure.process(&block)[:route] ].flatten
+  end
+
+end

data/lib/moon/context.rb

@@ -0,0 +1,25 @@
+
+# Context class that contains anything necessary to run a guard, action or response builder.
+class Moon::Context
+
+  attr_accessor :storage_name
+
+  def initialize(session = { }, parameters = { })
+    @session, @parameters = session, parameters
+  end
+
+  [ :session, :parameters, :models, :collections ].each do |key|
+
+    define_method :"#{key}" do
+      instance_variable_set :"@#{key}", { } unless instance_variable_defined?(:"@#{key}")
+      instance_variable_get :"@#{key}"
+    end
+
+    define_method :"#{key}=" do |value|
+      raise ArgumentError, "#{key} must be a hash" unless value.is_a?(Hash)
+      instance_variable_set :"@#{key}", value
+    end
+
+  end
+
+end

data/lib/moon/formatter.rb

@@ -0,0 +1,22 @@
+
+# Model formatter
+class Moon::Formatter
+
+  autoload :Base, File.join(File.dirname(__FILE__), "formatter", "base")
+  autoload :Generic, File.join(File.dirname(__FILE__), "formatter", "generic")
+
+  def self.configuration=(value)
+    @configuration = value
+  end
+
+  def self.configuration
+    @configuration
+  end
+
+  def self.hash_for(model)
+    formatter_class = (@configuration || { })[model.class]
+    formatter_class ||= Moon::Formatter::Generic
+    formatter_class.new(model).hash
+  end
+
+end

data/lib/moon/formatter/base.rb

@@ -0,0 +1,15 @@
+
+# Base class for a formatters.
+class Moon::Formatter::Base
+
+  attr_accessor :model
+
+  def initialize(model)
+    @model = model
+  end
+
+  def hash
+    raise NotImplementedError, "method :hash has not been implemented"
+  end
+
+end

data/lib/moon/formatter/generic.rb

@@ -0,0 +1,29 @@
+
+# Outputs a hash with all instance variables of the given model.
+class Moon::Formatter::Generic < Moon::Formatter::Base
+
+  def hash
+    initialize_hash
+    inject_instance_variables
+    inject_id
+    @hash
+  end
+
+  private
+
+  def initialize_hash
+    @hash = { }
+  end
+
+  def inject_instance_variables
+    @model.instance_variables.each do |variable_name|
+      key = variable_name.to_s.sub(/^@/, "").to_sym
+      @hash[key] = @model.instance_variable_get variable_name
+    end
+  end
+
+  def inject_id
+    @hash[:id] = GOM::Object.id @model
+  end
+
+end

data/lib/moon/response.rb

@@ -0,0 +1,7 @@
+
+module Moon::Response
+
+  autoload :Base, File.join(File.dirname(__FILE__), "response", "base")
+  autoload :JSON, File.join(File.dirname(__FILE__), "response", "json")
+
+end

data/lib/moon/response/base.rb

@@ -0,0 +1,18 @@
+
+# Moon::Response::Base is the base class for all responses. It simply provides default values
+# for status, headers and body
+class Moon::Response::Base
+
+  def status
+    200
+  end
+
+  def headers
+    { }
+  end
+
+  def body
+    nil
+  end
+
+end

data/lib/moon/response/json.rb

@@ -0,0 +1,26 @@
+require 'json'
+
+# Moon::Response::JSON is the base class for all json responses.
+class Moon::Response::JSON < Moon::Response::Base
+
+  autoload :Collection, File.join(File.dirname(__FILE__), "json", "collection")
+  autoload :Message, File.join(File.dirname(__FILE__), "json", "message")
+  autoload :Model, File.join(File.dirname(__FILE__), "json", "model")
+  autoload :ValidationErrors, File.join(File.dirname(__FILE__), "json", "validation_errors")
+
+  attr_accessor :status
+  attr_accessor :hash
+
+  def initialize(status, hash = { })
+    @status, @hash = status, hash
+  end
+
+  def headers
+    { "Content-Type" => "application/json" }
+  end
+
+  def body
+    ::JSON.generate hash
+  end
+
+end