platanus 0.0.1 → 0.0.2

data/README.md

@@ -1,6 +1,8 @@
 # Platanus
 
-TODO: Write a gem description
+Platan.us toolbelt.
+
+This gem includes various ruby and rails utility classes we use across most of our rails proyects.
 
 ## Installation
 
@@ -16,7 +18,35 @@ Or install it yourself as:
 
     $ gem install platanus
 
-## Usage
+## Tools & Usage
+
+### Stacked
+
+TODO: Write usage instructions here
+
+### Activable
+
+TODO: Write usage instructions here
+
+### Traceable
+
+TODO: Write usage instructions here
+
+### Canned
+
+TODO: Write usage instructions here
+
+### Gobal Controller
+
+Requires explicit inclusion:
+
+	require 'platanus/gcontroller'
+
+### Template: Spreadsheet
+
+TODO: Write usage instructions here
+
+### Template: prawn
 
 TODO: Write usage instructions here
 

data/lib/platanus/activable.rb

@@ -0,0 +1,67 @@
+# activable.rb : ActiveRecord Activable mod.
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.us+.
+
+module Platanus
+
+  # When included in a model definition, this module
+  # provides soft delete capabilities via the +remove+ method.
+  #
+  # This module also defines a +remove+ callback.
+  #
+  module Activable
+
+    def self.included(base)
+      base.define_callbacks :remove
+      base.attr_protected :removed_at
+      base.send(:default_scope, base.where(:removed_at => nil))
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Executes a mass remove, this wont call any callbacks!
+      def remove_all
+        # TODO: Find a way of doing mass updates and also call callbacks
+        # self.update_all(:removed_at => DateTime.now)
+        # For now, just call remove on each item
+        self.all.each { |item| item.remove! }
+      end
+
+      ## Shorthand method for adding callbacks before item removal
+      def before_remove(_callback)
+        self.set_callback :remove, :before, _callback
+      end
+
+      ## Shorthand method for adding callbacks after item removal
+      def after_remove(_callback)
+        self.set_callback :remove, :after, _callback
+      end
+    end
+
+    # Returns true if object hasnt been removed.
+    def is_active?
+      self.removed_at.nil?
+    end
+
+    # Deactivates a single record.
+    def remove!
+      self.transaction do
+        run_callbacks :remove do
+
+          # Retrieve dependant properties and remove them.
+          self.class.reflect_on_all_associations.select do |assoc|
+            if assoc.options[:dependent] == :destroy
+              collection = self.send(assoc.name)
+              collection.remove_all if collection.respond_to? :remove_all
+            end
+          end
+
+          self.removed_at = DateTime.now
+          self.save!
+        end
+      end
+    end
+  end
+end
+
+

data/lib/platanus/canned.rb

@@ -0,0 +1,222 @@
+# canned.rb : User profiling and authorization.
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.us+.
+
+module Platanus
+
+  # User profiling and authorization module
+  module Canned
+
+    class Interrupt < Exception; end
+    class Error < StandardError; end
+    class AuthError < Error; end
+    class SetupError < Error; end
+
+    # Controller extension, include this in the the base application
+    # controller and use the barracks_setup method to define the profiles
+    # definition object and the user profile provider block.
+    module ControllerExt
+
+      attr_accessor :brk_tag
+
+      def self.included(klass)
+        class << klass
+          # Excluded actions are defined in per class basis
+          attr_accessor :brk_excluded
+        end
+        protected
+        # Definition and role provider are shared with subclasses
+        klass.cattr_accessor :brk_definition
+        klass.cattr_accessor :brk_provider
+        public
+        klass.extend ClassMethods
+      end
+
+      # Wraps a controller instance and provides the profile
+      # testing enviroment used by the role provider function.
+      class ActionWrapper
+
+        attr_reader :tag
+
+        # Loads the testing enviroment.
+        def initialize(_owner, _action, _actions_feats)
+          @owner = _owner
+          @action = _action
+          @feats = _actions_feats
+          @tag = nil
+        end
+
+        # Test if a profile can execute the current action, raises a
+        # BarracksInterrupt exception if conditions are met.
+        def test(_profile, _user_feats, _tag=nil)
+          if @owner.class.brk_definition.can?(_profile, @action, @feats, _user_feats)
+            @tag = _tag
+            raise Interrupt
+          end
+        end
+
+        # Since we need to provide with all of controller functionality
+        # to provider, then proxy al failed method calls to it.
+        def method_missing(_method, *_args, &_block)
+          @owner.send(_method, *_args, &_block)
+        end
+      end
+
+      # Test if an action can be executed using the currently loaded roles.
+      def can?(_action, _action_feat)
+        wrapper = ActionWrapper.new(self,_action,_action_feat)
+        begin
+          provider = if brk_provider.is_a? Symbol then self.method(brk_provider) else brk_provider end
+          wrapper.instance_eval &provider
+          return false
+        rescue Interrupt
+          return (if wrapper.tag.nil? then true else wrapper.tag end)
+        end
+      end
+
+      module ClassMethods
+
+        # Setups the controller user profile definitions and
+        # profile provider block (or proc)
+        def canned_setup(_definition, _provider=nil, &pblock)
+          self.brk_definition = _definition
+          self.brk_provider = _provider || pblock
+          self.before_filter do
+            # Before filter is an instance_eval?
+            break if self.class.brk_excluded == :all
+            break if !self.class.brk_excluded.nil? and self.class.brk_excluded.include? params[:action].to_sym
+            tag = self.can?(params[:controller], params)
+            tag ||= self.can?(params[:controller] + '#' + params[:action], params)
+            raise AuthError unless tag
+            self.brk_tag = tag
+          end
+        end
+
+        # Removes protection for all controller actions.
+        def uncan_all()
+          self.brk_excluded = :all
+        end
+
+        # Removes protection for the especified controller actions.
+        def uncanned(*_excluded)
+          self.brk_excluded ||= []
+          self.brk_excluded.push(*_excluded)
+        end
+      end
+    end
+
+    # Profile DSL
+    module ProfileManager
+
+      # Auxiliary class used by profile manager to store profiles.
+      class BProfile
+
+        # This is required for the copy constructor to work.
+        protected
+        attr_reader :rules
+        attr_reader :def_test
+        public
+
+        # The initializer takes another profile as rules base.
+        def initialize(_owner, _base, _def_test)
+          @owner = _owner
+          @rules = if _base.nil? then {} else _base.rules.clone end
+          @def_test = _def_test
+        end
+
+        # Adds a new ability.
+        def ability(*_args)
+          @rules[_args.first] = tests = {}
+          if _args.last.is_a? Hash
+            hook = _args.last.delete(@hook)
+            _args[1...-1].each { |sym| tests[sym] = @def_test }
+            tests.merge!(_args.last)
+          else
+            hook = nil
+            _args[1..-1].each { |sym| tests[sym] = @def_test }
+          end
+        end
+
+        # Removes an action by its name.
+        def remove(_name)
+          @rules.delete(_name)
+        end
+
+        # Test an action agaist this profile
+        def test(_action, _action_feats, _user_feats)
+          tests = @rules[_action]
+          return false if tests.nil?
+          tests.each do |sym, test|
+
+            # Analize test.
+            if test.is_a? Hash
+              test_name = test.fetch(:name,@def_test)
+              test_transform = test[:transform]
+              user_sym = test.fetch(:key,sym)
+            else
+              test_name = test
+              test_transform = nil
+              user_sym = sym
+            end
+
+            # Extract user and action features.
+            action_feat = _action_feats[sym]
+            raise SetupError if action_feat.nil?
+            user_feat = _user_feats[user_sym]
+            return false if user_feat.nil?
+            next if user_feat == :wildcard # Wildcard matches always
+
+            # Compare features.
+            action_feat = _owner.send(test_transform,action_feat) unless test_transform.nil?
+            case test_name
+            when :equals
+              return false unless user_feat == action_feat
+            when :equals_int
+              return false unless user_feat.to_i == action_feat.to_i
+            when :if_higher
+              return false unless user_feat > action_feat
+            when :if_lower
+              return false unless user_feat < action_feat
+            else
+              # TODO: Check that method exists first.
+              if @owner.method_defined? test_name
+                return false unless @owner.send(test_name,action_feat,user_value)
+              end
+            end
+          end
+
+          return true
+        end
+      end
+
+      def self.included(base)
+        class << base
+          # Add a profile property to extended class
+          attr_accessor :profiles
+        end
+        base.profiles = {}
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        # Creates a new profile and passes it to the given block.
+        # This can optionally take an inherit parameter to use
+        # another profile as base for the new one.
+        def profile(_name, _options={})
+          inherit = _options.fetch(:inherits,nil)
+          def_test = _options.fetch(:default,:equals)
+          yield self.profiles[_name.to_s] = BProfile.new(self,self.profiles[inherit],def_test)
+        end
+
+        # Test if a user (profile + user data) can execute a given
+        # action (action name + action data).
+        def can?(_profile, _action, _action_feat, _user_data)
+          profile = self.profiles[_profile.to_s]
+          return false if profile.nil?
+          return profile.test(_action,_action_feat,_user_data)
+        end
+      end
+    end
+  end
+end

data/lib/platanus/cmap.rb

@@ -0,0 +1,80 @@
+module Platanus
+
+  module Cmap
+
+    class InvalidName < Exception; end
+
+    def self.included(base)
+      base.cattr_accessor :cmap
+      base.cmap = Hash.new { |hash, key| hash[key] = {} }
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def cmap_register(_key, _value, _cat=nil)
+        if _cat.nil?; self.cmap[_key] = _value
+        else; self.cmap[_cat.to_s][_key] = _value
+        end
+      end
+
+      def cmap_convert(_key, _cat=nil)
+        if _cat.nil?; return self.cmap[_key]
+        else; return self.cmap[_cat.to_s][_key]
+        end
+      end
+
+      def cmap_convert_back(_value, _cat=nil)
+        if _cat.nil?; return self.cmap.key(_value)
+        else; return self.cmap[_cat.to_s].key(_value)
+        end
+      end
+
+      def str_attr_accessor(_target, _options={})
+        str_attr_reader(_target,_options)
+        str_attr_writer(_target,_options)
+      end
+
+      def str_attr_writer(_target, _options={})
+        _target = _target.to_s
+        _self = _options.fetch(:extend, self)
+        _cat = _options[:cat]
+        _cmap = self.cmap
+
+        _self.send(:define_method, _target + '_str=') do |value|
+          if _cat.nil?; self.send(_target + '=', _cmap.fetch(value))
+          else; self.send(_target + '=', _cmap[_cat.to_s].fetch(value)); end
+        end
+      end
+
+      def str_attr_reader(_target, _options={})
+        _target = _target.to_s
+        _self = _options.fetch(:extend, self)
+        _cat = _options[:cat]
+        _cmap = self.cmap
+
+        _self.send(:define_method, _target + '_str') do
+          if _cat.nil?; _cmap.key(self.send(_target))
+          else; _cmap[_cat.to_s].key(self.send(_target)); end
+        end
+      end
+
+      # private
+      # def cmap_converters(_cat_or_name=nil)
+        # # Define new class methods.
+        # klass = (class << self; self; end)
+        # klass.send(:define_method, _target + '_to_str') do |value|
+          # if _cat.nil?; _cmap.index(value)
+          # else; _cmap[_cat].index(value); end
+        # end
+#
+        # klass.send(:define_method, 'str_to_' + _target) do |value|
+          # if _cat.nil?; _cmap.fetch(value)
+          # else; _cmap[_cat].fetch(value); end
+        # end
+      # end
+    end
+  end
+end
+
+

data/lib/platanus/gcontroller.rb

@@ -0,0 +1,26 @@
+# gcontroller.rb : ActionController global access.
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.us+.
+
+class Platanus::NotInRequestError < Exception; end
+
+# This makes the current request controller globally avaliable.
+class ActionController::Base
+  around_filter :wrap_store_controller
+
+  def wrap_store_controller
+    # We could do this instead: http://coderrr.wordpress.com/2008/04/10/lets-stop-polluting-the-threadcurrent-hash/
+    Thread.current[:controller] = self
+    begin; yield
+    ensure; Thread.current[:controller] = nil
+    end
+  end
+
+  # Gets the current controller.
+  #
+  # * *Raises* :
+  #   - +Platanus::NotInRequestError+ -> If current controller instance is not avaliable.
+  def self.current
+    Thread.current[:controller] || (raise Platanus::NotInRequestError, 'Current controller not loaded')
+  end
+end

data/lib/platanus/http_helpers.rb

@@ -0,0 +1,61 @@
+# http_helpers.rb : Various HTTP Related helpers
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.us+.
+
+module Platanus
+
+  ## HTTP STATUS EXCEPTIONS
+
+  # Allows to use an exception driven scheme to notify
+  # the request that a especial status should be send
+  # back to the client. Usefull when used with rescue_from.
+  class StatusError < StandardError
+
+    class << self
+      instance_variable_set(:@status, nil)
+      instance_variable_set(:@msg, nil)
+    end
+
+    def self.setup(_status, _msg)
+      @status = _status
+      @msg = _msg
+    end
+
+    def self.status; @status; end
+    def self.message; @msg; end
+
+    def self.as_json(_options={})
+      { 'status' => @status.to_s, 'msg' => @msg }
+    end
+
+    def initialize(_msg=nil)
+      @msg = _msg
+    end
+
+    def status; self.class.status; end
+    def message; if @msg.nil? then self.class.message else @msg end; end
+    def as_json(_options={})
+      { 'status' => status.to_s, 'msg' => message }
+    end
+  end
+
+  class StatusNotFound < StatusError
+    setup :not_found, 'Not found'
+  end
+
+  class StatusUnauthorized < StatusError
+    setup :unauthorized, 'Not authorized'
+  end
+
+  class StatusUnprocessable < StatusError
+    setup :unprocessable_entity, 'Invalid object'
+  end
+
+  class StatusBadRequest < StatusError
+    setup :bad_request, 'Invalid parameters'
+  end
+
+  class StatusConflict < StatusError
+    setup :conflict, 'Model conflict'
+  end
+end

data/lib/platanus/layered.rb

@@ -0,0 +1,23 @@
+module Platanus
+
+  # Adds simple proxy capabilities to a class, allowing
+  # it instances to wrap other objects transparently
+  module Layered
+    attr_reader :lo_target
+
+    def initialize(_entity)
+      @lo_target = _entity
+    end
+
+    def respond_to?(_what)
+      return true if super(_what)
+      return @lo_target.respond_to? _what
+    end
+
+    def method_missing(_method, *_args, &_block)
+      @lo_target.send(_method, *_args, &_block)
+    end
+  end
+end
+
+

data/lib/platanus/onetime.rb

@@ -0,0 +1,33 @@
+# onetime.rb : One time setter.
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.us+.
+
+module Kernel
+
+  # Creates a one time writer method.
+  #
+  # A one time writer is undefined after the first time it is used.
+  #
+  # * *Args*    :
+  #   - +_name+ -> Attribute name.
+  #
+  def onetime_attr_writer(_name)
+    define_method _name.to_s + '=' do |_value|
+      instance_variable_set('@' + _name.to_s, _value)
+      # Unset method by modifying singleton class.
+      metaclass = (class << self; self; end)
+      metaclass.send(:undef_method,_name.to_s + '=')
+      _value
+    end
+  end
+
+  # Adds a one time writer instead of a regular writer.
+  #
+  # * *Args*    :
+  #   - +_name+ -> Attribute name.
+  #
+  def onetime_attr_accessor(_name)
+    attr_reader(_name)
+    onetime_attr_writer(_name)
+  end
+end

data/lib/platanus/stacked.rb

@@ -0,0 +1,86 @@
+# stacked.rb : Stackable attributes for ActiveRecord
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.us+.
+
+module Platanus
+
+  # Adds the has_stacked association to an ActiveRecord model.
+  #
+  module StackedAttr
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Adds an stacked attribute to the model.
+      def has_stacked(_name, _options={}, &block)
+
+        tname = _name.to_s
+        to_cache = _options.delete(:cached)
+        to_cache_prf = if _options[:cache_prf].nil? then 'last_' else _options.delete(:cache_prf) end
+        stack_key = if _options[:stack_key].nil? then 'created_at DESC, id DESC' else _options.delete(:stack_key) end
+
+        _options[:order] = stack_key
+        _options[:limit] = 10 if _options[:limit].nil?
+
+        # Protect cached attributes.
+        unless to_cache.nil?
+          to_cache = to_cache.map { |name| name.to_s }
+          to_cache.each { |name| attr_protected(to_cache_prf + name) }
+        end
+
+        private
+        has_many(_name,_options)
+        public
+
+        send :define_method, 'push_' + tname[0...-1] + '!' do |obj|
+          self.class.transaction do
+
+            # Execute before callbacks
+            self.send(_options[:before_push], obj) if _options.has_key? :before_push
+            block.call(self, obj) unless block.nil?
+
+            # Cache required fields
+            unless to_cache.nil?
+              to_cache.each { |name| send(to_cache_prf + name + '=', obj.send(name)) }
+            end
+
+            # Save model and push attribute, cache last stacked attribute.
+            self.save! if _options[:autosave] and (self.new_record? or self.changed?)
+            raise ActiveRecord::RecordInvalid.new(obj) unless self.send(tname).send('<<',obj)
+            @_stacked_last = obj
+
+            # Execute after callback
+            self.send(_options[:after_push], obj) if _options.has_key? :after_push
+          end
+        end
+
+        send :define_method, 'push_' + tname[0...-1] do |obj|
+          begin
+            return self.send('push_' + tname[0...-1] + '!', obj)
+          rescue ActiveRecord::RecordInvalid
+            return false
+          end
+        end
+
+        send :define_method, 'top_' + tname[0...-1] do
+          # Storing the last stacked value will not prevent race conditions
+          # when simultaneous updates occur.
+          return @_stacked_last unless @_stacked_last.nil?
+          self.send(_name).first
+        end
+
+        # Generate shorcut properties for cached attributes.
+        unless to_cache.nil?
+          to_cache.each do |name|
+            send :define_method, name.to_s do
+              self.send(to_cache_prf + name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/platanus/templates/prawn.rb

@@ -0,0 +1,26 @@
+# prawn.rb : Prawn - Rails Templates integration.
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.ius+.
+
+require 'prawn'
+
+Mime::Type.register 'application/pdf', :pdf
+
+module Platanus
+
+  # Template Handler, just exposes prawn to a template.
+  class PrawnBuilder
+
+    class_attribute :default_format
+    self.default_format = Mime::PDF
+
+    def self.call(template)
+      # Create a new pdf doc object using a block, populate the block using
+      # the template contents.
+      "pdf = Prawn::Document.new(:skip_page_creation => true);" + template.source + ";pdf.render;"
+    end
+  end
+end
+
+# Register the template handler for the .prawn extension.
+ActionView::Template.register_template_handler :prawn, Platanus::PrawnBuilder

data/lib/platanus/templates/spreadsheet.rb

@@ -0,0 +1,24 @@
+# spreadsheet.rb : Spreadsheet - Rails Templates integration.
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.ius+.
+
+require 'spreadsheet'
+
+Mime::Type.register 'application/vnd.ms-excel', :xls
+
+module Platanus
+
+  # Template Handler, just exposes a spreadsheet's Workbook to a template.
+  class ExcelBuilder
+
+    class_attribute :default_format
+    self.default_format = Mime::XLS
+
+    def self.call(template)
+      "book = ::Spreadsheet::Workbook.new;" + template.source + ";io=StringIO.new('');book.write io;io.close;io.string;"
+    end
+  end
+end
+
+# Register the template handler for the .spreadsht extension
+ActionView::Template.register_template_handler :spreadsht, Platanus::ExcelBuilder

data/lib/platanus/traceable.rb

@@ -0,0 +1,74 @@
+# traceable.rb : Logged user action tracing
+#
+# Copyright April 2012, Ignacio Baixas +mailto:ignacio@platan.us+.
+
+module Platanus
+
+  # When included in a model, this module will provide seamless C(R)UD operations
+  # tracing.
+  #
+  # This module operates under a couple of conventions:
+  # * When a new operation is detected it will look for the +user_id+ method for the current controller
+  # and assing it's value to the <action>_by attribute of the current model.
+  # * When a new operation is detected the controllers +trace+ method is called passing the action and
+  # the current model.
+  #
+  # This module will also trace +Activable.remove+ calls.
+  # Will only work if the gcontroller mod is active.
+  #
+  module Traceable
+
+    def self.included(base)
+      # Make sure gcontroller was loaded.
+      unless ActionController::Base.respond_to? :current
+        # TODO: better warning!
+        base.logger.warn 'gcontroller not loaded, tracing disabled'
+        return
+      end
+
+      base.around_create :__trace_create
+      base.around_update :__trace_update
+      base.around_destroy :__trace_destroy
+      # Activable support (remove event).
+      begin; base.set_callback :remove, :around, :__trace_remove; rescue; end
+    end
+
+    ## CALLBACKS
+
+    def __trace_create # :nodoc:
+      controller = ActionController::Base.current
+      if controller.respond_to? :trace_user_id and self.respond_to? :created_by=
+        self.created_by = controller.trace_user_id
+      end
+      yield
+      controller.trace(:create, self) if controller.respond_to? :trace
+    end
+
+    def __trace_update # :nodoc:
+      controller = ActionController::Base.current
+      if controller.respond_to? :trace_user_id and self.respond_to? :updated_by=
+        self.updated_by = controller.trace_user_id
+      end
+      yield
+      controller.trace(:update, self) if controller.respond_to? :trace
+    end
+
+    def __trace_destroy # :nodoc:
+      controller = ActionController::Base.current
+      if controller.respond_to? :trace_user_id and self.respond_to? :destroyed_by=
+        self.destroyed_by = controller.trace_user_id
+      end
+      yield
+      controller.trace(:destroy, self) if controller.respond_to? :trace
+    end
+
+    def __trace_remove # :nodoc:
+      controller = ActionController::Base.current
+      if controller.respond_to? :trace_user_id and self.respond_to? :removed_by=
+        self.removed_by = controller.trace_user_id
+      end
+      yield
+      controller.trace(:remove, self) if controller.respond_to? :trace
+    end
+  end
+end

data/lib/platanus/version.rb

@@ -1,3 +1,3 @@
 module Platanus
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/platanus.rb

@@ -9,6 +9,7 @@ require 'platanus/cmap'
 require 'platanus/http_helpers'
 
 # require 'platanus/onetime'
+# require 'platanus/gcontroller'
 # require 'platanus/template/spreadsheet'
 # require 'platanus/template/prawn'
 

data/platanus.gemspec

@@ -12,6 +12,6 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "platanus"
-  gem.require_paths = ["lib"]
+  gem.require_paths = ["lib","lib/platanus"]
   gem.version       = Platanus::VERSION
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: platanus
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -24,6 +24,17 @@ files:
 - README.md
 - Rakefile
 - lib/platanus.rb
+- lib/platanus/activable.rb
+- lib/platanus/canned.rb
+- lib/platanus/cmap.rb
+- lib/platanus/gcontroller.rb
+- lib/platanus/http_helpers.rb
+- lib/platanus/layered.rb
+- lib/platanus/onetime.rb
+- lib/platanus/stacked.rb
+- lib/platanus/templates/prawn.rb
+- lib/platanus/templates/spreadsheet.rb
+- lib/platanus/traceable.rb
 - lib/platanus/version.rb
 - platanus.gemspec
 homepage: http://www.platan.us
@@ -32,6 +43,7 @@ post_install_message:
 rdoc_options: []
 require_paths:
 - lib
+- lib/platanus
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements: