moon 0.0.1 → 0.0.2

data/lib/moon/application.rb

@@ -2,8 +2,8 @@
 # Main application class.
 class Moon::Application
 
+  autoload :Configuration, File.join(File.dirname(__FILE__), "application", "configuration")
   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
@@ -11,23 +11,28 @@ class Moon::Application
   # 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
+  attr_reader :configuration
 
   def initialize
-    @routes = Routes.new
+    @rack = Rack.new self
+  end
+
+  def configure(&block)
+    @configuration = Configuration.new &block
+    @rack.session = @configuration.session
+    @rack.routes = @configuration.routes
   end
 
   def rack
-    @routes.rack.transponder
+    @rack.transponder
   end
 
   def environment
     @rack.environment
   end
 
-  def self.storage_name(environment)
-    environment == :test ? :dump : :main
+  def storage_name
+    @rack.environment == :test ? :dump : :main
   end
 
 end

data/lib/moon/application/configuration.rb

@@ -0,0 +1,55 @@
+require 'configure'
+
+# Application configuration.
+class Moon::Application::Configuration
+
+  SCHEMA = Configure::Schema.build {
+    only :session, :route, :validator, :formatter
+    nested {
+      session {
+        only :secret
+      }
+      route {
+        only :http_method, :path, :actions
+        argument_keys :http_method, :path
+      }
+      validator {
+        only :model_class, :attributes
+      }
+      formatter {
+        only :model_class, :object
+      }
+    }
+  }.freeze
+
+  def initialize(&block)
+    @hash = Configure.process SCHEMA, &block
+  end
+
+  def session
+    @hash[:session]
+  end
+
+  def routes
+    [ @hash[:route] ].compact.flatten
+  end
+
+  def validators
+    validators = { }
+    [ @hash[:validator] ].compact.flatten.each do |validator_hash|
+      model_class, attributes = validator_hash.values_at :model_class, :attributes
+      validators[model_class] = attributes
+    end
+    validators
+  end
+
+  def formatters
+    formatters = { }
+    [ @hash[:formatter] ].compact.flatten.each do |formatter_hash|
+      model_class, object = formatter_hash.values_at :model_class, :object
+      formatters[model_class] = object
+    end
+    formatters
+  end
+
+end

data/lib/moon/application/rack.rb

@@ -7,10 +7,16 @@ class Moon::Application::Rack
   attr_reader :transponder
   attr_reader :environment
 
-  def initialize
+  def initialize(application)
+    @application = application
     initialize_transponder
   end
 
+  def session=(session)
+    @session = session
+    set_session_secret
+  end
+
   def routes=(routes)
     @routes = routes
     map_routes
@@ -36,20 +42,23 @@ class Moon::Application::Rack
 
   def map_routes
     @routes.each do |route|
-      Route.new(@transponder, route).define
+      Route.new(@application, @transponder, route).define
     end
   end
 
+  def set_session_secret
+    @transponder.set :session_secret, @session[:secret]
+  end
+
   # Abstraction for a application route
   class Route
 
     attr_reader :response
     attr_reader :rack_response
 
-    def initialize(transponder, route)
-      @transponder = transponder
+    def initialize(application, transponder, route)
+      @application, @transponder, @route = application, transponder, route
       @environment = @transponder.environment
-      @route = route
     end
 
     def http_method
@@ -61,7 +70,8 @@ class Moon::Application::Rack
     end
 
     def actions
-      @route[:actions] || [ ]
+      actions = @route[:actions]
+      actions.is_a?(Array) ? actions : [ actions ].compact
     end
 
     def define
@@ -82,7 +92,7 @@ class Moon::Application::Rack
 
     def build_context(session, params)
       @context = Moon::Context.new session, params
-      @context.storage_name = Moon::Application.storage_name @environment
+      @context.application = @application
     end
 
     def perform_actions

data/lib/moon/context.rb

@@ -2,7 +2,7 @@
 # Context class that contains anything necessary to run a guard, action or response builder.
 class Moon::Context
 
-  attr_accessor :storage_name
+  attr_accessor :application
 
   def initialize(session = { }, parameters = { })
     @session, @parameters = session, parameters

data/lib/moon/formatter.rb

@@ -2,21 +2,12 @@
 # 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
+  def self.hash_for(formatters, model)
+    formatter = formatters[model.class]
+    formatter ||= Moon::Formatter::Generic.new
+    formatter.hash model
   end
 
 end

data/lib/moon/formatter/generic.rb

@@ -1,8 +1,9 @@
 
 # Outputs a hash with all instance variables of the given model.
-class Moon::Formatter::Generic < Moon::Formatter::Base
+class Moon::Formatter::Generic
 
-  def hash
+  def hash(model)
+    @model = model
     initialize_hash
     inject_instance_variables
     inject_id
@@ -18,12 +19,24 @@ class Moon::Formatter::Generic < Moon::Formatter::Base
   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
+      value = @model.instance_variable_get variable_name
+      value.is_a?(GOM::Object::Proxy) ?
+        put_reference(key, value) :
+        put_regular(key, value)
     end
   end
 
+  def put_regular(key, value)
+    @hash[key] = value
+  end
+
+  def put_reference(key, reference)
+    @hash[:"#{key}_id"] = reference.id
+  end
+
   def inject_id
-    @hash[:id] = GOM::Object.id @model
+    id = GOM::Object.id @model
+    @hash[:id] = id if id
   end
 
 end

data/lib/moon/response/json.rb

@@ -3,6 +3,7 @@ require 'json'
 # Moon::Response::JSON is the base class for all json responses.
 class Moon::Response::JSON < Moon::Response::Base
 
+  autoload :Blank, File.join(File.dirname(__FILE__), "json", "blank")
   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")

data/lib/moon/response/json/blank.rb

@@ -0,0 +1,9 @@
+
+# Moon::Response::JSON::Blank provides a simple response with an empty hash
+class Moon::Response::JSON::Blank < Moon::Response::JSON
+
+  def initialize
+    super 200, { }
+  end
+
+end

data/lib/moon/response/json/collection.rb

@@ -2,9 +2,9 @@
 # Moon::Response::JSON::Collection provides a response that contains one single collection.
 class Moon::Response::JSON::Collection < Moon::Response::JSON
 
-  def initialize(collection)
+  def initialize(collection, formatters)
     @collection = collection.map do |object|
-      Moon::Formatter.hash_for object
+      Moon::Formatter.hash_for formatters, object
     end
     super 200, @collection
   end

data/lib/moon/response/json/model.rb

@@ -2,15 +2,15 @@
 # Moon::Response::JSON::Collection provides a response that contains one single collection.
 class Moon::Response::JSON::Model < Moon::Response::JSON
 
-  def initialize(key, object)
-    @key, @object = key, object
+  def initialize(key, object, formatters)
+    @key, @object, @formatters = key, object, formatters
     super 200, hash
   end
 
   private
 
   def hash
-    { @key.to_s => Moon::Formatter.hash_for(@object) }
+    { @key.to_s => Moon::Formatter.hash_for(@formatters, @object) }
   end
 
 end

data/lib/moon/validator.rb

@@ -6,66 +6,38 @@ class Moon::Validator
   autoload :Length, File.join(File.dirname(__FILE__), "validator", "length")
   autoload :Presence, File.join(File.dirname(__FILE__), "validator", "presence")
 
-  attr_reader :model
+  attr_reader :model_class
 
-  def initialize(model)
-    @model = model
+  def initialize(context, checks)
+    @context, @checks = context, checks
   end
 
-  def ok?
-    perform_checks
-    @ok
-  end
-
-  def messages
-    perform_checks
+  def messages(model)
+    perform_checks model
     @messages
   end
 
   private
 
-  def perform_checks
-    @ok, @messages = true, { }
-    self.class.checks.each do |attribute, attribute_validator_class|
-      perform_attribute_checks attribute, attribute_validator_class
+  def perform_checks(model)
+    @messages = { }
+    @checks.each do |attribute, attribute_validator|
+      value = model.send attribute
+      perform_attribute_checks attribute, value, [ attribute_validator ].compact.flatten
     end
   end
 
-  def perform_attribute_checks(attribute, attribute_validator_classes)
-    attribute_validator_classes.each do |attribute_validator_class|
-      attribute_validator = attribute_validator_class.new @model.send(attribute)
-      ok, message = attribute_validator.ok?, attribute_validator.message
-      @ok &&= ok
-      add_message attribute, ok, message
+  def perform_attribute_checks(attribute, value, attribute_validators)
+    attribute_validators.each do |attribute_validator|
+      messages = attribute_validator.messages value, @context
+      add_messages attribute, messages
     end
   end
 
-  def add_message(attribute, ok, message)
-    return if ok || !message
+  def add_messages(attribute, messages)
+    return if messages.empty?
     @messages[attribute] ||= [ ]
-    @messages[attribute] << message
-  end
-
-  def self.configuration=(value)
-    @configuration = value
-  end
-
-  def self.configuration
-    @configuration
-  end
-
-  def self.checks=(value)
-    @checks = value
-  end
-
-  def self.checks
-    @checks || { }
-  end
-
-  def self.[](model_class)
-    validator = self.dup
-    validator.checks = self.configuration[model_class]
-    validator
+    @messages[attribute] += messages
   end
 
 end

data/lib/moon/validator/format.rb

@@ -1,32 +1,13 @@
 
 # Value format validator.
 class Moon::Validator::Format
-  extend Moon::Utility::Template
 
-  template :format
-
-  attr_accessor :value
-
-  def initialize(value)
-    @value = value
-    @ok, @message = true, nil
-  end
-
-  def ok?
-    check
-    @ok
+  def initialize(format)
+    @format = format
   end
 
-  def message
-    check
-    @message
-  end
-
-  private
-
-  def check
-    @ok = @value =~ self.class.format
-    @message = "Has a wrong format." unless @ok
+  def messages(value, context)
+    value =~ @format ? [ ] : [ "Has a wrong format." ]
   end
 
 end

data/lib/moon/validator/length.rb

@@ -1,42 +1,17 @@
 
 # Value length validator.
 class Moon::Validator::Length
-  extend Moon::Utility::Template
 
-  template :minimum, :maximum
-
-  attr_accessor :value
-
-  def initialize(value)
-    @value = value
-    @ok, @messages = true, [ ]
-  end
-
-  def ok?
-    check
-    @ok
-  end
-
-  def message
-    check
-    @message
+  def initialize(range)
+    @range = range
   end
 
-  def minimum
-    self.class.minimum
-  end
-
-  def maximum
-    self.class.maximum
-  end
-
-  private
-
-  def check
-    raise ArgumentError, "Value doesn't response to :size" unless @value.respond_to?(:size)
-    size, minimum, maximum = @value.size, self.minimum, self.maximum
-    @ok = (!minimum || size >= minimum) && (!maximum || size <= maximum)
-    @message = "Must have at #{size < minimum ? ("least " + minimum.to_s) : ("most " + maximum.to_s)} entries." unless @ok
+  def messages(value, context)
+    raise ArgumentError, "Value doesn't response to :size" unless value.respond_to?(:size)
+    size, minimum, maximum = value.size, @range.min, @range.max
+    @range.include?(size) ?
+      [ ] :
+      [ "Must have at #{size < minimum ? ("least " + minimum.to_s) : ("most " + maximum.to_s)} entries." ]
   end
 
 end