btucker-google_visualization 0.5.3

data/lib/google_visualization/data_row.rb

@@ -0,0 +1,79 @@
+module Google
+  module Visualization
+
+    ##
+    # = DataRow
+    #
+    # == Description
+    #
+    # Represents a row of data in a DataTable.
+    #
+    class DataRow < DataElement
+
+      ##
+      # Creates a new row.
+      #
+      def initialize(cells=[])
+        super()
+        @closed = false
+        @cells = []
+        add_cells(cells) unless (cells.nil? or cells.empty?)
+      end
+
+      ##
+      # Returns the number of cells.
+      #
+      def cells_count
+        @cells.size
+      end
+
+      ##
+      # Returns the cell at index.
+      #
+      def cell(index)
+        @cells[index]
+      end
+
+      ##
+      # Returns a enumerable of all cells.
+      #
+      def cells
+        @cells.to_enum
+      end
+
+      ##
+      # Adds a single object to the end of the row and returns self.
+      #
+      def add_cell(obj)
+        raise(StandardError, "can't modify closed row") if @closed
+        obj = DataCell.new(obj) unless obj.is_a?(DataCell)
+        @cells << obj
+        self
+      end
+
+      ##
+      # Adds multiple objects to the end of the row and returns self.
+      #
+      def add_cells(list)
+        list.each { |obj| add_cell(obj) }
+        self
+      end
+
+      ##
+      # Prevents new cells from being added.
+      #
+      def close
+        @closed = true
+      end
+
+      ##
+      # Returns true if closed.
+      #
+      def closed?
+        @closed
+      end
+
+    end
+
+  end
+end

data/lib/google_visualization/data_table.rb

@@ -0,0 +1,142 @@
+module Google
+  module Visualization
+
+    ##
+    # = DataTable
+    #
+    # == Description
+    #
+    # Represents a two-dimensional, mutable table of values.
+    #
+    class DataTable < DataElement
+
+      ##
+      # Creates a new table.
+      #
+      def initialize(columns=[], rows=[])
+        super()
+        @columns = []
+        @rows = []
+        add_columns(columns) unless (columns.nil? or columns.empty?)
+        add_rows(rows) unless (rows.nil? or rows.empty?)
+      end
+
+      ##
+      # Returns the number of rows.
+      #
+      def rows_count
+        @rows.size
+      end
+
+      ##
+      # Returns the number of columns.
+      #
+      def columns_count
+        @columns.size
+      end
+
+      ##
+      # Returns the row at index.
+      #
+      def row(index)
+        @rows[index]
+      end
+
+      ##
+      # Returns the column at index.
+      #
+      def column(index)
+        @columns[index]
+      end
+
+      ##
+      # Returns the cell at index.
+      #
+      def cell(row_index, column_index)
+        row(row_index).cell(column_index)
+      end
+
+      ##
+      # Returns a enumerable of all rows.
+      #
+      def rows
+        @rows.to_enum
+      end
+
+      ##
+      # Returns a enumerable of all columns.
+      #
+      def columns
+        @columns.to_enum
+      end
+
+      ##
+      # Adds a single row to the end of the table and returns self.
+      #
+      def add_row(obj)
+        obj = DataRow.new(obj) unless obj.is_a?(DataRow)
+        raise(StandardError, "wrong row size #{obj.cells_count}, should be #{columns_count})") if obj.cells_count != columns_count
+        obj.close
+        @rows << obj
+        self
+      end
+
+      ##
+      # Adds a single column to the end of the table and returns self.
+      #
+      def add_column(obj)
+        raise(StandardError, "can't add columns after adding rows") if rows_count > 0
+        obj = DataColumn.new(obj) unless obj.is_a?(DataColumn)
+        obj.close
+        @columns << obj
+        self
+      end
+
+      ##
+      # Adds multiple rows to the end of the table and returns self.
+      #
+      def add_rows(list)
+        list.each { |obj| add_row(obj) }
+        self
+      end
+
+      ##
+      # Adds multiple columns to the end of the table and returns self.
+      #
+      def add_columns(list)
+        list.each { |obj| add_column(obj) }
+        self
+      end
+
+      ##
+      # Sorts the table rows according to the specified order and columns.
+      #
+      def sort_rows!(order, *columns)
+        correlation = (order == :ascending ? 1 : -1)
+        @rows.sort! { |a,b|
+          pivot = 0
+          columns.each { |column|
+            pivot = column
+            break if a.cell(column).value != b.cell(column).value
+          }
+          (a.cell(pivot).value <=> b.cell(pivot).value) * correlation          
+        }
+      end
+      
+      ##
+      # Returns a JSON representation of the table, according to the Google Visualization API.
+      #
+      def to_json
+        Formatter::JSON.render(self)
+      end
+
+      ##
+      # Returns a CSV representation of the table, according to the Google Visualization API.
+      #
+      def to_csv
+        Formatter::CSV.render(self)
+      end
+    end
+
+  end
+end

data/lib/google_visualization/data_type.rb

@@ -0,0 +1,38 @@
+module Google
+  module Visualization
+
+    ##
+    # = DataType
+    #
+    # == Description
+    #
+    # Represents a data type for a DataColumn.
+    #
+    class DataType
+
+      ##
+      # Creates a new type.
+      #
+      def initialize(name)
+        @name = name
+      end
+
+      ##
+      # Returns a string representing the type.
+      #
+      def to_s
+        @name.to_s
+      end
+
+      STRING = DataType.new(:string)
+      NUMBER = DataType.new(:number)
+      BOOLEAN = DataType.new(:boolean)
+      DATE = DataType.new(:date)
+      DATETIME = DataType.new(:datetime)
+      TIMEOFDAY = DataType.new(:timeofday)
+
+      private_class_method :new
+    end
+
+  end
+end

data/lib/google_visualization/formatter.rb

@@ -0,0 +1,15 @@
+module Google
+  module Visualization
+    
+    ##
+    # = Formatter
+    #
+    # == Description
+    #
+    # The Google::Visualization::Formatter module contains classes that can be used for serializing a DataTable.
+    #
+    module Formatter
+    end
+    
+  end
+end

data/lib/google_visualization/formatter/csv.rb

@@ -0,0 +1,31 @@
+require 'csv'
+
+module Google
+  module Visualization
+    module Formatter
+      
+      ##
+      # = JSON Formatter
+      #
+      # == Description
+      #
+      # Serializes a DataTable to Comma Separated values (CSV)
+      class CSV
+        private_class_method :new
+        ##
+        # Generates a JSON string representation of a data table.
+        #
+        def self.render(data_table)
+          output = ""
+          ::CSV::Writer.generate(output) do |csv|
+            csv << data_table.columns.map(&:label)
+            data_table.rows.each do |row|
+              csv << row.cells.map(&:value)
+            end
+          end
+          output
+        end
+      end
+    end
+  end
+end

data/lib/google_visualization/formatter/json.rb

@@ -0,0 +1,90 @@
+require 'json'
+
+module Google
+  module Visualization
+    module Formatter
+      
+      ##
+      # = JSON Formatter
+      #
+      # == Description
+      #
+      # Serializes a DataTable to the JavaScript Object Notation (JSON).
+      #
+      class JSON
+        
+        private_class_method :new
+        
+        ##
+        # Generates a JSON string representation of a data table.
+        #
+        def self.render(data_table)
+          {
+            'cols' => render_columns(data_table),
+            'rows' => render_rows(data_table) #,
+#            'p' => render_custom_properties(data_table)
+          }.to_json
+        end
+
+        private
+
+        ##
+        # Generates a JSON string representation of a multiple columns.
+        #
+        def self.render_columns(data_table)
+          data_table.columns.map{|c| render_column(c)}
+        end
+
+        ##
+        # Generates a JSON string representation of a single column.
+        #
+        def self.render_column(column)
+          result = {}
+          %w(id label type pattern).each do |field|
+            result[field] = column.send(field).to_s if column.send(field)
+          end
+         # if column.custom_properties_count > 0
+         #   result["p"] = render_custom_properties(column)
+         # end
+          result
+        end
+
+        ##
+        # Generates a JSON string representation of multiple rows.
+        #
+        def self.render_rows(data_table)
+          data_table.rows.map{|r| render_row(r, data_table)}
+        end
+
+        ##
+        # Generates a JSON string representation of a single row.
+        #
+        def self.render_row(row, data_table)
+          result = {'c' => []}
+          result = {'c' => row.cells.map {|c| render_cell(c)}}
+          result
+        end
+
+        ##
+        # Generates a JSON string representation of a cell.
+        #
+        def self.render_cell(cell)
+          result = {'v' => cell.value} 
+          result['f'] = cell.formatted_value if cell.formatted_value
+          # result['p'] = render_custom_properties(row) if row.custom_properties_count > 0
+          result
+        end
+
+        ##
+        # Generates a JSON string representation of the custom properties.
+        #
+        #def self.render_custom_properties(data_element)
+        #  result = data_element.custom_properties.collect { |name,value|
+        #    "#{name.to_s}:#{rb_to_js(value, DataType::STRING)}"
+        #  }
+        #  "p:{#{result.join(',')}}"
+        #end
+      end
+    end
+  end
+end

data/tasks/ftp.rake

@@ -0,0 +1,182 @@
+require 'net/ftp'
+require 'pathname'
+require 'yaml'
+require 'rake'
+require 'rake/tasklib'
+
+module Rake
+
+  # = FTPTask
+  #
+  # == Description
+  # A Rake task that transfers local files to an FTP server.
+  #
+  # == Usage
+  #  Rake::FTPTask.new do |t|
+  #   t.host = "ftp.example.com"
+  #   t.user_name = "user"
+  #   t.password = "pass"
+  #   t.path = "public_html/"
+  #   t.upload_files = FileList["doc/**/*"].to_a
+  #  end
+  #
+  # To avoid hard-coding the connection configuration into the source code, the task can obtain that data from a YAML file.
+  #
+  #  Rake::FTPTask.new("ftp.yml") do |t|
+  #   t.path = "public_html/"
+  #   t.upload_files = FileList["doc/**/*"].to_a
+  #  end
+  #
+  #  # ftp.yml
+  #  host = ftp.example.com
+  #  user_name = user
+  #  password = pass
+  #  path = public_html/
+  #
+  class FTPTask < TaskLib
+
+    ##
+    # The address of the server (default is nil).
+    #
+    attr_accessor :host
+
+    ##
+    # The user name required to log into the server (default is "anonymous").
+    #
+    attr_accessor :user_name
+
+    ##
+    # The password required for the selected user name (default is nil).
+    #
+    attr_accessor :password
+
+    ##
+    # The (remote) base directory (default is "").
+    #
+    attr_accessor :path
+
+    ##
+    # The array of files to be included in the FTP upload (default is []).
+    #
+    attr_accessor :upload_files
+
+    ##
+    # The boolean to enable progress messages when true (default is false).
+    #
+    attr_accessor :verbose
+
+    ##
+    # Creates a new FTP task.
+    #
+    def initialize(config_file=nil)
+      @host = nil
+      @user_name = "anonymous"
+      @password = nil
+      @path = ""
+      @upload_files = []
+      @verbose = false
+      @ftp = nil
+      @history = {}
+      load_config(config_file) unless config_file.nil?
+      yield self if block_given?
+      define
+    end
+
+    ##
+    # Creates the tasks defined by this task lib.
+    #
+    def define
+
+      namespace :ftp do
+        desc "Upload files to an FTP account"
+        task(:upload) do
+          connect
+          upload
+          disconnect
+        end
+      end
+
+    end
+
+    private
+
+    ##
+    # Reads configuration values from a YAML file.
+    #
+    def load_config(file)
+      config = YAML::load_file(file)
+      @host = config["host"] || @host
+      @user_name = config["user_name"] || @user_name
+      @password = config["password"] || @password
+      @path = config["path"] || @path
+    end
+
+    ##
+    # Establishes the FTP connection.
+    #
+    def connect
+      @ftp = Net::FTP.new(@host, @user_name, @password)
+      puts "Connected to #{@host}" if @verbose
+      puts "Using #{@ftp.binary ? "binary" : "text"} mode to transfer files" if @verbose
+      unless @path.nil? or @path.empty?
+        make_dirs(@path)
+        @ftp.chdir(@path)
+        puts "The working directory is now #{@ftp.getdir}" if @verbose
+      end
+    end
+
+    ##
+    # Closes the FTP connection. Further remote operations are impossible.
+    #
+    def disconnect
+      @ftp.close
+      puts "Disconnected" if @verbose
+    end
+
+    ##
+    # Iterates through the array of files.
+    #
+    def upload
+      puts "Uploading #{@upload_files.length} files..." if @verbose
+      @upload_files.each do |entry|
+        if File.directory?(entry)
+          make_dirs(entry)
+        else
+          put_file(entry)
+        end
+      end
+    end
+
+    ##
+    # Transfers a local file to the server, relative to the current working directory.
+    #
+    def put_file(name)
+      puts "Uploading file #{name}" if @verbose
+      path = File.dirname(name)
+      make_dirs(path)
+      @ftp.put(name,name)
+    end
+
+    ##
+    # Creates a directory and all its parent directories in the server, relative to the current working directory.
+    #
+    def make_dirs(name)
+      Pathname.new(name).descend do |dir|
+        if @history[dir].nil?
+          @history[dir] = true
+          puts "Creating directory #{dir}" if @verbose
+          @ftp.mkdir(dir) rescue nil
+        end
+      end
+    end
+
+  end
+
+end
+
+if File.exists?("config/ftp.yml")
+  Rake::FTPTask.new("config/ftp.yml") do |ftp|
+    ftp.upload_files = FileList["doc/**/*"].to_a
+    ftp.verbose = true
+  end
+end