wanko 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35f8261a71528c603e7515fe97107c697f2f4085
+  data.tar.gz: 336126eb4c5c6fa8a2b476e019dd0f95bdb90f47
+SHA512:
+  metadata.gz: 737133a5a450221b492254ea0aba04b9e56844034e69e9fbb6af34e6733620900295534cec122b43ce71e139aafe5cc1ee4c9e6fcffde3e9e78b0d143f23d5e7
+  data.tar.gz: 2f94733f469498786a683df472458d02cf7cc4d1204ee51577b942e13d0f159c5285a2bdb753c3327b4bf2c034b24b09ef3957236f98f0e324cec8c4e6cfd638

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.sqlite3
+/test/dummy_app/log
+/test/dummy_app/tmp
+/gemfiles/*.lock

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wanko.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Akira Matsuda
+
+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.md

@@ -0,0 +1,221 @@
+# Wanko
+
+Wanko is a prototyping framework for Rails.
+It's something akin to "feature toggle".
+It can be used for "A/B testing" as well.
+But essentially, the main purpose of this framework is to provide a way to rapidly and safely deliver new features to the production environment.
+
+
+## Installation
+
+Bundle into your Rails app.
+
+
+## Features
+
+### Isolated Engine
+
+Wanko helps you mounting Isolated Engines called "extensions" onto the main Rails app.
+An extension can contain whole MVC conponents, which means that you can encapsulate everything that are needed for your new feature under one single directory.
+This helps your team creating multiple new features simultaneously without causing code conflict.
+
+### Conditional Execution
+Each Wanko extension can be configured to be enabled/disabled.
+The condition is not just a flag but can be a Ruby Proc which will be dynamically evaluated on each request in the controller context.
+
+### Error-proof
+
+If any RuntimeError happens inside an extension, Wanko absorbs the error and executes the appropriate fallback code so that the end users would never even notice the occurrence of the error.
+
+### Extending Action Methods in the Main App
+
+Wanko provides an interface to override the main app's controller actions.
+
+### Partially Extending Views in the Main App
+
+Wanko provides a hook to partially overwrite any part of your existing view.
+
+
+## Structure
+
+    main_app
+    ├── Gemfile
+    ├── Gemfile.lock
+    ├── Rakefile
+    ├── app
+    │   ├── assets
+    │   ├── controllers
+    │   ├── extensions
+    │   │   ├── my_awesome_new_feature
+    │   │   │   ├── app
+    │   │   │   │   ├── assets
+    │   │   │   │   ├── controllers
+    │   │   │   │   │   └── my_awesome_new_feature
+    │   │   │   │   │       └── welcome_controller.rb
+    │   │   │   │   ├── helpers
+    │   │   │   │   │   └── my_awesome_new_feature
+    │   │   │   │   │       └── welcome_helper.rb
+    │   │   │   │   ├── mailers
+    │   │   │   │   ├── models
+    │   │   │   │   └── views
+    │   │   │   │       ├── layouts
+    │   │   │   │       │   └── my_awesome_new_feature
+    │   │   │   │       │       └── application.html.erb
+    │   │   │   │       └── my_awesome_new_feature
+    │   │   │   │           └── welcome
+    │   │   │   ├── config
+    │   │   │   │   └── routes.rb
+    │   │   │   ├── lib
+    │   │   │   │   ├── my_awesome_new_feature
+    │   │   │   │   │   └── engine.rb
+    │   │   │   │   ├── my_awesome_new_feature.rb
+    │   │   │   │   └── tasks
+    │   │   │   ├── my_awesome_new_feature.gemspec
+    │   │   │   └── test
+    │   │   └── yet_another_new_feature
+    │   │       ├── app
+    │   │       ...
+    │   ├── helpers
+    │   ├── mailers
+    │   ├── models
+    │   └── views
+    ├── bin
+    ├── config
+    ├── db
+    ...
+
+
+## Components
+
+### lib/EXTENSION\_NAME/engine.rb
+
+Put `active_if` directive inside the Engine class. The whole extension will only be executed if the block is evaluated to be truthy on runtime.
+
+Example:
+
+```ruby
+# app/extensions/my_awesome_new_feature/config/routes.rb
+module MyAwesomeNewFeature
+  class Engine < ::Rails::Engine
+    include Wanko::Engine
+
+    # this whole extension will be executed only when logged in as admin users
+    active_if { current_user.admin? }
+  end
+end
+```
+
+### routes.rb
+
+All routes in extensions' routes.rb will be automatically prepended to the main app's Routes.
+
+
+### Controllers
+
+Controllers can be a normal Engine controller.
+Or, you can craft a controller class inheriting a controller that exists in the main app, and overriding some action methods.
+From inside the actions in extensions, you can call the main app's action via `super`.
+
+Example:
+
+```ruby
+# app/extensions/my_awesome_new_feature/app/controllers/my_awesome_new_feature/welcome_controller.rb
+class MyAwesomeNewFeature::WelcomeController < ::WelcomeController
+  include Wanko::Controller
+
+  def index
+    # invoking the main app's action first
+    super
+
+    # adding some more business logic
+    @notificaations = Notification.for current_user
+  end
+end
+```
+
+
+### Views
+
+When an extension renders the views, it looks up app/views/EXTENSION\_NAME/ directory first, then the main app's view directory next. This way you can overwrite views per template/partial file.
+Also, Wanko adds new `:extension` option to `render` method, which enables you to explicitly inject a piece of HTML from an extension into any place of the app.
+`render :extension` takes an `EXTENSION_NAME/view_path' parameter
+
+```haml
+# app/extensions/my_awesome_new_feature/app/views/my_awesome_new_feature/welcome/_index.html.haml
+.new_feature
+  Some contents for new feature
+
+# app/views/welcome/index.html.haml
+= render extension: 'my_awesome_new_feature/welcome/index' do
+  Some contents that will be shown by default
+```
+
+
+## Generators
+
+Wanko provides some handy code generators.
+
+### Generating an extension
+
+```ruby
+% rails g wanko:extension EXTENSION_NAME
+```
+
+Example:
+
+```ruby
+% rails g wanko:extension my_awesome_new_feature
+```
+
+  This generates an extension Engine in
+  ~/app/extensions/my\_awesome\_new\_feature/ directory.
+
+### Generating a controller extention that extends an existing controller
+
+```ruby
+% rails g wanko:controller EXTENSION_NAME/CONTROLLER_NAME [action action] [options]
+```
+
+Example:
+
+```ruby
+% rails g wanko:controller my_awesome_new_feature/welcome index
+```
+
+  This generates a controller that extends WelcomeController and implements index action inside ~/app/extensions/my\_awesome\_new\_feature/ directory.
+
+### Generating an extension + controller
+
+
+```ruby
+% rails g wanko:extension EXTENSION_NAME CONTROLLER_NAME [action action] [options]
+```
+
+Example:
+
+```ruby
+% rails g wanko:extension my_awesome_new_feature welcome index
+```
+
+  This generates an extension Engine in ~/app/extensions/my\_awesome\_new\_feature/ directory.  Plus, a controller that extends WelcomeController and implements index action inside the Engine.
+
+
+## Contributing
+
+Pull requests are welcome on GitHub at https://github.com/amatsuda/wanko.
+
+
+## Todo
+
+* Better generator
+
+* Better error handling
+
+* Model extension
+
+* Documentation
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wanko"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/gemfiles/Gemfile-rails.4.2.x

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec :path => '../'
+
+gem 'rails', '~> 4.2.4'
+gem 'controller_extension', path: '../test/dummy_app/app/extensions/controller_extension'
+gem 'controller_fallback', path: '../test/dummy_app/app/extensions/controller_fallback'
+gem 'view_render_fallback', path: '../test/dummy_app/app/extensions/view_render_fallback'
+gem 'routes_fallback', path: '../test/dummy_app/app/extensions/routes_fallback'

data/lib/generators/wanko/controller_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators/rails/controller/controller_generator'
+
+module Wanko
+  module Generators
+    class ControllerGenerator < ::Rails::Generators::ControllerGenerator
+      source_root ::Rails::Generators::ControllerGenerator.source_root
+
+      class << self
+        def source_paths
+          [File.expand_path('../templates', __FILE__), *super]
+        end
+      end
+
+      # override
+      def create_controller_files
+        @destination_stack[@destination_stack.size - 1] = File.join @destination_stack.last, 'app/extensions', class_path
+        template 'controller.rb', File.join('app/controllers', class_path, "#{file_name}_controller.rb")
+      end
+
+      # override
+      private
+      def generate_routing_code(action)
+        "get '#{file_name}/#{action}'"
+      end
+    end
+  end
+end

data/lib/generators/wanko/extension_generator.rb

@@ -0,0 +1,64 @@
+require 'rails/generators/rails/plugin/plugin_generator'
+
+module Wanko
+  class ExtensionBuilder < ::Rails::PluginBuilder
+    def readme() end
+    def rakefile() end
+  end
+
+  module Generators
+    class ExtensionGenerator < ::Rails::Generators::PluginGenerator
+      argument :base_controller, type: :string, optional: true, banner: 'base controller'
+      argument :actions, type: :array, default: [], banner: "action action"
+      source_root ::Rails::Generators::PluginGenerator.source_root
+
+      class << self
+        def source_paths
+          [File.expand_path('../templates', __FILE__), *super]
+        end
+      end
+
+      def initialize(*args)
+        options = args.extract_options!
+        options[:destination_root] = 'app/extensions'
+        super(*args, options)
+        options = @options.dup
+        options[:mountable] = options[:skip_bundle] = options[:skip_test_unit] = options[:skip_git] = options[:skip_gemfile] = true
+        @options = options.freeze
+      end
+
+      def get_builder_class
+        Wanko::ExtensionBuilder
+      end
+
+      # override
+      def create_bin_files
+      end
+
+      def put_litter_in_its_place
+        remove_file 'MIT-LICENSE'
+        remove_file "app/controllers/#{name}/application_controller.rb"
+        remove_file "lib/tasks/#{name}_tasks.rake"
+      end
+
+      def untodo_gemspec
+        gemspec = "#{name}.gemspec"
+        gsub_file gemspec, /"TODO.*?"/, '""'
+      end
+
+      def bundle_to_parent
+        gemfile = Rails.root + 'Gemfile'
+        append_to_file gemfile, "gem '#{name}', path: '#{destination_root}'\n" if gemfile.exist?
+      end
+
+      def generate_controller
+        if base_controller
+          Dir.chdir destination_root do
+            #FIXME call the controller generator directly
+            puts `rails g wanko:controller #{name}/#{base_controller} #{actions * ' '}`
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/wanko/templates/controller.rb

@@ -0,0 +1,15 @@
+<% if namespaced? -%>
+require_dependency "<%= namespaced_path %>/application_controller"
+
+<% end -%>
+<% module_namespacing do -%>
+class <%= class_name %>Controller < ::<%= file_name.camelize %>Controller
+  include Wanko::Controller
+
+<% actions.each do |action| -%>
+  def <%= action %>
+  end
+<%= "\n" unless action == actions.last -%>
+<% end -%>
+end
+<% end -%>

data/lib/generators/wanko/templates/lib/%name%/engine.rb

@@ -0,0 +1,9 @@
+require 'wanko/engine'
+
+module <%= camelized %>
+  class Engine < ::Rails::Engine
+    include Wanko::Engine
+
+    active_if { true }
+  end
+end

data/lib/wanko.rb

@@ -0,0 +1,12 @@
+require "wanko/version"
+
+module Wanko
+  class Railtie < ::Rails::Railtie
+    ActiveSupport.on_load :action_controller do
+      require 'wanko/abstract_controller'
+    end
+    ActiveSupport.on_load :action_view do
+      require 'wanko/action_view'
+    end
+  end
+end

data/lib/wanko/abstract_controller.rb

@@ -0,0 +1,65 @@
+module Wanko
+  module Helpers
+    module UrlHelper
+      #FIXME there has to be a better way doing this...
+      def method_missing(meth, *args, &block)
+        if main_app.routes.url_helpers.instance_methods.include? meth
+          main_app.send meth, *args, &block
+        else
+          super
+        end
+      end
+    end
+  end
+
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      helper Wanko::Helpers::UrlHelper
+    end
+  end
+
+  module AbstractController
+    def send_action(method_name, *args)
+      if self.is_a?(Wanko::Controller)
+        begin
+          super
+          @_wanko_action_successfully_finished = true
+        rescue => e
+          #TODO error handling
+          p e
+        end
+      else
+        if env.key? 'wanko_render_result'
+          headers.delete 'X-Cascade'
+          ret = env.delete 'wanko_render_result'
+          self.response_body = ret
+        else
+          super
+        end
+      end
+    end
+  end
+
+  module ActionController
+    def process_action(*args)
+      if self.is_a?(Wanko::Controller)
+        headers['X-Cascade'] = 'pass'
+        if self.class.parent::Engine.active?(self)
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def render_to_body(options = {})
+      return if (headers['X-Cascade'] == 'pass') && !defined?(@_wanko_action_successfully_finished)
+      env['wanko_render_result'] = super
+    end
+  end
+end
+
+AbstractController::Base.prepend Wanko::AbstractController
+ActionController::Base.prepend Wanko::ActionController

data/lib/wanko/action_view.rb

@@ -0,0 +1,47 @@
+module Wanko
+  module ActionView
+    module Helpers
+      module RenderingHelper
+        def render(options = {}, locals = {}, &block)
+          if (Hash === options) && options.key?(:extension)
+            ext_name = options[:extension][/[^\/]*/]
+            if ext_name.classify.constantize::Engine.active? controller
+              return view_renderer.render(self, options, &block)
+            else
+              return capture(&block)
+            end
+          end
+          super
+        end
+      end
+    end
+
+    module Renderer
+      def render(context, options)
+        if options.key? :extension
+          render_extension(context, options)
+        else
+          super
+        end
+      end
+
+      def render_extension(context, options, &block)
+        partial_name = options.delete :extension
+        Wanko::ExtensionRenderer.new(@lookup_context).render(context, options.merge(partial: partial_name), block)
+      end
+    end
+  end
+
+  class ExtensionRenderer < ::ActionView::PartialRenderer
+    def render(context, options, block)
+      super
+    rescue => e
+      #TODO error handling
+      p e
+      capture(&block)
+    end
+  end
+end
+
+ActionView::Base.prepend Wanko::ActionView::Helpers::RenderingHelper
+ActionView::Renderer.prepend Wanko::ActionView::Renderer

data/lib/wanko/engine.rb

@@ -0,0 +1,26 @@
+module Wanko
+  module Engine
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def active_if(&block)
+        @active_if = block
+      end
+
+      def active?(controller)
+        controller.instance_eval(&@active_if)
+      end
+    end
+
+    included do
+      isolate_namespace self.parent
+
+      engine_kls = self
+      ActiveSupport.on_load :after_initialize do
+        Rails.application.routes.prepend do
+          mount engine_kls, :at => '/'
+        end
+      end
+    end
+  end
+end

data/lib/wanko/version.rb

@@ -0,0 +1,3 @@
+module Wanko
+  VERSION = '0.0.1'.freeze
+end

data/wanko.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wanko/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wanko"
+  spec.version       = Wanko::VERSION
+  spec.authors       = ["Akira Matsuda"]
+  spec.email         = ["ronnie@dio.jp"]
+
+  spec.summary       = 'A safe and rapid prototyping framework for Rails'
+  spec.description   = 'Wanko is a Rails Engine framework that can be used for rapid prototyping, feature toggle, or A/B testing'
+  spec.homepage      = 'https://github.com/amatsuda/wanko'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency 'rails'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'capybara'
+  spec.add_development_dependency 'byebug'
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification
+name: wanko
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Akira Matsuda
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: rails
+  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: sqlite3
+  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: capybara
+  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: byebug
+  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: Wanko is a Rails Engine framework that can be used for rapid prototyping,
+  feature toggle, or A/B testing
+email:
+- ronnie@dio.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- gemfiles/Gemfile-rails.4.2.x
+- lib/generators/wanko/controller_generator.rb
+- lib/generators/wanko/extension_generator.rb
+- lib/generators/wanko/templates/controller.rb
+- lib/generators/wanko/templates/lib/%name%/engine.rb
+- lib/wanko.rb
+- lib/wanko/abstract_controller.rb
+- lib/wanko/action_view.rb
+- lib/wanko/engine.rb
+- lib/wanko/version.rb
+- wanko.gemspec
+homepage: https://github.com/amatsuda/wanko
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: A safe and rapid prototyping framework for Rails
+test_files: []