chanko 1.0.6 → 2.0.0

data/.gitignore

@@ -0,0 +1,22 @@
+log/*.log
+spec/dummy/db/*.sqlite3
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,26 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development, :test, :production do
+  gem "jquery-rails"
+  gem "quiet_assets"
+  gem "rails", ">= 3.0.10"
+  gem "slim"
+  gem "sqlite3"
+end
+
+group :test do
+  gem "rspec-rails", "2.12.2"
+end
+
+group :development, :test do
+  gem "pry-rails"
+  gem "thin"
+end
+
+group :assets do
+  gem "sass-rails", ">= 3.0.10"
+  gem "coffee-rails", ">= 3.0.10"
+  gem "uglifier"
+end

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryo Nakamura
+
+MIT License
+
+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,168 @@
+# Chanko
+Chanko provides a simple framework for rapidly and safely prototyping new
+features in your production Rails app, and exposing these prototypes to
+specified segments of your user base.
+
+With Chanko, you can release many concurrent features and independently manage
+which users see them. If there are errors with any chanko, it will be
+automatically removed, without impacting your site.
+
+
+## Requirements
+* Ruby >= 1.8.7
+* Rails >= 3.0.10
+
+
+## Usage
+Add to your Gemfile.
+
+```ruby
+gem "chanko"
+```
+
+## Files
+Chanko provides a generator to create a template of unit.
+
+```
+$ rails generate chanko:install example_unit
+```
+
+## Invoke
+You can invoke the logics defined in your units via `invoke` and `unit` methods.
+In controller class context, `unit_action` utility is also provided.
+The block passed to `invoke` is a fallback executed if any problem occurs in invoking.
+
+```ruby
+# app/controllers/users_controller.rb
+class UsersController < ApplicationController
+  unit_action :example_unit, :show
+
+  def index
+    invoke(:example_unit, :index) do
+      @users = User.all
+    end
+  end
+end
+```
+
+```
+-# app/views/examples/index.html.slim
+= unit.helper_method
+= invoke(:example_unit, :render_example)
+```
+
+```
+-# app/units/example_unit/views/_example.html.slim
+= foo
+```
+
+## Unit
+
+### module
+You can define your MVC code here.
+
+```ruby
+# app/units/example_unit/example_unit.rb
+module ExampleUnit
+  include Chanko::Unit
+  ...
+end
+```
+
+### active_if
+This block is used to decide if this unit is active or not.
+`context` is the receiver object of `invoke`.
+`options` is passed via `invoke(:foo, :bar, :active_if_options => { ... })`.
+By default, this is set as `active_if { true }`.
+
+```ruby
+active_if do |context, options|
+  true
+end
+```
+
+### raise_error
+By default, any error raised in production env is ignored.
+`raise_error` is used to force an unit to raise up errors occured in invoking.
+You can force all units to raise up errors by `Config.raise_error = true`.
+
+```ruby
+raise_error
+```
+
+### function
+In controller or view context, you can call functions defined by `function`
+via `invoke(:example_unit, :function_name)`.
+
+```ruby
+scope(:controller) do
+  function(:show) do
+    @user = User.find(params[:id])
+  end
+
+  function(:index) do
+    @users = User.active
+  end
+end
+```
+
+### render
+The view path app/units/example_unit/views is added into view_paths in invoking.
+So you can render app/units/example_unit/views/_example.html.slim in invoking.
+
+```ruby
+scope(:view) do
+  function(:render_example) do
+    render "/example", :foo => hello("world")
+  end
+end
+```
+
+### models
+In models block, you can expand model features by `expand` method.
+The expanded methods are available via unit proxy like `User.unit.active`,
+and `User.find(params[:id]).unit.active?`, and so on.
+
+```ruby
+models do
+  expand(:User) do
+    scope :active, lambda { where(:deleted_at => nil) }
+
+    def active?
+      deleted_at.nil?
+    end
+  end
+end
+```
+
+### shared
+You can call methods defined by `shared` in invoking.
+
+```ruby
+shared(:hello) do |world|
+  "Hello, #{world}"
+end
+```
+
+### helpers
+You can call helpers in view via unit proxy like `unit.helper_method`.
+
+```ruby
+helpers do
+  def helper_method
+    "helper method"
+  end
+end
+```
+
+
+## Example
+https://github.com/cookpad/chanko/tree/master/spec/dummy  
+Chanko provides an example rails application in spec/dummy directory.
+
+```
+$ git clone git@github.com:cookpad/chanko.git
+$ cd chanko/spec/dummy
+$ rails s
+$ open http://localhost:3000
+```

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = "spec/**/*_spec.rb"
+    spec.rspec_opts = ["-cfs"]
+  end
+rescue LoadError => e
+end
+
+task :default => :spec

data/chanko.gemspec

@@ -0,0 +1,30 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "chanko/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "chanko"
+  gem.version       = Chanko::VERSION
+  gem.authors       = ["Ryo Nakamura"]
+  gem.email         = ["r7kamura@gmail.com"]
+  gem.description   = "Chanko is a Rails extension tool"
+  gem.summary       = "Rails extension tool"
+  gem.homepage      = "https://github.com/cookpad/chanko"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "rails", ">= 3.0.10"
+  gem.add_development_dependency "coffee-rails", ">= 3.0.10"
+  gem.add_development_dependency "jquery-rails"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "rspec-rails", "2.12.2"
+  gem.add_development_dependency "sass-rails", ">= 3.0.10"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "slim"
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "thin"
+  gem.add_development_dependency "uglifier"
+end

data/lib/chanko.rb

@@ -0,0 +1,19 @@
+require "action_controller"
+require "action_view"
+require "active_record"
+require "active_support/all"
+require "rails"
+
+require "chanko/active_if"
+require "chanko/config"
+require "chanko/controller"
+require "chanko/exception_handler"
+require "chanko/function"
+require "chanko/helper"
+require "chanko/invoker"
+require "chanko/loader"
+require "chanko/logger"
+require "chanko/railtie"
+require "chanko/unit"
+require "chanko/unit_proxy"
+require "chanko/unit_proxy_provider"

data/lib/chanko/active_if.rb

@@ -0,0 +1,59 @@
+module Chanko
+  class ActiveIf
+    class << self
+      def define(label, &block)
+        definitions[label] = block
+      end
+
+      def find(label)
+        definitions[label]
+      end
+
+      def definitions
+        @definitions ||= {}
+      end
+
+      def clear
+        definitions.clear
+      end
+    end
+
+    attr_reader :conditions, :options
+
+    def initialize(*conditions, &block)
+      @options    = conditions.extract_options!
+      @conditions = conditions
+      @block      = block
+    end
+
+    def active?(context, options = {})
+      blocks.all? {|block| block.call(context, options) }
+    end
+
+    def blocks
+      @blocks ||= begin
+        conditions.map do |condition|
+          condition.is_a?(Any) ? condition.to_block : self.class.find(condition)
+        end << @block
+      end.compact
+    end
+
+    class Any
+      def initialize(*labels)
+        @labels = labels
+      end
+
+      def to_block
+        proc do |context, options|
+          definitions.any? do |definition|
+            definition.call(context, options)
+          end
+        end
+      end
+
+      def definitions
+        @labels.map {|label| ActiveIf.find(label) }
+      end
+    end
+  end
+end

data/lib/chanko/config.rb

@@ -0,0 +1,30 @@
+module Chanko
+  module Config
+    class << self
+      attr_accessor(
+        :auto_reload,
+        :backtrace_limit,
+        :cache_units,
+        :compatible_css_class,
+        :enable_logger,
+        :proxy_method_name,
+        :raise_error,
+        :resolver,
+        :units_directory_path
+      )
+
+      def reset
+        self.auto_reload          = Rails.env.development? || Rails.env.test?
+        self.backtrace_limit      = 10
+        self.compatible_css_class = false
+        self.enable_logger        = true
+        self.proxy_method_name    = :unit
+        self.raise_error          = Rails.env.development?
+        self.resolver             = ActionView::OptimizedFileSystemResolver
+        self.units_directory_path = "app/units"
+      end
+    end
+
+    reset
+  end
+end

data/lib/chanko/controller.rb

@@ -0,0 +1,31 @@
+module Chanko
+  module Controller
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      private
+
+      def inherited(base)
+        if Config.auto_reload && base.name == "ApplicationController"
+          base.class_eval do
+            prepend_before_filter do
+              Chanko::Loader.cache.clear
+            end
+          end
+        end
+        super
+      end
+
+      def unit_action(unit_name, *function_names, &block)
+        options = function_names.extract_options!
+        block ||= Proc.new { head 400 }
+        Array.wrap(function_names).each do |function_name|
+          define_method(function_name) do
+            invoke(unit_name, function_name, options, &block)
+          end
+        end
+      end
+      alias_method :ext_action, :unit_action
+    end
+  end
+end

data/lib/chanko/exception_handler.rb

@@ -0,0 +1,10 @@
+module Chanko
+  module ExceptionHandler
+    class << self
+      def handle(exception, unit = nil)
+        Logger.debug(exception)
+        raise exception if unit.try(:raise_error?) || Config.raise_error
+      end
+    end
+  end
+end