winton-rails_widget 1.0.1 → 1.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Winton Welsh <mail@wintoni.us>
+
+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.markdown

@@ -0,0 +1,8 @@
+Rails Widget
+============
+
+A mini-framework for your client side Rails assets.
+
+**This plugin is very beta. More details coming soon.**
+
+##### Copyright (c) 2008 [Winton Welsh](mailto:mail@wintoni.us), released under the MIT license

data/init.rb

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

data/lib/rails_widget/assets.rb

@@ -0,0 +1,114 @@
+module WidgetHelpers
+  
+  def default_javascript
+    "#{params[:controller]}/#{params[:action]}"
+  end
+  
+  def default_stylesheet
+    "#{params[:controller]}/#{params[:action]}"
+  end
+  
+  def javascripts(*paths, &block)
+    add_assets :javascripts, paths, &block
+  end
+  
+  def stylesheets(*paths, &block)
+    add_assets :stylesheets, paths, &block
+  end
+  
+  def templates(*paths, &block)
+    paths.each do |path|
+      add_assets :templates, path, &block
+    end
+    add_assets(:templates, paths, &block) if paths.empty?
+  end
+  
+  def textarea_template(id, path=nil, locals={})
+    controller.render_to_string(:partial => 'app_helpers/template/textarea', :locals => {
+      :id => id,
+      :body => controller.render_to_string(:partial => path, :locals => locals)
+    })
+  end
+  
+private
+
+  def add_assets(type, paths, &block)
+    options = paths.extract_options!
+    paths.flatten! unless type == :templates
+    
+    @assets ||= {}
+    @assets[type] ||= []
+    @layout_assets ||= {}
+    @layout_assets[type] ||= []
+    
+    paths = nil if paths.empty?
+    
+    if options[:layout]
+      options.delete :layout
+      paths.push(options) if paths
+      @layout_assets[type].push(paths          ) if paths
+      @layout_assets[type].push(capture(&block)) if block
+    else
+      paths.push(options) if paths
+      @assets[type].push(paths          ) if paths
+      @assets[type].push(capture(&block)) if block
+    end
+    
+    if !paths && !block
+      #logger.info type.inspect
+      #logger.info 'LAYOUT ' + @layout_assets[type].inspect
+      #logger.info @assets[type].inspect
+      
+      @assets[type] = @layout_assets[type] + @assets[type]
+      
+      @assets[type].uniq!
+      remove_dups @assets[type]
+      @assets[type].collect! { |a| a[0].respond_to?(:keys) ? nil : a }
+      @assets[type].compact!
+      
+      js = []
+      assets = @assets[type].collect do |item|
+        if item.respond_to?(:pop)
+          case type
+          when :javascripts
+            javascript_include_tag *item
+          when :stylesheets
+            stylesheet_link_tag *item
+          when :templates
+            textarea_template item[0], item[1], item[2]
+          end + "\n"
+        else
+          case type
+          when :javascripts
+            js.push(item) unless item.blank?
+            nil
+          else
+            item
+          end
+        end
+      end.compact
+      if type == :javascripts
+        assets.join + "<script type='text/javascript'>\n#{js.join "\n"}\n</script>"
+      else
+        assets.join
+      end
+    end
+  end
+
+  def remove_dups(arr, list=[])
+    arr.dup.each do |a|
+      if a.respond_to?(:keys)
+        next
+      elsif a.respond_to?(:pop)
+        remove_dups a, list
+      else
+        if list.include?(a) || a.blank?
+          arr.delete_at arr.rindex(a)
+        else
+          list << a
+        end
+      end
+    end
+  end
+  
+end

data/lib/rails_widget/widget.rb

@@ -0,0 +1,248 @@
+module WidgetHelpers
+  
+  def widget_base
+    @layout_happened = true
+    require_widget ''
+    render_widget ''
+  end
+  
+  def render_widget(*path)
+    widgets, options = widget_instances path
+    widgets.collect do |w|
+      # we want widgets rendered from the partial to include first
+      partial = w.render_init :partials, options
+      js = w.render_init :js, options
+      if options[:include_js] && js && !js.empty?
+        partial + "\n<script type='text/javascript'>\n#{js}\n</script>"
+      else
+        javascripts *(@layout_happened ? [ :layout => true ] : []) do
+          js
+        end
+        partial
+      end
+    end
+  end
+  
+  def require_widget(*path)
+    widgets, options = widget_instances path
+    widgets.each do |w|
+      w.copy_assets
+      js  = w.helper_targets :javascripts
+      css = w.helper_targets :stylesheets
+      javascripts *(js  + [ :cache => w.cache, :layout => @layout_happened ]) unless js.empty?
+      stylesheets *(css + [ :cache => w.cache, :layout => @layout_happened ]) unless css.empty?
+      templates   *(w.assets[:templates].collect do |t|
+        [ File.basename(t), t, options.merge(:options => options) ]
+      end) unless w.assets[:templates].empty?
+    end
+  end
+  
+  def widget_flash_path(*path)
+    flash = path.pop
+    "/flash/widgets/#{path.join('/')}/#{flash}"
+  end
+  
+  def widget_image(*path)
+    options = path.extract_options!
+    image = path.pop
+    image_tag "widgets/#{path.join('/')}/#{image}", options
+  end
+  
+  def widget_image_path(*path)
+    image = path.pop
+    "/images/widgets/#{path.join('/')}/#{image}"
+  end
+  
+  def widget_partial(*path)
+    options = path.extract_options!
+    partial = path.pop
+    path << options
+    widgets, options = widget_instances path
+    options = {
+      :locals  => options.merge(:options => options),
+      :partial => "#{path.join('/')}/partials/#{partial}"
+    }
+    render options
+  end
+  
+  def widget_instances(path)
+    @widgets ||= Widgets.new binding, controller, logger
+    options = path.extract_options!
+    @widgets.build path, options
+  end
+  
+  class Widgets
+    attr :widgets, true
+    
+    def initialize(bind, controller, logger)
+      @bind       = bind
+      @controller = controller
+      @logger     = logger
+      @widgets    = {}
+    end
+    
+    def build(path, options)
+      opts = {}
+      #@logger.info 'RELATED_PATHS ' + related_paths(path).inspect
+      widgets = related_paths(path).collect do |r|
+        @widgets[r] ||= Assets.new r, @bind, @controller, @logger
+        opts.merge! @widgets[r].options
+        @widgets[r]
+      end
+      [ widgets, opts.merge(options) ]
+    end
+    
+    private
+    
+    def related_paths(paths)
+      ordered = []
+      last = paths.length - 1
+      paths.each_index do |x|
+        if x != 0 && File.exists?("app/widgets/#{paths[x]}")
+          ordered << related_paths(paths[x..last])
+        end
+        path = paths[0..x].join '/'
+        if File.exists?("app/widgets/#{path}")
+          ordered << path
+        end
+      end
+      ordered.flatten
+    end
+    
+    class Assets
+      attr :assets,  true
+      attr :cache,   true
+      attr :options, true
+      attr :path,    true
+      
+      ASSET_TYPES = [ :flash, :images, :javascripts, :stylesheets, :templates, :init_js, :init_partials ]
+      
+      def initialize(path, bind, controller, logger)
+        @bind     = bind
+        @controller = controller
+        @logger   = logger
+        @assets   = {}
+        @options  = {}
+        @rendered = {}
+        @targeted = {}
+        @path     = path
+        @cache    = cache_name
+        update_options
+        ASSET_TYPES.each do |type|
+          update_asset type
+        end
+      end
+      
+      def copy_assets
+        @assets.each do |key, value|
+          from, to = to_path key
+          value.each do |asset|
+            base = File.basename asset
+            f = [ from, base ].join '/'
+            t = [ to,   base ].join '/'
+            t.gsub!('/stylesheets/', '/stylesheets/sass/') if t.include?('.sass')
+            next unless needs_update?(f, t)
+            case key
+            when :flash, :images
+              FileUtils.mkdir_p to
+              FileUtils.copy f, t
+            when :javascripts, :stylesheets
+              FileUtils.mkdir_p File.dirname(t)
+              File.open t, 'w' do |file|
+                file.write @controller.render_to_string(:file => f, :locals => @options.merge(:options => @options))
+              end
+            end
+          end
+        end
+      end
+      
+      def helper_targets(type)
+        return [] if @targeted[type]
+        @targeted[type] = true
+        
+        from, to = to_path type
+        case type
+        when :javascripts
+          @assets[type].collect do |asset|
+            [ to.split('javascripts/')[1], File.basename(asset, '.js') ].join '/'
+          end
+        when :stylesheets
+          @assets[type].collect do |asset|
+            sass = asset.include? '.sass'
+            [ to.split('stylesheets/')[1], File.basename(asset, sass ? '.sass' : '.css') ].join '/'
+          end
+        else @assets[type]
+        end
+      end
+      
+      def render_init(type, options=@options)
+        @rendered[type] ||= {}
+        return nil if @rendered[type][options[:id]]
+        @rendered[type][options[:id]] = true
+        
+        @assets["init_#{type}".intern].collect do |f|
+          @controller.render_to_string :file => f, :locals => options.merge(:options => options)
+        end.join("\n")
+      end
+      
+      private
+      
+      def cache_name
+        'cache/' + (@path.empty? ? 'base' : @path.gsub('/', '_'))
+      end
+      
+      def filename_to_partial(file, remove=nil)
+        base = File.basename file
+        dir  = File.dirname file
+        file = [ dir, (base[0..0] == '_' ? base[1..-1] : base ).split('.')[0..-2].join('.') ].join '/'
+        if remove
+          if remove.respond_to?(:pop)
+            remove.each { |r| file.gsub! r, '' }
+          else
+            file.gsub! remove, ''
+          end
+        end
+        file
+      end
+
+      def needs_update?(from, to)
+        File.exists?(to) ? File.mtime(from) > File.mtime(to) : true
+      end
+      
+      def to_path(type, path=@path)
+        slash = path.empty? ? '' : '/'
+        base  = "app/widgets#{slash}#{path}"
+        case type
+        when :base:          base
+        when :init_js:       base + '/javascripts/init'
+        when :init_partials: base + '/partials/_init'
+        when :options:       base + '/options.rb'
+        when :templates:     base + '/templates'
+        when :flash:       [ base + '/flash',       "public/flash/widgets"       + slash + path ]
+        when :images:      [ base + '/images',      "public/images/widgets"      + slash + path ]
+        when :javascripts: [ base + '/javascripts', "public/javascripts/widgets" + slash + path ]
+        when :stylesheets: [ base + '/stylesheets', "public/stylesheets/widgets" + slash + path ]
+        end
+      end
+      
+      def update_asset(type)
+        @assets[type] ||= []
+        from = to_path type
+        from = from[0] if from.respond_to?(:pop)
+        from = File.directory?(from) ? "#{from}/*" : "#{from}.*"
+        Dir[from].sort.each do |f|
+          next if type == :javascripts && File.basename(f) == 'init.js'
+          @assets[type] << (type == :templates ? filename_to_partial(f, 'app/widgets/') : f)
+        end
+      end
+      
+      def update_options(path=@path, empty=false)
+        options  = to_path :options, path
+        @options = (File.exists?(options) ? eval(File.read(options), @bind) : {}).merge(@options)
+        path = path.split('/')[0..-2]
+        # empty allows us to retrieve base directory's options
+        update_options(path.join('/'), path.empty?) unless empty
+      end
+    end
+  end
+end

data/lib/rails_widget.rb

@@ -0,0 +1,7 @@
+Dir[File.expand_path('*/*.rb', File.dirname(__FILE__))].each do |f|
+  require [ File.dirname(f), File.basename(f, '.rb') ].join('/')
+end
+
+ActionView::Base.send :include, WidgetHelpers
+ActionController::Base.send :include, WidgetHelpers
+ActionController::Base.view_paths += [ RAILS_ROOT + '/app/widgets' ]

data/tasks/rails_widget.rake

@@ -0,0 +1,31 @@
+desc 'Updates app/widgets assets'
+task :widgets => [ 'widgets:javascripts', 'widgets:stylesheets' ]
+
+namespace :widgets do    
+  desc 'Updates app/widgets/javascripts'
+  task :javascripts do
+    rails_widget_resource 'widgets/javascripts', 'app/widgets/javascripts'
+  end
+  
+  desc 'Updates app/widgets/stylesheets'
+  task :stylesheets do
+    rails_widget_resource 'widgets/stylesheets', 'app/widgets/stylesheets'
+  end
+  
+  def rails_widget_resource(type, to, reverse=false)
+    from = "#{File.dirname(__FILE__)}/../resources/#{type}"
+    from, to = to, from if reverse
+    puts "=> Removing old #{type}..."
+    FileUtils.remove_dir to, true
+    FileUtils.mkdir_p to
+    puts "=> Copying #{type}..."
+    Dir["#{from}/*"].each do |f|
+      if File.directory? f
+        FileUtils.mkdir_p "#{to}/#{File.basename(f)}"
+        FileUtils.cp_r f, to
+      else
+        FileUtils.cp f, to
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: winton-rails_widget
 version: !ruby/object:Gem::Version 
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors: 
 - Winton Welsh