dooly 0.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,87 @@
+PATH
+  remote: .
+  specs:
+    dooly (0.0.1)
+      activemodel
+      activesupport
+      rake
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.13)
+      activesupport (= 3.2.13)
+      builder (~> 3.0.0)
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    binding_of_caller (0.7.1)
+      debug_inspector (>= 0.0.1)
+    builder (3.0.4)
+    coderay (1.0.8)
+    columnize (0.3.6)
+    debug_inspector (0.0.2)
+    debugger (1.2.4)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.1.7)
+    debugger-linecache (1.1.2)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.1.8)
+    guard (1.6.2)
+      listen (>= 0.6.0)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      terminal-table (>= 1.4.3)
+      thor (>= 0.14.6)
+    guard-test (0.7.0)
+      guard (>= 1.1)
+      test-unit (~> 2.2)
+    i18n (0.6.1)
+    listen (0.7.2)
+    lumberjack (1.0.2)
+    metaclass (0.0.1)
+    method_source (0.8.1)
+    mocha (0.13.2)
+      metaclass (~> 0.0.1)
+    multi_json (1.7.1)
+    pry (0.9.12)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-debugger (0.2.1)
+      debugger (~> 1.2.0)
+      pry (~> 0.9.10)
+    pry-remote (0.1.6)
+      pry (~> 0.9)
+      slop (~> 3.0)
+    pry-stack_explorer (0.4.9)
+      binding_of_caller (>= 0.7)
+      pry (~> 0.9.11)
+    rake (10.0.4)
+    shoulda (3.3.2)
+      shoulda-context (~> 1.0.1)
+      shoulda-matchers (~> 1.4.1)
+    shoulda-context (1.0.2)
+    shoulda-matchers (1.4.1)
+      activesupport (>= 3.0.0)
+    slop (3.4.3)
+    terminal-table (1.4.5)
+    test-unit (2.5.4)
+    thor (0.17.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0)
+  dooly!
+  guard
+  guard-test
+  mocha
+  pry
+  pry-debugger
+  pry-remote
+  pry-stack_explorer
+  shoulda
+  shoulda-context

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Insoo Jung
+
+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.markdown

@@ -0,0 +1,164 @@
+Dooly
+==========
+
+_Dooly_ is a character of Korean animation. [둘리](http://ko.wikipedia.org/wiki/%EB%91%98%EB%A6%AC)
+
+This gem offer an extension for Rails Serialization, and some helpful feature. 
+
+
+Installation
+============
+
+    $ gem install dooly
+
+
+
+Usage
+==========
+
+
+Attachment
+----------
+
+By including Dooly::Attachment in your class, that class can attach some data to the instance
+
+```ruby
+require 'dooly'
+
+class User < ActiveRecord::Base
+  include Dooly::Attachment
+  make_attachable_as_json
+end
+
+user = User.first
+user.attachment.add(:email, 'dooly@kogil.dong')
+user.attachment.add(:friends) do |u|
+  u.friends
+end
+user.attachment.add(:address, {:city=>'seoul'}) do |u, addr_hash|
+  addr_hash.merge(:landlord=>'ko gil dong')
+end
+
+user.as_json
+  # {
+  #   'name'=>'dooly', ... ,
+  #   'email'=>'dooly@kogil.dong',
+  #   'friends'=>user.friends.as_json,
+  #   'address'=>{'city'=>'seoul', 'landlord'=>'ko gil dong'}
+  # }
+```
+
+Also extended attachment class can be apply
+
+```ruby
+class User < ActiveRecord::Base
+  include Dooly::Attachment
+  
+  class Attachment < Dooly::Attachment::Base
+    def add_email
+      self[:email] = body.email
+    end
+  end
+  
+  make_attachable_as_json User::Attachment
+end
+
+user = User.first
+user.attachment.add_email
+user.as_json #=> {..., 'email'=>'dooly@kogil.dong'}
+```
+
+
+IdProxy
+----------
+
+IdProxy is a simple idea for class method that need only model id.
+
+```ruby
+class User < ActiveRecord::Base
+  def self.friends(id)
+    NoSQL.find_friends_of(id)
+  end
+  
+  def friends
+    self.class.friends(self.id)
+  end
+end
+```
+
+using IdProxy...
+
+```ruby
+class User < ActiveRecord::Base
+  include Dooly::IdProxy
+  
+  class IdProxy < Dooly::IdProxy::Base
+    def friends
+      NoSQL.find_friends_of(id)
+    end
+  end
+  
+  id_proxy_class IdProxy
+  id_proxy_delegate
+  
+  def another_instance_method
+  end
+end
+
+User.id_proxy(1).friends
+User.first.friends                       # instance of original class can call method of id_proxy
+User.id_proxy(1).another_instance_method # id_proxy can call instance method of original class
+```
+
+Collection
+----------
+
+Fix as_json root option for collection classes. as-is,
+
+```ruby
+User.where('id < 10').as_json(:root=>'users')
+  # [
+  #   {"users"=>{"name"=>"dooly"}},
+  #   {"users"=>{"name"=>"ddochi"}},
+  #   ...
+  # ]
+```
+
+fix this,
+
+```ruby
+Dooly::Collection::Base.new(User.where('id < 10')).as_json(:root=>'users')
+  # {
+  #   "users" => [
+  #     {"name"=>"dooly"},
+  #     {"name"=>"ddochi"}
+  #   ]
+  # }
+```
+
+
+Model Regulator
+---------------
+
+Model Regulator can reduce effort of parameter validation.
+
+```ruby
+class User < ActiveRecord::Base
+  include Dooly::ModelRegulator
+end
+
+class Friend < ActiveRecord::Base
+  # this methods can accept number id of user, 
+  # number id's string of user, user instance, and id_proxy of user
+  
+  def self.sample_method(user)
+    u = User.by(user)
+    # u is a user instance
+  end
+  
+  def self.example_method(user)
+    uid = User.id(user)
+    # uid is a number id of user
+  end
+end
+```

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.verbose = true
+end

data/dooly.gemspec

@@ -0,0 +1,32 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'dooly/version'
+
+Gem::Specification.new do |s|
+  s.name = 'dooly'
+  s.description = 'Some helpful feature for rails'
+  s.version = Dooly::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.date = '2013-07-23'
+  s.summary = 'Little dinosaur, Dooly'
+  s.homepage = 'http://github.com/insoul/dooly'
+  s.authors = ['Insoo Jung']
+  s.email = 'ensoul@empal.com'
+  
+  s.files = Dir['**/*'].select{|f| File.file?(f)}
+  s.require_path = %w{lib}
+  
+  s.add_dependency 'rake'
+  s.add_dependency 'activemodel'
+  s.add_dependency 'activesupport'
+  
+  s.add_development_dependency 'bundler', '~> 1.0'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'pry-remote'
+  s.add_development_dependency 'pry-stack_explorer'
+  s.add_development_dependency 'pry-debugger'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'shoulda'
+  s.add_development_dependency 'shoulda-context'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-test'
+end

data/lib/dooly/attachment/base.rb

@@ -0,0 +1,107 @@
+module Dooly
+  module Attachment
+    class Base < HashWithIndifferentAccess
+      attr_accessor :body
+
+      def add(k, value = nil, options = {})
+        if key?(k)
+          warn_duplicated(k); return fetch(k)
+        end
+
+        if value
+          store(k, value)
+          if block_given?
+            self.as_json_procs(k, &Proc.new)
+          end
+        elsif block_given?
+          store(k, Proc.new)
+        else
+          warn_unassigned_value(k)
+        end
+
+        if options[:as_json_options]
+          as_json_options(k, options[:as_json_options])
+        else
+          as_json_options(k, options) unless options.empty?
+        end
+      end
+
+      def as_json_options(k = nil, options = nil)
+        @as_json_options ||= HashWithIndifferentAccess.new
+        return @as_json_options if k.nil?
+        return @as_json_options[k] if options.nil?
+
+        @as_json_options[k] = options
+      end
+
+      def as_json_procs(k = nil)
+        @as_json_procs ||= HashWithIndifferentAccess.new
+        return @as_json_procs if k.nil?
+        return @as_json_procs[k] unless block_given?
+
+        @as_json_procs[k] = Proc.new
+      end
+
+      def as_json_procs_run(k = nil, value = nil)
+        @as_json_procs_run ||= HashWithIndifferentAccess.new
+        return @as_json_procs_run if k.nil?
+        return @as_json_procs_run[k] if value.nil?
+
+        @as_json_procs_run[k] = value
+      end
+
+      alias :to_hash_with_string :to_hash
+
+      def to_hash
+        to_hash_with_string.symbolize_keys
+      end
+
+      def [](key)
+        value = fetch(key, nil)
+        return nil if value.nil?
+
+        if Proc === value
+          value = value.call(body)
+          store(key, value)
+        end
+
+        fetch(key)
+      end
+
+      def as_json
+        self.each_pair do |k, v|
+          if self.as_json_procs(k) and !as_json_procs_run(k)
+            v = self.as_json_procs(k).call(body, v)
+            self.as_json_procs_run(k, true)
+          end
+
+          if Proc === v
+            self[k] = v.call(body).as_json
+          elsif v.respond_to?(:as_json)
+            if as_json_options(k)
+              self[k] = v.as_json(as_json_options(k)).as_json
+            else
+              self[k] = v.as_json
+            end
+          else
+            self[k] = v.as_json
+          end
+        end
+        self
+      end
+
+      private
+      def warn_unassigned_value(key)
+        message = ["Attachment has been tried to add with none value, #{self.class.name}/#{key}"]
+        message += caller if Rails.env.development?
+        Configuration.logger.warn(message.join("\n"))
+      end
+
+      def warn_duplicated(key)
+        message = ["Attachment has been tried to add repeatedly about key, #{self.class.name}/#{key}."]
+        message += caller if Rails.env.development?
+        Configuration.logger.warn(message.join("\n"))
+      end
+    end
+  end
+end

data/lib/dooly/attachment.rb

@@ -0,0 +1,48 @@
+module Dooly
+  module Attachment
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :attachment_klass
+      self.attachment_klass = Dooly::Attachment::Base
+    end
+    
+    module ClassMethods
+      def make_attachable_as_json(klass = nil)
+        klass = Dooly::Attachment::Base if klass.nil?
+        unless klass <= Dooly::Attachment::Base
+          raise "Attachment class must inherit Dooly::Attachment::Base: #{klass}"
+        end
+        self.attachment_klass = klass
+        
+        if self.instance_methods.include?(:as_json)
+          self.class_eval do 
+            alias :as_json_exclude_attachment :as_json
+            define_method(:as_json) do |options = {}, &block|
+              js = if block
+                as_json_exclude_attachment(options, &block)
+              else
+                as_json_exclude_attachment(options)
+              end
+              
+              js.class <= Hash ? js.merge(attachment.as_json) : js
+            end
+          end
+        else
+          self.class_eval do 
+            define_method(:as_json) do |options = {}|
+              attachment.as_json
+            end
+          end
+        end
+      end
+    end
+
+    def attachment
+      return @attachment if @attachment
+      am = self.attachment_klass.new
+      am.body = self
+      @attachment = am
+    end
+  end
+end

data/lib/dooly/collection/base.rb

@@ -0,0 +1,53 @@
+module Dooly
+  module Collection
+    class Base
+      include ActiveModel::Serializers::JSON
+      
+      extend Forwardable
+      def_delegators :@collection, *Enumerable.instance_methods
+      def_delegators :@collection, :each
+
+      include Dooly::Attachment
+      
+      attr_reader :collection
+      
+      class_attribute :include_root_in_json
+
+      def initialize(*args)
+        if args.first.respond_to?(:each)
+          args = args.first
+        end
+        @collection = args
+      end
+
+      def as_json(options = {})
+        root = options.delete(:root) || self.include_root_in_json
+        jsons = block_given? ? self.as_jsons(options, &Proc.new) : self.as_jsons(options)
+        if root
+          if root == true
+            root = begin 
+                @collection[0].class.model_name.element.pluralize
+              rescue
+                self.class.name.underscore.split('/')[-2].pluralize rescue 'collection'
+              end
+          end
+          {root => jsons}
+        else
+          jsons
+        end
+      end
+
+      def as_jsons(options = {})
+        @collection.map do |member|
+          if block_given?
+            member.as_json(options, &Proc.new)
+          else
+            member.as_json(options)
+          end
+        end
+      end
+      
+      make_attachable_as_json
+    end
+  end
+end

data/lib/dooly/collection.rb

@@ -0,0 +1,23 @@
+module Dooly
+  module Collection
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :collection_klass
+      self.collection_klass = Dooly::Collection::Base
+    end
+    
+    module ClassMethods
+      def collection_class(klass)
+        unless klass <= Dooly::Collection::Base
+          raise "Collection class must inherit Dooly::Colletion::Base: #{klass}"
+        end
+        self.collection_klass = klass
+      end
+      
+      def collection(*args)
+        self.collection_klass.new(*args)
+      end
+    end
+  end
+end

data/lib/dooly/configuration.rb

@@ -0,0 +1,14 @@
+module Dooly
+  class Configuration
+    class << self
+      def logger(lg = nil)
+        if lg.nil?
+          return @logger if @logger
+          return Rails.logger if Rails.defined?
+          raise 'logger undefined'
+        end
+        @logger = lg
+      end
+    end
+  end
+end

data/lib/dooly/id_proxy/base.rb

@@ -0,0 +1,52 @@
+module Dooly
+  module IdProxy
+    class Base
+      class << self
+        attr_accessor :model
+        attr_reader :finders
+      
+        def finders=(*args)
+          if args[0].is_a? Array
+            @finders = args[0]
+          else
+            @finders = args
+          end
+        end
+        alias :finder :finders
+        alias :finder= :finders=
+      end
+
+      attr_reader :id
+
+      def initialize(id)
+        raise 'idea must have id' if id.blank?
+        @id = id
+      end
+
+      def record
+        return @record if @record
+      
+        self.class.finders.each do |finder|
+          f = finder.to_sym
+          if self.class.model.respond_to?(f)
+            @record = self.class.model.send(f, self.id)
+          end
+        end
+      
+        unless @record
+          @record = self.class.model.find(self.id)
+        end
+      
+        @record
+      end
+
+      def respond_to?(name)
+        self.record.respond_to?(name) || super
+      end
+
+      def method_missing(name, *args, &block)
+        self.record.send(name, *args, &block)
+      end
+    end
+  end
+end

data/lib/dooly/id_proxy.rb

@@ -0,0 +1,57 @@
+module Dooly
+  module IdProxy
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :id_proxy_klass, :id_proxy_options
+      self.id_proxy_klass = Dooly::IdProxy::Base
+    end
+
+    module ClassMethods
+      def id_proxy_class(klass, options = {})
+        raise "Id Proxy class must inherit Dooly::IdProxyBase: #{klass}" unless klass <= Dooly::IdProxy::Base
+        self.id_proxy_klass = klass
+        self.id_proxy_klass.model = self
+        finders = options[:finders] || options[:finder]
+        self.id_proxy_klass.finders = finders if finders
+      end
+
+      def id_proxy_delegate
+        self.extend Forwardable
+        self.def_delegators 'self.id_proxy', *self.id_proxy_klass.instance_methods(false)
+      end
+
+      def id_proxy(*args)
+        options = args.extract_options!
+
+        if args.length > 1
+          return args.map {|arg| id(arg, options)}
+        end
+
+        value = args[0]
+        begin
+          return value.idx if value.is_a? self
+          return self.id_proxy_klass.new(value) if value.is_a? Integer
+          return self.id_proxy_klass.new(Integer(value)) if value.is_a? String
+          return value if Dooly::IdProxy::Base === value
+        
+          if options[:relate]
+            fn = options[:relate] == true ? "#{self.name.underscore}_id".to_sym : options[:relate].to_sym
+            return self.id_proxy_klass.new(value.send(fn)) if value.respond_to?(fn)
+          end
+        rescue => e
+          raise "Cannot make id_proxy from #{self.name} with #{value.to_s}: #{e}"
+        else
+          raise "Cannot make id_proxy from #{self.name} with #{value.to_s}"
+        end
+      end
+      alias :idx :id_proxy
+    end
+    
+    def id_proxy
+      return nil unless self.id
+      @id_proxy ||= self.id_proxy_klass.new(self.id)
+    end
+    alias :idx :id_proxy
+  end
+end

data/lib/dooly/model_regulator.rb

@@ -0,0 +1,58 @@
+module Dooly
+  module ModelRegulator
+    def model_regulator_finder(finder = nil)
+      return (@model_regulator_finder || :find) if finder.nil?
+      @model_regulator_finder = finder.to_sym
+    end
+    
+    def by(*args)
+      options = args.extract_options!
+
+      if args.length > 1
+        return args.map {|arg| by(arg, options)}
+      end
+
+      value = args[0]
+      begin
+        return value if value.is_a? self
+        return self.send(model_regulator_finder, value) if value.is_a? Integer
+        return self.send(model_regulator_finder, Integer(value)) if value.is_a? String
+        return value.record if Dooly::IdProxy::Base === value
+        
+        if options[:relate]
+          fn = options[:relate] == true ? "#{self.name.underscore}_id".to_sym : options[:relate].to_sym
+          return self.send(model_regulator_finder, value.send(fn)) if value.respond_to?(fn)
+        end
+      rescue => e
+        raise "Cannot find record from #{self.name} with #{value.to_s}: #{e}"
+      else
+        raise "Cannot find record from #{self.name} with #{value.to_s}"
+      end
+    end
+
+    def id(*args)
+      options = args.extract_options!
+
+      if args.length > 1
+        return args.map {|arg| id(arg, options)}
+      end
+
+      value = args[0]
+      begin
+        return value.id if value.is_a? self
+        return value if value.is_a? Integer
+        return Integer(value) if value.is_a? String
+        return value.id if Dooly::IdProxy::Base === value
+        
+        if options[:relate]
+          fn = options[:relate] == true ? "#{self.name.underscore}_id".to_sym : options[:relate].to_sym
+          return value.send(fn) if value.respond_to?(fn)
+        end
+      rescue => e
+        raise "Cannot find id from #{self.name} with #{value.to_s}: #{e}"
+      else
+        raise "Cannot find id from #{self.name} with #{value.to_s}"
+      end
+    end
+  end
+end

data/lib/dooly/version.rb

@@ -0,0 +1,3 @@
+module Dooly
+  VERSION = '0.1.0'
+end

data/lib/dooly.rb

@@ -0,0 +1,20 @@
+require 'forwardable'
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/concern'
+require 'active_support/hash_with_indifferent_access'
+require 'active_model/serialization'
+require 'active_model/naming'
+require 'active_model/serializers/json'
+require 'dooly/version'
+require 'dooly/attachment'
+require 'dooly/attachment/base'
+require 'dooly/collection'
+require 'dooly/collection/base'
+require 'dooly/id_proxy'
+require 'dooly/id_proxy/base'
+require 'dooly/model_regulator'
+
+module Dooly
+end

data/test/test_attachment.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+module Dooly
+  class TestAttachment < Test::Unit::TestCase
+    
+    class ModelSample
+      include ActiveModel::Serializers::JSON
+      self.include_root_in_json = false
+      include Dooly::Attachment
+
+      attr_accessor :name
+      
+      def attributes
+        {'name' => name}
+      end
+      
+      make_attachable_as_json
+    end
+    
+    class ValueSample
+      attr_accessor :value
+    end
+    
+    class DefaultSample
+      include Dooly::Attachment
+    end
+    
+    def setup
+      super
+    end
+    
+    context 'attachment' do
+      setup do
+        @model = ModelSample.new
+        @model.name = 'ddochi'
+      end
+      
+      should 'simply' do
+        assert_equal({'name'=>'ddochi'}, @model.as_json)
+      end
+      
+      should 'defalut attachment class' do
+        assert_equal(Dooly::Attachment::Base, DefaultSample.new.attachment.class)
+      end
+      
+      should 'attach key-value' do
+        @model.attachment.add(:friend, 'donor')
+        assert_equal({'name'=>'ddochi', 'friend'=>'donor'}, @model.as_json)
+      end
+      
+      should 'attach key-block' do
+        @model.attachment.add(:friend) do |body|
+          body.name + " and donor"
+        end
+        assert_equal({'name'=>'ddochi', 'friend'=>'ddochi and donor'}, @model.as_json)
+        
+        # block must be called only once
+        assert_equal({'name'=>'ddochi', 'friend'=>'ddochi and donor'}, @model.as_json)
+      end
+      
+      should 'attach key-value with block' do
+        v = ValueSample.new
+        v.value = 'donor'
+        @model.attachment.add(:friend, v) do |body, value|
+          "#{body.name} #{value.value}"
+        end
+        assert_equal({'name'=>'ddochi', 'friend'=>'ddochi donor'}, @model.as_json)
+        
+        # block must be called only once
+        assert_equal({'name'=>'ddochi', 'friend'=>'ddochi donor'}, @model.as_json)
+      end
+    end
+  end
+end

data/test/test_collection.rb

@@ -0,0 +1,57 @@
+module Dooly
+  class TestCollection < Test::Unit::TestCase
+    class ModelSample
+      attr_accessor :name
+      include Dooly::Collection
+      include ActiveModel::Serializers::JSON
+      self.include_root_in_json = false
+      include Dooly::Attachment
+      
+      def initialize(name)
+        @name = name
+      end
+      
+      def attributes
+        {'name' => name}
+      end
+      
+      def as_json(options = {})
+        js = super
+        js = yield(js) if block_given?
+        js
+      end
+      make_attachable_as_json
+    end
+    
+    context 'collection' do
+      setup do
+        @ddochi = ModelSample.new('ddochi')
+        @donor = ModelSample.new('donor')
+        @friends = ModelSample.collection(@ddochi, @donor)
+        @friends.attachment.add(:total, 2)
+      end
+      
+      should 'simply' do
+        assert_equal([{"name"=>"ddochi"}, {"name"=>"donor"}], @friends.as_json)
+        assert_equal({
+          'friends' => [{"name"=>"ddochi"}, {"name"=>"donor"}],
+          'total' => 2
+        }, @friends.as_json(:root => 'friends'))
+        assert_equal('ddochi', @friends.to_a[0].name)
+      end
+      
+      should 'block call by member' do
+        assert_equal([
+          {'name'=>'ddochi', 'friend_of'=>'dooly'},
+          {'name'=>'donor', 'friend_of'=>'dooly'}
+        ],@friends.as_json {|f| f.merge('friend_of' => 'dooly')})
+      end
+      
+      should 'just using base class' do
+        assert_equal({
+          'friends' => [{"name"=>"ddochi"}, {"name"=>"donor"}]
+        }, Dooly::Collection::Base.new([@ddochi, @donor]).as_json(:root=>'friends'))
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+ENV['DEBUG'] = 'true'
+
+require 'test/unit'
+require 'shoulda-context'
+require 'pry'
+require 'pry-remote'
+require 'pry-stack_explorer'
+require 'pry-debugger'
+
+require 'rubygems'
+require 'bundler/setup'
+require 'dooly'

data/test/test_id_proxy.rb

@@ -0,0 +1,48 @@
+module Dooly
+  class TestIdProxy < Test::Unit::TestCase
+    class ModelSample
+      attr_accessor :id
+      
+      class IdProxyClass < Dooly::IdProxy::Base
+        def proxy_method_sample(arg)
+          ['class', arg, self.id.to_s].join(' ')
+        end
+      end
+      
+      include Dooly::IdProxy
+      id_proxy_class IdProxyClass, :finder => :get_cache
+      id_proxy_delegate
+      
+      def instance_method_sample(arg)
+        ['instance', arg, @id.to_s].join(' ')
+      end
+      
+      def self.get_cache(id)
+        instance = self.new
+        instance.id = id
+        instance
+      end
+    end
+    
+    class DefaultSample
+      attr_accessor :id
+      include Dooly::IdProxy
+    end
+    
+    context 'id_proxy' do
+      setup do
+        @model = ModelSample.new
+        @model.id = 11
+      end
+      
+      should 'simply' do
+        assert_equal('class simply 11', @model.proxy_method_sample('simply'))
+        assert_equal('instance simply 11', ModelSample.id_proxy(11).instance_method_sample('simply'))
+      end
+      
+      should 'default id proxy class' do
+        assert_equal(Dooly::IdProxy::Base, DefaultSample.idx(11).class)
+      end
+    end
+  end
+end

data/test/test_model_regulator.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+module Dooly
+  class TestModelRegulator < Test::Unit::TestCase
+    class ModelSample
+      attr_accessor :id
+      extend Dooly::ModelRegulator
+      
+      def self.find(id)
+        instance = self.new
+        instance.id = id
+        instance
+      end
+    end
+    
+    class CacheSample
+      attr_accessor :id
+      extend Dooly::ModelRegulator
+      model_regulator_finder :get_cache
+      
+      def self.get_cache(id)
+        instance = self.new
+        instance.id = id
+        instance
+      end
+    end
+    
+    def setup
+      super
+    end
+    
+    context 'model_regulator' do
+      setup do
+        
+      end
+      
+      should 'simply' do
+        instance = ModelSample.new
+        instance.id = 11
+        assert_equal(11, ModelSample.by(instance).id)
+        assert_equal(11, ModelSample.id(instance))
+        assert_equal(11, ModelSample.by(11).id)
+        assert_equal(11, ModelSample.id(11))
+        assert_equal(11, ModelSample.by('11').id)
+        assert_equal(11, ModelSample.id('11'))
+      end
+      
+      should 'simple cache' do
+        instance = CacheSample.new
+        instance.id = 11
+        assert_equal(11, CacheSample.by(instance).id)
+        assert_equal(11, CacheSample.id(instance))
+        assert_equal(11, CacheSample.by(11).id)
+        assert_equal(11, CacheSample.id(11))
+        assert_equal(11, CacheSample.by('11').id)
+        assert_equal(11, CacheSample.id('11'))
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: dooly
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Insoo Jung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70342471631920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70342471631920
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &70342471631080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70342471631080
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70342471629800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70342471629800
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70342471629000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471629000
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70342471628260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471628260
+- !ruby/object:Gem::Dependency
+  name: pry-remote
+  requirement: &70342471626760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471626760
+- !ruby/object:Gem::Dependency
+  name: pry-stack_explorer
+  requirement: &70342471626100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471626100
+- !ruby/object:Gem::Dependency
+  name: pry-debugger
+  requirement: &70342471625040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471625040
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70342471623840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471623840
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: &70342471623320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471623320
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: &70342471622660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471622660
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &70342471621900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471621900
+- !ruby/object:Gem::Dependency
+  name: guard-test
+  requirement: &70342471658400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342471658400
+description: Some helpful feature for rails
+email: ensoul@empal.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- dooly-0.1.0.gem
+- dooly.gemspec
+- Gemfile
+- Gemfile.lock
+- lib/dooly/attachment/base.rb
+- lib/dooly/attachment.rb
+- lib/dooly/collection/base.rb
+- lib/dooly/collection.rb
+- lib/dooly/configuration.rb
+- lib/dooly/id_proxy/base.rb
+- lib/dooly/id_proxy.rb
+- lib/dooly/model_regulator.rb
+- lib/dooly/version.rb
+- lib/dooly.rb
+- MIT-LICENSE
+- Rakefile
+- README.markdown
+- test/test_attachment.rb
+- test/test_collection.rb
+- test/test_helper.rb
+- test/test_id_proxy.rb
+- test/test_model_regulator.rb
+homepage: http://github.com/insoul/dooly
+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.17
+signing_key: 
+specification_version: 3
+summary: Little dinosaur, Dooly
+test_files: []
+has_rdoc: