rails-dsl 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98e3c0e380e01110c13f244d3c305baf997ea051
-  data.tar.gz: a144f783e3fe53a04f41a6f2e692681541c0d165
+  metadata.gz: 04e1b3b946f8f2897ff8bc2be1fedc2b709bcfd7
+  data.tar.gz: 44fd71741007bc871a55801efd256d7239853d7b
 SHA512:
-  metadata.gz: 8a1920286ea77abfb2e3dfe19b0b9db3f6448067cf37312e0f06f9f409c212890343d6c84b7ebe87cbe82f23c2d7964e24f2a3dfdd4170b585aa7657e1bfb901
-  data.tar.gz: 4d548d8d1f6768bd4249274befaf4e040625694e666d9b13bb7dcce18daeba97ea31755b4dec2eb6634b749709128d45592cec1130e457619c6e24f4844dbc9e
+  metadata.gz: 026b66fb2b258b32855e9a88efd3039cecc73ccfb6a01d2ef96075bbdeb7f5ea76638c2b9b18e68df4515e23c63543c751cb4724b4562b00941e476ea8fe52e3
+  data.tar.gz: 678ac5e394393c751bf3a2349c39b0342ddebcef5c3cd69523555f81527eb2afb9bb9183ad0d4adc071413cf68a49afc4a9dd1ded3b20eafe54840a4c89dc4af

data/VERSION

@@ -1 +1 @@
-0.6.0
+0.7.0

data/lib/rails-dsl/routes_ext.rb

@@ -5,105 +5,83 @@ module Rails
       module Helpers
         class << self
 
-          def array_to_url_params array,method_name
-
-            return "" unless array.class <= ::Array
-
-            var=nil
-            array.each do |ary|
+          def process_opts opts={}
 
-              if ary[0].to_s == method_name.to_s
-                var = ary[1]
-                break
-              end
-
-            end
-
-            if !var.nil?
-              return "/:#{var.join('/:')}"
-            else
-              return ""
-            end
-
-          end
-
-          def process_args *args
-
-            opts= args.select{|e|(e.class <= ::Hash)}.reduce( {}, :merge! )
+            opts = {class: opts} unless opts.class <= ::Hash
 
             # search for alt keys
             {
 
-                urls:     [:p,:paths,:url,:u],
-                scope:    [:s],
-                resource: [:r,:class],
-                defaults: [:d,:default],
-                params:   [:url_params],
-                ne:       [:exception,:exceptions,:ex],
+                urls:     [:url,:path,{}],
+                defaults: [:default,{}],
+                ne:       [:exception,:exceptions,:ex,[]],
 
                 get:      [:read],
                 post:     [:create],
                 put:      [:update],
-                delete:   [:delete]
+                delete:   [:delete],
+
+                class:    [:klass,:resource,:resources,:controller]
 
             }.each do |opts_sym,aliases|
               aliases.each do |alias_sym|
-                opts[opts_sym] ||= opts.delete(alias_sym) || opts.delete(alias_sym.to_s)
+                opts[opts_sym] ||= alias_sym.class == ::Symbol ? opts.delete(alias_sym) || opts.delete(alias_sym.to_s) : alias_sym
+              end
+              if aliases.last.class != ::Symbol
+                raise(ArgumentError,"Invalid object given for #{opts_sym}, should be: #{aliases.last.class}") unless opts[opts_sym].class <= aliases.last.class
               end
             end
 
             # set defaults
-            opts[:defaults] ||= {}
-            opts[:resource] ||= args.select{|e|([::Class,::String,::Symbol].include?(e.class))}[0]
-
-            opts[:params]   ||= args.select{|e|(e.class <= ::Array)}
-            opts[:params]   ||= []
-
-            opts[:urls]     ||= {}
-            opts[:ne]       ||= []
-
             opts[:ne].map!{|method_name_to_sym| method_name_to_sym.to_s.to_sym }
-
             [:get,:post,:put,:delete,:options].each{|sym| opts[sym] ||= [] ; opts[sym]= [opts[sym]]  unless opts[sym].class <= ::Array }
 
-            unless opts[:params].class <= ::Array
-              raise(ArgumentError,"invalid argument for url params: #{opts[:params]}.\nmust be something like [:method_name,[:url_params]] || [:method_name,:url_params]")
-            end
+            opts[:short_class_name]= opts[:class].to_s.underscore.split('_')[0]
+            opts[:class] = if  opts[:class].class == Class
+                             opts[:class]
 
-            unless opts[:urls].class <= ::Hash
-              raise(ArgumentError,"invalid argument for urls group: #{opts[:urls]}.\nmust be something like {method_name: '/path'}")
-            end
+                           else
 
-            unless opts[:params].empty?
+                             if opts[:class].to_s.include?('_controller')
+                               opts[:class].to_s.classify.constantize
 
-              opts[:params].each{|ary| raise unless ary.size == 2 }
-              opts[:params].each{|ary| ary[1]= [ary[1]] unless ary[1].class <= ::Array }
+                             elsif opts[:class].to_s.include?('Controller')
+                               opts[:class].to_s.constantize
 
-            end
+                             else
+                               begin
+                                 opts[:class].to_s.concat('_controller').classify.constantize
+                               rescue NameError
+                                 if opts[:class].to_s == opts[:class].to_s.downcase
+                                   opts[:class].to_s.classify.constantize
+
+                                 else
+                                   opts[:class].to_s.constantize
+
+                                 end
+                               end
 
-            # validations
-            raise(ArgumentError,"Invalid defaults given") unless opts[:defaults].class <= ::Hash
+                             end
+                           end
 
-            opts[:short_class_name]= opts[:resource].to_s.underscore.split('_')[0]
-            opts[:class] = ( opts[:resource].class == Class ? opts[:resource] : opts[:resource].to_s.concat('_controller').classify.constantize )
-            opts[:pim] = opts[:class].public_instance_methods(false).select{|e|(e.to_s.last != '?')} - opts[:ne]
+            opts[:pim] = opts[:class].public_instance_methods(false).select{|e| !(%W[ ? ! _ ].include?(e.to_s.last)) } - opts[:ne]
 
             # make setup able method configs
             opts[:pim].each do |sym|
 
               sym_str= sym.to_s
               {
-                  get:    /_get$/,
-                  post:   /_post$/,
-                  put:    /_put$/,
-                  delete: /_delete$/
-              }.each do |type,regex|
-
-                if sym_str =~ regex
-                  opts[type].push(sym)
-                  opts[:urls][sym] ||= "/#{sym_str.gsub(regex,"")}"
+                  get:    [/_get$/,/^get_/],
+                  post:   [/_post$/,/^post_/],
+                  put:    [/_put$/,/^put_/],
+                  delete: [/_delete$/,/^delete_/]
+              }.each do |type,regular_expressions|
+                regular_expressions.each do |regex|
+                  if sym_str =~ regex
+                    opts[type].push(sym)
+                    opts[:urls][sym] ||= "/#{sym_str.gsub(regex,"")}"
+                  end
                 end
-
               end
 
             end
@@ -112,50 +90,69 @@ module Rails
 
           end
 
-        end
-      end
-
-      def mount_controller *args
+          def array_to_url_params array,method_name
 
-        opts= nil
-        if args.size == 1 && args[0].class <= ::Hash
-          opts= args[0]
-        else
-          opts= Rails::DSL::ActionDispatchRouteEXT::Helpers.process_args(*args)
-        end
+            return "" unless array.class <= ::Array
 
-        # helper lambdas
+            var=nil
+            array.each do |ary|
 
-        create_mapping= lambda do
+              if ary[0].to_s == method_name.to_s
+                var = ary[1]
+                break
+              end
 
-          opts[:pim].each do |method_name|
+            end
 
-            method_to_use= nil
-            [:get,:post,:put,:delete,:options].each do |pre_spec_method_call_type|
-              if opts[pre_spec_method_call_type].include?(method_name)
-                method_to_use ||= pre_spec_method_call_type
-              end
+            if !var.nil?
+              return "/:#{var.join('/:')}"
+            else
+              return ""
             end
 
-            method_to_use ||= :match
+          end
 
-            url_path = opts[:urls][method_name].nil? ? "/#{method_name}" : opts[:urls][method_name].to_s
+        end
+      end
 
-            self.__send__ method_to_use,
-                          "#{url_path}#{Rails::DSL::ActionDispatchRouteEXT::Helpers.array_to_url_params(opts[:params],method_name)}",
-                          {to: "#{opts[:short_class_name]}##{method_name}", defaults: opts[:defaults].dup }
-
-          end
+      def mount_by(opts={})
+        opts = Helpers.process_opts(opts)
 
+        if opts[:class]
+          mount_controller opts
         end
 
-        # make scope
-        if !opts[:scope].nil? && opts[:scope].class <= String
-          self.scope opts[:scope] do
-            create_mapping.call
+      end
+
+      def mount_controller(opts={})
+
+        opts[:pim].each do |method_name|
+
+          # #> override methods if instance method variable detected, and will passed as input from params
+          # begin
+          #   var= opts[:class].constantize.instance_method(method_name)
+          #   unless var.parameters.select{|ary|(ary[0] ==:req)}.empty?
+          #     define_method(method_name) do
+          #       var.bind(self).call(*var.parameters.select{|ary|(ary[0] == :req)}.map{|ary| ary[1] }.map{ |param_key| params[param_key] })
+          #     end
+          #   end
+          # end
+
+          #> build path by method name
+          method_to_use= nil
+          [:get,:post,:put,:delete,:options].each do |pre_spec_method_call_type|
+            if opts[pre_spec_method_call_type].include?(method_name)
+              method_to_use ||= pre_spec_method_call_type
+            end
           end
-        else
-          create_mapping.call
+          method_to_use ||= :match
+
+          url_path = opts[:urls][method_name].nil? ? "/#{method_name}" : opts[:urls][method_name].to_s
+
+          self.__send__ method_to_use,
+                        "#{url_path}#{Helpers.array_to_url_params(opts[:params],method_name)}",
+                        {to: "#{opts[:short_class_name]}##{method_name}", defaults: opts[:defaults].dup }
+
         end
 
         return nil
@@ -172,25 +169,7 @@ module Rails
 
           opts[:pim].each do |sym|
 
-            var= self.instance_method(sym)
-            parameters= []
-
-            unless var.parameters.select{|ary|(ary[0] ==:req)}.empty?
-              parameters += var.parameters.select{|ary|(ary[0] ==:req)}.map{|ary| ary[1] }
-              conv_params.push [ sym, parameters ]
-            end
-
-            define_method(sym) do
-
-              value= var.bind(self).call(*parameters.map{ |param_key| params[param_key] })
 
-              respond_to do |format|
-                format.html
-                format.json { render json:  value }
-                format.xml  { render xml:   value }
-              end
-
-            end
 
           end
 
@@ -204,19 +183,7 @@ module Rails
       end
       alias mount_rendered_controller mount_controller_with_render
 
-      def get_controller_names *path
-        path += ['app','controllers','*_controller.{ru,rb}'] if path.empty?
-        return Dir.glob(::Rails.root.join(*path)).map{|p| p.split(File::Separator).last.split('_controller')[0].to_sym }
-      end
-
-      def mount_controllers
-        get_controller_names.each { |cn| mount_controller(cn) }
-      end
 
-      def mount_controllers_with_render
-        get_controller_names.each{ |cn| mount_controller_with_render(cn) }
-      end
-      alias mount_rendered_controllers mount_controllers_with_render
 
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-dsl
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-07 00:00:00.000000000 Z
+date: 2014-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler