simple_controller 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20f1e8a4f6f58fa76e1ee3679e43aae283a7fd4e
-  data.tar.gz: 43d4c9d22826ae45ad8b8dac49e7a3b8b4de47c6
+  metadata.gz: 022feec11ef15f421596afc8ab71a0f69dd271ed
+  data.tar.gz: e048c155d5ad1b659a0a5dd45eada31a64f46916
 SHA512:
-  metadata.gz: a11908aca45ebbfa600a58167c38b1cbbc6d84983bee759f3c0120fcbac25c716e2ce8450d2553edb69321389be53b871802d842148c4e077ec87a7dffd516a6
-  data.tar.gz: 0af55254de294c9d72731feedb60f05f455982e14839f7943b5a794fe7dd4b607b5c5c39c741dc08a7efd4d10c49fefc6493fcce1ed1d6a55d3d4f5c39c944de
+  metadata.gz: 52542cc33f334c554d80e15dbb635993c2562e77b3ea3d7536ddd8ec2be80c28105e5cabd0e9d5774717965cdd78c1d7a4e20168e07d1518d847454336cdbf55
+  data.tar.gz: eb967704ba637c82038b0ce0611fe8eecdf07d50320dead670c0123f9c7b4f53f4da0a3b10b71617e4d834350b5cf84207f11facffbf19b31a4a859ffac9acc9

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/.idea/*

data/README.md

@@ -39,4 +39,41 @@ UserController.new.call(:touch, user_id: 1) # => same as above
 It works like a Rails Controller, but has only has the following features:
 - Callbacks
 - `params`
-- `action_name`
+- `action_name`
+
+## Router
+A router is provided to decouple controller classes from identifiers.
+
+```ruby
+class Router < SimpleController::Router
+end
+
+# Router.instance is a singleton for ease of use
+Router.instance.draw do
+  match "threes/multiply"
+  match "threes/dividing" => "threes#divide"
+
+  controller :threes do
+    match :add
+    match subtracting: "subtract"
+  end
+  # custom syntax
+  controller :threes, actions: %i[power]
+  
+  namespace :some_namespace do
+    match :magic
+  end
+  
+  # no other Rails-like syntax is available
+end
+
+Router.call("threes/multiply", number: 6) # calls ThreesController.call(:multiply, number: 6)
+Router.instance.call("threes/multiply", number: 6) # same as above
+```
+
+To custom namespace the controller:
+```ruby
+Router.instance.parse_controller_name {|controller_name| "#{controller_name}_suffix_controller".classify.constantize }
+
+Router.call("threes/multiply", number: 6) # calls ThreesSuffixController.call(:multiply, number: 6)
+```

data/lib/simple_controller/base/callbacks.rb

@@ -0,0 +1,190 @@
+# based on: https://github.com/rails/rails/blob/d2876141d08341ec67cf6a11a073d1acfb920de7/actionpack/lib/abstract_controller/callbacks.rb
+module SimpleController
+  class Base
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      # Uses ActiveSupport::Callbacks as the base functionality. For
+      # more details on the whole callback system, read the documentation
+      # for ActiveSupport::Callbacks.
+      include ActiveSupport::Callbacks
+
+      included do
+        define_callbacks :call_action
+      end
+
+      # Override SimpleController::Base's call to run the
+      # call callbacks around the normal behavior.
+      def call_action(*args)
+        run_callbacks(:call_action) do
+          super
+        end
+      end
+
+      module ClassMethods
+        # If +:only+ or +:except+ are used, convert the options into the
+        # +:if+ and +:unless+ options of ActiveSupport::Callbacks.
+        #
+        # The basic idea is that <tt>:only => :index</tt> gets converted to
+        # <tt>:if => proc {|c| c.action_name == "index" }</tt>.
+        #
+        # Note that <tt>:only</tt> has priority over <tt>:if</tt> in case they
+        # are used together.
+        #
+        #   only: :index, if: -> { true } # the :if option will be ignored.
+        #
+        # Note that <tt>:if</tt> has priority over <tt>:except</tt> in case they
+        # are used together.
+        #
+        #   except: :index, if: -> { true } # the :except option will be ignored.
+        #
+        # ==== Options
+        # * <tt>only</tt>   - The callback should be run only for this action
+        # * <tt>except</tt>  - The callback should be run for all actions except this action
+        def _normalize_callback_options(options)
+          _normalize_callback_option(options, :only, :if)
+          _normalize_callback_option(options, :except, :unless)
+        end
+
+        def _normalize_callback_option(options, from, to) # :nodoc:
+          if from = options[from]
+            from = Array(from).map {|o| "action_name == '#{o}'"}.join(" || ")
+            options[to] = Array(options[to]).unshift(from)
+          end
+        end
+
+        # Take callback names and an optional callback proc, normalize them,
+        # then call the block with each callback. This allows us to abstract
+        # the normalization across several methods that use it.
+        #
+        # ==== Parameters
+        # * <tt>callbacks</tt> - An array of callbacks, with an optional
+        #   options hash as the last parameter.
+        # * <tt>block</tt>    - A proc that should be added to the callbacks.
+        #
+        # ==== Block Parameters
+        # * <tt>name</tt>     - The callback to be added
+        # * <tt>options</tt>  - A hash of options to be used when adding the callback
+        def _insert_callbacks(callbacks, block = nil)
+          options = callbacks.extract_options!
+          _normalize_callback_options(options)
+          callbacks.push(block) if block
+          callbacks.each do |callback|
+            yield callback, options
+          end
+        end
+
+        ##
+        # :method: before_action
+        #
+        # :call-seq: before_action(names, block)
+        #
+        # Append a callback before actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: prepend_before_action
+        #
+        # :call-seq: prepend_before_action(names, block)
+        #
+        # Prepend a callback before actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: skip_before_action
+        #
+        # :call-seq: skip_before_action(names)
+        #
+        # Skip a callback before actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: append_before_action
+        #
+        # :call-seq: append_before_action(names, block)
+        #
+        # Append a callback before actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: after_action
+        #
+        # :call-seq: after_action(names, block)
+        #
+        # Append a callback after actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: prepend_after_action
+        #
+        # :call-seq: prepend_after_action(names, block)
+        #
+        # Prepend a callback after actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: skip_after_action
+        #
+        # :call-seq: skip_after_action(names)
+        #
+        # Skip a callback after actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: append_after_action
+        #
+        # :call-seq: append_after_action(names, block)
+        #
+        # Append a callback after actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: around_action
+        #
+        # :call-seq: around_action(names, block)
+        #
+        # Append a callback around actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: prepend_around_action
+        #
+        # :call-seq: prepend_around_action(names, block)
+        #
+        # Prepend a callback around actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: skip_around_action
+        #
+        # :call-seq: skip_around_action(names)
+        #
+        # Skip a callback around actions. See _insert_callbacks for parameter details.
+
+        ##
+        # :method: append_around_action
+        #
+        # :call-seq: append_around_action(names, block)
+        #
+        # Append a callback around actions. See _insert_callbacks for parameter details.
+
+        # set up before_action, prepend_before_action, skip_before_action, etc.
+        # for each of before, after, and around.
+        [:before, :after, :around].each do |callback|
+          define_method "#{callback}_action" do |*names, &blk|
+            _insert_callbacks(names, blk) do |name, options|
+              set_callback(:call_action, callback, name, options)
+            end
+          end
+
+          define_method "prepend_#{callback}_action" do |*names, &blk|
+            _insert_callbacks(names, blk) do |name, options|
+              set_callback(:call_action, callback, name, options.merge(:prepend => true))
+            end
+          end
+
+          # Skip a before, after or around callback. See _insert_callbacks
+          # for details on the allowed parameters.
+          define_method "skip_#{callback}_action" do |*names|
+            _insert_callbacks(names) do |name, options|
+              skip_callback(:call_action, callback, name, options)
+            end
+          end
+
+          # *_action is the same as append_*_action
+          alias_method :"append_#{callback}_action", :"#{callback}_action"
+        end
+      end
+    end
+  end
+end

data/lib/simple_controller/base/core.rb

@@ -0,0 +1,30 @@
+module SimpleController
+  class Base
+    module Core
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :params, :action_name
+      end
+
+      def call(action_name, params={})
+        @params ||= ActiveSupport::HashWithIndifferentAccess.new(params)
+        @action_name ||= action_name.to_s
+
+        call_action
+      end
+
+      protected
+
+      def call_action
+        public_send action_name
+      end
+
+      module ClassMethods
+        def call(*args)
+          new.call *args
+        end
+      end
+    end
+  end
+end

data/lib/simple_controller/base.rb

@@ -1,5 +1,5 @@
-require 'simple_controller/core'
-require 'simple_controller/callbacks'
+require 'simple_controller/base/core'
+require 'simple_controller/base/callbacks'
 
 module SimpleController
   class Base

data/lib/simple_controller/router/mapper.rb

@@ -0,0 +1,68 @@
+require 'simple_controller/router/route'
+
+module SimpleController
+  class Router
+    class Mapper
+      attr_reader :router, :namespaces, :controller_name
+
+      def initialize(router, namespaces=[], controller_name=nil)
+        @router, @namespaces, @controller_name = router, namespaces, controller_name
+      end
+
+      def namespace(namespace, &block)
+        @namespaces << namespace
+
+        mapper = self.class.new(router, namespaces, controller_name)
+        mapper.instance_eval(&block)
+      ensure
+        @namespaces.pop
+      end
+
+      def controller(controller_name, options={}, &block)
+        raise "can't have multiple controller scopes" if self.controller_name
+
+        mapper = self.class.new(router, namespaces, controller_name)
+        Array(options[:actions]).each { |action| mapper.match(action) }
+
+        mapper.instance_eval(&block) if block_given?
+      end
+
+      def match(arg)
+        route_path, partition = parse_match_arg(arg)
+
+        route_parts = [route_path]
+        route_parts.unshift(self.controller_name) if self.controller_name
+        route_parts.unshift(*namespaces)
+
+        controller_name_parts = [self.controller_name || partition.first]
+        controller_name_parts.unshift(*namespaces)
+
+        action_name = partition.last
+
+        router.add_route join_parts(route_parts), Route.new(join_parts(controller_name_parts), action_name)
+      end
+
+      protected
+      def join_parts(parts)
+        parts.map do |part|
+          s = part.to_s.dup
+          s.chomp!("/")
+          s.slice!(0) if part[0] == "/"
+          s
+        end.join("/")
+      end
+
+      def parse_match_arg(arg)
+        if arg.class == Hash
+          raise "takes only one option" unless arg.size == 1
+          route_path = arg.keys.first.to_s
+          partition = arg.values.first.to_s.rpartition("#")
+        else
+          route_path = arg.to_s
+          partition = route_path.rpartition("/")
+        end
+        [route_path, partition]
+      end
+    end
+  end
+end

data/lib/simple_controller/router/route.rb

@@ -0,0 +1,20 @@
+module SimpleController
+  class Router
+    class Route
+      attr_reader :controller_name, :action_name
+      attr_accessor :controller_name_block
+
+      def initialize(controller_name, action_name)
+        @controller_name, @action_name = controller_name, action_name
+      end
+
+      def controller(controller_name_block=nil)
+        controller_name_block ? controller_name_block.call(controller_name) : "#{controller_name}_controller".classify.constantize
+      end
+
+      def call(params, controller_name_block=nil)
+        controller(controller_name_block).call action_name, params
+      end
+    end
+  end
+end

data/lib/simple_controller/router.rb

@@ -0,0 +1,55 @@
+require 'simple_controller/router/mapper'
+
+module SimpleController
+  class Router
+    attr_reader :route_mapping, :route, :route_path, :controller_name_block
+
+    include ActiveSupport::Callbacks
+    define_callbacks :call
+
+    def initialize
+      @route_mapping = {}
+    end
+
+    def call(route_path, params={})
+      @route_path = route_path.to_s
+      @route = @route_mapping[@route_path]
+
+      raise "#{self.class} route for '#{@route_path}' not found" unless route
+
+      run_callbacks(:call) do
+        @route.call params, controller_name_block
+      end
+    ensure
+      @route_path = nil
+      @route = nil
+    end
+
+    def route_paths
+      route_mapping.keys
+    end
+
+    def draw(&block)
+      mapper = Mapper.new(self)
+      mapper.instance_eval(&block)
+    end
+
+    def add_route(route_path, route)
+      @route_mapping[route_path] = route
+    end
+
+    def parse_controller_name(&block)
+      @controller_name_block = block
+    end
+
+    class << self
+      def instance
+        @instance ||= new
+      end
+
+      def call(*args)
+        instance.call(*args)
+      end
+    end
+  end
+end

data/lib/simple_controller/version.rb

@@ -1,3 +1,3 @@
 module SimpleController
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/simple_controller.rb

@@ -5,11 +5,13 @@ require "simple_controller/version"
 
 require 'active_support/callbacks'
 require 'active_support/hash_with_indifferent_access'
+require 'active_support/inflector'
 
 if autoload && defined?(Rails)
   require 'simple_controller/engine'
 else
   require 'simple_controller/base'
+  require 'simple_controller/router'
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_controller
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Steve Chung
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-07 00:00:00.000000000 Z
+date: 2015-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -42,9 +42,12 @@ files:
 - bin/setup
 - lib/simple_controller.rb
 - lib/simple_controller/base.rb
-- lib/simple_controller/callbacks.rb
-- lib/simple_controller/core.rb
+- lib/simple_controller/base/callbacks.rb
+- lib/simple_controller/base/core.rb
 - lib/simple_controller/engine.rb
+- lib/simple_controller/router.rb
+- lib/simple_controller/router/mapper.rb
+- lib/simple_controller/router/route.rb
 - lib/simple_controller/version.rb
 - simple_controller.gemspec
 homepage: https://github.com/FinalCAD/simple_controller

data/lib/simple_controller/callbacks.rb

@@ -1,188 +0,0 @@
-# based on: https://github.com/rails/rails/blob/d2876141d08341ec67cf6a11a073d1acfb920de7/actionpack/lib/abstract_controller/callbacks.rb
-module SimpleController
-  module Callbacks
-    extend ActiveSupport::Concern
-
-    # Uses ActiveSupport::Callbacks as the base functionality. For
-    # more details on the whole callback system, read the documentation
-    # for ActiveSupport::Callbacks.
-    include ActiveSupport::Callbacks
-
-    included do
-      define_callbacks :call_action
-    end
-
-    # Override SimpleController::Base's call to run the
-    # call callbacks around the normal behavior.
-    def call_action(*args)
-      run_callbacks(:call_action) do
-        super
-      end
-    end
-
-    module ClassMethods
-      # If +:only+ or +:except+ are used, convert the options into the
-      # +:if+ and +:unless+ options of ActiveSupport::Callbacks.
-      #
-      # The basic idea is that <tt>:only => :index</tt> gets converted to
-      # <tt>:if => proc {|c| c.action_name == "index" }</tt>.
-      #
-      # Note that <tt>:only</tt> has priority over <tt>:if</tt> in case they
-      # are used together.
-      #
-      #   only: :index, if: -> { true } # the :if option will be ignored.
-      #
-      # Note that <tt>:if</tt> has priority over <tt>:except</tt> in case they
-      # are used together.
-      #
-      #   except: :index, if: -> { true } # the :except option will be ignored.
-      #
-      # ==== Options
-      # * <tt>only</tt>   - The callback should be run only for this action
-      # * <tt>except</tt>  - The callback should be run for all actions except this action
-      def _normalize_callback_options(options)
-        _normalize_callback_option(options, :only, :if)
-        _normalize_callback_option(options, :except, :unless)
-      end
-
-      def _normalize_callback_option(options, from, to) # :nodoc:
-        if from = options[from]
-          from = Array(from).map {|o| "action_name == '#{o}'"}.join(" || ")
-          options[to] = Array(options[to]).unshift(from)
-        end
-      end
-
-      # Take callback names and an optional callback proc, normalize them,
-      # then call the block with each callback. This allows us to abstract
-      # the normalization across several methods that use it.
-      #
-      # ==== Parameters
-      # * <tt>callbacks</tt> - An array of callbacks, with an optional
-      #   options hash as the last parameter.
-      # * <tt>block</tt>    - A proc that should be added to the callbacks.
-      #
-      # ==== Block Parameters
-      # * <tt>name</tt>     - The callback to be added
-      # * <tt>options</tt>  - A hash of options to be used when adding the callback
-      def _insert_callbacks(callbacks, block = nil)
-        options = callbacks.extract_options!
-        _normalize_callback_options(options)
-        callbacks.push(block) if block
-        callbacks.each do |callback|
-          yield callback, options
-        end
-      end
-
-      ##
-      # :method: before_action
-      #
-      # :call-seq: before_action(names, block)
-      #
-      # Append a callback before actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_before_action
-      #
-      # :call-seq: prepend_before_action(names, block)
-      #
-      # Prepend a callback before actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_before_action
-      #
-      # :call-seq: skip_before_action(names)
-      #
-      # Skip a callback before actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_before_action
-      #
-      # :call-seq: append_before_action(names, block)
-      #
-      # Append a callback before actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: after_action
-      #
-      # :call-seq: after_action(names, block)
-      #
-      # Append a callback after actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_after_action
-      #
-      # :call-seq: prepend_after_action(names, block)
-      #
-      # Prepend a callback after actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_after_action
-      #
-      # :call-seq: skip_after_action(names)
-      #
-      # Skip a callback after actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_after_action
-      #
-      # :call-seq: append_after_action(names, block)
-      #
-      # Append a callback after actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: around_action
-      #
-      # :call-seq: around_action(names, block)
-      #
-      # Append a callback around actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: prepend_around_action
-      #
-      # :call-seq: prepend_around_action(names, block)
-      #
-      # Prepend a callback around actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: skip_around_action
-      #
-      # :call-seq: skip_around_action(names)
-      #
-      # Skip a callback around actions. See _insert_callbacks for parameter details.
-
-      ##
-      # :method: append_around_action
-      #
-      # :call-seq: append_around_action(names, block)
-      #
-      # Append a callback around actions. See _insert_callbacks for parameter details.
-
-      # set up before_action, prepend_before_action, skip_before_action, etc.
-      # for each of before, after, and around.
-      [:before, :after, :around].each do |callback|
-        define_method "#{callback}_action" do |*names, &blk|
-          _insert_callbacks(names, blk) do |name, options|
-            set_callback(:call_action, callback, name, options)
-          end
-        end
-
-        define_method "prepend_#{callback}_action" do |*names, &blk|
-          _insert_callbacks(names, blk) do |name, options|
-            set_callback(:call_action, callback, name, options.merge(:prepend => true))
-          end
-        end
-
-        # Skip a before, after or around callback. See _insert_callbacks
-        # for details on the allowed parameters.
-        define_method "skip_#{callback}_action" do |*names|
-          _insert_callbacks(names) do |name, options|
-            skip_callback(:call_action, callback, name, options)
-          end
-        end
-
-        # *_action is the same as append_*_action
-        alias_method :"append_#{callback}_action", :"#{callback}_action"
-      end
-    end
-  end
-end

data/lib/simple_controller/core.rb

@@ -1,28 +0,0 @@
-module SimpleController
-  module Core
-    extend ActiveSupport::Concern
-
-    included do
-      attr_reader :params, :action_name
-    end
-
-    def call(action_name, params={})
-      @params ||= ActiveSupport::HashWithIndifferentAccess.new(params)
-      @action_name ||= action_name.to_s
-
-      call_action
-    end
-
-    protected
-
-    def call_action
-      public_send action_name
-    end
-
-    module ClassMethods
-      def call(*args)
-        new.call *args
-      end
-    end
-  end
-end