nyanko 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: 3bf6a9e3b51bc80536b6dd54ca34a36cce8bde19
+  data.tar.gz: ee455931da637b0687a514b177bdbcb42a43c1b1
+!binary "U0hBNTEy":
+  metadata.gz: 49253ba6ec4aa0195957714b64ab93802ed1727c3af38a90b2c7bf003f861517209261f2e1c9a0a8b3d9e5b39191fe09d526bc4d03ce9cc0696db4180ac9a3dd
+  data.tar.gz: 29bb6270a940e5a74208536928f58c547c9b4fa042f69135e92a672b2dbf6b4458de9f388d7feaa58dbef81340c686131dddfe9096a8735ae63d0f2fa2598041

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/Gemfile

@@ -0,0 +1,25 @@
+source "http://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"
+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,105 @@
+# Nyanko
+Nyanko is a Rails extension tool.  
+This is deeply inspired from [Chanko](https://github.com/cookpad/chanko) and has same API as Chanko.
+
+![](http://octodex.github.com/images/nyantocat.gif)
+
+
+## Requirements
+* Ruby >= 1.8.7
+* Rails >= 3.0.10
+
+
+## Install
+```
+$ gem install nyanko
+```
+
+
+## Usage
+
+### Gemfile
+```ruby
+# Gemfile
+gem "nyanko"
+```
+
+### Invoke
+```ruby
+class EntriesController < ApplicationController
+  unit_action :entry_deletion, :destroy
+
+  def index
+    invoke(:entry_deletion, :index) do
+      @entries = Entry.all
+    end
+  end
+end
+```
+
+### Unit
+```ruby
+# app/units/entry_deletion/entry_deletion.rb
+module EntryDeletion
+  include Nyanko::Unit
+
+  active_if { Rails.env.development? }
+
+  scope(:view) do
+    function(:delete_link) do
+      render "/delete_link", :entry => entry if entry.persisted?
+    end
+  end
+
+  scope(:controller) do
+    function(:destroy) do
+      entry = Entry.find(params[:id])
+      entry.unit.soft_delete
+      redirect_to entries_path
+    end
+
+    function(:index) do
+      @entries = Entry.unit.active
+    end
+  end
+
+  models do
+    expand(:Entry) do
+      scope :active, lambda { where(:deleted_at => nil) }
+
+      def soft_delete
+        update_attributes(:deleted_at => Time.now)
+      end
+    end
+  end
+
+  helpers do
+    def link_to_deletion(entry)
+      link_to "Delete", entry, :method => :delete
+    end
+  end
+end
+```
+
+```
+-# app/units/entry_deletion/views/_delete_link.html.slim
+= unit.link_to_deletion(entry)
+```
+
+
+## Example App
+There is an example rails application for Nyanko in spec/dummy directory.
+```
+$ git clone git@github.com:r7kamura/nyanko.git
+$ cd nyanko/spec/dummy
+$ rails s
+```
+
+
+## Todo
+* auto-reloading
+* logger
+* configuration
+* backwoard compatibility (alias ext to unit)
+* document
+* test (for now, test coverage is 100%)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/nyanko/active_if.rb

@@ -0,0 +1,57 @@
+module Nyanko
+  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
+
+    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/nyanko/config.rb

@@ -0,0 +1,13 @@
+module Nyanko
+  module Config
+    class << self
+      def units_directory_path
+        @units_directory_path ||= "app/units"
+      end
+
+      def units_directory_path=(path)
+        @units_directory_path = path
+      end
+    end
+  end
+end

data/lib/nyanko/controller.rb

@@ -0,0 +1,23 @@
+module Nyanko
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      include Invoker
+    end
+
+    module ClassMethods
+      private
+
+      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
+    end
+  end
+end

data/lib/nyanko/function.rb

@@ -0,0 +1,50 @@
+module Nyanko
+  class Function
+    attr_reader :block, :unit, :label
+
+    class << self
+      def units
+        @units ||= []
+      end
+
+      def current_unit
+        units.last
+      end
+    end
+
+    def initialize(unit, label, &block)
+      @unit  = unit
+      @label = label
+      @block = block
+    end
+
+    def invoke(context, options = {})
+      with_unit_stack(context) do
+        with_unit_view_path(context) do
+          context.instance_eval(&block)
+        end
+      end
+    end
+
+    private
+
+    def with_unit_stack(context)
+      context.units << @unit
+      self.class.units << @unit
+      yield
+    ensure
+      self.class.units.pop
+      context.units.pop
+    end
+
+    def with_unit_view_path(context)
+      if context.view?
+        origin = context.view_paths
+        context.view_paths.unshift unit.view_path
+      end
+      yield
+    ensure
+      context.view_paths = origin if context.view?
+    end
+  end
+end

data/lib/nyanko/helper.rb

@@ -0,0 +1,29 @@
+module Nyanko
+  module Helper
+    class << self
+      def define(class_name, &block)
+        prefix = UnitProxy.generate_prefix(class_name)
+        define_methods_with_prefix(prefix, &block)
+      end
+
+      def define_methods_with_prefix(prefix, &block)
+        define_methods(&block).each do |name|
+          change_method_name(name, "#{prefix}#{name}")
+        end
+      end
+
+      def define_methods(&block)
+        before = instance_methods(false)
+        self.class_eval(&block)
+        instance_methods(false) - before
+      end
+
+      def change_method_name(from, to)
+        class_eval do
+          alias_method to, from
+          remove_method from
+        end
+      end
+    end
+  end
+end

data/lib/nyanko/invoker/function_finder.rb

@@ -0,0 +1,48 @@
+module Nyanko
+  module Invoker
+    class FunctionFinder
+      UnitNotFound     = Class.new(StandardError)
+      FunctionNotFound = Class.new(StandardError)
+
+      def self.find(*args)
+        new(*args).find or raise FunctionNotFound
+      end
+
+      def initialize(context, options)
+        @context = context
+        @options = options
+      end
+
+      def find
+        @options[:functions].find do |unit_name, label|
+          unit       = find_unit(unit_name)
+          identifier = @options[:as] || @context.class
+          next unless unit.active?(@context, @options[:active_if_options])
+          function = unit.find_function(identifier, label)
+          break function if function
+        end
+      end
+
+      def find_with_dependencies
+        find_without_dependencies unless has_inactive_dependent_unit?
+      end
+      alias_method_chain :find, :dependencies
+
+      def find_unit(name)
+        Loader.load(name) or raise UnitNotFound
+      end
+
+      def has_inactive_dependent_unit?
+        dependent_units.any? {|unit| !unit.active?(@context, @options[:active_if_options]) }
+      end
+
+      def dependent_units
+        dependent_unit_names.map {|name| find_unit(name) }
+      end
+
+      def dependent_unit_names
+        Array.wrap(@options[:dependencies])
+      end
+    end
+  end
+end

data/lib/nyanko/invoker/options.rb

@@ -0,0 +1,69 @@
+module Nyanko
+  module Invoker
+    class Options
+      CANDIDATES = {
+        :active_if_options => true,
+        :as                => true,
+        :capture           => true,
+        :if                => true,
+        :locals            => true,
+        :type              => true,
+      }
+
+      def initialize(*args)
+        @raw_options = args.extract_options!
+        @args = args
+      end
+
+      def [](key)
+        send(key)
+      end
+
+      def functions
+        @args.first.is_a?(Array) ? @args : [[@args[0], @args[1]]]
+      end
+
+      def locals
+        (options[:locals] || {}).symbolize_keys
+      end
+
+      def active_if_options
+        options[:active_if_options] || {}
+      end
+
+      def as
+        options[:as]
+      end
+
+      def dependencies
+        options[:if]
+      end
+
+      def capture
+        options.has_key?(:capture) ? capture[:capture] : true
+      end
+
+      def type
+        options[:type]
+      end
+
+      def invoke_options
+        { :capture => capture, :type => type }
+      end
+
+      def options
+        @options ||= begin
+          if short_hand_options?
+            { :locals => @raw_options }
+          else
+            @raw_options
+          end
+        end
+      end
+
+      def short_hand_options?
+        @raw_options.any? && @raw_options.keys.all? {|key| !CANDIDATES[key] }
+      end
+    end
+  end
+end

data/lib/nyanko/invoker.rb

@@ -0,0 +1,68 @@
+require "nyanko/invoker/options"
+require "nyanko/invoker/function_finder"
+
+module Nyanko
+  module Invoker
+    def invoke(*args, &block)
+      options = Options.new(*args)
+      unit_locals_stack << options.locals
+      function = FunctionFinder.find(self, options)
+      result   = function.invoke(self, options.invoke_options)
+      result   = surround_with_html_tag(result, function, options) if view?
+      result
+    rescue Exception
+      p $!
+      case
+      when !block
+        nil
+      when view?
+        capture(&block)
+      else
+        instance_exec(&block)
+      end
+    ensure
+      unit_locals_stack.pop
+    end
+
+    def units
+      @units ||= []
+    end
+
+    def view?
+      is_a?(ActionView::Base)
+    end
+
+    private
+
+    # Search shared method or locals variable
+    def method_missing(method_name, *args, &block)
+      if (methods = units.last.try(:shared_methods)) && block = methods[method_name]
+        self.instance_exec(*args, &block)
+      elsif args.empty? && value = (unit_locals_stack.last || {})[method_name]
+        value
+      else
+        super
+      end
+    end
+
+    def unit_locals_stack
+      @unit_locals_stack ||= []
+    end
+
+    def surround_with_html_tag(str, function, options)
+      classes = %W[
+        unit
+        unit__#{function.unit.name.underscore}
+        unit__#{function.unit.name.underscore}__#{function.label}
+      ]
+      case options.type
+      when :plain
+        str
+      when :inline
+        content_tag(:span, str, :class => classes)
+      else
+        content_tag(:div, str, :class => classes)
+      end
+    end
+  end
+end

data/lib/nyanko/loader.rb

@@ -0,0 +1,59 @@
+require "pathname"
+
+module Nyanko
+  class Loader
+    class << self
+      def load(unit_name)
+        new(unit_name).load
+      end
+
+      def cache
+        @cache ||= {}
+      end
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def load
+      loaded? ? load_from_cache : load_from_file
+    end
+
+    def loaded?
+      cache[@name] != nil
+    end
+
+    def load_from_cache
+      cache[@name]
+    end
+
+    def load_from_file
+      require_unit_files
+      cache[@name] = constantize
+    rescue Exception
+      cache[@name] = false
+      nil
+    end
+
+    def require_unit_files
+      paths.each {|path| require Rails.root.join(path) }
+    end
+
+    def paths
+      Pathname.glob("#{directory_path}/#@name/#@name.rb").sort
+    end
+
+    def directory_path
+      Config.units_directory_path
+    end
+
+    def constantize
+      @name.to_s.camelize.constantize
+    end
+
+    def cache
+      self.class.cache
+    end
+  end
+end

data/lib/nyanko/railtie.rb

@@ -0,0 +1,13 @@
+require "rails"
+
+module Nyanko
+  class Railtie < Rails::Railtie
+    initializer "nyanko" do |app|
+      ::ActionView::Base.send(:include, Invoker, Helper, UnitProxyProvider)
+      ::ActionController::Base.send(:include, Controller)
+      ::ActiveRecord::Base.send(:include, UnitProxyProvider)
+      ::ActiveRecord::Relation.send(:include, UnitProxyProvider)
+      ::ActiveRecord::Associations::CollectionAssociation.send(:include, UnitProxyProvider)
+    end
+  end
+end

data/lib/nyanko/unit/extender/active_record_class_methods.rb

@@ -0,0 +1,56 @@
+module Nyanko
+  module Unit
+    class Extender
+      module ActiveRecordClassMethods
+        delegate(
+          :apply_modules,
+          :arel,
+          :array_of_strings?,
+          :build_arel,
+          :build_joins,
+          :build_select,
+          :build_where,
+          :create_with,
+          :custom_join_sql,
+          :eager_load,
+          :extending,
+          :from,
+          :group,
+          :having,
+          :includes,
+          :joins,
+          :limit,
+          :lock,
+          :offset,
+          :order,
+          :preload,
+          :readonly,
+          :reorder,
+          :reverse_order,
+          :reverse_sql_order,
+          :scope,
+          :select,
+          :where,
+          :to => :@mod
+        )
+
+        %w[belongs_to has_many has_one].each do |method_name|
+          class_eval <<-EOS
+            def #{method_name}(*args, &block)
+              name    = @prefix + args.shift.to_s
+              options = args.extract_options!
+              options = options.reverse_merge(:class_name => @mod.to_s)
+              args << options
+              @mod.#{method_name}(name.to_sym, *args, &block)
+            end
+          EOS
+        end
+
+        def scope(*args, &block)
+          name = @prefix + args.shift.to_s
+          @mod.scope(name, *args)
+        end
+      end
+    end
+  end
+end