pinkman 0.9.9.8 → 0.9.9.9.0

data/lib/pinkman/form_helper/form_helpers.rb

@@ -0,0 +1,65 @@
+require_relative '../base_helper.rb'
+require_relative '../views_helpers/form_helper.rb'
+
+module Pinkman
+  module FormHelper
+    module FormHelpers
+      
+      extend Pinkman::BaseHelper
+      
+      include Pinkman::ViewsHelpers::FormHelper
+      
+      define_helper :string do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name}}
+      end
+      
+      define_helper :text do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_textarea', locals: {attr_name: attr_name, label: label, textarea_options: {name: attr_name}}
+      end
+      
+      define_helper :date do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name, type: 'date'}}
+      end
+      
+      define_helper :datetime do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name}, type: 'time'}
+      end
+      
+      define_helper :color do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name}}
+      end
+      
+      define_helper :select do |attr_name,label,options_hash,html_options={}|
+        if html_options.has_key?(:placeholder)
+          placeholder = html_options[:placeholder]
+          obligatory = html_options[:obligatory]
+          html_options.delete(:placeholder)
+        end
+        obligatory = true if obligatory.nil?
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_select', locals: {attr_name: attr_name, label: label, options_hash: options_hash, html_options: html_options, placeholder: placeholder, obligatory: obligatory}
+      end
+      
+      define_helper :password do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name, type: 'password'}}
+      end
+      
+      define_helper :number do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name, type: 'number'}}
+      end
+      
+      define_helper :money do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name, type: 'number', min: 0, step: 0.01}}
+      end
+      
+    end
+  end
+end

data/lib/pinkman/form_helper.rb

@@ -0,0 +1,36 @@
+require_relative 'base_helper.rb'
+require_relative 'form_helper/form_helpers.rb'
+
+module Pinkman
+  module FormHelper
+    class Dispatcher
+      attr_accessor :rails_helper
+      
+      def initialize value
+        @rails_helper = value
+      end
+      
+      def method_missing m, *args, &block
+        if Pinkman::FormHelper.respond_to?(m)
+          if block_given?
+            rails_helper.instance_exec(*args,block,&Pinkman::FormHelper.send(m))
+          else
+            rails_helper.instance_exec(*args,&Pinkman::FormHelper.send(m))
+          end
+        else
+          super(m)
+        end
+      end
+    end
+    
+    def self.dispatcher rails_helper
+      Dispatcher.new(rails_helper)
+    end
+  
+    extend Pinkman::FormHelper::FormHelpers
+    
+  end
+end
+    
+# --- About:
+# This file defines the Pinkman form helpers we use in views. See views helper to understand how this works.

data/lib/pinkman/serializer/base.rb

@@ -16,7 +16,6 @@ module Pinkman
         self
       end
 
-
       self.root = false
 
       def self.scope name=:public, &block

data/lib/pinkman/version.rb

@@ -1,3 +1,3 @@
 module Pinkman
-  VERSION = "0.9.9.8"
+  VERSION = "0.9.9.9.0"
 end

data/lib/pinkman/views_helpers/collection_helper.rb

@@ -0,0 +1,16 @@
+require_relative '../base_helper.rb'
+
+module Pinkman
+  module ViewsHelpers
+    module CollectionHelper
+      
+      extend Pinkman::BaseHelper
+      
+      define_helper :each do |block=nil|
+        p.wrap_in('collection',&block)
+      end
+      define_helper_alias :collection, :each
+      
+    end
+  end
+end

data/lib/pinkman/views_helpers/conditional_helper.rb

@@ -0,0 +1,19 @@
+require_relative '../base_helper.rb'
+
+module Pinkman
+  module ViewsHelpers
+    module ConditionalHelper
+      
+      extend Pinkman::BaseHelper
+      
+      define_helper :if do |condition, block=nil|
+        p.wrap_in(condition,&block) if block.is_a?(Proc)
+      end
+
+      define_helper :unless do |condition, block=nil|
+        raw "\n{{^ #{condition} }}\n \t #{capture(&block)} \n{{/ #{condition} }}\n" if block.is_a?(Proc)
+      end
+    
+    end
+  end
+end

data/lib/pinkman/views_helpers/dispatcher.rb

@@ -0,0 +1,27 @@
+module Pinkman
+  module ViewsHelpers
+    class Dispatcher
+      attr_accessor :rails_helper
+      
+      def initialize value
+        @rails_helper = value
+      end
+      
+      def method_missing m, *args, &block
+        if Pinkman::ViewsHelpers.respond_to?(m)
+          if block_given?
+            rails_helper.instance_exec(*args,block,&Pinkman::ViewsHelpers.send(m))
+          else
+            rails_helper.instance_exec(*args,&Pinkman::ViewsHelpers.send(m))
+          end
+        else
+          super(m)
+        end
+      end
+    end
+    
+    def self.dispatcher rails_helper
+      Dispatcher.new(rails_helper)
+    end
+  end
+end

data/lib/pinkman/views_helpers/form_helper.rb

@@ -0,0 +1,63 @@
+require_relative '../base_helper.rb'
+
+module Pinkman
+  module ViewsHelpers
+    module FormHelper
+      
+      extend Pinkman::BaseHelper
+      
+      define_helper :textfield do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name}}
+      end
+      
+      define_helper :datefield do |attr_name,label=nil|
+        label ||= attr_name.titleize
+        render partial: 'pinkman/pinkman/form_input', locals: {attr_name: attr_name, label: label, input_options: {name: attr_name}}
+      end
+      
+      define_helper :input do |hash|
+        hash[:type] ||= 'text'
+        tag(:input,hash.merge(data: {pinkey: p.pinkey, action: hash[:name]}, value: p.write(hash[:name])))
+      end
+    
+      define_helper :textarea do |hash|
+        content_tag('textarea',hash.merge(data: {pinkey: p.pinkey, action: hash[:name]}, value: p._w(hash[:name]))) do 
+          p._w(hash[:name])
+        end
+      end
+      
+      define_helper :select do |attr_name,options_hash={}, block|
+        content_tag('select',options_hash.merge(name: attr_name, data: {pinkey: p.pinkey, action: attr_name}),&block)
+      end
+      
+      define_helper :form do |action_name, hash={}, block|
+        content_tag 'form',hash.merge({action: '', data: {pinkey: p.pinkey, action: action_name}}) do
+          block.call(Pinkman::FormHelper.dispatcher(self))
+        end
+      end
+      
+      define_helper :submit do |val|
+        tag 'input', {type: 'submit', value: val, class: 'submit-button'}
+      end
+      
+      define_helper :error_for do |attr,label=nil|
+        label ||= attr.to_s.titleize
+        render partial: '/pinkman/error_for', locals: {attribute: attr, label: label}
+      end
+      
+      define_helper :has_errors? do |block|
+        p.if('errors',block)
+      end
+      
+      define_helper :valid? do |block|
+        p.unless('errors',block)
+      end
+      
+      define_helper :first_error do
+        p._w('firstError')
+      end
+      
+    end
+  end
+end

data/lib/pinkman/views_helpers/template_helper.rb

@@ -0,0 +1,65 @@
+require_relative '../base_helper.rb'
+
+module Pinkman
+  module ViewsHelpers
+    module TemplateHelper
+      
+      extend Pinkman::BaseHelper
+      
+      define_helper :template  do |path, block=nil|
+        # definition mode
+        if block.is_a?(Proc)
+          name = path.to_s
+          id = (/(?:-template)$/ =~ name) ? name : (name + '-template')
+          content_tag('script',{id: id, type: 'text/p-template'},&block)
+        # rendering mode
+        else
+          render partial: "pinkman/#{path}"
+        end
+      end
+      
+      define_helper :layout do |path, block=nil|
+        path = path + '-layout' unless path.match /-layout$/
+        p.template(path,block)
+      end
+      
+      define_helper :content_tag do |*args|
+        block = args.pop if args.last.is_a?(Proc)
+        if block
+          content_tag(*args,&block)
+        else
+          content_tag(*args)
+        end
+      end
+       
+      define_helper :partial do |path, block=nil|
+        # definition mode
+        name = path.to_s
+        id = (/(?:-template)$/ =~ name) ? name : (name + '-template')
+        if block.is_a?(Proc)
+          content_tag('script',{id: id, type: 'text/p-partial', class: 'p'},&block)
+        # rendering template partial mode
+        else
+          content_tag 'div', {id: name} do 
+            raw("{{ partial(#{id}) }}")
+          end
+        end
+      end
+      
+      define_helper :load_templates do |dir_path=nil|
+        if Rails
+          pinkman_views_dir_path = Rails.root.join('app','views','pinkman')
+          selected_dir_path = pinkman_views_dir_path
+          selected_dir_path = selected_dir_path.join(dir_path.to_s) if dir_path.class.in?([String,Symbol])
+          files = Dir.glob(selected_dir_path.join('**/_*')).map do |f|    
+            f.sub!(Regexp.new("#{pinkman_views_dir_path.to_s}[\\\/]"),'')
+            f.sub(File.basename(f),File.basename(f).sub('_',''))
+          end
+          raw(files.map{|f| p.template(f)}.join("\n"))
+        else
+          raise 'Rails application not found.'
+        end
+      end
+    end
+  end
+end

data/lib/pinkman/views_helpers/writer_helper.rb

@@ -0,0 +1,31 @@
+require_relative '../base_helper.rb'
+
+module Pinkman
+  module ViewsHelpers
+    module WriterHelper
+      
+      extend Pinkman::BaseHelper
+      
+      define_helper :write do |string|
+        raw "{{ #{string} }}"
+      end
+      define_helper_alias :w, :write
+      
+      define_helper :write_and_escape_sync do |string|
+        raw("{{. #{string} }}")
+      end
+      define_helper_alias :_w, :write_and_escape_sync
+      
+      define_helper :wrap_in do |tag,block=nil|
+        raw "\n{{# #{tag} }}\n \t #{capture(&block)} \n{{/ #{tag} }}\n" if block.is_a?(Proc)
+      end
+      define_helper_alias :wrap, :wrap_in
+      
+      define_helper :pinkey do
+        p.write('pinkey')
+      end
+      define_helper_alias :key, :pinkey
+      
+    end
+  end
+end

data/lib/pinkman/views_helpers.rb

@@ -0,0 +1,71 @@
+Dir[File.expand_path('../views_helpers/*.rb',__FILE__)].each {|file| require file }
+
+module Pinkman
+  module ViewsHelpers
+    extend WriterHelper
+    extend ConditionalHelper
+    extend CollectionHelper
+    extend TemplateHelper
+    extend FormHelper
+  end
+end
+    
+# --- About:
+# This file defines the Pinkman helpers we use in views.
+
+# There is an extra layer of code so 
+# we can namespace all Pinkman helpers with a 'p'.
+# Just call p.method_name in the application.
+
+# --- How this work:
+
+# The Dispatcher's role is binding Rails Helpers and this module.
+# It allow us to run this module methods within a Rails Helpers context (scope). 
+# In other words, this module acts exactly like a Rails Helper. 
+# Every method acessible there also is acessible here.
+
+# The dispatcher, as the name suggests, is responsible to be up front in a Rails 
+# Helper and pass this module all the messages received.
+#  module NormalRailsHelper 
+#    def p
+#      Pinkman::ViewsHelpers.dispatcher(self)
+#    end
+#  end
+# 
+#  p.some_method => Pinkman::ViewsHelpers.some_method
+#
+
+# Another thing to keep in mind is that
+# to define new methods, use the 'define_helper' method.
+
+# --- Why not a simple Rails Helper?
+# I swear I tried. But:
+
+# 1. Pinkman Helpers should be isolated from Rails and Custom Helpers
+
+# 2. p_some_method would not acomplished that.
+
+# 3. If I were to define these as -- instance -- methods of a common Rails Helper,
+# then those methods wouldn't be isolated.
+
+# 4. If I were to define these as -- class -- methods of a common Rails Helper (PinkmanHelper.do_something),
+# then the scope would not allow us to call ActionView::Helpers like capture, raw, etc.
+
+# 5. If I were to extend/include ActionViews::Helpers directly here, 
+# it would broke. I tried. A lot.
+
+# 6. This what I got for now. 
+# If you think of another better way to solve this 
+# keeping the p.method_name convention (not p_method_name), 
+# just send a pull request.
+
+# --- Attention
+# Blocks will be passed to these helpers in the last argument position
+# as procs. So...
+
+# Use:
+#   define_method :method_name do |one, two, block=nil|
+
+# DONT't use:
+#   define_method :method_name do |one, two, &block| 
+#   (this won't work)

data/lib/pinkman.rb

@@ -2,6 +2,8 @@ require 'rails'
 require 'pathname'
 require 'active_model_serializers'
 require 'pinkman/serializer'
+require 'pinkman/views_helpers'
+require 'pinkman/form_helper'
 require 'pinkman/version'
 
 module Pinkman
@@ -22,6 +24,14 @@ module Pinkman
   
   class Engine < ::Rails::Engine
     config.after_initialize do
+      Rails.application.routes.append do
+        mount Pinkman::Engine => '/'
+      end
+      
+      module ApplicationHelper
+        extend PinkmanHelper
+      end
+      
       if defined? Slim
         Slim::Engine.set_options attr_list_delims: {'(' => ')', '[' => ']'}
       end
@@ -37,12 +47,17 @@ module Pinkman
         end
       end
 
-      # Active Record Relation: json_for
+      # Active Record Relation: json
       ActiveRecord::Relation.class_eval do 
-        def json_for scope_name, params_hash = {}
+        def json scope_name, params_hash = {}
           serialize_for(scope_name,params_hash).to_json
         end
         
+        def json_for *args, &block
+          ActiveSupport::Deprecation.warn('"json_for" deprecated. Use "json" instead.')
+          json(*args,&block)
+        end
+        
         def serialize_for scope_name, params_hash = {}
           options = {scope: scope_name}.merge(params: params_hash)
           s = Pinkman::Serializer::array(self, options)
@@ -51,10 +66,15 @@ module Pinkman
       end
 
       Array.class_eval do
-        def json_for scope_name, params_hash = {}
+        def json scope_name, params_hash = {}
           serialize_for(scope_name,params_hash).to_json
         end
         
+        def json_for *args, &block
+          ActiveSupport::Deprecation.warn('"json_for" deprecated. Use "json" instead.')
+          json(*args,&block)
+        end
+        
         def serialize_for scope_name, params_hash = {}
           options = {scope: scope_name}.merge(params: params_hash)
           s = Pinkman::Serializer::array(self, options)
@@ -62,19 +82,25 @@ module Pinkman
         end
       end
 
-      # Instance method: json_for
+      # Instance method: json
       ActiveRecord::Base.class_eval do
         def serialize_for scope_name, params_hash = {}
           options = {scope: scope_name}.merge(params: params_hash)
           self.class.serializer.new(self,options)
         end
 
-        def json_for scope_name, params_hash={}
+        def json scope_name, params_hash={}
           serialize_for(scope_name,params_hash).to_json
         end
+        
+        def json_for *args, &block
+          ActiveSupport::Deprecation.warn('"json_for" deprecated. Use "json" instead.')
+          json(*args,&block)
+        end
 
       end
     end
+    
   end
   
 end