rack-charts-api 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9d9e73cfb5510f3759cb0427a5e0520731add2d39b679ba3cd982b9b483dfac9
+  data.tar.gz: 4cb7889529666731b1943f765c842ecac86eeb66eef5d802ffd3d7e9ea0fd688
+SHA512:
+  metadata.gz: bd5cfb122e6efe0a49d3419e923906956a48c541aeb935933b2b373ada2a248ba6e71bc6c268fabeb99fa1723fa3b5b3785e8cab7c593027dce775df10c6e200
+  data.tar.gz: 59a45e4696df7261e46e04196837489537b8d62e1655dd7755e46ad0bb6b7fe91bd1f4cf173901731be41438c73ab8243a233a46986bf4c3b3dfd016448438be

data/lib/rack/charts_api/app.rb

@@ -0,0 +1,109 @@
+module Rack
+  class ChartsApi
+    # The core Rack application.  Can be used standalone or behind the
+    # ChartsApi middleware.
+    #
+    # Response format is determined by the URL extension:
+    #
+    #   GET /charts.png?data=...&w=800&h=400   -> PNG image
+    #   GET /charts.html?data=...              -> HTML page with Chart.js chart
+    #   GET /charts?data=...                   -> HTML (default)
+    #   POST /charts.png  (JSON body)          -> PNG image
+    #   POST /charts.html (JSON body)          -> HTML page
+    #
+    class App
+      def call(env)
+        data, opts = DataParser.parse(env)
+
+        unless data
+          return [
+            400,
+            { 'content-type' => 'application/json' },
+            ['{"error":"Missing or invalid chart data. Pass a `data` param (JSON) or POST a JSON body with a `data` key."}']
+          ]
+        end
+
+        format = detect_format(env)
+
+        case format
+        when :png
+          render_png(data, opts)
+        else
+          render_html(env, data, opts)
+        end
+      rescue StandardError => e
+        [
+          500,
+          { 'content-type' => 'application/json' },
+          [{ error: e.message }.to_json]
+        ]
+      end
+
+      private
+
+      def detect_format(env)
+        path = env['PATH_INFO'].to_s
+
+        if path.end_with?('.png')
+          :png
+        elsif path.end_with?('.html')
+          :html
+        else
+          # Check Accept header
+          accept = env['HTTP_ACCEPT'].to_s
+          if accept.include?('image/png')
+            :png
+          else
+            :html
+          end
+        end
+      end
+
+      def render_png(data, opts)
+        blob = PngRenderer.render(data, opts)
+        [
+          200,
+          {
+            'content-type' => 'image/png',
+            'content-length' => blob.bytesize.to_s,
+            'content-disposition' => 'inline; filename="chart.png"',
+            'cache-control' => 'no-cache'
+          },
+          [blob]
+        ]
+      end
+
+      def render_html(env, data, opts)
+        # For the HTML renderer, we want the original chartkick-compatible
+        # JSON, not the normalised hash.  Re-parse to get the raw data.
+        raw_data = extract_raw_data(env)
+        html = HtmlRenderer.render(raw_data || data, opts)
+        [
+          200,
+          {
+            'content-type' => 'text/html; charset=utf-8',
+            'content-length' => html.bytesize.to_s,
+            'cache-control' => 'no-cache'
+          },
+          [html]
+        ]
+      end
+
+      def extract_raw_data(env)
+        request = Rack::Request.new(env)
+
+        if request.post? && DataParser.json_content?(env)
+          body = env['rack.input'].read
+          env['rack.input'].rewind
+          payload = JSON.parse(body)
+          payload['data']
+        else
+          raw = request.params['data']
+          raw ? JSON.parse(raw) : nil
+        end
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/rack/charts_api/data_parser.rb

@@ -0,0 +1,110 @@
+module Rack
+  class ChartsApi
+    # Extracts chart data and options from either the query string or a JSON
+    # request body.  Supports chartkick-compatible data formats:
+    #
+    #   Single series hash:   {"Jan": 10, "Feb": 20}
+    #   Array of pairs:       [["Jan", 10], ["Feb", 20]]
+    #   Multi-series array:   [{"name": "A", "data": {...}}, ...]
+    #
+    # Query-string mode (GET with short payloads):
+    #   ?data=URL-ENCODED-JSON&type=line&w=800&h=400&title=Hello
+    #
+    # JSON body mode (POST with large payloads):
+    #   POST body: {"data": ..., "type": "line", "options": {"w": 800}}
+    #
+    module DataParser
+      module_function
+
+      # Returns [chart_data, options_hash]
+      def parse(env)
+        request = Rack::Request.new(env)
+        params  = request.params # merged GET + POST form params
+
+        if request.post? && json_content?(env)
+          parse_json_body(env, params)
+        else
+          parse_query(params)
+        end
+      end
+
+      def json_content?(env)
+        ct = env['CONTENT_TYPE'].to_s
+        ct.include?('application/json') || ct.include?('text/json')
+      end
+
+      def parse_json_body(env, params)
+        body = env['rack.input'].read
+        env['rack.input'].rewind
+        payload = JSON.parse(body)
+
+        chart_data = payload['data']
+        opts = extract_options(payload.merge(params))
+        [normalize_data(chart_data), opts]
+      rescue JSON::ParserError
+        [nil, {}]
+      end
+
+      def parse_query(params)
+        raw = params['data']
+        return [nil, {}] unless raw
+
+        chart_data = begin
+          JSON.parse(raw)
+        rescue JSON::ParserError
+          nil
+        end
+
+        [normalize_data(chart_data), extract_options(params)]
+      end
+
+      # Normalise chartkick-format data into a consistent internal format:
+      #   { "series_name" => [values...], ... }
+      #
+      # This is used by PngRenderer (Gruff).  HtmlRenderer passes the raw
+      # JSON straight through to chartkick.js which handles all formats
+      # natively.
+      def normalize_data(data)
+        return nil if data.nil?
+
+        case data
+        when Hash
+          # { "Jan" => 10, "Feb" => 20 } -- single series hash
+          data
+        when Array
+          if data.first.is_a?(Hash) && data.first.key?('name')
+            # Multi-series: [{"name": "A", "data": [...]}, ...]
+            data.each_with_object({}) do |series, h|
+              name = series['name'] || 'Series'
+              values = series['data']
+              h[name] = case values
+                        when Hash then values.values
+                        when Array
+                          values.map { |v| v.is_a?(Array) ? v.last : v }
+                        else
+                          Array(values)
+                        end
+            end
+          elsif data.first.is_a?(Array)
+            # Array of pairs: [["Jan", 10], ["Feb", 20]]
+            { 'Series' => data.map(&:last) }
+          else
+            # Flat array of numbers
+            { 'Series' => data }
+          end
+        end
+      end
+
+      def extract_options(params)
+        {
+          type: params['type'] || 'line',
+          w: (params['w']    || params.dig('options', 'w') || 800).to_i,
+          h: (params['h']    || params.dig('options', 'h') || 600).to_i,
+          title: params['title'] || params.dig('options', 'title'),
+          colors: params['colors'] || params.dig('options', 'colors'),
+          labels: params['labels'] || params.dig('options', 'labels')
+        }.compact
+      end
+    end
+  end
+end

data/lib/rack/charts_api/html_renderer.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'securerandom'
+
+module Rack
+  class ChartsApi
+    module HtmlRenderer
+      CHARTKICK_CDN = 'https://unpkg.com/chartkick@5.0.1/dist/chartkick.js'
+      CHARTJS_CDN   = 'https://unpkg.com/chart.js@4/dist/chart.umd.js'
+      DATE_ADAPTER  = 'https://unpkg.com/chartjs-adapter-date-fns@3/dist/chartjs-adapter-date-fns.bundle.js'
+
+      # Map our type names to chartkick JS class names
+      JS_CHART_TYPES = {
+        'line' => 'LineChart',
+        'bar' => 'ColumnChart',
+        'column' => 'ColumnChart',
+        'pie' => 'PieChart',
+        'area' => 'AreaChart',
+        'scatter' => 'ScatterChart',
+        'side_bar' => 'BarChart',
+        'stacked_bar' => 'ColumnChart',
+        'dot' => 'LineChart',
+        'spider' => 'LineChart'
+      }.freeze
+
+      module_function
+
+      # Renders a standalone HTML page containing a Chart.js chart via
+      # chartkick.js.  Designed to be loaded in an <iframe>.
+      #
+      # @param raw_data  the original parsed JSON data (any chartkick format)
+      # @param opts      [Hash] :type, :w, :h, :title, :colors
+      # @return [String]  HTML document
+      def render(raw_data, opts = {})
+        chart_id = "chart-#{SecureRandom.hex(4)}"
+        js_type  = JS_CHART_TYPES.fetch(opts[:type].to_s, 'LineChart')
+        width    = opts[:w] || 800
+        height   = opts[:h] || 600
+
+        js_options = {}
+        js_options['title']   = opts[:title]  if opts[:title]
+        js_options['colors']  = opts[:colors] if opts[:colors]
+        js_options['stacked'] = true          if opts[:type].to_s == 'stacked_bar'
+
+        # For the JS side, pass the raw data exactly as chartkick expects.
+        # chartkick.js handles Hash, Array-of-pairs, and multi-series natively.
+        chart_data_json    = raw_data.to_json
+        chart_options_json = js_options.to_json
+
+        <<~HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <meta charset="utf-8">
+            <meta name="viewport" content="width=device-width, initial-scale=1">
+            <style>
+              * { margin: 0; padding: 0; box-sizing: border-box; }
+              body { font-family: system-ui, -apple-system, sans-serif; }
+              ##{chart_id} { width: #{width}px; height: #{height}px; max-width: 100%; }
+            </style>
+            <script src="#{CHARTJS_CDN}"></script>
+            <script src="#{DATE_ADAPTER}"></script>
+            <script src="#{CHARTKICK_CDN}"></script>
+          </head>
+          <body>
+            <div id="#{chart_id}"></div>
+            <script>
+              new Chartkick.#{js_type}("#{chart_id}", #{chart_data_json}, #{chart_options_json});
+            </script>
+          </body>
+          </html>
+        HTML
+      end
+    end
+  end
+end

data/lib/rack/charts_api/png_renderer.rb

@@ -0,0 +1,61 @@
+require 'gruff'
+
+module Rack
+  class ChartsApi
+    module PngRenderer
+      CHART_TYPES = {
+        'line' => Gruff::Line,
+        'bar' => Gruff::Bar,
+        'pie' => Gruff::Pie,
+        'area' => Gruff::Area,
+        'side_bar' => Gruff::SideBar,
+        'stacked_bar' => Gruff::StackedBar,
+        'dot' => Gruff::Dot,
+        'spider' => Gruff::Spider
+      }.freeze
+
+      # Map chartkick type names to gruff equivalents
+      TYPE_ALIASES = {
+        'column' => 'bar',
+        'scatter' => 'line'
+      }.freeze
+
+      module_function
+
+      # @param data [Hash{String => Array}]  normalised series data
+      # @param opts [Hash]                   :w, :h, :type, :title, :labels, :colors
+      # @return [String] binary PNG blob
+      def render(data, opts = {})
+        width  = opts[:w] || 800
+        height = opts[:h] || 600
+        type   = resolve_type(opts[:type] || 'line')
+
+        chart = type.new("#{width}x#{height}")
+        chart.title = opts[:title] if opts[:title]
+
+        if opts[:labels]
+          chart.labels = case opts[:labels]
+                         when Hash then opts[:labels].transform_keys(&:to_i)
+                         when Array
+                           opts[:labels].each_with_index.to_h { |l, i| [i, l.to_s] }
+                         else
+                           {}
+                         end
+        end
+
+        colors = opts[:colors]
+        data.each_with_index do |(name, points), i|
+          color = colors[i] if colors.is_a?(Array)
+          chart.data(name.to_s, Array(points), color)
+        end
+
+        chart.to_image.to_blob
+      end
+
+      def resolve_type(name)
+        key = TYPE_ALIASES.fetch(name.to_s.downcase, name.to_s.downcase)
+        CHART_TYPES.fetch(key, Gruff::Line)
+      end
+    end
+  end
+end

data/lib/rack/charts_api/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class ChartsApi
+    VERSION = "0.1.0"
+  end
+end

data/lib/rack/charts_api/version.rb.erb

@@ -0,0 +1,5 @@
+module Rack
+  class ChartsApi
+    VERSION = "<%= version %>"
+  end
+end

data/lib/rack/charts_api.rb

@@ -0,0 +1,35 @@
+require 'rack'
+require 'json'
+
+require_relative 'charts_api/version'
+require_relative 'charts_api/data_parser'
+require_relative 'charts_api/png_renderer'
+require_relative 'charts_api/html_renderer'
+require_relative 'charts_api/app'
+
+module Rack
+  # Rack middleware that intercepts requests to a chart endpoint and returns
+  # either a PNG image or an HTML page with an interactive Chart.js chart.
+  #
+  #   # config.ru or Rails application.rb
+  #   use Rack::ChartsApi
+  #   use Rack::ChartsApi, path: "/charts"   # custom mount path
+  #
+  class ChartsApi
+    DEFAULT_PATH = '/charts'
+
+    def initialize(app, path: DEFAULT_PATH)
+      @app = app
+      @path = path.chomp('/')
+      @charts_app = App.new
+    end
+
+    def call(env)
+      if env['PATH_INFO']&.start_with?(@path)
+        @charts_app.call(env)
+      else
+        @app.call(env)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: rack-charts-api
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nathan
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gruff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A mountable Rack app that accepts chartkick-compatible data via URL params
+  or JSON request body and returns either a server-rendered PNG (via Gruff) or an
+  HTML page with a Chart.js chart suitable for iframe embedding.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack/charts_api.rb
+- lib/rack/charts_api/app.rb
+- lib/rack/charts_api/data_parser.rb
+- lib/rack/charts_api/html_renderer.rb
+- lib/rack/charts_api/png_renderer.rb
+- lib/rack/charts_api/version.rb
+- lib/rack/charts_api/version.rb.erb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Rack middleware that serves PNG and HTML charts from query params or JSON
+  body
+test_files: []