syncsign 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2ec8ce97ef1f4882420617de3310d74e2d4a3783a4f1922847c706c3eb04b13c
+  data.tar.gz: 0a867fa0debe259b37d347aff38800f9ae589a4e2afde253d69fbe2f2cab4bbe
+SHA512:
+  metadata.gz: fc9cc2483763d6a35cee7d3c9370b2abe6774b5870321ec219ed02c26b61a0d60378c8a38149507bcef9e4cecbb6b88f9a4888e888732d7d47516d6597ab4d3b
+  data.tar.gz: 9bba6acf10f9b33d4a9d11065e12ae6c3d4270bc95e991e03651aace8dd0c52655fe07ea628f110572a0b58b6fce7ca51601dcf48d43cd30308b574b5b165de9

data/README.md

@@ -0,0 +1,38 @@
+# SyncSign - Ruby interface to the SyncSign e-paper display system
+
+## Description
+
+Ruby class/gem to access the [SyncSign](http://sync-sign.com) cloud service to display information on e-paper displays.
+
+## Features
+ * Display circles, lines, rectangles, QR codes, and text on the displays.
+ * Obtain information about associated hubs and displays.
+
+## TODO
+ * Support non-display nodes that connect to the SyncSign hub (like temperature or occupancy sensors)
+ * Support display-resident images (item type IMAGE)
+ * Support bitmap images from a URI (item type BITMAP\_URI)
+ * Support icons in text boxes
+
+## Use
+
+Create a SyncSign Service instance using your API key (found in the SyncSign portal settings):
+
+    require 'syncsign'
+
+    signsvc = SyncSign::Service.new('<api key>')
+    node = signsvc.node('<node id>')
+    items = [
+        SyncSign::Widget::Rectangle.new(x: 8, y: 8, width: 208, height: 60, pen_width: 2),
+        SyncSign::Widget::Textbox.new(x: 16, y: 16, width: 192, height: 44, font: :roboto_slab, size: 24, align: :center, text: "Hello, World!")
+    ]
+    template = SyncSign::Template.new(items: items)
+    node.render(template: template)
+
+## Examples
+
+Check out the examples/ folder for:
+ * account\_info.rb - Show information about the account associated with the provided API key.
+ * nodes.rb - List all nodes on the system and information about them.
+ * render.rb - Render a sample screen to the given node.
+

data/Rakefile

@@ -0,0 +1,38 @@
+require 'bundler'
+Bundler.setup
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+end
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "syncsign/version"
+require "yard"
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ['lib/**/*.rb']
+  t.options = %w(--markup-provider=redcarpet --markup=markdown --main=README.md)
+end
+
+desc "Builds the gem"
+task :gem => :build
+task :build => :yard do
+  system "gem build syncsign.gemspec"
+  Dir.mkdir("pkg") unless Dir.exists?("pkg")
+  system "mv syncsign-#{SyncSign::VERSION}.gem pkg/"
+end
+
+task :install => :build do
+  system "sudo gem install pkg/syncsign-#{SyncSign::VERSION}.gem"
+end
+
+desc "Release the gem - Gemcutter"
+task :release => :build do
+  system "git tag -a v#{SyncSign::VERSION} -m 'Tagging #{SyncSign::VERSION}'"
+  system "git push --tags"
+  system "gem push pkg/syncsign-#{SyncSign::VERSION}.gem"
+end
+
+task :default => [:spec]

data/lib/syncsign.rb

@@ -0,0 +1,9 @@
+require 'net/http'
+
+require 'syncsign/version.rb'
+require 'syncsign/service.rb'
+require 'syncsign/hub.rb'
+require 'syncsign/node.rb'
+require 'syncsign/node-display.rb'
+require 'syncsign/template.rb'
+require 'syncsign/widgets.rb'

data/lib/syncsign/hub.rb

@@ -0,0 +1,25 @@
+module SyncSign
+  ##
+  # Object that represents a SyncSign hub.
+  class Hub
+    # @return [String] the serial number of the hub.
+    attr_reader :sn
+    # @return [String] the friendly name of the hub.
+    attr_reader :name
+    
+    ##
+    # Initialize a new hub object (normally only called from Service#hubs)
+    def initialize(sn: null, name: null, service: null)
+      @sn = sn
+      @name = name
+      @service = service
+    end
+    
+    ##
+    # Retrieve a collection of all +Node+ objects serviced by this hub.
+    def nodes
+      SyncSign::Node::parse_collection(service: @service, nodeinfo: @service.api_call(path: "/devices/#{@sn}/nodes"))
+    end
+  end
+end
+

data/lib/syncsign/node-display.rb

@@ -0,0 +1,18 @@
+module SyncSign
+  ##
+  # Object that represents a SyncSign display node.
+  class Display < Node
+    ##
+    # Render a template to this display.
+    # @param template [Template] Template to render to this display.
+    def render(template: nil)
+      @service.api_call(type: :post, path: "/nodes/#{@id}/renders", data: template.to_s)
+    end
+
+    ##
+    # Return true if the node can display a colour other than black and white.
+    def has_colour?
+      ['D29R', 'D75'].include? @model
+    end
+  end
+end

data/lib/syncsign/node.rb

@@ -0,0 +1,73 @@
+module SyncSign
+  ##
+  # Object that represents a SyncSign node.
+  # TODO: Split this up and add support for non-display nodes.
+  class Node
+    # @return [String] the Node ID of this node.
+    attr_reader :id
+    # @return [String] the friendly name of this node.
+    attr_reader :name
+    # @return [Integer] the current battery level of this node (0-100)
+    attr_reader :battery
+    # @return [Integer] the current signal level of this node (0-100)
+    attr_reader :signal
+    # @return [String] model of thid node.
+    attr_reader :model
+
+    ##
+    # Initialize a new Node object (normally only called from Hub#nodes or Service#nodes).
+    def initialize(service: nil, id: nil, name: nil, online: nil, battery: nil, signal: nil, model: nil)
+      @service = service
+      @id = id
+      @name = name
+      @online = online
+      @battery = battery
+      @signal = signal
+      @model = model
+    end
+
+    ##
+    # Return true if the node was online during the last information gathering.
+    def is_online?
+      @online
+    end
+
+    ##
+    # Parse a JSON description of a single node into a +Node+ object.
+    # Normally only called from Hub#nodes or Service#nodes.
+    # @api private
+    def self.parse(service: nil, nodeinfo: nil)
+      node_class = Node
+      case nodeinfo['type']
+        when 'DISPLAY'
+          node_class = Display
+        # TODO: support sensors and any other node types
+      end
+      node_class.new(
+        service: service,
+        id: nodeinfo['nodeId'],
+        name: nodeinfo['name'],
+        online: nodeinfo['onlined'],
+        battery: nodeinfo['batteryLevel'],
+        signal: nodeinfo['signalLevel'],
+        model: nodeinfo['model']
+      )
+    end
+    
+    ##
+    # Parse JSON array of nodes into a collection of Node objects.
+    # @param service [SyncSign::Service] Instance of the SyncSign Service class.
+    # @param nodeinfo [String] Information about a collection of nodes,
+    #   in JSON format.
+    # @return [Array] Array of Node objects.
+    # @api private
+    def self.parse_collection(service: nil, nodeinfo: nil)
+      nodes = []
+      nodeinfo.each do |node|
+        nodes.push Node::parse(service: service, nodeinfo: node)
+      end
+p nodes
+      nodes
+    end
+  end
+end

data/lib/syncsign/service.rb

@@ -0,0 +1,89 @@
+require 'net/http'
+require 'json'
+
+##
+# The SyncSign module contains everything needed to interface with the
+# SyncSign cloud server and display information on their e-paper displays.
+module SyncSign
+  ##
+  # Raised if an error occurs communicating with the SyncSign cloud service.
+  class APICallException < StandardError
+  end
+
+  ##
+  # Object that communicates with the SyncSign cloud service.
+  class Service
+    ##
+    # Set up a new connection to the SyncSign cloud service.
+    # @param apikey [String] the API key provided through the SyncSign portal.
+    def initialize(apikey: null)
+      @apikey = apikey
+      @baseurl = "https://api.sync-sign.com/v2/key/#{apikey}"
+    end
+
+    ##
+    # Retrieve an array of information about the SyncSign cloud service account
+    # associated with this object.
+    def account_info()
+      api_call()
+    end
+    
+    ##
+    # Retrieve a collection of all +Hub+ objects registered under the account.
+    def hubs
+      hubs = []
+      hub_data = api_call(path: "/devices")
+      hub_data.each do |hub|
+        hubs.push Hub.new(
+          service: self,
+          sn: hub['sn'],
+          name: hub['info']['friendlyName']
+        )
+      end
+
+      hubs
+    end
+
+    ##
+    # Retrieve a collection of all +Node+ objects registered under the account.
+    def nodes()
+      Node::parse_collection(service: self, nodeinfo: api_call(path: "/nodes"))
+    end
+
+    ##
+    # Retrieve a single +Node+ object with the given id.
+    # @param id [String] Node ID to retrieve the object for.
+    def node(id)
+      Node::parse(service: self, nodeinfo: api_call(path: "/nodes/#{id}"))
+    end
+
+    ##
+    # Make a call to the SyncSign cloud service.
+    # @param type [Symbol] The HTTP method to use, either :get or :put.
+    # @param path [String] The path to make the API call to, minus the base path.
+    # @param data [String] The POST data to send with the API call.
+    # @api private
+    def api_call(type: :get, path: "", data: "")
+      apiurl = URI.parse("#{@baseurl}#{path}")
+      http_obj = Net::HTTP.new(apiurl.host, apiurl.port)
+      http_obj.use_ssl = true
+      response = nil
+      http_obj.start() do |http|
+        req = nil
+        if(type == :get) then
+          req = Net::HTTP::Get.new(apiurl.request_uri)
+        else
+          req = Net::HTTP::Post.new(apiurl.request_uri)
+          req.body = data
+          req['Content-Type'] = 'application/json'
+        end
+        response = http.request(req)
+      end
+      if(response.code.to_i != 200) then
+        raise APICallException, response.read_body
+      end
+      JSON.parse(response.read_body)['data']
+    end
+  end
+end
+

data/lib/syncsign/template.rb

@@ -0,0 +1,50 @@
+require 'json'
+
+module SyncSign
+  ##
+  # Object that represents a template that can be rendered onto a display.
+  # Contains +Widget+s which define the UI elements on the +Template+.
+  class Template
+    attr_accessor :bgcolour, :pollrate
+    attr_reader :items
+
+    ##
+    # Initialize a new template and optionally add items to it.
+    # @param bgcolour [Symbol] Background colour, one of :black, :white, or :red.
+    # @param items [Array] List of Widgets to add to the template.
+    # @param pollrate [Integer] How often (in ms) the node should poll the hub
+    #   for new information.
+    def initialize(bgcolour: :white, items: [], pollrate: 10000)
+      @bgcolour = bgcolour
+      @pollrate = pollrate
+      
+      @items = []
+      items.each do |item|
+        self.+(item)
+      end
+    end
+    
+    ##
+    # Add a new widget to the template.
+    # @param to_add [Widget] Widget to add to the template.
+    def +(to_add)
+      # TODO: make sure we only add widgets
+      @items.push to_add
+    end
+    
+    ##
+    # Output this template as JSON in the format that the SyncSign service understands.
+    def to_s
+      background = {bgColor: @bgcolour.to_s.upcase}
+      items = @items.collect { |item| item.to_a }
+      options = {'pollRate': @pollrate}
+      {
+        layout: {
+          background: background,
+          items: items,
+          options: options
+        }
+      }.to_json
+    end
+  end
+end

data/lib/syncsign/version.rb

@@ -0,0 +1,4 @@
+module SyncSign
+  # The version number of the SyncSign module.
+  VERSION = '0.2.0'
+end

data/lib/syncsign/widgets.rb

@@ -0,0 +1,323 @@
+module SyncSign
+  ##
+  # Raised when UI elements are not properly aligned.
+  # Several UI elements must be aligned to a multiple of 8 or corruption will
+  # occur on the display.
+  class AlignmentException < StandardError
+  end
+
+  ##
+  # Widgets are UI elements that are placed onto a +Template+ for rendering.
+  class Widget
+    ##
+    # An item that contains only x/y coordinates. This can't be used on its own, only its
+    # superclasses can be added to templates.
+    class Item
+      # @return [Integer] horizontal position of the item.
+      attr_accessor :x
+      # @return [Integer] vertical position of the item.
+      attr_accessor :y
+      
+      ##
+      # Initialize a new Item widget.
+      # @param x [Integer] The horizontal position of the item.
+      # @param y [Integer] The vertical position of the item.
+      def initialize(x: nil, y: nil)
+        @x = x
+        @y = y
+      end
+    end
+
+    ##
+    # A box that contains x/y coordinates, width and height, and colour information.
+    # This can't be used on its own, only its superclasses can be added to templates.
+    # You may be looking for +Rectangle+ if you want to draw rectangles.
+    class Box < Item
+      # @return [Integer] the width of the box.
+      attr_accessor :width
+      # @return [Integer] the height of the box.
+      attr_accessor :height
+      # @return [Symbol] the stroke or foreground colour of the box.
+      attr_accessor :colour
+      # @return [Symbol] the background colour of the box.
+      attr_accessor :bgcolour
+
+      def initialize(x: nil, y: nil, width: nil, height: nil, colour: :black, bgcolour: :white)
+        Widget::check_colours [colour, bgcolour]
+        @colour = colour
+        @bgcolour = bgcolour
+        @width = width
+        @height = height
+        super(x: x, y: y)
+      end
+    end
+
+    ##
+    # A widget that draws a rectangle.
+    class Rectangle < Box
+      attr_accessor :pen_width
+      
+      ##
+      # Initialize a new rectangle widget.
+      # @param x [Integer] horizontal position of the left side of the rectangle.
+      # @param y [Integer] vertical position of the top of the rectangle.
+      # @param width [Integer] how wide the rectangle should be.
+      # @param height [Integer] how tall the rectangle should be.
+      # @param colour [Symbol] The stroke colour used for the rectangle
+      #   (either black, white, or red).
+      # @param bgcolour [Symbol] The fill colour used for the rectangle
+      #   (either black, white, or red).
+      # @param pen_width [Integer] The width in pixels of the stroke.
+      def initialize(x: nil, y: nil, width: nil, height: nil, colour: :black, bgcolour: :white, pen_width: 1, fillpattern: :none, strokepattern: :solid)
+        Widget::check_patterns [fillpattern, strokepattern]
+        raise(AlignmentException, "Rect: x and width must both be a multiple of 8") if x % 8 != 0 or width % 8 != 0
+        @pen_width = pen_width
+        @fillpattern = fillpattern
+        @strokepattern = strokepattern
+        super(x: x, y: y, width: width, height: height, colour: colour, bgcolour: bgcolour)
+      end
+      
+      ##
+      # Convert the widget into an array for sending to the SyncSign service.
+      def to_a
+        {
+          'type': 'RECTANGLE',
+          'data': {
+            'block': {x: @x, y: @y, w: @width, h: @height},
+            'fillColor': @bgcolour.to_s.upcase,
+            'fillPattern': @fillpattern.to_s.upcase,
+            'strokeColor': @colour.to_s.upcase,
+            'strokePattern': @strokepattern.to_s.upcase,
+            'strokeThickness': @pen_width
+          }
+        }
+      end
+    end
+
+    ##
+    # A widget that draws a line.
+    class Line
+      attr_accessor :x0, :y0, :x1, :y1, :bgcolour, :colour, :pattern
+
+      ##
+      # Initialize a new line widget.
+      # @param x0 [Integer] horizontal position of the starting point of the line.
+      # @param y0 [Integer] vertical position of the starting point of the line.
+      # @param x1 [Integer] horizontal position of the ending point of the line.
+      # @param y1 [Integer] vertical position of the ending point of the line.
+      # @param colour [Symbol] The stroke colour used for the rectangle
+      #   (either black, white, or red).
+      # @param bgcolour [Symbol] The fill colour used for the rectangle
+      #   (either black, white, or red).
+      # @param pattern [Symbol] The linestyle to use when drawing the line, one of solid, interleave, dash_tiny, dash_mid, or dash_wide.
+      def initialize(x0: nil, y0: nil, x1: nil, y1: nil, bgcolour: :white, colour: :black, pattern: :solid)
+        Widget::check_colours [colour, bgcolour]
+        Widget::check_patterns [pattern]
+        @x0 = x0
+        @y0 = y0
+        @x1 = x1
+        @y1 = y1
+        @colour = colour
+        @bgcolour = bgcolour
+        @pattern = pattern
+      end
+      
+      ##
+      # Convert the widget into an array for sending to the SyncSign service.
+      def to_a
+        {
+          'type': 'LINE',
+          'data': {
+            'block': {x0: @x0, y0: @y0, x1: @x1, y1: @y1},
+            'backgroundColor': @bgcolour.to_s.upcase,
+            'lineColor': @colour.to_s.upcase,
+            'linePattern': @pattern.to_s.upcase
+          }
+        }
+      end
+    end
+
+    ##
+    # A widget that draws a circle.
+    class Circle < Item
+      attr_accessor :radius, :bgcolour, :colour, :fillpattern, :strokepattern
+
+      ##
+      # Initialize a new circle widget.
+      # @param x [Integer] horizontal position of the centre of the circle.
+      # @param y [Integer] vertical position of the centre of the circle
+      # @param radius [Integer] The radius of the circle in pixels.
+      # @param colour [Symbol] The stroke colour used for the circle
+      #   (either black, white, or red).
+      # @param bgcolour [Symbol] The fill colour used for the circle
+      #   (either black, white, or red).
+      # @param fillpattern [Symbol] The fill pattern to use when filling the circle.
+      # @param strokepattern [Symbol] The stroke pattern to use when drawing the circle.
+      # @param pen_width [Integer] The thickness in pixels of the stroke.
+      def initialize(x: nil, y: nil, radius: nil, bgcolour: :white, colour: :black, fillpattern: :none, strokepattern: :solid, pen_width: 1)
+        Widget::check_colours [colour, bgcolour]
+        Widget::check_patterns [fillpattern, strokepattern]
+        @radius = radius
+        @colour = colour
+        @bgcolour = bgcolour
+        @fillpattern = fillpattern
+        @strokepattern = strokepattern
+        @pen_width = pen_width
+        super(x: x, y:y)
+      end
+      
+      ##
+      # Convert the widget into an array for sending to the SyncSign service.
+      def to_a
+        {
+          'type': 'CIRCLE',
+          'data': {
+            'center': {x: @x, y: @y},
+            'fillColor': @bgcolour.to_s.upcase,
+            'fillPattern': @fillpattern.to_s.upcase,
+            'strokeColor': @colour.to_s.upcase,
+            'strokePattern': @strokepattern.to_s.upcase,
+            'strokeThickness': @pen_width
+          }
+        }
+      end
+    end
+
+    ##
+    # A widget that draws a text box.
+    class Textbox < Box
+      attr_accessor :font, :size, :id, :align, :text
+
+      ##
+      # Initialize a new text box widget.
+      # @param x [Integer] horizontal position of the left side of the text box.
+      # @param y [Integer] vertical position of the top of the text box.
+      # @param width [Integer] how wide the text box should be.
+      # @param height [Integer] how tall the text box should be.
+      # @param colour [Symbol] The text colour used for the text.
+      # @param bgcolour [Symbol] The background colour used for the text box.
+      # @param font [Symbol] The font to use when drawing the text.
+      # @param size [Integer] The point size to use when drawing the text.
+      # @param align [Symbol] Whether to align the text left, center, or right.
+      # @param text [String] The text to draw in the box.
+      # @param id [String] An ID value to attach to the text box.
+      def initialize(x: nil, y: nil, width: nil, height: nil, colour: :black, bgcolour: :white, font: nil, size: nil, id: nil, align: :left, text: nil)
+        check_font(font: font, size: size)
+        raise(AlignmentException, "Textbox: either y or height must be a multiple of 8") if y % 8 != 0 and height % 8 != 0
+        raise(AlignmentException, "Textbox: width must be a multiple of 8") if width % 8 != 0
+        @font = font.upcase
+        @size = size
+        @id = id
+        @align = align
+        @text = text
+        super(x: x, y: y, width: width, height: height, colour: colour, bgcolour: bgcolour)
+      end
+
+      ##
+      # Convert the widget into an array for sending to the SyncSign service.
+      def to_a
+        {
+          'type': 'TEXT',
+          'data': {
+            'block': {x: @x, y: @y, w: @width, h: @height},
+            'textColor': @colour.to_s.upcase,
+            'textAlign': @align.to_s.upcase,
+            'font': "#{@font}_#{@size.to_s}",
+            'text': @text
+          }
+        }
+      end
+
+      def check_font(font: nil, size: nil)
+        available_sizes = {
+          :ddin => [16, 24, 32, 48, 64, 128],
+          :ddin_condensed => [16, 24, 32, 48, 64],
+          :charriot => [10],
+          :aprilsans => [10, 16, 24],
+          :roboto_condensed => [24, 48],
+          :roboto_slab => [24, 48],
+          :yanone_kaffeesatz => [24, 44],
+          :kaushan_script => [20, 32],
+          :sriracha => [24],
+          :dorsa => [32],
+          :londrina_outline => [36],
+          :bungee_shade => [36],
+          :noto_serif => [16],
+          :noto_sans => [24, 40]
+        }
+
+        if(!available_sizes.keys.include? font) then
+          raise ArgumentError, "#{font} is not a valid font. Available fonts: #{available_sizes.keys}"
+        end
+        if(!available_sizes[font].include? size) then
+          raise ArgumentError, "#{font} is not available in size #{size}. Available sizes for this font: #{available_sizes[font].join(", ")}"
+        end
+      end
+    end
+
+    ##
+    # A widget that draws a QR code.
+    class QRCode < Item
+      # @return [Integer] scale of the QR code (how many pixels to use to
+      #   represent each base pixel).
+      attr_accessor :scale
+      # @return [Integer] the version (which is actually size, in QR-speak)
+      #   of this QR code.
+      attr_accessor :version
+      # @return [Symbol] the level of error checking code for this QR code,
+      #   either :low, :medium, :quartile, or :high.
+      attr_accessor :ecclevel
+      # @return [String] the text to encode in this QR code.
+      attr_accessor :text
+      
+      ##
+      # Initialize a new QR code widget.
+      # @param x [Integer] horizontal position of the left side of the QR code.
+      # @param y [Integer] vertical position of the top of the QR code.
+      # @param scale [Integer] scale of the QR code (how many pixels to use to
+      #   represent each base pixel).
+      # @param version [Integer] the version (which is actually size, in QR-speak)
+      #   of this QR code. 
+      # @param ecclevel [Symbol] the level of error checking code for this QR code,
+      #   either :low, :medium, :quartile, or :high. 
+      # @param text [String] the text to encode in this QR code.
+      def initialize(x: nil, y: nil, scale: 4, version: 2, ecclevel: :medium, text: nil)
+        @scale = scale
+        @version = version
+        @ecclevel = ecclevel
+        @text = text
+
+        super(x: x, y: y)
+      end
+
+      ##
+      # Convert the widget into an array for sending to the SyncSign service.
+      def to_a
+        {
+          'type': 'QRCODE',
+          'data': {
+            'scale': @scale,
+            'eccLevel': @ecclevel.to_s.upcase,
+            'version': @version,
+            'position': {x: @x, y: @y},
+            'text': @text
+          }
+        }
+      end
+    end
+
+    def self.check_colours(colours)
+      colours.each do |colour|
+        next if [:white, :black, :red].include? colour
+        raise ArgumentError, "Colour must be :white, :black, or :red."
+      end
+    end
+    
+    def self.check_patterns(patterns)
+      patterns.each do |pattern|
+        next if [:solid, :interleave, :dash_tiny, :dash_medium, :dash_wide, :none].include? pattern
+        raise ArgumentError, "Pattern must be :solid, :interleave, :dash_tiny, :dash_medium, :dash_wide, or :none."
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: syncsign
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- sarahemm
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-08-16 00:00:00.000000000 Z
+dependencies: []
+description: Interface library for SyncSign e-paper displays
+email: github@sen.cx
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/syncsign.rb
+- lib/syncsign/hub.rb
+- lib/syncsign/node-display.rb
+- lib/syncsign/node.rb
+- lib/syncsign/service.rb
+- lib/syncsign/template.rb
+- lib/syncsign/version.rb
+- lib/syncsign/widgets.rb
+homepage: http://github.com/sarahemm/ruby-syncsign
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.9
+signing_key: 
+specification_version: 4
+summary: SyncSign interface library
+test_files: []