compositor 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a5579d42c800d76ab62fe943c825237b216cf84
-  data.tar.gz: c74728ad5a2cbb902926c7b7a18d2931a91dae3c
+  metadata.gz: 39aa83a1dbde3279e06295e7a5ce005444812d92
+  data.tar.gz: b36f918486e1adcd5daa2da24676b96a2fac0d26
 SHA512:
-  metadata.gz: 39e18ac43d15623e0c3bdca5b6e6eb82960e99d6f1e5b1cac8786f0df97a7c4d1f5f2b7ae821dc2eb2ca6a97dde7203587923a1e457ab9915229fcc3860cd185
-  data.tar.gz: 550e32aa5840d1e228d2bab660a0e3fc725219f0e4984275319073106af1a6517fd15bc3e9c4e0db40131dc6fef5dc7cbb648876ff5e43deacefd57f331e3490
+  metadata.gz: c878fb457203fdd022a49e991d2dee76ac18bb068b7811a196e03e81222a23b73304740efac40a45c6b632561b639a5b04367481841a9419f0e8a4368f050373
+  data.tar.gz: e6850ec7f0c0fd5a0b4c4eab1eb5ad2a69873db8afefd93ffde011b43c61e7f705251df25deb1957f230a493e0551d6e1f601ea434ab611ad757855c34601ca1

data/README.md

@@ -3,6 +3,7 @@ Compositor
 
 [![Gem Version](https://badge.fury.io/rb/compositor.png)](http://badge.fury.io/rb/compositor)
 [![Build status](https://secure.travis-ci.org/wanelo/compositor.png)](http://travis-ci.org/wanelo/compositor)
+[![Code Climate](https://codeclimate.com/github/wanelo/compositor.png)](https://codeclimate.com/github/wanelo/compositor)
 
 A Composite Design Pattern with a neat DSL for constructing trees of objects in order to render them as a Hash, and subsequently
 JSON.  Used by Wanelo to generate all JSON API responses by compositing multiple objects together in API responses, converting to
@@ -83,9 +84,11 @@ element.
 So here is how to create a list of users in this way, but explicitly declaring classes:
 
 ```ruby
-   compositor = Compositor::Map.new(view_context,
-        :collection => @users.map{|user| UserCompositor.new(view_context, user, { :root => true }),
-        :root => :users
+   compositor = ListCompositor.new(view_context,
+                                   :collection => @users.map { |user|
+                                     UserCompositor.new(view_context, user, { :root => true })
+                                   },
+                                   :root => :users)
 ```
 
 When calling ```to_hash``` on the top level compositor, we get:
@@ -121,7 +124,7 @@ of complex responses, as described below.
 ```UserCompositor``` class, when defined, automatically adds a ```user``` method to the DSL class, which effictively
 instantiates the new UserCompositor instance, passing the context into it automatically.
 
-Using built-in ```Compositor::Map``` and ```Compositor::List``` we can construct multiple objects into a larger
+Using built-in ```MapCompositor``` and ```ListCompositor``` we can construct multiple objects into a larger
 hierarchy.
 
 In the example below, an application is assumed to define ```StoreCompositor```and ```ProductCompositor``` classes
@@ -164,7 +167,7 @@ similar to ```UserCompositor```, but wrapping ```Store``` and ```Product``` Acti
 ```
 
 Inside the list definition above, ```@products``` is a collection of Products, ```ActiveRecord``` objects,
-and the block maps each to a Compositor using ```product()``` method, registered by ProductCompositor.
+and the block maps each to a Compositor using ```product``` method, registered by ProductCompositor.
 
 ### Instance Variables
 
@@ -174,11 +177,11 @@ was defined on ```view_context``` (by Rails, which copies them from the Controll
 so became automatically available inside DSL.  Note that all instance variables must be
 defined *before* the DSL instance is created.
 
-### Method Name Collisions in the DSL
+### Method Names in the DSL
 
-Because DSL uses only the last word of the class name (eg, ```user``` for a class named ```MyModule::UserCompositor```),
-there is a possibility of name collisions. In order to prevent that, Compositor will detect if a DSL method is already
-defined and throw exception if another class tries to redefine it.
+Compositor will extract the full name of the class and place that name into the DSL. For example, ```MyModule::UserCompositor```
+will define a ```my_module_user``` method in the DSL. To create a method called ```user```, the standard convention
+is to define a class in the global namespace called ```UserCompositor```.
 
 If you prefer to have your own ```Compositor``` class hierarchy, or just compositors that should not be added to the
 DSL, you can name the classes starting with ```Abstract```, such as ```MyModule::AbstractCompositor```.

data/lib/compositor/base.rb

@@ -1,5 +1,6 @@
 module Compositor
-  class MethodAlreadyDefinedError < RuntimeError; end
+  class MethodAlreadyDefinedError < RuntimeError;
+  end
 
   class Base
     attr_reader :attrs
@@ -33,16 +34,12 @@ module Compositor
       self.root ? true : false
     end
 
-    def root_class_name
-      self.class.root_class_name(self.class)
-    end
-
-    def self.root_class_name(klazz)
-      klazz.name.gsub(/(.*::)|(Compositor$)/, '').underscore
+    def self.original_dsl_name
+      self.name.gsub(/(Compositor$)/, '').gsub(/::/, '_').underscore
     end
 
     def self.inherited(subclass)
-      method_name = root_class_name(subclass)
+      method_name = subclass.original_dsl_name
       unless method_name.eql?("base") || method_name.start_with?("abstract")
         # check if it's already defined
         if Compositor::DSL.instance_methods.include?(method_name.to_sym)
@@ -65,6 +62,6 @@ end
 require_relative 'dsl'
 require_relative 'composite'
 require_relative 'leaf'
-require_relative 'literal'
-require_relative 'list'
-require_relative 'map'
+require_relative 'compositors/literal_compositor'
+require_relative 'compositors/list_compositor'
+require_relative 'compositors/map_compositor'

data/lib/compositor/compositors/list_compositor.rb

@@ -0,0 +1,5 @@
+class ListCompositor < Compositor::Composite
+  def renderer
+    @renderer ||= Compositor::Renderer::Iterator
+  end
+end

data/lib/compositor/compositors/literal_compositor.rb

@@ -0,0 +1,12 @@
+class LiteralCompositor < Compositor::Leaf
+  attr_accessor :object
+
+  def initialize(view_context, object = {}, args = {})
+    super(view_context, args)
+    self.object = object
+  end
+
+  def to_hash
+    object
+  end
+end

data/lib/compositor/compositors/map_compositor.rb

@@ -0,0 +1,5 @@
+class MapCompositor < ::Compositor::Composite
+  def renderer
+    @renderer ||= Compositor::Renderer::Merged
+  end
+end

data/lib/compositor/version.rb

@@ -1,3 +1,3 @@
 module Compositor
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/spec/compositor/base_spec.rb

@@ -1,28 +1,22 @@
 require 'spec_helper'
 
 describe Compositor::Base do
-  describe "#root_class_name" do
-    it "returns the underscored class name" do
-      Compositor::Base.root_class_name(Object).should == "object"
-    end
-
+  describe "#original_dsl_name" do
     it "returns the underscored class name with compositor stripped out" do
-      Compositor::Base.root_class_name(DslStringCompositor).should == "dsl_string"
+      DslStringCompositor.original_dsl_name.should == "dsl_string"
     end
+  end
 
-    it "raises exception when two subclasses that clash on the same name are defined" do
-      block = lambda {
-        # first class
-        class UserCompositor < Compositor::Leaf
-        end
-
-        # 2nd class
-        module ::Foo
-          class UserCompositor < Compositor::Leaf
+  describe '.inherited' do
+    describe "when class is defined inside a module" do
+      it "returns the underscored class name with compositor stripped out but with the module added" do
+        module Exploding
+          class ExplosionCompositor < Compositor::Leaf
           end
         end
-      }
-      expect { block.call }.to raise_error
+
+        expect(Compositor::DSL.instance_methods).to include(:exploding_explosion)
+      end
     end
 
     it "does not add DSL when class name begins with Abstract" do
@@ -39,6 +33,5 @@ describe Compositor::Base do
       expect { block.call }.not_to raise_error
       Compositor::DSL.instance_methods.should_not include(:abstract_user)
     end
-
   end
 end

data/spec/compositor/{list_spec.rb → compositors/list_compositor_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Compositor::List do
+describe ListCompositor do
   let(:context) { Object.new }
 
   it 'returns the generated array with the explicit receiver' do

data/spec/compositor/{literal_spec.rb → compositors/literal_compositor_spec.rb}

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe Compositor::Literal do
+describe LiteralCompositor do
 
   let(:context) { Object.new }
 
   it 'returns the hash its given' do
     actual = { test: 123 }
 
-    Compositor::Literal.new(context, actual).to_hash.should == actual
+    LiteralCompositor.new(context, actual).to_hash.should == actual
   end
 end

data/spec/compositor/{hash_spec.rb → compositors/map_compositor_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Compositor::Map do
+describe MapCompositor do
   let(:context) { Object.new }
 
   it 'returns the generated map' do

data/spec/compositor/performance_spec.rb

@@ -34,10 +34,10 @@ describe 'Performance' do
         10000.times do
           string = DslStringCompositor.new(context)
           int = DslIntCompositor.new(context, 3)
-          list = Compositor::List.new(context,
+          list = ListCompositor.new(context,
                                       root: :numbers,
                                       collection: [1, 2, 3].map! { |n| DslIntCompositor.new(context, n) })
-          cmp = Compositor::Map.new(context, collection: [string, int, list])
+          cmp = MapCompositor.new(context, collection: [string, int, list])
           cmp.to_hash.should == {:a => "b", :number => 3, :numbers => [{:number => 1}, {:number => 2}, {:number => 3}]}
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: compositor
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Konstantin Gredeskoul
@@ -9,62 +9,62 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-21 00:00:00.000000000 Z
+date: 2014-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rb-fsevent
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Define simple "compositor" classes that represent your domain objects
@@ -77,10 +77,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .pairs
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".pairs"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE
@@ -90,21 +90,21 @@ files:
 - lib/compositor.rb
 - lib/compositor/base.rb
 - lib/compositor/composite.rb
+- lib/compositor/compositors/list_compositor.rb
+- lib/compositor/compositors/literal_compositor.rb
+- lib/compositor/compositors/map_compositor.rb
 - lib/compositor/dsl.rb
 - lib/compositor/leaf.rb
-- lib/compositor/list.rb
-- lib/compositor/literal.rb
-- lib/compositor/map.rb
 - lib/compositor/renderer/base.rb
 - lib/compositor/renderer/iterator.rb
 - lib/compositor/renderer/merged.rb
 - lib/compositor/version.rb
 - spec/compositor/base_spec.rb
+- spec/compositor/compositors/list_compositor_spec.rb
+- spec/compositor/compositors/literal_compositor_spec.rb
+- spec/compositor/compositors/map_compositor_spec.rb
 - spec/compositor/dsl_spec.rb
-- spec/compositor/hash_spec.rb
 - spec/compositor/leaf_spec.rb
-- spec/compositor/list_spec.rb
-- spec/compositor/literal_spec.rb
 - spec/compositor/performance_spec.rb
 - spec/spec_helper.rb
 - spec/support/sample_dsl.rb
@@ -118,28 +118,29 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: Composite design pattern with a convenient DSL for building JSON/Hashes of
   complex objects.
 test_files:
 - spec/compositor/base_spec.rb
+- spec/compositor/compositors/list_compositor_spec.rb
+- spec/compositor/compositors/literal_compositor_spec.rb
+- spec/compositor/compositors/map_compositor_spec.rb
 - spec/compositor/dsl_spec.rb
-- spec/compositor/hash_spec.rb
 - spec/compositor/leaf_spec.rb
-- spec/compositor/list_spec.rb
-- spec/compositor/literal_spec.rb
 - spec/compositor/performance_spec.rb
 - spec/spec_helper.rb
 - spec/support/sample_dsl.rb
+has_rdoc: 

data/lib/compositor/list.rb

@@ -1,7 +0,0 @@
-module Compositor
-  class List < Compositor::Composite
-    def renderer
-      @renderer ||= Compositor::Renderer::Iterator
-    end
-  end
-end

data/lib/compositor/literal.rb

@@ -1,14 +0,0 @@
-module Compositor
-  class Literal < Compositor::Leaf
-    attr_accessor :object
-
-    def initialize(view_context, object = {}, args = {})
-      super(view_context, args)
-      self.object = object
-    end
-
-    def to_hash
-      object
-    end
-  end
-end

data/lib/compositor/map.rb

@@ -1,7 +0,0 @@
-module Compositor
-  class Map < ::Compositor::Composite
-    def renderer
-      @renderer ||= Compositor::Renderer::Merged
-    end
-  end
-end