skozlov-netzke-core 0.1.0

data/lib/netzke/controller_extensions.rb

@@ -0,0 +1,87 @@
+module Netzke
+  module ControllerExtensions
+    def self.included(base)
+      base.extend ControllerClassMethods
+    end
+    
+    def method_missing(method_name)
+      if self.class.widget_config_storage == {}
+        super
+      else
+        widget, *action = method_name.to_s.split('__')
+        widget = widget.to_sym
+        action = !action.empty? && action.join("__").to_sym
+      
+        # only widget's actions starting with "interface_" are accessible from outside (security)
+        if action
+          interface_action = action.to_s.index('__') ? action : "interface_#{action}"
+
+          # widget module
+          widget_class = "Netzke::#{self.class.widget_config_storage[widget][:widget_class_name]}".constantize
+
+          # instantiate the server part of the widget
+          widget_instance = widget_class.new(self.class.widget_config_storage[widget].merge(:controller => self)) # OPTIMIZE: top-level widgets have access to the controller - can we avoid that?
+          render :text => widget_instance.send(interface_action, params)
+        end
+      end
+    end
+    
+    module ControllerClassMethods
+
+      # widget_config_storage for all widgets
+      def widget_config_storage
+        @@widget_config_storage ||= {}
+      end
+    
+      #
+      # Use this method to declare a widget in the controller
+      #
+      def netzke_widget(name, config={})
+        # which module is the widget?
+        config[:widget_class_name] ||= name.to_s.classify
+        config[:name] ||= name
+      
+        # register the widget config in the storage
+        widget_config_storage[name] = config
+
+        # provide widget helpers
+        ActionView::Base.module_eval <<-END_EVAL, __FILE__, __LINE__
+          def #{name}_widget_instance(config = {})
+            # get the global config from the controller's singleton class
+            global_config = controller.class.widget_config_storage[:#{name}]
+
+            # when instantiating a client side instance, the configuration may be overwritten 
+            # (but the server side will know nothing about it!)
+            local_config = global_config.merge(config)
+
+            # instantiate it
+            widget_instance = Netzke::#{config[:widget_class_name]}.new(local_config)
+          
+            # return javascript code for instantiating on the javascript level
+            widget_instance.js_widget_instance
+          end
+          
+          def #{name}_class_definition
+            config = controller.class.widget_config_storage[:#{name}]
+            Netzke::#{config[:widget_class_name]}.new(config).js_missing_code
+          end
+        END_EVAL
+      
+        # add controller action which will render a simple HTML page containing the widget
+        define_method("#{name}_test") do
+          render :inline => %Q(
+          <script type="text/javascript" charset="utf-8">
+          <%= #{name}_class_definition %>
+          Ext.onReady(function(){
+          	<%= #{name}_widget_instance %>
+          	#{name.to_js}.render("#{name.to_s.split('_').join('-')}");
+          })
+        	</script>
+          <div id="#{name.to_s.split('_').join('-')}"></div>
+          ), :layout => "netzke"
+        end
+      end
+    end
+  end
+  
+end

data/lib/netzke/core_ext.rb

@@ -0,0 +1,77 @@
+class Hash
+
+  # Recursively convert the keys. Example:
+  # irb> {:bla_bla => 1, "wow_now" => {:look_ma => true}}.convert_keys{|k| k.camelize} 
+  # irb> => {:BlaBla => 1, "WowNow" => {:LookMa => true}}
+  def convert_keys(&block)
+    block_given? ? self.inject({}) do |h,(k,v)|
+      h[k.is_a?(Symbol) ? yield(k.to_s).to_sym : yield(k.to_s)] = v.respond_to?('convert_keys') ? v.convert_keys(&block) : v
+      h
+    end : self
+  end
+  
+  # First camelizes the keys, then convert the whole hash to JSON
+  def to_js
+    # self.delete_if{ |k,v| v.nil? } # we don't need to explicitely pass null values to javascript
+    self.recursive_delete_if_nil.convert_keys{|k| k.camelize(:lower)}.to_json
+  end
+
+  # Converts values to strings
+  def stringify_values!
+    self.each_pair{|k,v| self[k] = v.to_s if v.is_a?(Symbol)}
+  end
+  
+  def recursive_delete_if_nil
+    self.inject({}) do |h,(k,v)|
+      if !v.nil?
+        h[k] = v.respond_to?('recursive_delete_if_nil') ? v.recursive_delete_if_nil : v
+      end
+      h
+    end
+  end
+  
+end
+
+class Array
+  # Camelizes the keys of hashes and converts them to JSON
+  def to_js
+    self.recursive_delete_if_nil.map{|el| el.is_a?(Hash) ? el.convert_keys{|k| k.camelize(:lower)} : el}.to_json
+  end
+  
+  # Applies convert_keys to each element which responds to convert_keys
+  def convert_keys(&block)
+    block_given? ? self.map do |i|
+      i.respond_to?('convert_keys') ? i.convert_keys(&block) : i
+    end : self
+  end
+  
+  def recursive_delete_if_nil
+    self.map{|el| el.respond_to?('recursive_delete_if_nil') ? el.recursive_delete_if_nil : el}
+  end
+end
+
+class String
+  # Converts self to "literal JSON"-string - one that doesn't get quotes appended when being sent "to_json" method
+  def l
+    def self.to_json
+      self
+    end
+    self
+  end
+  
+  def to_js
+    self.camelize(:lower)
+  end
+  
+  # removes JS-comments (both single-line and multiple-line) from the string
+  def strip_js_comments
+    regexp = /\/\/.*$|(?m:\/\*.*?\*\/)/
+    self.gsub(regexp, '')
+  end
+end
+
+class Symbol
+  def to_js
+    self.to_s.camelize(:lower).to_sym
+  end
+end

data/lib/netzke/js_class_builder.rb

@@ -0,0 +1,125 @@
+module Netzke
+  # 
+  # Module which provides JS-class generation functionality for the widgets ("client-side"). This code is executed only once per widget class, and the results are cached at the server (unless widget specifies config[:no_caching] => true).
+  # Included into Netzke::Base class
+  # Most of the methods below are meant to be overwritten by a concrete widget class.
+  # 
+  module JsClassBuilder
+    # the JS (Ext) class that we inherit from
+    def js_base_class; "Ext.Panel"; end
+
+    # widget's actions that are loaded at the moment of instantiating a widget
+    def actions; null; end
+
+    # widget's tools that are loaded at the moment of instantiating a widget see (js_config method)
+    def tools; []; end
+    
+    def tbar; null; end
+
+    def bbar; null; end
+
+    # functions and properties that will be used to extend the functionality of (Ext) JS-class specified in js_base_class
+    def js_extend_properties; {}; end
+    
+    # code executed before and after the constructor
+    def js_before_constructor; ""; end
+    def js_after_constructor; ""; end
+
+    # widget's listeners
+    def js_listeners; {}; end
+    
+    # widget's menus
+    def js_menus; []; end
+    
+    # items
+    def js_items; null; end
+
+    # default config that is passed into the constructor
+    def js_default_config
+      {
+        :title => short_widget_class_name,
+        :listeners => js_listeners,
+        :tools => "config.tools".l,
+        :actions => "config.actions".l,
+        :tbar => "config.tbar".l,
+        :bbar => "config.bbar".l,
+        :items => js_items,
+        :height => 400,
+        :width => 800,
+        :border => false
+      }
+    end
+
+    # declaration of widget's class (stored directly in the cache storage at the client side to be reused at the moment of widget instantiation)
+    def js_class
+      <<-JS
+      
+      /* Wow, look...
+      Wow, look...
+      Wow, look...
+      Wow, look...
+      Wow, look...
+      Wow, look...
+      Wow, look...
+      Wow, look...
+      */
+      
+      Ext.componentCache['#{short_widget_class_name}'] = Ext.extend(#{js_base_class}, Ext.chainApply([Ext.widgetMixIn, {
+        constructor: function(config){
+          this.widgetInit(config);
+          #{js_before_constructor}
+          Ext.componentCache['#{short_widget_class_name}'].superclass.constructor.call(this, Ext.apply(#{js_default_config.to_js}, config));
+          #{js_after_constructor}
+          this.setEvents();
+          this.addMenus(#{js_menus.to_js});
+        }
+      }, #{js_extend_properties.to_js}]))
+      JS
+    end
+
+    # generate instantiating - used when a widget is generated stand-alone (as a part of a HTML page)
+    def js_widget_instance
+      %Q(var #{config[:name].to_js} = new Ext.componentCache['#{short_widget_class_name}'](#{js_config.to_js});)
+    end
+
+    # the config that is send from the server and is used for instantiating a widget
+    def js_config
+      res = {}
+      
+      # recursively include configs of all (non-late) aggregatees, so that the widget can instantiate them, too
+      aggregatees.each_pair do |aggr_name, aggr_config|
+        next if aggr_config[:late_aggregation]
+        res["#{aggr_name}_config".to_sym] = aggregatee_instance(aggr_name.to_sym).js_config
+      end
+      
+      # interface
+      interface = interface_points.inject({}){|h,interfacep| h.merge(interfacep => widget_action(interfacep))}
+      res.merge!(:interface => interface)
+      
+      res.merge!(:widget_class_name => short_widget_class_name)
+
+      res.merge!(config[:ext_config])
+      res.merge!(:id => @id_name)
+      
+      # include tools and actions
+      res.merge!(:tools => tools)
+      res.merge!(:actions => actions)
+      res
+    end
+
+    # class definition of the widget plus that of all the dependencies, minus those that are specified as dependencies_to_exclude
+    def js_missing_code(dependencies_to_exclude = [])
+      result = ""
+      dependencies.each do |dep_name|
+        dependency_class = "Netzke::#{dep_name}".constantize
+        result << dependency_class.new(config).js_missing_code(dependencies_to_exclude)
+      end
+      result << js_class.strip_js_comments unless dependencies_to_exclude.include?(short_widget_class_name) && !config[:no_caching]
+      result
+    end
+   
+    # little helpers
+    def this; "this".l; end
+    def null; "null".l; end
+  end
+end

data/lib/netzke-core.rb

@@ -0,0 +1,22 @@
+# NetzkeCore
+require 'netzke/js_class_builder'
+require 'netzke/base'
+require 'netzke/core_ext'
+require 'netzke/controller_extensions'
+
+# Vendor
+require 'vendor/facets/hash/recursive_merge'
+
+
+%w{ models controllers }.each do |dir|
+  path = File.join(File.dirname(__FILE__), 'app', dir)
+  $LOAD_PATH << path
+  ActiveSupport::Dependencies.load_paths << path
+  ActiveSupport::Dependencies.load_once_paths.delete(path)
+end
+
+ActionController::Base.class_eval do
+  include Netzke::ControllerExtensions
+end
+
+# Netzke::Base.config[:javascripts] << "#{File.dirname(__FILE__)}/../javascripts/core.js"

data/lib/vendor/facets/hash/recursive_merge.rb

@@ -0,0 +1,28 @@
+class Hash
+  # Same as Hash#merge but recursively merges sub-hashes.
+  def recursive_merge(other)
+    hash = self.dup
+    other.each do |key, value|
+      myval = self[key]
+      if value.is_a?(Hash) && myval.is_a?(Hash)
+        hash[key] = myval.recursive_merge(value)
+      else
+        hash[key] = value
+      end
+    end
+    hash
+  end
+
+  # Same as Hash#merge! but recursively merges sub-hashes.
+  def recursive_merge!(other)
+    other.each do |key, value|
+      myval = self[key]
+      if value.is_a?(Hash) && myval.is_a?(Hash)
+        myval.recursive_merge!(value)
+      else
+        self[key] = value
+      end
+    end
+    self
+  end
+end

data/netzke-core.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{netzke-core}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sergei Kozlov"]
+  s.date = %q{2008-12-27}
+  s.description = %q{Build ExtJS/Rails widgets with minimum effort}
+  s.email = %q{sergei@writelesscode.com}
+  s.extra_rdoc_files = ["CHANGELOG", "lib/app/controllers/netzke_controller.rb", "lib/app/models/netzke_layout.rb", "lib/app/models/netzke_preference.rb", "lib/netzke/base.rb", "lib/netzke/controller_extensions.rb", "lib/netzke/core_ext.rb", "lib/netzke/js_class_builder.rb", "lib/netzke-core.rb", "lib/vendor/facets/hash/recursive_merge.rb", "LICENSE", "README.markdown", "tasks/netzke_core_tasks.rake"]
+  s.files = ["CHANGELOG", "generators/netzke_core/netzke_core_generator.rb", "generators/netzke_core/templates/create_netzke_layouts.rb", "generators/netzke_core/templates/create_netzke_preferences.rb", "generators/netzke_core/templates/netzke.html.erb", "generators/netzke_core/USAGE", "init.rb", "install.rb", "javascripts/core.js", "lib/app/controllers/netzke_controller.rb", "lib/app/models/netzke_layout.rb", "lib/app/models/netzke_preference.rb", "lib/netzke/base.rb", "lib/netzke/controller_extensions.rb", "lib/netzke/core_ext.rb", "lib/netzke/js_class_builder.rb", "lib/netzke-core.rb", "lib/vendor/facets/hash/recursive_merge.rb", "LICENSE", "Manifest", "Rakefile", "README.markdown", "tasks/netzke_core_tasks.rake", "test/app_root/app/controllers/application.rb", "test/app_root/config/boot.rb", "test/app_root/config/database.yml", "test/app_root/config/environment.rb", "test/app_root/config/environments/in_memory.rb", "test/app_root/config/environments/mysql.rb", "test/app_root/config/environments/postgresql.rb", "test/app_root/config/environments/sqlite.rb", "test/app_root/config/environments/sqlite3.rb", "test/app_root/config/routes.rb", "test/app_root/script/console", "test/core_ext_test.rb", "test/netzke_core_test.rb", "test/test_helper.rb", "uninstall.rb", "netzke-core.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://writelesscode.com}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Netzke-core", "--main", "README.markdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{netzke-core}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Build ExtJS/Rails widgets with minimum effort}
+  s.test_files = ["test/core_ext_test.rb", "test/netzke_core_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/tasks/netzke_core_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :netzke-core do
+#   # Task goes here
+# end

data/test/app_root/app/controllers/application.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/test/app_root/config/boot.rb

@@ -0,0 +1,114 @@
+# Allow customization of the rails framework path
+RAILS_FRAMEWORK_ROOT = (ENV['RAILS_FRAMEWORK_ROOT'] || "#{File.dirname(__FILE__)}/../../../../../../vendor/rails") unless defined?(RAILS_FRAMEWORK_ROOT) 
+
+# Don't change this file!
+# Configure your app in config/environment.rb and config/environments/*.rb
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/.." unless defined?(RAILS_ROOT)
+
+module Rails
+  class << self
+    def boot!
+      unless booted?
+        preinitialize
+        pick_boot.run
+      end
+    end
+
+    def booted?
+      defined? Rails::Initializer
+    end
+
+    def pick_boot
+      (vendor_rails? ? VendorBoot : GemBoot).new
+    end
+
+    def vendor_rails?
+      File.exist?(RAILS_FRAMEWORK_ROOT)
+    end
+
+    def preinitialize
+      load(preinitializer_path) if File.exist?(preinitializer_path)
+    end
+
+    def preinitializer_path
+      "#{RAILS_ROOT}/config/preinitializer.rb"
+    end
+  end
+
+  class Boot
+    def run
+      load_initializer
+      Rails::Initializer.run(:set_load_path)
+    end
+  end
+
+  class VendorBoot < Boot
+    def load_initializer
+      require "#{RAILS_FRAMEWORK_ROOT}/railties/lib/initializer"
+      Rails::Initializer.run(:install_gem_spec_stubs)
+    end
+  end
+
+  class GemBoot < Boot
+    def load_initializer
+      self.class.load_rubygems
+      load_rails_gem
+      require 'initializer'
+    end
+
+    def load_rails_gem
+      if version = self.class.gem_version
+        gem 'rails', version
+      else
+        gem 'rails'
+      end
+    rescue Gem::LoadError => load_error
+      $stderr.puts %(Missing the Rails #{version} gem. Please `gem install -v=#{version} rails`, update your RAILS_GEM_VERSION setting in config/environment.rb for the Rails version you do have installed, or comment out RAILS_GEM_VERSION to use the latest version installed.)
+      exit 1
+    end
+
+    class << self
+      def rubygems_version
+        Gem::RubyGemsVersion rescue nil
+      end
+
+      def gem_version
+        if defined? RAILS_GEM_VERSION
+          RAILS_GEM_VERSION
+        elsif ENV.include?('RAILS_GEM_VERSION')
+          ENV['RAILS_GEM_VERSION']
+        else
+          parse_gem_version(read_environment_rb)
+        end
+      end
+
+      def load_rubygems
+        require 'rubygems'
+        min_version = '1.1.1'
+        unless rubygems_version >= min_version
+          $stderr.puts %Q(Rails requires RubyGems >= #{min_version} (you have #{rubygems_version}). Please `gem update --system` and try again.)
+          exit 1
+        end
+ 
+      rescue LoadError
+        $stderr.puts %Q(Rails requires RubyGems >= #{min_version}. Please install RubyGems and try again: http://rubygems.rubyforge.org)
+        exit 1
+      end
+
+      def parse_gem_version(text)
+        $1 if text =~ /^[^#]*RAILS_GEM_VERSION\s*=\s*["']([!~<>=]*\s*[\d.]+)["']/
+      end
+
+      private
+        def read_environment_rb
+          environment_rb = "#{RAILS_ROOT}/config/environment.rb"
+          environment_rb = "#{HELPER_RAILS_ROOT}/config/environment.rb" unless File.exists?(environment_rb)
+          File.read(environment_rb)
+        end
+    end
+  end
+end
+
+# All that for this:
+Rails.boot!

data/test/app_root/config/database.yml

@@ -0,0 +1,21 @@
+in_memory:
+  adapter: sqlite3
+  database: ":memory:"
+  verbosity: quiet
+sqlite:
+  adapter: sqlite
+  dbfile: plugin_test.sqlite.db
+sqlite3:
+  adapter: sqlite3
+  dbfile: plugin_test.sqlite3.db
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: plugin_test
+mysql:
+  adapter: mysql
+  host: localhost
+  username: root
+  password:
+  database: plugin_test

data/test/app_root/config/environment.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  config.cache_classes = false
+  config.whiny_nils = true
+  config.plugin_locators.unshift(
+    Class.new(Rails::Plugin::Locator) do
+      def plugins
+        [Rails::Plugin.new(File.expand_path('.'))]
+      end
+    end
+  ) unless defined?(PluginTestHelper::PluginLocator)
+end

data/test/app_root/config/routes.rb

@@ -0,0 +1,4 @@
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end

data/test/app_root/script/console

@@ -0,0 +1,6 @@
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+libs =  " -r irb/completion"
+libs << " -r test/test_helper"
+libs << " -r console_app"
+libs << " -r console_with_helpers"
+exec "#{irb} #{libs} --simple-prompt"

data/test/core_ext_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+require 'netzke/core_ext'
+
+require 'json'
+
+class CoreExtTest < ActiveSupport::TestCase
+  test "to_js" do
+    assert_equal({"aProperty" => true}, JSON.parse({:a_property => true}.to_js))
+    assert_equal({"aProperty" => true}, JSON.parse({:a_property => true, :nil_property => nil}.to_js))
+    assert_equal([{"aProperty" => true}, {"anotherProperty" => false}], JSON.parse([{:a_property => true}, {:another_property => false}].to_js))
+    assert_equal([{"aProperty" => true}, {"anotherProperty" =>false}], JSON.parse([{:a_property => true, :nil_property => nil}, {:another_property => false}].to_js))
+  end
+  
+  test "recursive delete if nil" do
+    assert_equal({:a => 1, :b => {:c => 4, :d => 5}}, {:a => 1, :aa => nil, :b => {:c => 4, :d => 5, :cc => nil}}.recursive_delete_if_nil)
+
+    assert_equal({:a => [{:e => 5}, {:f => 7}], :b => {:c => 4, :d => 5}}, {:a => [{:e => 5, :ee => nil},{:f => 7, :ff => nil}], :aa => nil, :b => {:c => 4, :d => 5, :cc => nil}}.recursive_delete_if_nil)
+
+    assert_equal([
+      {:a => [{:e => 5}]}, 
+      {}, 
+      {:b => {:c => 4, :d => 5}}
+    ], [
+      {:a => [{:e => 5, :ee => nil}]}, 
+      {:aa => nil}, 
+      {:b => {:c => 4, :d => 5, :cc => nil}}
+    ].recursive_delete_if_nil)
+  end
+  
+  test "convert keys" do
+    assert_equal([
+      {:aB => 1, :cDD => [{:lookMa => true},{:wowNow => true}]}
+    ],[:a_b => 1, :c_d_d => [{:look_ma => true},{:wow_now => true}]].convert_keys{|k| k.camelize(:lower)})
+  end
+end