objectify 0.0.3 → 0.0.5

data/lib/objectify/rails/helpers.rb

@@ -0,0 +1,14 @@
+module Objectify
+  module Rails
+    module Helpers
+      def objectify_data
+        @_objectify_data ||
+          raise(ArgumentError, "No data was passed to this view.")
+      end
+
+      def policy_allowed?(policy_name)
+        objectify_executor.call(policy_name, :policy)
+      end
+    end
+  end
+end

data/lib/objectify/rails/log_subscriber.rb

@@ -0,0 +1,59 @@
+require "active_support/all"
+
+module Objectify
+  module Rails
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def start_processing(event)
+        logger.debug("    [Objectify] Started #{event.payload[:route]}")
+      end
+
+      def inject(event)
+        if logger.debug?
+          object     = event.payload[:object]
+          method     = event.payload[:method]
+          parameters = event.payload[:parameters].map do |req, param|
+            param if req == :req
+          end.compact
+          resolvers  = Hash[*parameters.zip(event.payload[:resolvers].map(&:class)).flatten]
+          arguments  = event.payload[:arguments].map(&:class).inspect[1..-2]
+
+          message = "      [Injector] Invoking #{object}.#{method}(#{arguments}). "
+          message << "Resolutions: #{resolvers}. " if !resolvers.empty?
+          message << duration(event)
+
+          logger.debug(message)
+        end
+      end
+
+      def executor_start(event)
+        if logger.debug?
+          type = event.payload[:type].to_s.capitalize
+          logger.debug("    [#{type}] Executing #{event.payload[:name]} " + duration(event))
+        end
+      end
+
+      def executor(event)
+        if logger.debug?
+          type = event.payload[:type].to_s.capitalize
+          logger.debug("    [#{type}] Executed #{event.payload[:name]} " + duration(event))
+        end
+      end
+
+      def policy_chain_halted(event)
+        if logger.debug?
+          logger.debug("    [Policy] Chain halted at #{event.payload[:policy]}. Responding with #{event.payload[:responder]}." + duration(event))
+        end
+      end
+
+      def logger
+        ::Rails.logger
+      end
+
+      def duration(event)
+        "#{"(%.1fms)" % event.duration}"
+      end
+    end
+  end
+end
+
+Objectify::Rails::LogSubscriber.attach_to(:objectify)

data/lib/objectify/rails/railtie.rb

@@ -0,0 +1,11 @@
+module Objectify
+  module Rails
+    class Railtie < Rails::Railtie
+      initializer "objectify.reloader" do
+        ActionDispatch::Callbacks.to_prepare do
+          Rails.application.objectify.reload
+        end
+      end
+    end
+  end
+end

data/lib/objectify/rails/renderer.rb

@@ -0,0 +1,47 @@
+module Objectify
+  module Rails
+    class Renderer
+      def initialize(controller)
+        @controller = controller
+      end
+
+      def template(template, opts)
+        @controller.render opts.merge(:template => template)
+      end
+
+      def action(action, opts)
+        @controller.render opts.merge(:action => action)
+      end
+
+      def partial(partial, opts)
+        @controller.render opts.merge(:partial => partial)
+      end
+
+      def file(file, opts)
+        @controller.render opts.merge(:file => file)
+      end
+
+      def nothing(opts)
+        @controller.render opts.merge(:nothing => true)
+      end
+
+      def render(opts)
+        @controller.render opts
+      end
+
+      def respond_to
+        @controller.respond_to do |format|
+          yield(format)
+        end
+      end
+
+      def redirect_to(*args)
+        @controller.redirect_to(*args)
+      end
+
+      def data(data)
+        @controller.instance_variable_set(:@objectify_data, data)
+      end
+    end
+  end
+end

data/lib/objectify/rails/routing.rb

@@ -0,0 +1,97 @@
+require "action_dispatch"
+require "objectify/config/action"
+
+module Objectify
+  module Rails
+    module Routing
+      RESOURCE_ACTIONS = [:index, :show, :new, :create,
+                          :edit, :update, :destroy].freeze
+      OBJECTIFY_OPTIONS = [:policies].freeze
+
+      class ObjectifyMapper
+        def initialize(rails_mapper,
+                       application = ::Rails.application,
+                       action_factory = Config::Action)
+          @rails_mapper = rails_mapper
+          @application = application
+          @action_factory = action_factory
+        end
+
+        def resources(*args)
+          options           = args.extract_options!
+          objectify_options = extract_objectify_options(options)
+          controller        = @application.objectify.objectify_controller
+          rails_options     = options.merge(:controller => controller)
+
+          args.each do |resource_name|
+            objectify_defaults = {:objectify => {:resource => resource_name}}
+            defaults = (rails_options[:defaults] || {}).merge(objectify_defaults)
+            with_defaults = rails_options.merge(:defaults => defaults)
+            @rails_mapper.resources(resource_name, with_defaults)
+
+            RESOURCE_ACTIONS.each do |action_name|
+              action = @action_factory.new(resource_name,
+                                           action_name,
+                                           objectify_options,
+                                           @application.objectify.policies)
+
+              @application.objectify.append_action(action)
+            end
+          end
+        end
+
+        def defaults(options)
+          @application.objectify.append_defaults(options)
+        end
+
+        def policy_responders(options)
+          @application.objectify.append_policy_responders(options)
+        end
+
+        def resolutions(options)
+          @application.objectify.append_resolutions(options)
+        end
+
+        def legacy_action(controller, actions, options)
+          [*actions].each do |action_name|
+            action = @action_factory.new(controller,
+                                         action_name,
+                                         options,
+                                         @application.objectify.policies)
+            @application.objectify.append_action(action)
+          end
+        end
+
+        private
+          def extract_objectify_options(options)
+            Hash[*(RESOURCE_ACTIONS + OBJECTIFY_OPTIONS).map do |key|
+              [key, options.delete(key)] if options.include?(key)
+            end.compact.flatten]
+          end
+      end
+
+      class Mapper < ActionDispatch::Routing::Mapper
+        def objectify
+          @objectify ||= ObjectifyMapper.new(self)
+        end
+      end
+
+      class RouteSet < ActionDispatch::Routing::RouteSet
+        def draw(&block)
+          clear! unless @disable_clear_and_finalize
+
+          mapper = Mapper.new(self)
+          if block.arity == 1
+            mapper.instance_exec(ActionDispatch::Routing::DeprecatedMapper.new(self), &block)
+          else
+            mapper.instance_exec(&block)
+          end
+
+          finalize! unless @disable_clear_and_finalize
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/objectify/resolver.rb

@@ -0,0 +1,27 @@
+module Objectify
+  class NamedValueResolver
+    attr_reader :name
+
+    def initialize(name, value)
+      @name  = name
+      @value = value
+    end
+
+    def call
+      @value
+    end
+  end
+
+  class NameTranslationResolver
+    attr_reader :name
+
+    def initialize(name, value)
+      @name  = name
+      @value = value.to_s.classify
+    end
+
+    def call
+      @value.constantize.new
+    end
+  end
+end

data/lib/objectify/resolver_locator.rb

@@ -0,0 +1,73 @@
+require "objectify/resolver"
+
+module Objectify
+  class ArrayResolverLocator
+    def initialize(resolvers)
+      @resolvers = resolvers
+    end
+
+    def call(name)
+      @resolvers.detect { |resolver| resolver.name == name }
+    end
+  end
+
+  class MultiResolverLocator
+    def initialize(locators)
+      @locators = [*locators]
+    end
+
+    def call(name)
+      @locators.each do |locator|
+        resolver = locator.call(name)
+        return resolver if resolver
+      end
+
+      raise ArgumentError, "No resolver found for #{name}."
+    end
+
+    def context(context)
+      @locators.unshift(context)
+    end
+
+    def clear_context
+      @locators.shift
+    end
+  end
+
+  class NamedValueResolverLocator
+    def initialize(resolver_factory = NamedValueResolver)
+      @resolver_factory = resolver_factory
+      @resolvers        = {}
+    end
+
+    def add(name, value)
+      @resolvers[name] = @resolver_factory.new(name, value)
+    end
+
+    def call(name)
+      @resolvers[name]
+    end
+  end
+
+  class ConstResolverLocator
+    def initialize(namespace = nil)
+      @namespace = namespace
+      @cache = {}
+    end
+
+    def call(name)
+      @cache[name] || locate_and_store(name)
+    end
+
+    private
+      def locate_and_store(name)
+        begin
+          const_name = [@namespace, [name, :resolver].join("_")].compact.join("/")
+          const_name.classify.constantize.new.tap do |obj|
+            @cache[name] = obj
+          end
+        rescue NameError
+        end
+      end
+  end
+end

data/lib/objectify/route.rb

@@ -0,0 +1,4 @@
+module Objectify
+  class Route < Struct.new(:resource, :action)
+  end
+end

data/lib/objectify/version.rb

@@ -1,3 +1,3 @@
 module Objectify
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

data/objectify.gemspec

@@ -5,12 +5,11 @@ require "objectify/version"
 Gem::Specification.new do |s|
   s.name        = "objectify"
   s.version     = Objectify::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Andrew Kiellor"]
-  s.email       = ["akiellor@gmail.com"]
+  s.authors     = ["James Golick"]
+  s.email       = ["jamesgolick@gmail.com"]
   s.homepage    = ""
-  s.summary     = %q{A simple gem to make hashes and arrays of hashes behave like objects.}
-  s.description = %q{A simple gem to make hashes and arrays of hashes behave like objects using proxies.}
+  s.summary     = %q{}
+  s.description = %q{}
 
   s.rubyforge_project = "objectify"
 
@@ -19,7 +18,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency('activesupport', '>= 2.3')
-  s.add_development_dependency('rspec')
-  s.add_development_dependency('rake')
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec", "~> 2.4.0"
+  s.add_development_dependency "bundler", "~> 1.0.0"
+  s.add_development_dependency "jeweler", "~> 1.6.4"
+  s.add_development_dependency "bourne", "1.0"
+  s.add_development_dependency "mocha", "0.9.8"
+
+  s.add_runtime_dependency "rails", ">=3.0.0"
+  s.add_runtime_dependency "i18n"
 end

data/spec/config/action_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+require "objectify/config/action"
+
+describe "Objectify::Config::Action" do
+  before do
+    @merged_policies  = stub("MergedPolicies")
+    @default_policies = stub("PolicyConf", :merge => @merged_policies)
+
+    @route            = stub("Route")
+    @route_factory    = stub("RouteFactory", :new => @route)
+  end
+
+  context "when everything is specified" do
+    before do
+      @index_options = {
+        :service => :something,
+        :responder => :pictures_index
+      }
+
+      @options = {
+        :policies => :asdf,
+        :skip_policies => :bsdf,
+        :index => @index_options
+      }
+
+      @action = Objectify::Config::Action.new(:pictures,
+                                              :index,
+                                              @options,
+                                              @default_policies,
+                                              @route_factory)
+    end
+
+    it "creates and stores a route from the route factory" do
+      @route_factory.should have_received(:new).with(:pictures, :index)
+      @action.route.should == @route
+    end
+
+    it "stores its resource_name" do
+      @action.resource_name.should == :pictures
+    end
+
+    it "stores its name" do
+      @action.name.should == :index
+    end
+
+    it "merges and stores the policy configurations" do
+      @default_policies.should have_received(:merge).with(@options,
+                                                          @index_options)
+      @action.policies.should == @merged_policies
+    end
+
+    it "stores service overrides" do
+      @action.service.should == :something
+    end
+
+    it "stores responder overrides" do
+      @action.responder.should == :pictures_index
+    end
+  end
+
+  context "when nothing is specified" do
+    before do
+      @options = {}
+      @action = Objectify::Config::Action.new(:pictures,
+                                              :index,
+                                              @options,
+                                              @default_policies,
+                                              @route_factory)
+    end
+
+    it "has a default service of \#{resource_name}_\#{action_name}" do
+      @action.service.should == :pictures_index
+    end
+
+    it "has a default responder of \#{resource_name}_\#{action_name}" do
+      @action.responder.should == :pictures_index
+    end
+  end
+end