rubicus 0.1.0

data/CHANGES

@@ -0,0 +1,6 @@
+= Rubicus Changelog
+
+== Version 0.1.0
+(August 24th, 2006)
+
+* Initial release.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Jonathan Younger (jonathan@daikini.com)
+
+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

@@ -0,0 +1,11 @@
+==Rubicus
+
+Author:: Jonathan Younger (jonathan@daikini.com)
+Date:: August 24th, 2006
+
+Rubicus is a pure Ruby wrapper around the ploticus http://ploticus.sourceforge.net graphing library.
+
+For basic usage instructions, refer to the documentation for Rubicus::Graph.
+
+Based on the design of Scruffy Graphs (a beautiful graphing library for Ruby) by Brasten Sager. http://scruffy.rubyforge.org/
+Custom ploticus graph code taken from ploticus.rb by Mike Neumann. http://www.ntecs.de/blog-old/Blog/RubyPloticus.rdoc

data/Rakefile

@@ -0,0 +1,84 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'lib/rubicus'
+
+PKG_NAME = "rubicus"
+PKG_VERSION   = Rubicus::VERSION
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*.rb',
+  'test/**/*.rb'
+]
+
+desc "Deploy docs to RubyForge" 
+task :rdoc_deploy => [:rdoc] do
+  dirs = %w{doc}
+  onserver = "poogle@rubyforge.org:/var/www/gforge-projects/rubicus" 
+  dirs.each do | dir|
+    `scp -r "#{`pwd`.chomp}/#{dir}" "#{onserver}"`
+  end
+end
+
+# Genereate the RDoc documentation
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Rubicus - Graphing Library for Ruby using the ploticus backend."
+  rdoc.rdoc_files.include("README", "CHANGELOG", "MIT-LICENSE")
+  rdoc.rdoc_files.include("lib/rubicus.rb")
+  rdoc.rdoc_files.include("lib/rubicus/*.rb")
+  rdoc.rdoc_files.include("lib/rubicus/layers/*.rb")
+}
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.author = "Jonathan Younger" 
+  s.email = "jonathan@daikini.com"
+  s.homepage = "http://rubicus.rubyforge.org"
+  s.summary = "Graphing library for Ruby using the ploticus backend."
+  s.description = "Rubicus is a pure Ruby wrapper around the ploticus http://ploticus.sourceforge.net graphing library."
+  s.files = PKG_FILES.to_a
+  s.has_rdoc = false
+  s.rubyforge_project = "rubicus"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+task :verify_user do
+  raise "RUBYFORGE_USER environment variable not set!" unless ENV['RUBYFORGE_USER']
+end
+
+task :verify_password do
+  raise "RUBYFORGE_PASSWORD environment variable not set!" unless ENV['RUBYFORGE_PASSWORD']
+end
+
+desc "Publish gem+tgz+zip on RubyForge. You must make sure lib/version.rb is aligned with the CHANGELOG file"
+task :publish_packages => [:verify_user, :verify_password, :package] do
+  require 'meta_project'
+  require 'rake/contrib/xforge'
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME}.gem",
+    "pkg/#{PKG_FILE_NAME}.tgz",
+    "pkg/#{PKG_FILE_NAME}.zip",
+    "pkg/#{PKG_FILE_NAME}.gem.md5",
+    "pkg/#{PKG_FILE_NAME}.tgz.md5",
+    "pkg/#{PKG_FILE_NAME}.zip.md5"
+  ]
+
+  Rake::XForge::Release.new(MetaProject::Project::XForge::RubyForge.new(PKG_NAME)) do |xf|
+    # Never hardcode user name and password in the Rakefile!
+    xf.user_name = ENV['RUBYFORGE_USER']
+    xf.password = ENV['RUBYFORGE_PASSWORD']
+    xf.files = release_files.to_a
+    xf.release_name = "Rubicus #{PKG_VERSION}"
+  end
+end

data/lib/rubicus.rb

@@ -0,0 +1,8 @@
+module Rubicus; end
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'rubicus/version'
+require 'rubicus/graph'
+require 'rubicus/layers'

data/lib/rubicus/graph.rb

@@ -0,0 +1,125 @@
+require 'tempfile'
+
+module Rubicus
+  
+  # ==Rubicus Graph
+  #
+  # Author:: Jonathan Younger
+  # Date:: August 24th, 2006
+  #
+  #
+  # ====Graphs vs. Layers (Graph Types)
+  #
+  # Rubicus::Graph is the primary class you will use to generate your graphs.  A Graph does not
+  # define a graph type nor does it directly hold any data.  Instead, a Graph object can be thought
+  # of as a canvas on which other graphs are draw.  (The actual graphs themselves are subclasses of Rubicus::Layers::Base)
+  # Despite the technical distinction, we will refer to Rubicus::Graph objects as 'graphs' and Rubicus::Layers as
+  # 'layers' or 'graph types.'
+  #
+  #
+  # ==== Creating a Graph
+  #
+  # You can begin building a graph by instantiating a Graph object
+  #
+  #   graph = Rubicus::Graph.new
+  #
+  # Once you have a Graph object you can begin adding graph layers.  
+  # You can add a graph layer to a graph by using the Graph#add or Graph#<< methods.
+  # The two methods are identical and used to accommodate syntax preferences.
+  #
+  #   graph.add :lines, [[10, 20], [20, 30], [30, 40], [40, 50]], :title => "Jack", :x => 1, :y => 2, :pointsym => :none, :rectangle => [1, 1, 3, 3]
+  #   graph.add :lines, [[10, 20], [20, 30], [30, 40], [40, 50]], :title => "Jill", :x => 1, :y => 2, :pointsym => :none, :rectangle => [4, 1, 6, 3]
+  #
+  # Now that we've created our graph and added a layer to it, we're ready to render!  You can render the graph
+  # directly to PNG or any other image format (supported by ploticus) with the Graph#render method:
+  #
+  #   # Defaults to PNG
+  #   graph.render
+  #
+  #   # For image formats other than PNG:
+  #   graph.render(:as => 'GIF')
+  #
+  #   # To render directly to a file:
+  #   graph.render(:to => '<filename>')
+  #
+  #   graph.render(:as => 'GIF', :to => '<filename>')
+  #
+  # And that's your basic Rubicus graph!  Please check the ploticus documentation for the various methods and
+  # classes you'll be using, as there are a bunch of options not demonstrated here.
+  #
+  # A couple final things worth noting:
+  # * You can call Graph#render as often as you wish with different rendering options.  In
+  #   fact, you can modify the graph any way you wish between renders.
+  #
+  #
+  # * There are no restrictions to the combination of graph layers you can add.  It is perfectly
+  #   valid to do something like:
+  #     graph.add(:lines, [100, 200, 300])
+  #     graph.add(:vbars, [200, 150, 150])
+  class Graph
+    attr_accessor :layers
+    attr_accessor :default_type
+    attr_accessor :options
+    
+    def initialize(options = {})
+      @default_type = options.delete(:type)
+      @options = options
+      @layers ||= []
+    end
+
+    def <<(*args, &block)
+      if args[0].kind_of?(Rubicus::Layers::Base)
+        layers << args[0]
+      else
+        type = args.first.is_a?(Symbol) ? args.shift : @default_type
+        data = args.first.is_a?(Array) ? args.shift : []
+        options = args.first.is_a?(Hash) ? args.shift : {}
+        
+        raise ArgumentError, "You must specify a graph type (:scat, :lines, :pie, etc) if you do not have a default type specified." if type.nil?
+        
+        unless Rubicus::Layers.const_defined? to_camelcase(type.to_s)
+          layer = Rubicus::Layers::Prefab.new(options.merge({ :prefab => type, :data => data }))
+        else
+          layer = Kernel::module_eval("Rubicus::Layers::#{to_camelcase(type.to_s)}").new(options.merge({ :data => data }), &block)
+        end
+        
+        layers << layer
+      end
+      layer
+    end
+    
+    alias :add :<<
+
+    # Renders the graph in it's current state to an PNG object.
+    #
+    # Options:
+    # as:: File format to render to ('PNG', 'JPG', etc)
+    # to:: Name of file to save graph to, if desired.  If not provided, image is returned as blob/string.
+    def render(options = {})
+      options[:o] ||= "stdout"
+      image_type = options.delete(:as) || "png"
+      to = options.delete(:to)
+      
+      image = case layers.size
+      when 0
+        raise "You haven't specified any layers to render."
+      when 1
+        layers.first.draw(image_type, @options.merge(options))
+      else
+        dump_file = Tempfile.new("rubicus_dump_file")
+        layers.each { |layer| layer.draw(nil, :drawdumpa => dump_file.path) }
+        layer = Rubicus::Layers::Prefab.new(:prefab => :draw, :dumpfile => dump_file.path)
+        layer.draw(image_type, @options.merge(options))
+      end
+      
+      File.open(to, "w") { |file| file.write(image) } if to
+      
+      image
+    end
+    
+    protected
+    def to_camelcase(type)  # :nodoc:
+      type.split("_").map { |e| e.capitalize }.join("")
+    end
+  end
+end

data/lib/rubicus/layers.rb

@@ -0,0 +1,3 @@
+require 'rubicus/layers/base'
+require 'rubicus/layers/custom'
+require 'rubicus/layers/prefab'

data/lib/rubicus/layers/base.rb

@@ -0,0 +1,46 @@
+module Rubicus::Layers
+  class Base
+    protected
+    def convert_options(obj)
+      case obj
+      when String
+        obj.gsub("\n", "\\n")
+      when Array
+        if obj[0].kind_of? Array
+          obj.map { |row| row.join(" ") }.join
+        else
+          obj.join(" ")
+        end
+      when Hash
+        obj.map { |k,v| "#{k}=#{convert_options(v)}" }.join(" ")
+      when true
+        'yes'
+      when false
+        'no'
+      else
+        obj.to_s
+      end
+    end
+  
+    def convert(obj)
+      case obj
+      when String
+        obj.gsub("\n", "\\n") + "\n"
+      when Array
+        if obj[0].kind_of? Array
+          obj.map {|row| row.join(" ") + "\n"}.join
+        else
+          obj.join(" ")
+        end
+      when Hash
+        obj.map {|k,v| "#{ k }=#{ convert(v) }" }.join(" ")
+      when true
+        'yes'
+      when false
+        'no'
+      else
+        obj.to_s
+      end
+    end
+  end
+end

data/lib/rubicus/layers/custom.rb

@@ -0,0 +1,68 @@
+# Most of this code is from the ploticus.rb file by Mike Neumann http://www.ntecs.de/blog-old/Blog/RubyPloticus.rdoc
+
+module Rubicus::Layers
+  class Custom < Base
+    def initialize
+      reset!
+    end
+
+    def data=(rows)
+      data {|a| a.data = rows }
+    end
+
+    def draw(image_type = "png", options = {})
+      options[image_type] = nil if image_type
+      ploticus_options = options.map { |key, option| "-#{key} #{convert_options(option)}" }.join(" ")
+      io = IO.popen("ploticus -stdin #{ploticus_options}", "w+")
+      io.write @s
+      io.close_write
+      img = io.read
+      io.close
+      img
+    end
+
+    def reset!
+      @s = ""
+    end
+
+    PROCS = [ 
+      [:data, :getdata],
+      [:area, :areadef], 
+    ]
+
+    PROCS.each do |m, mp|
+      mp ||= m
+      eval %[ def #{ m }(&block) do_block("#{ mp }", &block) end ]
+    end
+
+    def method_missing(id, &block)
+      do_block(id.to_s, &block)
+    end
+
+    private
+    def do_block(mp, &block)
+      @s << "#proc #{ mp }\n"
+      AttrWriter.new(&block).__attrs__.each do |k, v|
+        @s << "#{ k }: #{ convert(v) }\n"
+      end
+      @s << "\n"
+    end
+
+    class AttrWriter
+      instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+
+      def __attrs__
+        @attrs
+      end
+
+      def initialize(&block)
+        @attrs = {}
+        block.call(self)
+      end
+
+      def method_missing(id, value)
+        @attrs[id.to_s.gsub("=", "")] = value
+      end
+    end
+  end
+end

data/lib/rubicus/layers/prefab.rb

@@ -0,0 +1,49 @@
+module Rubicus::Layers
+  class Prefab < Base
+    def initialize(options = {})
+      @type = options.delete(:prefab)
+      @data = options.delete(:data)
+      @options = options
+      @options[:delim] ||= :comma
+    end
+    
+    def draw(image_type = "png", options = {})
+      options[image_type] = nil if image_type
+      options[:prefab] ||= @type
+      
+      if @data
+        data = if @data[0].kind_of? Array
+          @data.map {|row| row.join(delimiter_for_delim(@options[:delim])) }.join("\n")
+        else
+          @data.join(",")
+        end
+      else
+        data = nil
+      end
+      
+      ploticus_options = options.map { |key, option| "-#{key} #{convert_options(option)}" }.join(" ")
+      prefab_options = @options.map { |key, option| "#{key}=\"#{convert_options(option)}\"" }.join(" ")
+      io = IO.popen("ploticus #{@data ? "data=stdin" : ""} #{ploticus_options} #{prefab_options}", "w+")
+      if @data
+        io.write data
+        io.close_write
+      end
+      img = io.read
+      io.close
+      img
+    end
+    
+    
+    protected
+    def delimiter_for_delim(delim)
+      case delim
+      when :comma
+        ","
+      when :tab
+        "\t"
+      else
+        " "
+      end
+    end
+  end
+end

data/lib/rubicus/version.rb

@@ -0,0 +1,3 @@
+module Rubicus
+  VERSION = '0.1.0'
+end

data/test/test.rb

@@ -0,0 +1,131 @@
+#/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../lib/rubicus'
+
+data = [
+  ["Name", "Concentration", "PeakArea"],
+  ["A", 1, 2],
+  ["B", 2, 3],
+  ["C", 2, 4],
+  ["D", 1, 4],
+  ["E", 6, 7]
+]
+
+# layer = Rubicus::Layers::Scat.new(:data => data, :xgrid => { :width => "0.1", :color => "gray(0.9)"}, :x => 2, :y => 3, :corr => true)
+
+g = Rubicus::Graph.new
+g.add :scat, data, :xgrid => { :width => "0.1", :color => "gray(0.9)" }, :x => 2, :y => 3, :corr => true, :rectangle => [1, 1, 3, 3]
+g.add :scat, data, :xgrid => { :width => "0.6", :color => "gray(2.5)" }, :x => 2, :y => 3, :corr => true, :rectangle => [4, 1, 6, 3]
+# g.add layer
+g.render(:to => "bob.png")
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+layer = Rubicus::Layers::Custom.new
+
+layer.data = [
+    [2000, 750],
+    [2010, 1700],
+    [2015, 2000],
+    [2020, 1800],
+    [2025, 1300],
+    [2030, 400]
+  ]
+
+layer.area {|a|
+  a.title = "Social Security trust fund asset estimates, in $ billions\nhallo\nsuper"
+  a.titledetails = {:adjust => "0,0.1"}
+  a.rectangle = [1, 1, 5, 2]
+  a.xrange = [2000, 2035]
+  a.yrange = [0, 2000]
+}
+
+layer.xaxis {|a| 
+  a.stubs = "inc 5"
+  a.label = "Year"
+}
+
+layer.lineplot {|a|
+  a.xfield = 1
+  a.yfield = 2
+ a.fill = "pink"
+}
+
+layer.lineplot {|a|
+  a.xfield = 1
+  a.yfield = 2
+  a.fill = "rgb(.7,.3,.3)"
+  a.linerange = [2010, 2020]
+}
+
+layer.lineplot {|a|
+  a.xfield = 1
+  a.yfield = 2
+  a.linedetails = {:color => 'red'}
+  a.fill = "rgb(.7,.3,.3)"
+  a.linerange = [2010, 2020]
+}
+
+layer.yaxis {|a|
+  a.stubs = "incremental 500"
+  a.grid = {:color=> 'blue'}
+  a.axisline = 'none'
+}
+
+g = Rubicus::Graph.new
+g.add layer
+g.render(:to => "bob2.png")
+
+
+
+
+
+
+
+
+g = Rubicus::Graph.new
+g.add :lines, [[10, 20], [20, 30], [30, 40], [40, 50]], :title => "Jack", :x => 1, :y => 2, :pointsym => :none, :rectangle => [1, 1, 3, 3]
+g.add :lines, [[10, 20], [20, 30], [30, 40], [40, 50]], :title => "Jill", :x => 1, :y => 2, :pointsym => :none, :rectangle => [4, 1, 6, 3]
+g.render :to => "hmm.png"
+
+
+
+
+
+
+
+data = (1..12).collect { |i| ["Test #{i}", rand(110), rand(20)] }
+
+g = Rubicus::Graph.new
+g.add :vbars, data, :x => 1, :y => 2, :autow => false, :errunder => true, :ygrid => true, :barwidth => :line, :stubvert => true, :xaxis => :none, :yaxis => :none, :rectangle => [0, 0, 0.5, 0.2], :legend => false, :header => false, :yrange => 110
+g.render(:to => "sweet.png")
+
+
+# data = (1..12).collect { |i| [i, rand(20)] }
+# 
+# g = Rubicus::Graph.new
+# g.add :line, data, :x => 1, :y => 2, :pointsym => :none, :xaxis => :none
+# g.render(:to => "sweet.png")

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: rubicus
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-08-30 00:00:00 -07:00
+summary: Graphing library for Ruby using the ploticus backend.
+require_paths: 
+- lib
+email: jonathan@daikini.com
+homepage: http://rubicus.rubyforge.org
+rubyforge_project: rubicus
+description: Rubicus is a pure Ruby wrapper around the ploticus http://ploticus.sourceforge.net graphing library.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Jonathan Younger
+files: 
+- CHANGES
+- MIT-LICENSE
+- Rakefile
+- README
+- lib/rubicus.rb
+- lib/rubicus/graph.rb
+- lib/rubicus/layers.rb
+- lib/rubicus/version.rb
+- lib/rubicus/layers/base.rb
+- lib/rubicus/layers/custom.rb
+- lib/rubicus/layers/prefab.rb
+- test/test.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+