nested_resource_url 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'activesupport', "~> 3.0"
+gem 'actionpack', "~> 3.0"
+
+group :test do
+  gem "rspec", "~> 2.11.0"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 menostos
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# NestedResourceUrl
+
+this gem will add some functionality to the rails actioncontroller.
+it'll provide the +nested_resource+ method which you can use to 
+specify the nesting. See Usage
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'nested_resource_url'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nested_resource_url
+
+## Usage
+
+### routes.rb
+
+    resource :projects do 
+      resource :tasks
+    end
+
+### tasks_controller.rb
+
+    class TasksController < ...
+      nested_resource :task
+    end
+
+this will make the following methods available to your controller and views
+(example when a project is defined)
+
+* nested_resource(@task) # => [<Project>, <Task>]
+* nested_task_path(@task) # => /project/:project_id/tasks
+* new_nested_task_path # => /project/:project_id/tasks/new
+* edit_nested_task_path(@task) # => /project/:project_id/tasks/1/edit
+
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/nested_resource_url.rb

@@ -0,0 +1,13 @@
+
+require 'nested_resource_url/version'
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/slice'
+require 'action_controller'
+require 'nested_resource_url/collector'
+require 'nested_resource_url/method_definer'
+require 'nested_resource_url/nested_resource'
+require 'nested_resource_url/helpers'
+
+module NestedResourceUrl
+end

data/lib/nested_resource_url/collector.rb

@@ -0,0 +1,76 @@
+module NestedResourceUrl
+
+  # The class collects objects in a controller
+  # it is initialized with a controller and an array of object_names
+  class Collector < Struct.new(:controller, :object_names)
+
+    # Collects the resources specified when creating the
+    # collector. it'll also filter the array of resources
+    # according to the options
+    #
+    # === Options:
+    # * +:only+:: specify an array of symbols, classes or objects which are allowed to be returned
+    # * +:except+:: specify an array of symbols, classes or objects which are not allowed to be returned
+    # * +:max_level+:: specifies the max amount of objects returned
+    # * +:exclusive+:: if set to true it'll return no resources, same as max_level = 0
+    def resources(options = {})
+      resources = self.collect_resources(options)
+
+      return self.apply_only_and_except(resources, options).compact
+    end
+
+    protected
+    # collects the resources without applying the only and except options
+    #
+    # === Options:
+    # * +:max_level+:: specifies the max amount of objects returned
+    # * +:exclusive+:: if set to true it'll return no resources, same as max_level = 0
+    def collect_resources(options)
+      max_level = self.max_nesting_level(options)
+      resources = NestedResourceUrl::NestedResource.new
+
+      self.object_names.each do |object_name|
+        break if resources.length >= max_level
+        resources << self.resource_from_object_name(object_name)
+      end
+      return resources
+    end
+
+    # evaluates the options only and except and filters the given resources
+    # 
+    # === Options:
+    # * +:max_level+:: specifies the max amount of objects returned
+    # * +:exclusive+:: if set to true it'll return no resources, same as max_level = 0
+    def apply_only_and_except(resources, options)
+      resources = resources.only(options[:only]) if options.include?(:only)
+      resources = resources.except(options[:except]) if options.include?(:except)
+      return resources
+    end
+
+    # the method will lookup the object_name on the given controller.
+    # it'll search for the method with it's name or an instace variable
+    # 
+    # === Params:
+    # * +object_name+: a symbol specifing an object_name
+    def resource_from_object_name(object_name)
+      if self.controller.respond_to?(object_name)
+        self.controller.send(object_name)
+      else
+        self.controller.instance_variable_get(:"@#{object_name}")
+      end
+    end
+
+    # returns the max level of nesting allowed through options
+
+    # === Options:
+    # * +:max_level+:: specifies the max amount of objects returned
+    # * +:exclusive+:: if set to true it'll return no resources, same as max_level = 0
+    def max_nesting_level(options)
+      max_nesting_level = options.delete(:max_level) || 99
+      max_nesting_level = 0 if options.delete(:exclusive) === true
+      max_nesting_level
+    end
+
+  end
+
+end

data/lib/nested_resource_url/helpers.rb

@@ -0,0 +1,52 @@
+module NestedResourceUrl
+  
+  module Helpers
+
+    extend ActiveSupport::Concern
+
+    protected
+    # returns the options valid for collecting nested_resources
+    #
+    # Note: options will be modified
+    def extract_nested_collect_options!(options = {})
+      options.extract!(:max_level, :exclusive, :only, :except).select{|key, value| value }
+    end
+
+    # collects the resources for the given objects_names
+    # 
+    # === Params:
+    # * +object_names+:: an array of symbols
+    # * +options+:: an options hash
+    #
+    # === Options:
+    # * +:only+:: specify an array of symbols, classes or objects which are allowed to be returned
+    # * +:except+:: specify an array of symbols, classes or objects which are not allowed to be returned
+    # * +:max_level+:: specifies the max amount of objects returned
+    # * +:exclusive+:: if set to true it'll return no resources, same as max_level = 0
+    def collect_nested_resource_objects(object_names, options = {})
+      return NestedResourceUrl::Collector.new(self, object_names).resources(options)
+    end
+
+    module ClassMethods
+
+      protected
+      # setup the nested_resource methods for the current controller.
+      # creates the following methods where you need to replace the word task:
+      #
+      # * nested_task:: used for form_for
+      # * nested_task_path:: normal links
+      # * nested_task_url:: normal links
+      #
+      # === Options:
+      # * +:max_level+:: specifies the max amount of objects returned
+      def nested_resource(object, options = {})
+        nested_object_names = options.delete(:through)
+        MethodDefiner.new(self).define_methods!(object, nested_object_names, options)
+      end
+
+    end
+
+  end
+
+end
+ActionController::Base.send :include, NestedResourceUrl::Helpers

data/lib/nested_resource_url/method_definer.rb

@@ -0,0 +1,67 @@
+module NestedResourceUrl
+
+  class MethodDefiner < Struct.new(:receiver)
+
+    # define the methods on the given receiver
+    #
+    # === Params:
+    # * scope_name: the symbol which object to nest
+    # * object_names: an array of symbols to nest
+    # * default_options: an options hash
+    def define_methods!(scope_name, object_names, default_options)
+      define_nested_helper_method(scope_name, object_names, default_options)
+      define_nested_url_methods(scope_name)
+    end
+
+    def define_nested_url_methods(object_name)
+        pluralized_object_name = object_name.to_s.pluralize
+        [:path, :url].each do |type|
+          define_nested_url_method_show_and_edit(object_name, type)
+          define_nested_url_method_new(object_name, type)
+          define_nested_url_method_index(object_name, pluralized_object_name, type)
+        end
+      end
+
+      def define_nested_url_method_show_and_edit(scope_name, type)
+        [nil, :edit_].each do |action|
+          method_name = :"#{action}nested_#{scope_name}_#{type}"
+          self.receiver.class_eval <<-EOF
+            def #{method_name}(object, options = {})
+              self.#{action}polymorphic_#{type}(self.nested_#{scope_name}(object, extract_nested_collect_options!(options)), options)
+            end
+          EOF
+          self.receiver.send(:helper_method, method_name)
+        end
+      end
+
+      def define_nested_url_method_new(scope_name, type)
+        new_method_name = :"new_nested_#{scope_name}_#{type}"
+        self.receiver.class_eval <<-EOF
+          def #{new_method_name}(options = {})
+            self.new_polymorphic_#{type}(self.nested_#{scope_name}(:#{scope_name}, extract_nested_collect_options!(options)), options)
+          end
+        EOF
+        self.receiver.send(:helper_method, new_method_name)
+      end
+
+      def define_nested_url_method_index(scope_name, plural_scope_name, type)
+        index_method_name = :"nested_#{plural_scope_name}_#{type}"
+        self.receiver.class_eval <<-EOF
+          def #{index_method_name}(options = {})
+            self.polymorphic_#{type}(self.nested_#{scope_name}(:#{plural_scope_name}, extract_nested_collect_options!(options)), options)
+          end
+        EOF
+        self.receiver.send(:helper_method, index_method_name)
+      end
+
+      def define_nested_helper_method(scope_name, object_names, default_options = {})
+        method_name = :"nested_#{scope_name}"
+        receiver.send(:define_method, method_name) do |object, options = {}|
+          self.collect_nested_resource_objects(object_names, default_options.merge(options)) + [object]
+        end
+        self.receiver.send(:helper_method, method_name)
+      end
+
+  end
+
+end

data/lib/nested_resource_url/nested_resource.rb

@@ -0,0 +1,51 @@
+module NestedResourceUrl
+
+  # Nested resource extends the array overiding the "-" and the "&" method to
+  # filter elements with symbol, class or object itself
+  class NestedResource < Array
+
+    # returns a new array without any object within +other+ that matches
+    # one of this
+    #
+    # === Params:
+    # * +other+:: an object or array of objects containing symbols, class or object
+    def -(*other)
+      objects_to_delete = other.flatten
+      self.select do |resource|
+        !self.contains_type_of(resource, objects_to_delete)
+      end
+    end
+
+    # returns a new array only containing the objects given with other
+    #
+    # === Params:
+    # * +other+:: an object or array of objects containing symbols, class or object
+    def &(*other)
+      objects_to_keep = other.flatten
+      self.select do |resource|
+        self.contains_type_of(resource, objects_to_keep)
+      end
+    end
+    alias :except :-
+    alias :only :&
+
+    protected
+    # checks if the resource is within the object_to_checks.
+    # returns true if:
+    #
+    # * the objects_to_check contains the resource itself
+    # * the objects_to_check contains a symbol matching the classname
+    # * the objects_to_check contains the resources class
+    def contains_type_of(resource, objects_to_check)
+      objects_to_check.include?(resource) ||
+      objects_to_check.include?(self.resource_name(resource)) || 
+      objects_to_check.include?(resource.class)
+    end
+
+    def resource_name(resource)
+      resource.class.name.underscore.to_sym
+    end
+
+  end
+
+end

data/lib/nested_resource_url/version.rb

@@ -0,0 +1,3 @@
+module NestedResourceUrl
+  VERSION = "0.1.0"
+end

data/nested_resource_url.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nested_resource_url/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "nested_resource_url"
+  gem.version       = NestedResourceUrl::VERSION
+  gem.authors       = ["menostos"]
+  gem.email         = ["menostos@gmail.com"]
+  gem.description   = %q{The gem will add some helpers to controllers and view to automatically create nested urls}
+  gem.summary       = %q{nested url helper for controller and views}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency("activesupport", ["~> 3.0"])
+end

data/spec/helper_spec.rb

@@ -0,0 +1,26 @@
+
+require 'spec_helper'
+
+describe NestedResourceUrl::Helpers do
+
+  class Helper
+    include NestedResourceUrl::Helpers
+  end
+
+  subject{
+    Helper.new
+  }
+
+  it 'should extract valid NestedResourceUrl with optional options' do
+    options = {max_level: 5, test: "number1"}
+    subject.send(:extract_nested_collect_options!, options).should eq({max_level: 5})
+    options.should eq(test: "number1")
+  end
+
+  it 'should extract valid NestedResourceUrl with all options' do
+    options = {max_level: 5, test: "number1", exclusive: true, only: :project, except: :user, another: :param}
+    subject.send(:extract_nested_collect_options!, options).should eq({max_level: 5, exclusive: true, only: :project, except: :user})
+    options.should eq(test: "number1", another: :param)
+  end
+
+end

data/spec/helpers/receiver.rb

@@ -0,0 +1,14 @@
+class Receiver < ActionController::Base
+
+  attr_accessor :user, :project
+  
+end
+
+class Project
+end
+
+class Issue
+end
+
+class User
+end

data/spec/method_definer_call_merged_options_spec.rb

@@ -0,0 +1,22 @@
+
+require 'spec_helper'
+
+describe NestedResourceUrl::MethodDefiner do
+
+  setup_receiver!(options: {max_level: 5})
+
+  it 'should collect_nested_resource_objects with merged options' do
+    setup_subject!(options: {max_level: 5, exclusive: true}).should_receive(:task_path)
+    subject.nested_task_path(:task, {exclusive: true})
+  end
+
+  it 'should override default_options with options' do
+    setup_subject!(options: {max_level: 7}).should_receive(:task_path)
+    subject.nested_task_path(:task, {max_level: 7})
+  end
+
+  it 'should' do
+
+  end
+
+end

data/spec/method_definer_call_spec.rb

@@ -0,0 +1,24 @@
+
+require 'spec_helper'
+
+describe NestedResourceUrl::MethodDefiner do
+
+  setup_receiver!
+
+  it 'should return the task alone when no objects available' do
+    setup_subject!
+    subject.nested_task(:task).should eq([:task])
+  end
+
+  it 'should return the project with the task' do
+    project = Project.new
+    setup_subject! nested_resources: [project]
+    subject.nested_task(:task).should eq([project, :task])
+  end
+
+  it 'should collect_nested_resource_objects with options' do
+    setup_subject!(options: {max_level: 5}).should_receive(:task_path)
+    subject.nested_task_path(:task, {max_level: 5})
+  end
+
+end

data/spec/method_definer_method_spec.rb

@@ -0,0 +1,35 @@
+
+require 'spec_helper'
+
+describe NestedResourceUrl::MethodDefiner do
+
+  setup_receiver!
+
+  [:path, :url].each do |type|
+    {
+      1 => [
+        :"new_nested_task_#{type}",
+        :"nested_tasks_#{type}"
+      ],
+      2 => [
+        :"nested_task_#{type}",
+        :"edit_nested_task_#{type}",
+      ]
+    }.each do |parameter_count, method_names|
+      method_names.each do |method_name|
+
+        it "it should define #{method_name} with #{parameter_count}" do
+          subject.should respond_to(method_name)
+          subject.method(method_name).arity.should eq(-parameter_count) # options is optional
+          subject.method(method_name).parameters.length.should eq(parameter_count)
+        end
+      end
+    end
+  end
+
+  it 'should define the nested_task method with' do
+    subject.should respond_to(:nested_task)
+    subject.method(:nested_task).arity.should eq(1)
+  end
+
+end

data/spec/nested_resource_spec.rb

@@ -0,0 +1,60 @@
+
+require 'spec_helper'
+
+describe NestedResourceUrl::NestedResource do
+
+  let(:user) { User.new }
+  let(:project) { Project.new }
+  let(:issue) { Issue.new }
+
+  subject do
+    obj = NestedResourceUrl::NestedResource.new
+    obj << user
+    obj << project
+    obj << issue
+    obj
+  end
+
+  it 'should remove instances of symbol project' do
+    (subject - :project).should eq([user, issue])
+  end
+
+  it 'should remove instances of symbol project through except' do
+    subject.except(:project).should eq([user, issue])
+  end
+
+  it 'should remove instances of symbol user and issue' do
+    (subject - [:user, :issue]).should eq([project])
+  end
+
+
+  it 'should keep everything but user by symbol' do
+    (subject & :user).should eq([user])
+  end
+
+  it 'should keep everything but user by symbol through only' do
+    subject.only(:user).should eq([user])
+  end
+
+  it 'should keep everything but project and issue by symbol' do
+    (subject & [:project, :issue]).should eq([project, issue])
+  end
+
+  it 'should match an object in array by symbol' do
+    subject.send(:contains_type_of, project, [:project]).should be_true
+  end
+
+  it 'should match an object in array by class' do
+    subject.send(:contains_type_of, issue, [Issue]).should be_true
+  end
+
+  it 'should match an object in array by instance' do
+    subject.send(:contains_type_of, issue, [issue]).should be_true
+  end
+
+  it 'should return a symbol from object instance' do
+    subject.send(:resource_name, issue).should be(:issue)
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end
+
+require 'nested_resource_url'
+require 'helpers/receiver'
+
+def setup_receiver!(configuration = {})
+  configuration = {
+    resource: :task,
+    object_names: [:user, :project],
+    options: {}
+  }.merge(configuration)
+  let(:method_definer) { NestedResourceUrl::MethodDefiner.new(Receiver) }
+  subject do
+    method_definer.define_methods!(configuration[:resource], configuration[:object_names], configuration[:options])
+    Receiver.new
+  end
+end
+
+def setup_subject!(configuration = {})
+  configuration = {
+    nested_resources: [],
+    object_names: [:user, :project],
+    options: {}
+  }.merge(configuration)
+  subject.stub(:collect_nested_resource_objects){ configuration[:nested_resources] }
+  subject.should_receive(:collect_nested_resource_objects).with(configuration[:object_names], configuration[:options])
+  return subject
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: nested_resource_url
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- menostos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: The gem will add some helpers to controllers and view to automatically
+  create nested urls
+email:
+- menostos@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/nested_resource_url.rb
+- lib/nested_resource_url/collector.rb
+- lib/nested_resource_url/helpers.rb
+- lib/nested_resource_url/method_definer.rb
+- lib/nested_resource_url/nested_resource.rb
+- lib/nested_resource_url/version.rb
+- nested_resource_url.gemspec
+- spec/helper_spec.rb
+- spec/helpers/receiver.rb
+- spec/method_definer_call_merged_options_spec.rb
+- spec/method_definer_call_spec.rb
+- spec/method_definer_method_spec.rb
+- spec/nested_resource_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: nested url helper for controller and views
+test_files:
+- spec/helper_spec.rb
+- spec/helpers/receiver.rb
+- spec/method_definer_call_merged_options_spec.rb
+- spec/method_definer_call_spec.rb
+- spec/method_definer_method_spec.rb
+- spec/nested_resource_spec.rb
+- spec/spec_helper.rb