basic_assumption 0.5.1 → 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bd80407a5479a8d946adf03a45d8247bd6053e2f
+  data.tar.gz: 4c163098fc31e77b897a7c3cbd98bb4a749e7a07
+SHA512:
+  metadata.gz: 82613fbd47114b44ef886757e42fd07336faa5d82f48ba2ee73d602652808803bcb5d6302c889bcdda755b06f4fbe722344d2a8522a1d29165665da3f6907cf5
+  data.tar.gz: 33ce020aa383b3c806d641d802475d8e43f1667d3152bcbe48f554d832918400e3e6b204a487a78f866b1c7bf32aebc1e9a7bf7aba84af60e893dd9154afc479

data/HISTORY.rdoc

@@ -1,3 +1,6 @@
+== 0.5.2 / 2015-08-10
+* Use Rails 3 or greater
+  * Permit use of Rails 4
 == 0.5.1 / 2011-10-05
 * Bug Fix
   * Included missing file in gem package

data/README.rdoc

@@ -360,10 +360,9 @@ an actual Rails app.
 There is an .rvmrc file in the repository that will require a basic_assumption
 gemset if you're using RVM, which will help to manage the gem dependencies.
 
-The test suites are dependent on the Bundler gem. Ensure that it is installed
-with:
+The test suites are dependent on the Bundler gem.
 
-    gem install bundler --version="~> 1.0.3"
+    gem install bundler
 
 It is highly recommended to use RVM to manage development BasicAssumption against
 various Rails and Ruby versions. Run the following command to create an

data/lib/basic_assumption.rb

@@ -62,23 +62,9 @@ module BasicAssumption
   # value returned by the instance method (the reader, from this point of view)
   # to be overriden.
   def assume(name, context={}, &block)
-    define_method(name) do
-      @basic_assumptions       ||= {}
-      unless @basic_assumptions.key?(name)
-        @basic_assumptions[name] = if block_given?
-          instance_eval(&block)
-        else
-          which = context.delete(:using) || self.class
-          block = DefaultAssumption.resolve(which)
-          instance_exec(name, context, &block)
-        end
-      end
-      @basic_assumptions[name]
-    end
-    define_method("#{name}=") do |value|
-      @basic_assumptions       ||= {}
-      @basic_assumptions[name] = value
-    end
+    define_basic_assumptions
+    define_reader_method(name, context, &block)
+    define_writer_method(name)
     after_assumption(name)
   end
 
@@ -96,8 +82,37 @@ module BasicAssumption
   #     end
   #   end
   def after_assumption(name); end
+
+  private
+
+  def define_basic_assumptions
+    define_method(:basic_assumptions) do
+      @basic_assumptions ||= {}
+    end
+  end
+
+  def define_reader_method(name, context, &block)
+    define_method(name) do
+      unless basic_assumptions.key?(name)
+        basic_assumptions[name] = if block_given?
+          instance_eval(&block)
+        else
+          which = context.delete(:using) || self.class
+          block = DefaultAssumption.resolve(which)
+          instance_exec(name, context, &block)
+        end
+      end
+      basic_assumptions[name]
+    end
+  end
+
+  def define_writer_method(name)
+    define_method("#{name}=") do |value|
+      basic_assumptions[name] = value
+    end
+  end
 end
 
-if defined?(Rails) && Rails::VERSION::MAJOR == 3
+if defined?(Rails) && Rails::VERSION::MAJOR >= 3
   require 'basic_assumption/rails'
 end

data/lib/basic_assumption/default_assumption.rb

@@ -55,7 +55,7 @@ module BasicAssumption
         when Proc
           given
         when Symbol
-          ClassResolver.instance(given).block
+          ClassResolver.new(given, 'BasicAssumption::DefaultAssumption').instance.block
         else
           Base.new.block
         end

data/lib/basic_assumption/default_assumption/action.rb

@@ -0,0 +1,56 @@
+module BasicAssumption
+  module DefaultAssumption
+    class Action
+      attr_reader :request, :callbacks
+
+      def initialize(request, &block)
+        @request   = request
+        @callbacks = {}
+
+        block.yield self
+      end
+
+      %w(new update find index).each do |name|
+        class_eval <<-MET, __FILE__, __LINE__
+          def #{name}(&block)
+            if block_given?
+              callbacks[:#{name}] = block
+            else
+              (callbacks[:#{name}] || callbacks[:default]).call
+            end
+          end
+        MET
+      end
+
+      def default(&block)
+        callbacks[:default] = block
+      end
+
+      def outcome
+        return index  if index?
+        return new    if make?
+        return update if update?
+        find
+      end
+
+      private
+
+      def index?
+        action == 'index'
+      end
+
+      def make? #:nodoc:
+        %w(new create).include?(action)
+      end
+
+      def update?
+        %w(update edit).include?(action)
+      end
+
+      def action
+        request.params['action']
+      end
+
+    end
+  end
+end

data/lib/basic_assumption/default_assumption/class_resolver.rb

@@ -1,22 +1,28 @@
+require 'active_support/inflector'
+
 module BasicAssumption
   module DefaultAssumption
     class ClassResolver #:nodoc:
-      def self.instance(name, *args)
-        new(name).instance(*args)
+      include ActiveSupport::Inflector
+
+      attr_reader :name, :namespace
+
+      def initialize(name, namespace='')
+        @name, @namespace = name, namespace
       end
-      def initialize(name)
-        @name = name
+
+      def klass
+        @klass ||= constantize(class_name_in_namespace)
       end
-      def instance(*args)
-        constantize(camelize(@name)).new(*args)
+
+      def instance
+        klass.new
       end
-      def camelize(name)
-        name.to_s.gsub(/(?:^|_)(.)/) { "#{$1.upcase}" }
-      end
-      def constantize(name)
-        namespace = BasicAssumption::DefaultAssumption
-        namespace.const_missing(name) unless namespace.const_defined? name
-        namespace.const_get(name)
+
+      private
+
+      def class_name_in_namespace
+        "#{namespace}::#{camelize(name)}"
       end
     end
   end

data/lib/basic_assumption/default_assumption/name.rb

@@ -0,0 +1,32 @@
+require 'active_support/inflector'
+
+module BasicAssumption
+  module DefaultAssumption
+    class Name
+      include ActiveSupport::Inflector
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name.to_s
+      end
+
+      def singular
+        singularize(name)
+      end
+
+      def plural
+        pluralize(name)
+      end
+
+      def plural?
+        plural.eql?(name)
+      end
+
+      def to_s
+        singular
+      end
+
+    end
+  end
+end

data/lib/basic_assumption/default_assumption/owner_attributes.rb

@@ -0,0 +1,36 @@
+module BasicAssumption
+  module DefaultAssumption
+    class OwnerAttributes
+      attr_reader :controller, :owner_context, :owner_method
+
+      def initialize(owner_method_or_context, controller)
+        @controller = controller
+
+        if owner_method_or_context.kind_of? Hash
+          @owner_method  = owner_method_or_context[:object]
+          @owner_context = owner_method_or_context
+        else
+          @owner_method  = owner_method_or_context
+          @owner_context = {}
+        end
+      end
+
+      def attributes
+        {column_name => owner_object.id}
+      end
+
+      def owner_object
+        if owner_method.respond_to? :call
+          controller.instance_eval(&owner_method)
+        else
+          controller.send(owner_method)
+        end
+      end
+
+      def column_name
+        owner_context[:column_name] || :"#{owner_object.class.name.downcase}_id"
+      end
+    end
+  end
+end
+

data/lib/basic_assumption/default_assumption/rails.rb

@@ -1,15 +1,56 @@
+require 'basic_assumption/default_assumption/action'
+require 'basic_assumption/default_assumption/class_resolver'
+require 'basic_assumption/default_assumption/name'
+require 'basic_assumption/default_assumption/owner_attributes'
+
 module BasicAssumption
   module DefaultAssumption
-    # Custom default behavior in the context of Rails.
-    class Rails < BasicAssumption::DefaultAssumption::Base
-      attr_reader :name, :context, :params #:nodoc:
+    # Restful default behavior in the context of Rails
+    class Rails
+      attr_reader :action, :context, :name, :request #:nodoc:
+
+      def initialize(name=nil, context={}, request=nil) #:nodoc:
+        @context = context
+        @name    = Name.new(context.delete(:as) || name)
+        @request = request
 
-      def initialize(name=nil, context={}, params={}) #:nodoc:
-        @name, @context, @params = name.to_s, context, params
+        @action  = initialize_action
       end
-      # Returns a block that will attempt to find an instance of
-      # an ActiveRecord model based on the name that was given to
-      # BasicAssumption#assume and an id value in the parameters.
+
+      # Returns a block that will attempt to do the correct thing depending
+      # on the plurality of the name passed to +assume+ and the action for the
+      # current request. If the name is singular and the action is not 'new'
+      # or 'create', then +assume+ will find an instance of
+      # an ActiveRecord model of the name that it received and an id
+      # value in the parameters. If the action is 'new' or 'create', +assume+
+      # will instantiate a new instance of the model class, passing in the
+      # values it finds in the +params+ hash with for a key of the name passed
+      # to +assume+. For example:
+      #
+      #    class WidgetController < ApplicationController
+      #      default_assumption :rails
+      #      assume :widget
+      #
+      #      def create
+      #        widget.save!    # widget is: Widget.new(params[:widget])
+      #      end
+      #    end
+      #
+      # Note the object will have been instantiated but not saved, destroyed,
+      # etc.
+      #
+      # If the name passed to assume is plural, +assume+ returns all records
+      # for the model.
+      #
+      # It is possible to specify an alternative model name:
+      #
+      #   class WidgetController < ApplicationController
+      #     assume :sprocket, :as => :widget
+      #   end
+      #
+      # This will create a +sprocket+ method in your actions and view
+      # that will use the Widget model for its lookup.
+      #
       # The following two examples would be equivalent:
       #
       #   class WidgetController < ActionController::Base
@@ -46,6 +87,7 @@ module BasicAssumption
       # configuration options, such as:
       #
       #   conf.active_record.raise_error = true
+      #   conf.active_record.find_on_id  = true
       #
       # It is possible to specify an alternative model name:
       #
@@ -56,36 +98,78 @@ module BasicAssumption
       # This will create a +sprocket+ method in your actions and view
       # that will use the Widget model for its lookup.
       def block
-        klass = self.class
+        default = self
         Proc.new do |name, context|
-          klass.new(name, context, params).result
+          context[:controller] = self
+
+          default.class.new(name, context, request).result
         end
       end
 
       def result #:nodoc:
-        begin
-          model_class.find(lookup_id)
-        rescue
-          raise if settings[:raise_error]
-          nil
-        end
+        action.outcome
       end
 
       protected
-      def lookup_id #:nodoc:
-        if settings[:find_on_id]
-          params["#{name}_id"] || params['id']
-        else
-          params["#{name}_id"]
+
+      def initialize_action
+        name.plural? ? plural_action : singular_action
+      end
+
+      def singular_action
+        Action.new(request) do |action|
+          action.find do
+            find_and_maybe_raise
+          end
+          action.update do
+            record            = find_and_maybe_raise
+            record.attributes = resource_attributes
+            record
+          end
+          action.default do
+            model_class.new(resource_attributes.merge(owner_attributes))
+          end
         end
       end
 
-      def model_class #:nodoc:
-        @model_class ||= model_name.classify.constantize
+      def plural_action
+        Action.new(request) do |action|
+          action.default do
+            finder_scope
+          end
+        end
+      end
+
+      def finder_scope
+        model_class.where(owner_attributes)
+      end
+
+      def model_class
+        @model_class ||= ClassResolver.new(name).klass
+      end
+
+      def params
+        @params ||= request ? request.params : {}
       end
 
-      def model_name #:nodoc:
-        context[:as] ? context[:as].to_s : name
+      def find_and_maybe_raise
+        begin
+          finder_scope.find(params['id'])
+        rescue
+          raise if settings[:raise_error]
+        end
+      end
+
+      def resource_attributes
+        params[name.singular] || {}
+      end
+
+      def owner_attributes
+        @owner_attributes ||= if context[:owner]
+          OwnerAttributes.new(context[:owner], context[:controller]).attributes
+        else
+          {}
+        end
       end
 
       def settings #:nodoc:

data/lib/basic_assumption/rails.rb

@@ -1,6 +1,5 @@
-if defined?(Rails) && Rails::VERSION::MAJOR == 3
+if defined?(Rails) && Rails::VERSION::MAJOR >= 3
   require 'basic_assumption/default_assumption/rails'
-  require 'basic_assumption/default_assumption/restful_rails'
 
   module BasicAssumption
     # Must be required explicitly in Rails 3. Extends ActionController::Base
@@ -16,7 +15,7 @@ if defined?(Rails) && Rails::VERSION::MAJOR == 3
           # by +assume+ as a helper inside of views, and also disallows the
           # method from being called directly as a route endpoint.
           def self.after_assumption(name)
-            hide_action name
+            hide_action   name
             helper_method name
           end
         end