plotrb 0.0.1

data/examples/scatter.rb

@@ -0,0 +1,43 @@
+require 'plotrb'
+
+raw_data = pdata.name('iris').url('iris_data.json')
+xs = linear_scale.name('x').from('iris.sepalWidth').to_width.nicely
+ys = linear_scale.name('y').from('iris.petalLength').to_height.nicely
+cs = ordinal_scale.name('c').from('iris.species').range(["#800", "#080", "#008"])
+
+xaxis = x_axis.scale(xs).offset(5).ticks(5).title('Sepal Width')
+yaxis = y_axis.scale(ys).offset(5).ticks(5).title('Petal Length')
+
+lgnd = legend.fill(cs).title('Species') do
+	properties(:symbols) do
+		fill_opacity 0.5
+        stroke :transparent
+    end
+end
+
+mark = symbol_mark.from(raw_data) do
+	enter do 
+		x	{ scale(xs).field('sepalWidth') }
+		y 	{ scale(ys).field('petalLength') }
+		fill	{ scale(cs).field('species') }
+		fill_opacity		0.5
+	end
+	update do
+		size 100
+		stroke 'transparent'
+	end
+	hover do
+		size 300
+		stroke 'white'
+	end
+end
+
+vis = visualization.name('arc').width(200).height(200) do
+	data raw_data
+	scales xs, ys, cs
+	axes xaxis, yaxis
+	legends lgnd
+	marks mark
+end
+
+puts vis.generate_spec(:pretty)

data/lib/plotrb.rb

@@ -0,0 +1,25 @@
+require 'yajl'
+require 'json'
+require 'uri'
+
+require_relative 'plotrb/base'
+
+require_relative 'plotrb/data'
+require_relative 'plotrb/transforms'
+require_relative 'plotrb/scales'
+require_relative 'plotrb/marks'
+require_relative 'plotrb/axes'
+require_relative 'plotrb/kernel'
+require_relative 'plotrb/visualization'
+require_relative 'plotrb/legends'
+require_relative 'plotrb/simple'
+
+module Plotrb
+
+end
+
+class Object
+
+  include ::Plotrb::Kernel
+
+end

data/lib/plotrb/axes.rb

@@ -0,0 +1,208 @@
+module Plotrb
+
+  # Axes provide axis lines, ticks, and labels to convey how a spatial range
+  #   represents a data range.
+  # See {https://github.com/trifacta/vega/wiki/Axes}
+  class Axis
+
+    include ::Plotrb::Base
+
+    TYPES = %i(x y)
+
+    TYPES.each do |t|
+      define_singleton_method(t) do |&block|
+        ::Plotrb::Axis.new(t, &block)
+      end
+    end
+
+    # @!attribute type
+    #   @return [Symbol] type of the axis, either :x or :y
+    # @!attribute scale
+    #   @return [String] the name of the scale backing the axis
+    # @!attribute orient
+    #   @return [Symbol] the orientation of the axis
+    # @!attribute format
+    #   @return [String] the formatting pattern for axis labels
+    # @!attribute ticks
+    #   @return [Integer] a desired number of ticks
+    # @!attribute values
+    #   @return [Array] explicitly set the visible axis tick values
+    # @!attribute subdivide
+    #   @return [Integer] the number of minor ticks between major ticks
+    # @!attribute tick_padding
+    #   @return [Integer] the padding between ticks and text labels
+    # @!attribute tick_size
+    #   @return [Integer] the size of major, minor, and end ticks
+    # @!attribute tick_size_major
+    #   @return [Integer] the size of major ticks
+    # @!attribute tick_size_minor
+    #   @return [Integer] the size of minor ticks
+    # @!attribute tick_size_end
+    #   @return [Integer] the size of end ticks
+    # @!attribute offset
+    #   @return [Integer] the offset by which to displace the axis from the edge
+    #     of the enclosing group or data rectangle
+    # @!attribute properties
+    #   @return [Hash] optional mark property definitions for custom styling
+    # @!attribute title
+    #   @return [String] the title for the axis
+    # @!attribute tittle_offset
+    #   @return [Integer] the offset from the axis at which to place the title
+    # @!attribute grid
+    #   @return [Boolean] whether gridlines should be created
+    add_attributes :type, :scale, :orient, :format, :ticks, :values, :subdivide,
+                  :tick_padding, :tick_size, :tick_size_major, :tick_size_minor,
+                  :tick_size_end, :offset, :layer, :properties, :title,
+                  :title_offset, :grid
+
+    def initialize(type, &block)
+      @type = type
+      define_single_val_attributes(:scale, :orient, :title, :title_offset,
+                                   :format, :ticks, :subdivide, :tick_padding,
+                                   :tick_size, :tick_size_major, :tick_size_end,
+                                   :tick_size_minor, :offset, :layer)
+      define_boolean_attribute(:grid)
+      define_multi_val_attributes(:values)
+      self.singleton_class.class_eval {
+        alias_method :from, :scale
+        alias_method :offset_title_by, :title_offset
+        alias_method :subdivide_by, :subdivide
+        alias_method :major_tick_size, :tick_size_major
+        alias_method :minor_tick_size, :tick_size_minor
+        alias_method :end_tick_size, :tick_size_end
+        alias_method :offset_by, :offset
+        alias_method :show_grid, :grid
+        alias_method :with_grid, :grid
+        alias_method :show_grid?, :grid?
+        alias_method :with_grid?, :grid?
+      }
+      self.instance_eval(&block) if block_given?
+      ::Plotrb::Kernel.axes << self
+      self
+    end
+
+    def type
+      @type
+    end
+
+    def above(&block)
+      @layer = :front
+      self.instance_eval(&block) if block_given?
+      self
+    end
+
+    def above?
+      @layer == :front
+    end
+
+    def below(&block)
+      @layer = :back
+      self.instance_eval(&block) if block_given?
+      self
+    end
+
+    def below?
+      @layer == :back
+    end
+
+    def no_grid(&block)
+      @grid = false
+      self.instance_eval(&block) if block
+      self
+    end
+
+    def properties(element=nil, &block)
+      @properties ||= {}
+      return @properties unless element
+      @properties.merge!(
+          element.to_sym => ::Plotrb::Mark::MarkProperty.new(:text, &block)
+      )
+      self
+    end
+
+    def method_missing(method, *args, &block)
+      case method.to_s
+        when /^with_(\d+)_ticks$/  # set number of ticks. eg. in_20_ticks
+          self.ticks($1.to_i, &block)
+        when /^subdivide_by_(\d+)$/ # set subdivide of ticks
+          self.subdivide($1.to_i, &block)
+        when /^at_(top|bottom|left|right)$/ # set orient of the axis
+          self.orient($1.to_sym, &block)
+        when /^in_(front|back)$/ # set layer of the axis
+          self.layer($1.to_sym, &block)
+        else
+          super
+      end
+    end
+
+  private
+
+    def attribute_post_processing
+      process_type
+      process_scale
+      process_orient
+      process_format
+      process_layer
+      process_properties
+    end
+
+    def process_type
+      unless TYPES.include?(@type)
+        raise ArgumentError, 'Invalid Axis type'
+      end
+    end
+
+    def process_scale
+      return unless @scale
+      case @scale
+        when String
+          unless ::Plotrb::Kernel.find_scale(@scale)
+            raise ArgumentError, 'Scale not found'
+          end
+        when ::Plotrb::Scale
+          @scale = @scale.name
+        else
+          raise ArgumentError, 'Unknown Scale'
+      end
+    end
+
+    def process_orient
+      return unless @orient
+      unless %i(top bottom left right).include?(@orient.to_sym)
+        raise ArgumentError, 'Invalid Axis orient'
+      end
+    end
+
+    def process_format
+      return unless @format
+      # D3's format specifier has general form:
+      # [​[fill]align][sign][symbol][0][width][,][.precision][type]
+      # the regex is taken from d3/src/format/format.js
+      re =
+        /(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i
+      @format = @format.to_s
+      if @format =~ re
+        if "#{$1}#{$2}#{$3}#{$4}#{$5}#{$6}#{$7}#{$8}#{$9}" != @format
+          raise ArgumentError, 'Invalid format specifier'
+        end
+      end
+    end
+
+    def process_layer
+      return unless @layer
+      unless %i(front back).include?(@layer.to_sym)
+        raise ArgumentError, 'Invalid Axis layer'
+      end
+    end
+
+    def process_properties
+      return unless @properties
+      valid_elements = %i(ticks major_ticks minor_ticks grid labels axis)
+      unless (@properties.keys - valid_elements).empty?
+        raise ArgumentError, 'Invalid property element'
+      end
+    end
+
+  end
+
+end

data/lib/plotrb/base.rb

@@ -0,0 +1,193 @@
+module Plotrb
+
+  # Some internal methods for mixin
+  module Base
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # add setter methods to attributes
+      def add_attributes(*vars)
+        @attributes ||= []
+        @attributes.concat(vars)
+        vars.each do |var|
+          define_method("#{var}=") { |value|
+            instance_variable_set("@#{var}", value)
+          }
+        end
+      end
+
+      def attributes
+        @attributes
+      end
+
+    end
+
+    # @return [Array<Symbol>] attributes of the particular instance combined
+    #   with attributes of the class
+    def attributes
+      singleton_attr = self.singleton_class.attributes || []
+      class_attr = self.class.attributes || []
+      singleton_attr.concat(class_attr).uniq
+    end
+
+    # add and set new attributes and values to the instance
+    # @param args [Hash] attributes in the form of a Hash
+    def set_attributes(args)
+      args.each do |k, v|
+        # use singleton_class as attributes are instance-specific
+        self.singleton_class.add_attributes(k)
+        self.instance_variable_set("@#{k}", v) unless v.nil?
+      end
+    end
+
+    # add new attributes to the instance
+    # @param args [Array<Symbol>] the attributes to add to the instance
+    def add_attributes(*args)
+      self.singleton_class.add_attributes(*args)
+    end
+
+    # @return [Array<Symbol>] attributes that have values
+    def defined_attributes
+      attributes.reject { |attr| self.instance_variable_get("@#{attr}").nil? }
+    end
+
+    # to be implemented in each Plotrb class
+    def attribute_post_processing
+      raise NotImplementedError
+    end
+
+    # @return [Hash] recursively construct a massive hash
+    def collect_attributes
+      attribute_post_processing
+      collected = {}
+      defined_attributes.each do |attr|
+        value = self.instance_variable_get("@#{attr}")
+        # change snake_case attributes to camelCase used in Vega's JSON spec
+        json_attr = classify(attr, :json)
+        if value.respond_to?(:collect_attributes)
+          collected[json_attr] = value.collect_attributes
+        elsif value.is_a?(Array)
+          collected[json_attr] = [].concat(value.collect{ |v|
+            v.respond_to?(:collect_attributes) ? v.collect_attributes : v
+          })
+        else
+          collected[json_attr] = value
+        end
+      end
+      collected
+    end
+
+    def define_boolean_attribute(method)
+      # when setting boolean values, eg. foo.bar sets bar attribute to true,
+      #   foo.bar? returns state of bar attribute
+      define_singleton_method(method) do |&block|
+        self.instance_variable_set("@#{method}", true)
+        self.instance_eval(&block) if block
+        self
+      end
+      define_singleton_method("#{method}?") do
+        self.instance_variable_get("@#{method}")
+      end
+    end
+
+    def define_boolean_attributes(*methods)
+      methods.each { |m| define_boolean_attribute(m) }
+    end
+
+    def define_single_val_attribute(method, proc=nil)
+      # when only single value is allowed, eg. foo.bar(1)
+      # proc is passed in to process value before assigning to attributes
+      define_singleton_method(method) do |*args, &block|
+        case args.size
+          when 0
+            self.instance_variable_get("@#{method}")
+          when 1
+            val = proc.is_a?(Proc) ? proc.call(args[0]) : args[0]
+            self.instance_variable_set("@#{method}", val)
+            self.instance_eval(&block) if block
+            self
+          else
+            raise ArgumentError
+        end
+      end
+    end
+
+    def define_single_val_attributes(*methods)
+      methods.each { |m| define_single_val_attribute(m) }
+    end
+
+    def define_multi_val_attribute(method, proc=nil)
+      # when multiple values are allowed, eg. foo.bar(1,2) or foo.bar([1,2])
+      # proc is passed in to process values before assigning to attributes
+      define_singleton_method(method) do |*args, &block|
+        case args.size
+          when 0
+            self.instance_variable_get("@#{method}")
+          else
+            vals = proc.is_a?(Proc) ? proc.call(*args) : [args].flatten
+            self.instance_variable_set("@#{method}", vals)
+            self.instance_eval(&block) if block
+            self
+        end
+      end
+    end
+
+    def define_multi_val_attributes(*methods)
+      methods.each { |m| define_multi_val_attribute(m) }
+    end
+
+    def classify(name, format=nil)
+      klass = name.to_s.split('_').collect(&:capitalize).join
+      if format == :json
+        klass[0].downcase + klass[1..-1]
+      else
+        klass
+      end
+    end
+
+    # monkey patch Hash class to support reverse_merge and collect_attributes
+    class ::Hash
+
+      def attribute_post_processing
+        # nothing to do for Hash
+      end
+
+      def reverse_merge(other_hash)
+        other_hash.merge(self)
+      end
+
+      def collect_attributes
+        collected = {}
+        self.each do |k, v|
+          json_attr = classify(k, :json)
+          if v.respond_to?(:collect_attributes)
+            collected[json_attr] = v.collect_attributes
+          elsif v.is_a?(Array)
+            collected[json_attr] = [].concat(v.collect{ |va|
+              va.respond_to?(:collect_attributes) ? va.collect_attributes : va
+            })
+          else
+            collected[json_attr] = v
+          end
+        end
+        collected
+      end
+
+      def classify(name, format=nil)
+        klass = name.to_s.split('_').collect(&:capitalize).join
+        if format == :json
+          klass[0].downcase + klass[1..-1]
+        else
+          klass
+        end
+      end
+
+    end
+
+  end
+
+end