objectify 0.0.3 → 0.0.5

data/Rakefile

@@ -1,13 +1,20 @@
+# encoding: utf-8
+
 require 'rubygems'
-require 'rake'
-require 'rake/gempackagetask'
-require 'rspec/core/rake_task'
 require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
 
-Bundler::GemHelper.install_tasks
-
-RSpec::Core::RakeTask.new :spec do |t|
-  t.rspec_opts= '--color'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
 task :default => :spec

data/lib/objectify.rb

@@ -1,29 +1,4 @@
-require 'active_support'
+require "objectify/railtie"
 
 module Objectify
-  class Proxy < ActiveSupport::BasicObject
-    def initialize target
-      @target = target
-    end
-
-    def method_missing name, *args, &block
-      if @target.respond_to?(:has_key?) && @target.has_key?(name)
-        Proxy.new @target[name]
-      else
-        Proxy.new @target.send(name, *args, &block)
-      end
-    end
-
-    def send name, *args, &block
-      method_missing name.to_sym, *args, &block
-    end
-  end
-
-  def objectify
-    Proxy.new self
-  end
-end
-
-def Objectify object
-  Objectify::Proxy.new object
 end

data/lib/objectify/config/action.rb

@@ -0,0 +1,31 @@
+require "objectify/config/policies"
+require "objectify/route"
+
+module Objectify
+  module Config
+    class Action
+      attr_reader :resource_name, :name, :route, :policies, :service, :responder
+
+      def initialize(resource_name, name, options, default_policies,
+                     route_factory = Route)
+        @route = route_factory.new(resource_name, name)
+        @resource_name = resource_name
+        @name = name
+        @policies = default_policies.merge(options, options[name])
+
+        if options[name]
+          @service = options[name][:service]
+          @responder = options[name][:responder]
+        end
+      end
+
+      def service
+        @service ||= [resource_name, name].join("_").to_sym
+      end
+
+      def responder
+        @responder ||= [resource_name, name].join("_").to_sym
+      end
+    end
+  end
+end

data/lib/objectify/config/context.rb

@@ -0,0 +1,97 @@
+require "objectify/config/action"
+require "objectify/config/policies"
+require "objectify/injector"
+require "objectify/instantiator"
+require "objectify/resolver"
+require "objectify/resolver_locator"
+require "objectify/executor"
+
+module Objectify
+  module Config
+    class Context
+      DONT_RELOAD = [:@objectify_controller].freeze
+
+      attr_reader :policy_responders, :defaults, :actions, :policies
+      attr_writer :injector, :resolver_locator, :instantiator, :executor,
+                  :locator, :objectify_controller
+
+      def initialize(policies_factory = Policies, action_factory = Action)
+        @policies_factory = policies_factory
+        @action_factory   = action_factory
+
+        @policy_responders = {}
+        @defaults = {}
+        @actions = {}
+      end
+
+      def append_policy_responders(responders)
+        @policy_responders.merge!(responders)
+      end
+
+      def policy_responder(policy)
+        @policy_responders[policy] ||
+          raise(ArgumentError, "Can't find a responder for #{policy}.")
+      end
+
+      def policies
+        @policies ||= @policies_factory.new
+      end
+
+      def append_defaults(defaults)
+        @policies = @policies_factory.new(defaults)
+      end
+
+      def append_action(action)
+        @actions[action.route] = action
+      end
+
+      def action(route)
+        @actions[route] ||
+          raise(ArgumentError, "No action matching #{route} was found.")
+      end
+
+      def legacy_action(route)
+        @actions[route] ||
+          @action_factory.new(route.resource, route.action, {}, policies)
+      end
+
+      def injector
+        @injector ||= Injector.new(resolver_locator)
+      end
+
+      def append_resolutions(opts)
+        opts.each do |k,v|
+          locator.add(k, v)
+        end
+      end
+
+      def locator
+        @locator ||= NamedValueResolverLocator.new(NameTranslationResolver)
+      end
+
+      def resolver_locator
+        @resolver_locator ||= MultiResolverLocator.new(
+                                [locator, ConstResolverLocator.new]
+                              )
+      end
+
+      def instantiator
+        @instantiator ||= Instantiator.new(injector)
+      end
+
+      def executor
+        @executor ||= Executor.new(injector, instantiator)
+      end
+
+      def objectify_controller
+        @objectify_controller ||= "objectify/rails/objectify"
+      end
+
+      def reload
+        instance_variables.each do |name|
+          instance_variable_set(name, nil) unless DONT_RELOAD.include?(name)
+        end
+      end
+    end
+  end
+end

data/lib/objectify/config/policies.rb

@@ -0,0 +1,18 @@
+module Objectify
+  module Config
+    class Policies
+      attr_reader :policies, :skip_policies
+
+      def initialize(options = {})
+        @policies = [*options[:policies]]
+        @skip_policies = [*options[:skip_policies]]
+      end
+
+      def merge(*others)
+        others.compact.inject(@policies - @skip_policies) do |total, opts|
+          total + [*opts[:policies]] - [*opts[:skip_policies]]
+        end
+      end
+    end
+  end
+end

data/lib/objectify/executor.rb

@@ -0,0 +1,21 @@
+require "objectify/instrumentation"
+
+module Objectify
+  class Executor
+    include Instrumentation
+
+    def initialize(injector, instantiator)
+      @injector = injector
+      @instantiator = instantiator
+    end
+
+    def call(name, type)
+      method = type == :policy ? :allowed? : :call
+      opts = { :name => name, :type => type }
+      instrument("executor_start.objectify", opts)
+      instrument("executor.objectify", opts) do
+        @injector.call(@instantiator.call(name, type), method)
+      end
+    end
+  end
+end

data/lib/objectify/injector.rb

@@ -0,0 +1,39 @@
+require "objectify/instrumentation"
+
+module Objectify
+  class Injector
+    include Instrumentation
+
+    def initialize(resolver_locator)
+      @resolver_locator = resolver_locator
+    end
+
+    def call(object, method)
+      payload = {:object => object, :method => method}
+      instrument("inject.objectify", payload) do |payload|
+        method_obj           = method_object(object, method)
+        resolvers            = method_obj.parameters.map do |reqd, name|
+          @resolver_locator.call(name) if reqd == :req
+        end.compact
+        arguments            = resolvers.map do |resolver|
+          call(resolver, :call)
+        end
+
+        payload[:parameters] = method_obj.parameters
+        payload[:resolvers]  = resolvers
+        payload[:arguments]  = arguments
+
+        object.send(method, *arguments)
+      end
+    end
+
+    private
+      def method_object(object, method)
+        if method == :new
+          object.instance_method(:initialize)
+        else
+          object.method(method)
+        end
+      end
+  end
+end

data/lib/objectify/instantiator.rb

@@ -0,0 +1,14 @@
+require "active_support/all"
+
+module Objectify
+  class Instantiator
+    def initialize(injector)
+      @injector = injector
+    end
+
+    def call(name, type)
+      klass = [name, type].join("_").classify.constantize
+      @injector.call(klass, :new)
+    end
+  end
+end

data/lib/objectify/instrumentation.rb

@@ -0,0 +1,12 @@
+require "active_support/all"
+
+module Objectify
+  module Instrumentation
+    private
+      def instrument(name, payload={})
+        ActiveSupport::Notifications.instrument(name, payload) do |payload|
+          yield(payload) if block_given?
+        end
+      end
+  end
+end

data/lib/objectify/logging.rb

@@ -0,0 +1,22 @@
+require "logger"
+
+module Objectify
+  module Logging
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= Logger.new("/dev/null")
+      end
+    end
+
+    private
+      def logger
+        if Kernel.const_defined?(:Rails)
+          ::Rails.logger
+        else
+          Logging.logger
+        end
+      end
+  end
+end

data/lib/objectify/policy_chain_executor.rb

@@ -0,0 +1,27 @@
+require "objectify/instrumentation"
+
+module Objectify
+  class PolicyChainExecutor
+    include Instrumentation
+
+    def initialize(executor, context)
+      @executor = executor
+      @context  = context
+    end
+
+    def call(action)
+      action.policies.each do |policy|
+        if !@executor.call(policy, :policy)
+          responder = @context.policy_responder(policy)
+          instrument("policy_chain_halted.objectify", :policy    => policy,
+                                                      :responder => responder)
+          @executor.call(responder, :responder)
+
+          return false
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/objectify/rails/application.rb

@@ -0,0 +1,16 @@
+require "objectify/rails/routing"
+require "objectify/config/context"
+
+module Objectify
+  module Rails
+    module Application
+      def objectify
+        @objectify ||= Config::Context.new
+      end
+
+      def routes
+        @routes ||= Routing::RouteSet.new
+      end
+    end
+  end
+end

data/lib/objectify/rails/controller.rb

@@ -0,0 +1,117 @@
+require "objectify/resolver_locator"
+require "objectify/executor"
+require "objectify/policy_chain_executor"
+require "objectify/instrumentation"
+require "objectify/rails/renderer"
+
+module Objectify
+  module Rails
+    module ControllerHelpers
+      def self.included(klass)
+        klass.helper_method(:objectify_executor) if klass.respond_to?(:helper_method)
+      end
+
+      private
+        def objectify
+          ::Rails.application.objectify
+        end
+
+        def injector
+          objectify.injector
+        end
+
+        def request_resolver
+          klass = Objectify::NamedValueResolverLocator
+          @request_resolver ||= klass.new.tap do |resolver|
+            resolver.add(:controller, self)
+            resolver.add(:params, params)
+            resolver.add(:session, session)
+            resolver.add(:cookies, cookies)
+            resolver.add(:request, request)
+            resolver.add(:response, response)
+            resolver.add(:flash, flash)
+            resolver.add(:renderer, Renderer.new(self))
+          end
+        end
+        
+        def objectify_executor
+          objectify.executor
+        end
+
+        def policy_chain_executor
+          @policy_chain_executor ||= Objectify::PolicyChainExecutor.new(objectify_executor, objectify)
+        end
+
+        def objectify_route
+          @objectify_route ||= if params[:objectify]
+            Objectify::Route.new(params[:objectify][:resource].to_sym,
+                                 params[:action].to_sym)
+          else
+            Objectify::Route.new(params[:controller].to_sym,
+                                 params[:action].to_sym)
+          end
+        end
+
+        def action
+          @action ||= if params[:objectify]
+                        objectify.action(objectify_route)
+                      else
+                        objectify.legacy_action(objectify_route)
+                      end
+        end
+
+        def execute_policy_chain
+          policy_chain_executor.call(action)
+        end
+
+        def objectify_around_filter
+          objectify.resolver_locator.context(request_resolver)
+          yield
+          objectify.resolver_locator.clear_context
+        end
+
+        def execute_objectify_action
+          service_result = objectify_executor.call(action.service, :service)
+          request_resolver.add(:service_result, service_result)
+
+          objectify_executor.call(action.responder, :responder)
+        end
+    end
+
+    module LegacyControllerBehaviour
+      include ControllerHelpers
+      include Instrumentation
+
+      def self.included(klass)
+        klass.helper_method(:objectify_executor) if klass.respond_to?(:helper_method)
+      end
+
+      def method_missing(name, *args, &block)
+        instrument("start_processing.objectify", :route => objectify_route)
+
+        execute_objectify_action
+      end
+    end
+
+    module ControllerBehaviour
+      include ControllerHelpers
+      include Instrumentation
+
+      def self.included(klass)
+        klass.helper_method(:objectify_executor) if klass.respond_to?(:helper_method)
+      end
+
+      def method_missing(name, *args, &block)
+        instrument("start_processing.objectify", :route => objectify_route)
+
+        if execute_policy_chain
+          execute_objectify_action
+        end
+      end
+    end
+
+    class ObjectifyController < ActionController::Base
+      include ControllerBehaviour
+    end
+  end
+end