RubyGems - styx - Versions diffs - 0.0.1 - Mend

styx 0.0.1

Files changed (12) hide show

data/README.md +158 -0
data/app/assets/javascripts/styx.forms.js.coffee +27 -0
data/app/assets/javascripts/styx.js.coffee +22 -0
data/app/views/styx/_initializer.html.haml +9 -0
data/init.rb +1 -0
data/lib/styx.rb +8 -0
data/lib/styx/engine.rb +4 -0
data/lib/styx/forms.rb +33 -0
data/lib/styx/helpers.rb +32 -0
data/lib/styx/initializer.rb +27 -0
data/styx.gemspec +14 -0
metadata +57 -0

data/README.md ADDED

@@ -0,0 +1,158 @@
+Styx
+========
+Bridge between Server (Rails) side and Client (JS) side divided into several modules:
+* **Helpers**: set of helpers to support all other modules.
+* **Initializer**: organizes JS into bootstrap classes and allows you to pass data from controller/view.
+* **Forms**: remote validaton engine.
+Installation
+------------
+    $ gem install styx
+Basic Usage
+------------
+```ruby
+# app/controllers/foos_controller.rb
+class FoosController < ApplicationController
+  include Styx::Initializer
+  include Styx::Forms
+end
+```
+Include modules to ApplicationController if you want to use it everywhere.
+Initializer
+------------
+In common each controller in Rails comes with *app/assets/javascripts/controller_name.js.coffee*.
+Styx.Initializer allows you to separately define bootstrap logic for each Rails action and pass
+some data from server right in.
+To enable initializers bootstrap, add *styx_initialize* line to your layout:
+```erb
+  <head>
+    <title>Rails Application</title>
+    <%= stylesheet_link_tag    "application" %>
+    <%= javascript_include_tag "application" %>
+    <%= styx_initialize %>
+    <%= csrf_meta_tags %>
+```
+Imagine you have controller *Foos* and therefore *app/assets/javascripts/foos.js.coffee* file.
+```coffee-script
+@Styx.Initializers.Foos =
+  initialize: ->
+    console.log 'This will be called in foos#ANY action after <head> was parsed'
+  index: (data) ->
+    console.log 'This will be called in foos#index action after <head> was parsed'
+  show: (data) ->
+    $ ->
+      console.log 'This will be called in foos#show action after the page was loaded'
+```
+Note that any method besides common *initialize* has the *data* parameter. To pass some data to your
+initializers you can use *styx_initialize_with* helper in your controller or views. Like that:
+```ruby
+# app/controllers/foos_controller.rb
+class FoosController < ApplicationController
+  def index
+    styx_initialize_with :some => 'data', :and => {:even => 'more data'}
+  end
+end
+# app/views/foos/index.html.erb
+<%- styx_initialize_with :enabled => true %>
+```
+As the result *Styx.Initializers.Foos->index* will be called with data equal to
+    {some: data, and: {even: 'mode data'}, enabled: true}
+Forms
+------------
+Forms assist *form_for @foo, :remote => true* to automate server response and UJS callbacks.
+If everything went smooth you can respond with URL for redirect or with JSON for your callback.
+If validation failed appropriate form fields will be wraped with native
+    <div class="field_with_errors">
+### Client side
+```erb
+# app/views/foos/new.html.erb
+<%= form_for @foo, :remote => true, :html => {:id => 'foo_form'} do |f| %>
+  <%= f.text_field :f.title %>
+<% end %>
+```
+```javascript
+// Light case
+Forms.attach('#foo_form')
+// Heavy case
+success_callback = function(data) {}    // Form validated and stored. Data is what you pass from server.
+error_callback = function() {}          // Form wasn't validated
+Forms.attach('#foo_form', success_callback, error_callback)
+```
+Note that if success_callback was not given but server responded with some data, Styx.Forms will try
+to evaluate it as URL and will try to redirect to it.
+Javascript part goes best with Styx.Initializers.
+### Server side
+In common you just want to store your form as model. Styx.Forms come with predefined helper for this:
+```ruby
+# app/controllers/foos_controller.rb
+def create
+  @entity  = Foo.new(params[:foo])
+  response = foos_url                   # Return URL or anything for your custom callback
+  styx_form_store_and_respond(@foo, response) do
+    # this will be called after (and if) @foo was validated and saved
+  end
+end
+```
+*response* parameter can either be passed as lambda{|x|}.
+### What if form was invalid?
+First of all, *success_callback* and server-side block won't be called. *response* won't be return to JS.
+Validation errors for @entity will be returned instead. All invalid form fields will be wraped with
+    <div class="field_with_errors">
+### Server side without models
+To work without models (i.e. to serve login form) you can use two helpers
+```ruby
+  styx_form_respond_success(data)
+```
+```ruby
+  styx_form_respond_failure(entity_name, fields) # fields = {'field_name' => 'error message'}
+```
+To choose which fields have to be marked as invalid JS part will concatenate entity_name + field _name. So if
+you don't have entity, simply pass empty string as the first arg.

data/app/assets/javascripts/styx.forms.js.coffee ADDED

@@ -0,0 +1,27 @@
+@Styx.Forms =
+  validate: (element, success_action=false, error_action=false, substitutions={}) ->
+    $(element).live 'ajax:success', (event, result, status, xhr) ->
+      $(element).find('.field_with_errors').children().unwrap()
+      unless success_action
+        Styx.URL.go xhr.responseText, true
+      else
+        success_action.call(this, xhr.responseText)
+    $(element).live 'ajax:error', (evt, xhr, status, error) ->
+      $(element).find('.field_with_errors').children().unwrap()
+      error_action.call(this) if error_action
+      errors = jQuery.parseJSON xhr.responseText
+      console.log errors if console?
+      for field, notifications of errors.messages
+        field = substitutions[field] if substitutions[field]?
+        input = $(element).find("##{errors.entity}_#{field}")
+        # Support for Chosen jQuery plugin
+        if input.is('.chzn-done')
+          input = $(element).find("##{errors.entity}_#{field}_chzn")
+        input.wrap("<div class='field_with_errors' />")

data/app/assets/javascripts/styx.js.coffee ADDED

@@ -0,0 +1,22 @@
+@Styx = {
+  Initializers: {}
+}
+@Styx.URL =
+  go: (url, force=false) ->
+    # 'Force' required if you want to reload same page with another anchor
+    url = this.build(url, "reloadthispagepls=#{Math.random()}") if force
+    window.location.href = url
+  build: (url, params) ->
+    hash = url.match(/\#.*$/)
+    hash = if hash then hash[0] else false
+    url = url.replace(hash, '') if hash
+    url = url + "?" if url.indexOf("?") == -1
+    url = "#{url}&#{params}"
+    url = url + hash if hash
+    return url

data/app/views/styx/_initializer.html.haml ADDED

@@ -0,0 +1,9 @@
+:javascript
+  if (Styx.Initializers.#{klass} && Styx.Initializers.#{klass}.initialize)
+  {
+    Styx.Initializers.#{klass}.initialize(#{data.to_json})
+  }
+  if (Styx.Initializers.#{klass} && Styx.Initializers.#{klass}.#{method})
+  {
+    Styx.Initializers.#{klass}.#{method}(#{data.to_json})
+  }

data/init.rb ADDED

	@@ -0,0 +1 @@
1	+ require 'styx'

data/lib/styx.rb ADDED

@@ -0,0 +1,8 @@
+require 'styx/engine'
+require 'styx/helpers'
+require 'styx/forms'
+require 'styx/initializer'
+ActionController::Base.send :include, Styx::Helpers
+# ActionController::Base.send :include, Styx::Forms
+# ActionController::Base.send :include, Styx::Initializer

data/lib/styx/engine.rb ADDED

@@ -0,0 +1,4 @@
+module Styx #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/styx/forms.rb ADDED

@@ -0,0 +1,33 @@
+module Styx
+  module Forms
+    def self.included base
+      base.send(:include, InstanceMethods)
+    end
+    module InstanceMethods
+      def styx_form_store_and_respond(entity, data=nil, &block)
+        response.content_type = Mime::TEXT
+        if entity.save
+          styx_form_respond_success(data, entity, &block)
+        else
+          styx_form_respond_failure(entity.class.name, entity.errors.messages)
+        end
+      end
+      def styx_form_respond_failure(entity, errors)
+        response.content_type = Mime::TEXT
+        errors = Hash[*errors.map {|x| [x, nil]}.flatten] if errors.is_a?(Array)
+        render :text => {:entity => entity.to_s.underscore.gsub('/', '_'), :messages => errors}.to_json, :status => :unprocessable_entity
+      end
+      def styx_form_respond_success(data, entity=nil, &block)
+        response.content_type = Mime::TEXT
+        block.call(entity) if block_given?
+        render :text => (data.is_a?(Proc) ? data.call(entity) : data)
+      end
+    end
+  end
+end

data/lib/styx/helpers.rb ADDED

@@ -0,0 +1,32 @@
+module Styx
+  module Helpers
+    def self.included base
+      base.send(:include, InstanceMethods)
+      base.class_eval do
+        helper_method :this_page?, :this_namespace?
+      end
+    end
+    module InstanceMethods
+      def this_page?(mask)
+        mask = mask.split('#')
+        c = mask[0]
+        a = mask[1]
+        flag = true
+        flag = false if !c.blank? && c != controller_path
+        flag = false if !a.blank? && a != action_name
+        flag
+      end
+      def this_namespace?(namespace)
+        current = controller_path.split('/').first
+        return namespace == current
+      end
+    end
+  end
+end

data/lib/styx/initializer.rb ADDED

@@ -0,0 +1,27 @@
+module Styx
+  module Initializer
+    def self.included base
+      base.send(:include, InstanceMethods)
+      base.class_eval do
+        helper_method :styx_initialize, :styx_initialize_with
+        before_filter { @styx_initialize_with = {} }
+      end
+    end
+    module InstanceMethods
+      def styx_initialize_with(data)
+        @styx_initialize_with.merge! data
+      end
+      def styx_initialize()
+        result = render_to_string :partial => 'styx/initializer', :locals => {
+          :klass  => controller_path.gsub('/', '_').camelize,
+          :method => action_name,
+          :data   => @styx_initialize_with
+        }
+        result.html_safe
+      end
+    end
+  end
+end

data/styx.gemspec ADDED

@@ -0,0 +1,14 @@
+SPEC = Gem::Specification.new do |s|
+  s.name        = "styx"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "Set of helpers to maintain bridge between Server (Rails) side and Client (JS) side"
+  s.email       = "boris@roundlake.ru"
+  s.homepage    = "http://github.com/roundlake/styx"
+  s.description = s.summary
+  s.authors     = ['Boris Staal']
+  s.has_rdoc = false # disable rdoc generation until we've got more
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+end

metadata ADDED

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: styx
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease:
+platform: ruby
+authors:
+- Boris Staal
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-11-22 00:00:00.000000000 Z
+dependencies: []
+description: Set of helpers to maintain bridge between Server (Rails) side and Client
+  (JS) side
+email: boris@roundlake.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- app/assets/javascripts/styx.forms.js.coffee
+- app/assets/javascripts/styx.js.coffee
+- app/views/styx/_initializer.html.haml
+- init.rb
+- lib/styx.rb
+- lib/styx/engine.rb
+- lib/styx/forms.rb
+- lib/styx/helpers.rb
+- lib/styx/initializer.rb
+- styx.gemspec
+homepage: http://github.com/roundlake/styx
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.10
+signing_key:
+specification_version: 3
+summary: Set of helpers to maintain bridge between Server (Rails) side and Client
+  (JS) side
+test_files: []