simple_controller 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 022feec11ef15f421596afc8ab71a0f69dd271ed
-  data.tar.gz: e048c155d5ad1b659a0a5dd45eada31a64f46916
+  metadata.gz: 524340d2ca7c377417e63196f002bf3d6c26e2ed
+  data.tar.gz: 9d7cefb26e4bd4821643eff5979143d5d113820e
 SHA512:
-  metadata.gz: 52542cc33f334c554d80e15dbb635993c2562e77b3ea3d7536ddd8ec2be80c28105e5cabd0e9d5774717965cdd78c1d7a4e20168e07d1518d847454336cdbf55
-  data.tar.gz: eb967704ba637c82038b0ce0611fe8eecdf07d50320dead670c0123f9c7b4f53f4da0a3b10b71617e4d834350b5cf84207f11facffbf19b31a4a859ffac9acc9
+  metadata.gz: 6ed3f6ed15a1a6567923ffd324fc15e4b550cba0a23be0455a8a26ad066f65e4396ff42f0eda1183d88068b0664b743ab987ff755eadf0db8db2644eaab60a23
+  data.tar.gz: 05e9b2d919c96ca1355fc364c7bcdd3b91dfd85920df263432f7d693070efc01b110e08e7c6cb7dc7945dc16cacdae01664f0690570ffd9d5ebfa2eb34078001

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# SimpleController Breaking Changes
+## 1.0.0
+- rename `controller_name` to `controller_path` to match Rails convention

data/README.md

@@ -42,11 +42,10 @@ It works like a Rails Controller, but has only has the following features:
 - `action_name`
 
 ## Router
-A router is provided to decouple controller classes from identifiers.
+An **optional** router is provided to decouple controller classes from identifiers.
 
 ```ruby
-class Router < SimpleController::Router
-end
+class Router < SimpleController::Router; end
 
 # Router.instance is a singleton for ease of use
 Router.instance.draw do
@@ -71,9 +70,68 @@ Router.call("threes/multiply", number: 6) # calls ThreesController.call(:multipl
 Router.instance.call("threes/multiply", number: 6) # same as above
 ```
 
-To custom namespace the controller:
+To customize the controller class:
 ```ruby
-Router.instance.parse_controller_name {|controller_name| "#{controller_name}_suffix_controller".classify.constantize }
-
+Router.instance.parse_controller_path do |controller_path|
+  # similar to default implementation
+  "#{controller_name}_suffix_controller".classify.constantize
+end
 Router.call("threes/multiply", number: 6) # calls ThreesSuffixController.call(:multiply, number: 6)
+```
+
+Routers add the following Rails features to the Controllers:
+- `params[:action]` and `params[:controller]`
+- `controller_path` and `controller_name`
+
+## Post-Process
+Inspired by [`rails/sprockets` Processors](https://github.com/rails/sprockets#using-processors), Routes can have processor suffixes to ensure that controller endpoints
+are [composable](https://en.wikipedia.org/wiki/Function_composition_(computer_science)). For example, given:
+
+```ruby
+class FoldersController < FileSystemController
+  def two_readmes
+    dir = create_new_directory
+    dir.add_files Router.call('files/readme'), Router.call('files/readme')
+    dir.path
+  end
+end
+
+class FilesController < FileSystemController
+  def readme
+    write_new_file_and_return_path
+  end
+end
+```
+
+And the [Router](#router) is set up, `FoldersController#two_readmes` generates a directory of `FilesController#readme`s. Processors add the ability to do these calls:
+
+```ruby
+# calls the `s3_key` processor
+Router.call('files/readme.s3_key')
+# equivalent to:
+FilesController.call(:readme, {}, { processors: [:s3_key] }) 
+
+# calls the `zip` processor then the `s3_key` processor
+Router.call('folders/two_readmes.s3_key.zip')
+# equivalent to (NOTE the reverse order to the processor suffixes):
+FoldersController.call(:two_readmes, {}, { processors: [:zip, :s3_key] })
+```
+
+The processors (`zip` and `s3_key`) can be defined and implemented in a common Parent controller, in this case:
+```ruby
+class FileSystemController < SimpleController::Base
+  # output => "path_to_file_or_directory"
+  # processors => some combination of [:zip, :s3_key]
+  def post_process(output, processors)
+    processors.each do |processor|
+      case processor
+      when :zip
+        output = zip_directory_and_return_path_of_zip(output)
+      when :s3_key
+        output = upload_file_path_to_amazon_s3_and_return_the_s3_key(output)
+      end
+    end
+    output
+  end
+end
 ```

data/lib/simple_controller/base.rb

@@ -1,9 +1,11 @@
 require 'simple_controller/base/core'
+require 'simple_controller/base/context'
 require 'simple_controller/base/callbacks'
 
 module SimpleController
   class Base
     include Core
     include Callbacks # included last to wrap method
+    include Context
   end
 end

data/lib/simple_controller/base/context.rb

@@ -0,0 +1,27 @@
+module SimpleController
+  class Base
+    module Context
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :context
+      end
+
+      def call(action_name, params={}, context={})
+        @context ||= OpenStruct.new context
+
+        super(action_name, params)
+      end
+
+      def call_action(*args)
+        post_process super, context.processors || []
+      end
+
+      protected
+
+      def post_process(output, processors)
+        output
+      end
+    end
+  end
+end

data/lib/simple_controller/base/core.rb

@@ -4,12 +4,14 @@ module SimpleController
       extend ActiveSupport::Concern
 
       included do
-        attr_reader :params, :action_name
+        attr_reader :params, :action_name, :controller_path, :controller_name
       end
 
       def call(action_name, params={})
         @params ||= ActiveSupport::HashWithIndifferentAccess.new(params)
         @action_name ||= action_name.to_s
+        @controller_path ||= params[:controller]
+        @controller_name ||= controller_path.split("/").last if controller_path
 
         call_action
       end

data/lib/simple_controller/router.rb

@@ -1,55 +1,9 @@
-require 'simple_controller/router/mapper'
+require 'simple_controller/router/core'
+require 'simple_controller/router/context'
 
 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
+    include Core
+    include Context
   end
 end

data/lib/simple_controller/router/context.rb

@@ -0,0 +1,38 @@
+module SimpleController
+  class Router
+    module Context
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :context
+      end
+
+      def call(route_path, params={})
+        route_path = parse_route_path(route_path.to_s)
+
+        super(route_path, params)
+      ensure
+        @context = nil
+      end
+
+      protected
+
+      def _call(route)
+        route.call params, context, controller_path_block
+      end
+
+      def parse_route_path(route_path)
+        processors = []
+
+        until (extension = File.extname(route_path)).empty?
+          route_path = route_path.chomp(extension)
+          processors << extension[1..-1].to_sym
+        end
+
+        @context = { processors: processors }
+
+        route_path
+      end
+    end
+  end
+end

data/lib/simple_controller/router/core.rb

@@ -0,0 +1,61 @@
+require 'simple_controller/router/route'
+require 'simple_controller/router/mapper'
+
+module SimpleController
+  class Router
+    module Core
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :route_mapping, :route_path, :params, :controller_path_block
+      end
+      def initialize
+        @route_mapping = {}
+      end
+
+      def call(route_path, params={})
+        @route_path = route_path.to_s
+        @params = params
+
+        route = @route_mapping[@route_path]
+        raise "#{self.class} route for '#{@route_path}' not found" unless route
+        _call(route)
+      ensure
+        @route_path = @params = nil
+      end
+
+      def route_paths
+        route_mapping.keys
+      end
+
+      def draw(&block)
+        mapper = Mapper.new(self)
+        mapper.instance_eval(&block)
+        self
+      end
+
+      def add_route(route_path, controller_path, action)
+        @route_mapping[route_path] = Route.new(controller_path, action)
+      end
+
+      def parse_controller_path(&block)
+        @controller_path_block = block
+      end
+
+      protected
+      def _call(route)
+        route.call params, controller_path_block
+      end
+
+      module ClassMethods
+        def instance
+          @instance ||= new
+        end
+
+        def call(*args)
+          instance.call(*args)
+        end
+      end
+    end
+  end
+end

data/lib/simple_controller/router/mapper.rb

@@ -1,45 +1,41 @@
-require 'simple_controller/router/route'
-
 module SimpleController
   class Router
     class Mapper
-      attr_reader :router, :namespaces, :controller_name
+      attr_reader :router, :namespaces, :controller_path
 
-      def initialize(router, namespaces=[], controller_name=nil)
-        @router, @namespaces, @controller_name = router, namespaces, controller_name
+      def initialize(router, namespaces=[], controller_path=nil)
+        @router, @namespaces, @controller_path = router, namespaces, controller_path
       end
 
       def namespace(namespace, &block)
         @namespaces << namespace
 
-        mapper = self.class.new(router, namespaces, controller_name)
+        mapper = self.class.new(router, namespaces, controller_path)
         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
+      def controller(controller_path, options={}, &block)
+        raise "can't have multiple controller scopes" if self.controller_path
 
-        mapper = self.class.new(router, namespaces, controller_name)
+        mapper = self.class.new(router, namespaces, controller_path)
         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_path, controller_name, action_name = parse_match_arg(arg)
 
         route_parts = [route_path]
-        route_parts.unshift(self.controller_name) if self.controller_name
+        route_parts.unshift(self.controller_path) if self.controller_path
         route_parts.unshift(*namespaces)
 
-        controller_name_parts = [self.controller_name || partition.first]
-        controller_name_parts.unshift(*namespaces)
-
-        action_name = partition.last
+        controller_path_parts = [self.controller_path || controller_name]
+        controller_path_parts.unshift(*namespaces)
 
-        router.add_route join_parts(route_parts), Route.new(join_parts(controller_name_parts), action_name)
+        router.add_route join_parts(route_parts), join_parts(controller_path_parts), action_name
       end
 
       protected
@@ -54,14 +50,18 @@ module SimpleController
 
       def parse_match_arg(arg)
         if arg.class == Hash
+          # match "threes/dividing" => "threes#divide"
+          # match subtracting: "subtract"
           raise "takes only one option" unless arg.size == 1
           route_path = arg.keys.first.to_s
-          partition = arg.values.first.to_s.rpartition("#")
+          controller_name, _, action_name = arg.values.first.to_s.rpartition("#")
         else
+          # match :threes
+          # match "threes/multiply"
           route_path = arg.to_s
-          partition = route_path.rpartition("/")
+          controller_name, _, action_name = route_path.rpartition("/")
         end
-        [route_path, partition]
+        [route_path, controller_name, action_name]
       end
     end
   end

data/lib/simple_controller/router/route.rb

@@ -1,19 +1,17 @@
 module SimpleController
   class Router
     class Route
-      attr_reader :controller_name, :action_name
-      attr_accessor :controller_name_block
+      attr_reader :controller_path, :action_name
 
-      def initialize(controller_name, action_name)
-        @controller_name, @action_name = controller_name, action_name
+      def initialize(controller_path, action_name)
+        @controller_path, @action_name = controller_path, 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, context, controller_path_block)
+        controller_class = controller_path_block ? controller_path_block.call(controller_path) : "#{controller_path}_controller".classify.constantize
 
-      def call(params, controller_name_block=nil)
-        controller(controller_name_block).call action_name, params
+        params = { 'controller' => controller_path, 'action' => action_name }.reverse_merge(params)
+        controller_class.call action_name, params, context
       end
     end
   end

data/lib/simple_controller/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_controller
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Steve Chung
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-12-15 00:00:00.000000000 Z
+date: 2016-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -34,6 +34,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -43,9 +44,12 @@ files:
 - lib/simple_controller.rb
 - lib/simple_controller/base.rb
 - lib/simple_controller/base/callbacks.rb
+- lib/simple_controller/base/context.rb
 - lib/simple_controller/base/core.rb
 - lib/simple_controller/engine.rb
 - lib/simple_controller/router.rb
+- lib/simple_controller/router/context.rb
+- lib/simple_controller/router/core.rb
 - lib/simple_controller/router/mapper.rb
 - lib/simple_controller/router/route.rb
 - lib/simple_controller/version.rb
@@ -70,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Rails Controllers, but general purpose.