rezource 0.0.1

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rails'
+gem "mocha"

data/Rakefile

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+desc 'Run tests for Rezource.'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = true
+end
+
+# Make test the default task.
+task :default => :test

data/lib/rezource.rb

@@ -0,0 +1,173 @@
+require "active_support/all"
+
+module Rezource
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def resource(opts={})
+      @belongs_to = opts[:belongs_to] if opts[:belongs_to]
+      self
+    end
+  end
+
+  # ----------
+  
+  def index
+    respond_with *namespace, find_resources
+  end
+
+  def show
+    respond_with *namespace, find_resource
+  end
+
+  def new
+    respond_with *namespace, build_resource
+  end
+
+  def create
+    resource_create build_resource(permitted_params_create)
+  end
+
+  def edit
+    respond_with *namespace, find_resource
+  end
+
+  def update
+    resource_update find_resource, permitted_params_update
+  end
+
+  def destroy
+    resource_destroy find_resource
+  end
+
+  # -----------
+
+  def namespace
+    self.class.name.split("::").slice(0...-1).map(&:underscore).map(&:to_sym)
+  end
+
+  # -----------
+
+  def parent?
+    parent_class
+  end
+
+  def parent_class
+    belongs_to = self.class.instance_variable_get("@belongs_to")
+    belongs_to ? (belongs_to.is_a?(Class) ? belongs_to : belongs_to.to_s.camelcase.constantize) : nil
+  end
+
+  def find_parent
+    parent_ivar_get || parent_ivar_set(find_parent_scope.first)
+  end
+
+  def find_parent_scope
+    parent_class.where(id: params[:"#{parent_ivar}_id"])
+  end
+
+  def parent_ivar;              parent_class.name.split("::").last.underscore; end
+  def parent_ivar_set(value);   instance_variable_set("@#{parent_ivar}", value); value; end
+  def parent_ivar_get;          instance_variable_get "@#{parent_ivar}"; end
+  def parent;                   parent_ivar_get; end
+
+
+  # -----------
+
+  def resource_class
+    self.class.name.split("::").last.gsub(/Controller$/, "").singularize.constantize
+  end
+
+  def build_resource(attributes={})
+    resource_ivar_get || resource_ivar_set(send(parent? ? :build_resource_with_parent : :build_resource_without_parent, attributes))
+  end
+
+  def build_resource_with_parent(attributes)
+    find_parent.send(resources_ivar.to_sym).build(attributes)
+  end
+
+  def build_resource_without_parent(attributes)
+    resource_class.new(attributes)
+  end
+
+  def find_resources
+    resources_ivar_get || resources_ivar_set(find_resources_scope.to_a)
+  end
+
+  def find_resources_scope
+    parent? ? find_parent.send(resources_ivar.to_sym) : resource_class
+  end
+
+  def find_resource
+    return resource_ivar_get if resource_ivar_get
+
+    resource = find_resource_scope.first
+    reverse_set_parent_from_resource resource if parent?
+
+    resource_ivar_set resource
+  end
+
+  def find_resource_scope
+    resource_class.where(id: params[:id])
+  end
+
+  def reverse_set_parent_from_resource(resource)
+    parent_ivar_set resource.send(parent_ivar.to_sym) if resource.respond_to?(parent_ivar.to_sym)
+  end
+
+  # -----------
+
+
+
+  def resource_ivar;              resource_class.name.split("::").last.underscore; end
+  def resource_ivar_set(value);   instance_variable_set("@#{resource_ivar}", value); value; end
+  def resource_ivar_get;          instance_variable_get "@#{resource_ivar}"; end
+  def resource;                   resource_ivar_get; end
+
+  def resources_ivar;             resource_class.name.split("::").last.pluralize.underscore; end
+  def resources_ivar_set(value);  instance_variable_set("@#{resources_ivar}", value); value; end
+  def resources_ivar_get;         instance_variable_get "@#{resources_ivar}"; end
+  def resources;                  resources_ivar_get; end
+
+  def before_create(resource); end
+  def before_update(resource); end
+  def before_destroy(resource); end
+
+  def after_create(resource); end
+  def after_update(resource); end
+  def after_destroy(resource); end
+
+  def resource_create(resource)
+    before_create resource
+    resource.save if resource.valid?
+    after_create resource
+
+    respond_with *namespace, resource
+  end
+
+  def resource_update(resource, attributes={})
+    before_update resource
+    resource.update_attributes attributes if resource.valid?
+    after_update resource
+
+    respond_with *namespace, resource
+  end
+
+  def resource_destroy(resource)
+    before_destroy resource
+    resource.destroy
+    after_destroy resource
+
+    respond_with *namespace, resource
+  end
+
+
+  def permitted_params_create;  permitted_params; end
+  def permitted_params_update;  permitted_params; end
+  def permitted_params;         raise RuntimeError.new("implement me"); end
+
+
+  def interpolation_options
+    {resource_name: resource.respond_to?(:name) ? resource.send(:name) : "NAME"}
+  end
+
+end

data/rezource.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name               = "rezource"
+  s.version            = "0.0.1"
+
+  s.authors = ["Jan Zimmek"]
+  s.email = %q{jan.zimmek@web.de}
+
+  s.summary = %q{Make Rails restful controller even more simple}
+  s.description = %q{Make Rails restful controller even more simple}
+
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.require_paths = ["lib"]
+end

data/test/test_rezource.rb

@@ -0,0 +1,401 @@
+require "test/unit"
+require "mocha/setup"
+require "rezource"
+
+class SampleParent
+end
+
+class Sample
+end
+
+class SamplesController
+  include Rezource
+end
+
+module Namespaced
+  class SamplesController
+    include Rezource
+  end
+end
+
+class RezourceTest < Test::Unit::TestCase
+
+
+  def teardown
+    SamplesController.instance_variable_set "@belongs_to", nil    
+    Namespaced::SamplesController.instance_variable_set "@belongs_to", nil
+  end
+
+  def test_namespace
+    assert_equal [], SamplesController.new.namespace
+    assert_equal [:namespaced], Namespaced::SamplesController.new.namespace
+  end
+
+
+  # ----- actions
+
+
+  # def test_index_no_parent
+  #   c = SamplesController.new
+  #   c.expects(:find_resources).returns [1,2,3]
+  #   c.expects(:respond_with)
+  #   c.index
+
+  #   assert_equal c.resources, [1,2,3]
+  #   assert_equal c.resource, nil
+  # end
+
+  # def test_index_with_parent
+  #   c = SamplesController.resource(belongs_to: SampleParent).new
+  #   c.expects(:params).with(:action).returns "index"
+
+  #   parent = {samples: [{id: 1}]}
+
+  #   c.expects(:find_parent).returns(parent)
+  #   c.expects(:respond_with)
+  #   c.index
+
+  #   # assert_equal c.resources, [1,2,3]
+  #   # assert_equal c.resource, nil
+  # end
+
+
+  # -----
+
+  def test_resource_class
+    assert_equal Sample, SamplesController.new.resource_class
+    assert_equal Sample, Namespaced::SamplesController.new.resource_class
+  end
+
+  def test_build_resource__with_parent
+    c = SamplesController.new
+    attributes = {name: "joe"}
+    c.expects(:build_resource_without_parent).with(attributes)
+    c.build_resource attributes
+  end
+
+  def test_build_resource__without_parent
+    c = SamplesController.resource(belongs_to: SampleParent).new
+    attributes = {name: "joe"}
+    c.expects(:build_resource_with_parent).with(attributes)
+    c.build_resource attributes
+  end
+
+  def test_build_resource_with_parent
+    c = SamplesController.resource(belongs_to: SampleParent).new
+    attributes = {name: "joe"}
+
+    association = mock()
+    association.expects(:build).with(attributes)
+
+    parent = mock()
+    parent.expects(:send).returns association
+
+    c.expects(:find_parent).returns parent
+    c.build_resource_with_parent attributes
+  end
+
+  def test_build_resource_without_parent
+    c = SamplesController.new
+    attributes = {name: "joe"}
+    Sample.stubs(:new).with(attributes)
+    c.build_resource_without_parent attributes
+  end
+
+  # --- find resources 
+
+  def test_find_resources
+    c = SamplesController.new
+
+    scope = mock();
+    scope.expects(:to_a).returns 123
+
+    c.expects(:find_resources_scope).returns scope
+    c.find_resources
+
+    assert_equal c.resources, 123
+  end
+
+  def test_find_resources__without_parent
+    c = SamplesController.new
+
+    scope = mock()
+    scope.expects(:to_a)
+
+    c.expects(:find_resources_scope).returns scope
+    c.find_resources
+  end
+
+  def test_find_resources__with_parent
+    c = SamplesController.resource(belongs_to: SampleParent).new
+
+    association = mock()
+    association.expects(:to_a)
+
+    parent = mock();
+    parent.expects(:send).returns(association)
+
+    c.expects(:find_parent).returns(parent)
+    c.find_resources
+  end
+
+  def test_find_resources_scope
+    c = SamplesController.new
+    assert_same Sample, c.find_resources_scope
+  end
+
+
+  # --- find resource
+
+  def test_find_resource
+    # TODO
+  end
+
+  def test_find_resource_scope
+    c = SamplesController.new
+
+    c.expects(:params).returns({id: 123})
+
+    scope = mock()
+    scope.expects(:where).with({id: 123})
+
+    c.expects(:resource_class).returns scope
+
+    c.find_resource_scope
+  end
+
+  def test_reverse_set_parent_from_resource__with_reverse_association
+    c = SamplesController.resource(belongs_to: SampleParent).new
+
+    resource = mock()
+    resource.expects(:respond_to?).with(:sample_parent).returns true
+    resource.expects(:sample_parent).returns 123
+
+    c.expects(:parent_ivar_set).with(123)
+    c.reverse_set_parent_from_resource resource
+  end
+
+  def test_reverse_set_parent_from_resource__without_reverse_association
+    c = SamplesController.resource(belongs_to: SampleParent).new
+
+    resource = mock()
+    resource.expects(:respond_to?).with(:sample_parent).returns false
+    c.reverse_set_parent_from_resource resource
+  end
+
+
+  # ------ resource
+
+  def test_resource_ivar
+    assert_equal "sample", SamplesController.new.resource_ivar
+    assert_equal "sample", Namespaced::SamplesController.new.resource_ivar
+  end
+
+  def test_resource_ivar_set
+    c = SamplesController.new
+    res = c.resource_ivar_set 123
+    assert_equal 123, res
+    assert_equal 123, c.instance_variable_get("@sample")
+  end
+
+  def test_resource_ivar_get
+    c = SamplesController.new
+    c.instance_variable_set "@sample", 123
+
+    assert_equal 123, c.resource_ivar_get
+  end
+
+  def test_resource
+    c = SamplesController.new
+    c.expects(:resource_ivar_get)
+    c.resource
+  end
+
+  # ------ resources
+
+  def test_resources_ivar
+    assert_equal "samples", SamplesController.new.resources_ivar
+    assert_equal "samples", Namespaced::SamplesController.new.resources_ivar
+  end
+
+  def test_resources_ivar_set
+    c = SamplesController.new
+    res = c.resources_ivar_set 123
+    assert_equal 123, res
+    assert_equal 123, c.instance_variable_get("@samples")
+  end
+
+  def test_resources_ivar_get
+    c = SamplesController.new
+    c.instance_variable_set "@samples", 123
+
+    assert_equal 123, c.resources_ivar_get
+  end
+
+  def test_resources
+    c = SamplesController.new
+    c.expects(:resources_ivar_get)
+    c.resources
+  end
+
+
+  # ---- parent
+
+  def test_parent?
+    c = SamplesController.new
+    c.expects(:parent_class)
+    c.parent?
+  end
+
+  def test_parent_class__none
+    c = SamplesController.new
+    assert_nil c.parent_class
+  end
+
+  def test_parent_class__symbol
+    c = SamplesController.new
+    c.class.instance_variable_set("@belongs_to", :sample_parent)
+    assert_equal SampleParent, c.parent_class
+  end
+
+  def test_parent_class__class
+    c = SamplesController.new
+    c.class.instance_variable_set("@belongs_to", SampleParent)
+    assert_equal SampleParent, c.parent_class
+  end
+
+  def find_parent
+    c = SamplesController.resource(belongs_to: SampleParent).new
+
+    scope = mock()
+    scope.expects(:first).returns 123
+
+    c.expects(:find_parent_scope).returns scope
+    c.expects(:parent_ivar_set).with(123)
+
+    c.find_parent
+  end
+
+  def test_parent_ivar
+    c = SamplesController.new
+    c.expects(:parent_class).returns SampleParent
+    assert_equal "sample_parent", c.parent_ivar
+  end
+
+  def test_parent_ivar_set
+    c = SamplesController.resource(belongs_to: SampleParent).new
+    res = c.parent_ivar_set(123)
+    assert_equal 123, res
+    assert_equal 123, c.instance_variable_get("@sample_parent")
+  end
+
+  def test_parent_ivar_get
+    c = SamplesController.resource(belongs_to: SampleParent).new
+    c.instance_variable_set "@sample_parent", 123
+    assert_equal 123, c.parent_ivar_get
+  end
+
+  def parent
+    c = SamplesController.resource(belongs_to: SampleParent).new
+    c.expects(:parent_ivar_get)
+    c.parent
+  end
+
+  # ---- create, update, destroy
+
+  def test_resource_create__valid
+    c = SamplesController.new
+    m = mock()
+
+    c.expects(:before_create).with(m)
+    m.expects(:valid?).returns true
+    m.expects(:save)
+    c.expects(:after_create).with(m)
+    c.expects(:respond_with).with(*(c.namespace + [m]))
+
+    c.resource_create m
+  end
+
+  def test_resource_create__invalid
+    c = SamplesController.new
+    m = mock()
+
+    c.expects(:before_create).with(m)
+    m.expects(:valid?).returns false
+    c.expects(:after_create).with(m)
+    c.expects(:respond_with).with(*(c.namespace + [m]))
+
+    c.resource_create m
+  end
+
+  def test_resource_update__valid
+    c = SamplesController.new
+    attributes = {name: "joe"}
+    m = mock()
+
+    c.expects(:before_update).with(m)
+    m.expects(:valid?).returns true
+    m.expects(:update_attributes).with(attributes)
+    c.expects(:after_update).with(m)
+    c.expects(:respond_with).with(*(c.namespace + [m]))
+
+    c.resource_update m, attributes
+  end
+
+ def test_resource_update__invalid
+    c = SamplesController.new
+    attributes = {name: "joe"}
+    m = mock()
+
+    c.expects(:before_update).with(m)
+    m.expects(:valid?).returns false
+    c.expects(:after_update).with(m)
+    c.expects(:respond_with).with(*(c.namespace + [m]))
+
+    c.resource_update m, attributes
+  end
+
+  def test_resource_destroy
+    c = SamplesController.new
+    m = mock()
+
+    c.expects(:before_destroy).with(m)
+    m.expects(:destroy)
+    c.expects(:after_destroy).with(m)
+    c.expects(:respond_with).with(*(c.namespace + [m]))
+
+    c.resource_destroy m
+  end
+
+
+
+  # -----
+
+
+  def test_permitted_params_create
+    c = SamplesController.new
+    c.expects(:permitted_params)
+    c.permitted_params_create
+  end
+
+  def test_permitted_params_update
+    c = SamplesController.new
+    c.expects(:permitted_params)
+    c.permitted_params_update
+  end
+
+  def test_permitted_params
+    c = SamplesController.new
+    
+    assert_raise RuntimeError do
+      c.permitted_params
+    end
+  end
+
+  # ----
+
+  def test_interpolation_options
+    # TODO
+  end
+
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: rezource
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jan Zimmek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-17 00:00:00.000000000 Z
+dependencies: []
+description: Make Rails restful controller even more simple
+email: jan.zimmek@web.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- lib/rezource.rb
+- rezource.gemspec
+- test/test_rezource.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.23
+signing_key: 
+specification_version: 3
+summary: Make Rails restful controller even more simple
+test_files:
+- test/test_rezource.rb