open_rosa 0.1.0

data/lib/open_rosa/submission.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "rack"
+require "nokogiri"
+
+module OpenRosa
+  # Represents a parsed OpenRosa form submission
+  #
+  # Handles parsing of multipart MIME submissions containing:
+  # - XML submission file (required, named "xml_submission_file")
+  # - Media attachments (optional, images/audio/video)
+  #
+  # Per OpenRosa spec:
+  # - POST to /submission with multipart/form-data
+  # - XML part must be named "xml_submission_file"
+  # - Other parts are treated as media attachments
+  class Submission # rubocop:disable Metrics/ClassLength
+    attr_reader :form_id, :instance_id, :data, :attachments, :metadata, :raw_xml
+
+    class ParseError < StandardError; end
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(form_id:, instance_id:, data:, raw_xml:, attachments: [], metadata: {})
+      # rubocop:enable Metrics/ParameterLists
+      @form_id = form_id
+      @instance_id = instance_id
+      @data = data
+      @attachments = attachments
+      @metadata = metadata
+      @raw_xml = raw_xml
+    end
+
+    class << self
+      # Parse a Rack request into a Submission object
+      #
+      # @param rack_request [Rack::Request] The incoming request
+      # @return [Submission] Parsed submission
+      # @raise [ParseError] If submission is invalid
+      def parse(rack_request)
+        validate_request!(rack_request)
+        raw_xml = extract_raw_xml(rack_request)
+        doc = parse_xml(raw_xml)
+
+        build_submission(doc, rack_request, raw_xml)
+      end
+
+      private
+
+      def validate_request!(rack_request)
+        raise ParseError, "Request must be POST" unless rack_request.post?
+        raise ParseError, "Content-Type must be multipart/form-data" unless multipart?(rack_request)
+      end
+
+      def extract_raw_xml(rack_request)
+        xml_param = rack_request.params["xml_submission_file"]
+        raise ParseError, "Missing xml_submission_file parameter" unless xml_param
+
+        raw_xml = read_xml_param(xml_param)
+        raise ParseError, "Empty xml_submission_file" if raw_xml.nil? || raw_xml.empty?
+
+        raw_xml
+      end
+
+      def read_xml_param(xml_param)
+        if xml_param.respond_to?(:read)
+          xml_param.read
+        elsif xml_param.is_a?(Hash) && xml_param[:tempfile]
+          xml_param[:tempfile].read
+        else
+          xml_param.to_s
+        end
+      end
+
+      def build_submission(doc, rack_request, raw_xml)
+        new(
+          form_id: extract_form_id(doc),
+          instance_id: extract_instance_id(doc),
+          data: extract_data(doc),
+          attachments: extract_attachments(rack_request),
+          metadata: extract_metadata(doc),
+          raw_xml: raw_xml
+        )
+      end
+
+      def multipart?(request)
+        content_type = request.content_type
+        content_type&.start_with?("multipart/form-data")
+      end
+
+      def parse_xml(raw_xml)
+        Nokogiri::XML(raw_xml) do |config|
+          config.strict.nonet
+        end
+      rescue Nokogiri::XML::SyntaxError => e
+        raise ParseError, "Invalid XML: #{e.message}"
+      end
+
+      def extract_form_id(doc)
+        # The root element's name or id attribute is the form ID
+        root = doc.root
+        raise ParseError, "XML document has no root element" unless root
+
+        # Try id attribute first, then use element name
+        root["id"] || root.name
+      end
+
+      def extract_instance_id(doc)
+        # Look for meta/instanceID element
+        instance_id_node = doc.at_xpath("//meta/instanceID") ||
+                           doc.at_xpath("//*[local-name()='instanceID']")
+
+        instance_id_node&.text&.strip
+      end
+
+      def extract_data(doc)
+        root = doc.root
+        data = {}
+
+        # Recursively extract all leaf nodes as data
+        extract_node_data(root, data)
+
+        data
+      end
+
+      def extract_node_data(node, data, prefix = nil)
+        node.element_children.each do |child|
+          # Skip meta elements
+          next if child.name == "meta"
+
+          field_name = prefix ? "#{prefix}/#{child.name}" : child.name
+
+          if child.element_children.empty?
+            # Leaf node - extract value
+            data[field_name] = child.text.strip
+          else
+            # Has children - recurse (for groups/repeats)
+            extract_node_data(child, data, field_name)
+          end
+        end
+      end
+
+      def extract_metadata(doc)
+        metadata = {}
+
+        # Extract common metadata fields
+        meta_node = doc.at_xpath("//meta") || doc.at_xpath("//*[local-name()='meta']")
+        return metadata unless meta_node
+
+        ["instanceID", "timeStart", "timeEnd", "deviceID", "userID"].each do |field|
+          node = meta_node.at_xpath(field) || meta_node.at_xpath("*[local-name()='#{field}']")
+          metadata[field.to_sym] = node.text.strip if node
+        end
+
+        metadata
+      end
+
+      def extract_attachments(rack_request)
+        rack_request.params.filter_map do |name, value|
+          next if name == "xml_submission_file"
+          next unless value.is_a?(Hash) && value[:tempfile]
+
+          Attachment.new(
+            filename: value[:filename],
+            content_type: value[:type] || "application/octet-stream",
+            size: value[:tempfile].size,
+            tempfile: value[:tempfile]
+          )
+        end
+      end
+    end
+
+    # Represents an uploaded file attachment
+    class Attachment
+      attr_reader :filename, :content_type, :size, :tempfile
+
+      def initialize(filename:, content_type:, size:, tempfile:)
+        @filename = filename
+        @content_type = content_type
+        @size = size
+        @tempfile = tempfile
+      end
+
+      # Read the file contents
+      def read
+        tempfile.rewind
+        tempfile.read
+      end
+
+      # Get the file path (useful for moving/copying)
+      def path
+        tempfile.path
+      end
+    end
+  end
+end

data/lib/open_rosa/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OpenRosa
+  VERSION = "0.1.0"
+end

data/lib/open_rosa/xform.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module OpenRosa
+  # Generates XForm XML from Form definitions
+  # rubocop:disable Metrics/ClassLength
+  class XForm
+    XFORMS_NS = "http://www.w3.org/2002/xforms"
+    XHTML_NS = "http://www.w3.org/1999/xhtml"
+
+    def initialize(form_class)
+      @form_class = form_class
+      @form_id = form_class.form_id
+      @version = form_class.version
+      @name = form_class.name || form_class.form_id
+      @fields = form_class.fields
+    end
+
+    def to_xml
+      builder = Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+        xml.html(xform_namespaces) do
+          generate_head(xml)
+          generate_body(xml)
+        end
+      end
+
+      builder.to_xml
+    end
+
+    def xform_namespaces
+      {
+        "xmlns" => XFORMS_NS,
+        "xmlns:h" => XHTML_NS,
+        "xmlns:ev" => "http://www.w3.org/2001/xml-events",
+        "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+        "xmlns:jr" => "http://openrosa.org/javarosa"
+      }
+    end
+
+    private
+
+    def generate_head(xml)
+      xml.head do
+        xml.title(@name, xmlns: XHTML_NS)
+        xml.model do
+          generate_instance(xml)
+          generate_bindings(xml)
+        end
+      end
+    end
+
+    def generate_instance(xml)
+      xml.instance do
+        xml.send(@form_id.to_sym, id: @form_id, version: @version) do
+          generate_instance_fields(xml, @fields)
+          generate_metadata(xml)
+        end
+      end
+    end
+
+    def generate_instance_fields(xml, fields, _path_prefix = nil)
+      fields.each do |field|
+        case field
+        when Fields::Group, Fields::Repeat
+          xml.send(field.name.to_sym) do
+            generate_instance_fields(xml, field.fields, field.name)
+          end
+        else
+          xml.send(field.name.to_sym)
+        end
+      end
+    end
+
+    def generate_metadata(xml)
+      xml.meta do
+        xml.instanceID
+      end
+    end
+
+    def generate_bindings(xml)
+      generate_field_bindings(xml, @fields, "/#{@form_id}")
+    end
+
+    def generate_field_bindings(xml, fields, path_prefix)
+      fields.each do |field|
+        nodeset = "#{path_prefix}/#{field.name}"
+        generate_binding_for_field(xml, field, nodeset)
+      end
+    end
+
+    def generate_binding_for_field(xml, field, nodeset)
+      case field
+      when Fields::Group
+        xml.bind(nodeset: nodeset, relevant: field.relevant) if field.relevant
+        generate_field_bindings(xml, field.fields, nodeset)
+      when Fields::Repeat
+        generate_field_bindings(xml, field.fields, nodeset)
+      else
+        xml.bind(build_bind_attrs(field, nodeset))
+      end
+    end
+
+    def build_bind_attrs(field, nodeset)
+      attrs = { nodeset: nodeset, type: binding_type(field) }
+      attrs[:required] = "true()" if field.required
+      attrs[:constraint] = field.constraint if field.respond_to?(:constraint) && field.constraint
+      attrs
+    end
+
+    def binding_type(field)
+      case field
+      when Fields::Input, Fields::Range
+        field.type.to_s
+      when Fields::Upload
+        "binary"
+      else
+        "string"
+      end
+    end
+
+    def generate_body(xml)
+      xml.body(xmlns: XHTML_NS) do
+        generate_controls(xml, @fields, "/#{@form_id}")
+      end
+    end
+
+    def generate_controls(xml, fields, path_prefix)
+      fields.each do |field|
+        ref = "#{path_prefix}/#{field.name}"
+        generate_control_for_field(xml, field, ref)
+      end
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+    def generate_control_for_field(xml, field, ref)
+      case field
+      when Fields::Input then generate_input_control(xml, field, ref)
+      when Fields::Select1 then generate_select1_control(xml, field, ref)
+      when Fields::Select then generate_select_control(xml, field, ref)
+      when Fields::Boolean then generate_boolean_control(xml, field, ref)
+      when Fields::Upload then generate_upload_control(xml, field, ref)
+      when Fields::Range then generate_range_control(xml, field, ref)
+      when Fields::Trigger then generate_trigger_control(xml, field, ref)
+      when Fields::Group then generate_group_control(xml, field, ref)
+      when Fields::Repeat then generate_repeat_control(xml, field, ref)
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+    def generate_input_control(xml, field, ref)
+      xml.input(ref: ref) do
+        add_label_and_hint(xml, field)
+      end
+    end
+
+    def generate_select1_control(xml, field, ref)
+      xml.select1(ref: ref) do
+        add_label_and_hint(xml, field)
+        generate_choices(xml, field.choices)
+      end
+    end
+
+    def generate_select_control(xml, field, ref)
+      xml.select(ref: ref) do
+        add_label_and_hint(xml, field)
+        generate_choices(xml, field.choices)
+      end
+    end
+
+    def generate_boolean_control(xml, field, ref)
+      xml.select1(ref: ref) do
+        add_label_and_hint(xml, field)
+        generate_boolean_choices(xml)
+      end
+    end
+
+    def generate_boolean_choices(xml)
+      xml.item do
+        xml.label "Yes"
+        xml.value "true"
+      end
+      xml.item do
+        xml.label "No"
+        xml.value "false"
+      end
+    end
+
+    def generate_upload_control(xml, field, ref)
+      xml.upload(ref: ref, mediatype: field.mediatype) do
+        add_label_and_hint(xml, field)
+      end
+    end
+
+    def generate_range_control(xml, field, ref)
+      xml.range(ref: ref, start: field.start, end: field.end, step: field.step) do
+        add_label_and_hint(xml, field)
+      end
+    end
+
+    def generate_trigger_control(xml, field, ref)
+      xml.trigger(ref: ref) do
+        add_label_and_hint(xml, field)
+      end
+    end
+
+    def generate_group_control(xml, field, ref)
+      xml.group(ref: ref) do
+        xml.label field.label if field.label
+        generate_controls(xml, field.fields, ref)
+      end
+    end
+
+    def generate_repeat_control(xml, field, ref)
+      xml.repeat(nodeset: ref) do
+        xml.label field.label if field.label
+        generate_controls(xml, field.fields, ref)
+      end
+    end
+
+    def add_label_and_hint(xml, field)
+      xml.label field.label if field.label
+      xml.hint field.hint if field.hint
+    end
+
+    def generate_choices(xml, choices)
+      generate_array_choices(xml, choices) if choices.is_a?(Array)
+      generate_hash_choices(xml, choices) if choices.is_a?(Hash)
+    end
+
+    def generate_array_choices(xml, choices)
+      choices.each do |choice|
+        xml.item do
+          xml.label choice
+          xml.value choice
+        end
+      end
+    end
+
+    def generate_hash_choices(xml, choices)
+      choices.each do |label, value|
+        xml.item do
+          xml.label label
+          xml.value value
+        end
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/open_rosa.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "open_rosa/version"
+require_relative "open_rosa/fields/base"
+require_relative "open_rosa/fields/input"
+require_relative "open_rosa/fields/select1"
+require_relative "open_rosa/fields/select"
+require_relative "open_rosa/fields/upload"
+require_relative "open_rosa/fields/range"
+require_relative "open_rosa/fields/trigger"
+require_relative "open_rosa/fields/boolean"
+require_relative "open_rosa/fields/group"
+require_relative "open_rosa/fields/repeat"
+require_relative "open_rosa/field_context"
+require_relative "open_rosa/form_dsl"
+require_relative "open_rosa/form"
+require_relative "open_rosa/xform"
+require_relative "open_rosa/form_list"
+require_relative "open_rosa/submission"
+require_relative "open_rosa/media_file"
+require_relative "open_rosa/manifest"
+require_relative "open_rosa/middleware"
+
+module OpenRosa
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/openrosa.rbs

@@ -0,0 +1,4 @@
+module OpenRosa
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: open_rosa
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alex Watt
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description:
+email:
+- alex@alexcwatt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CLAUDE.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/authentication.rb
+- examples/rack_app.rb
+- examples/rails_integration.rb
+- lib/open_rosa.rb
+- lib/open_rosa/field_context.rb
+- lib/open_rosa/fields/base.rb
+- lib/open_rosa/fields/boolean.rb
+- lib/open_rosa/fields/group.rb
+- lib/open_rosa/fields/input.rb
+- lib/open_rosa/fields/range.rb
+- lib/open_rosa/fields/repeat.rb
+- lib/open_rosa/fields/select.rb
+- lib/open_rosa/fields/select1.rb
+- lib/open_rosa/fields/trigger.rb
+- lib/open_rosa/fields/upload.rb
+- lib/open_rosa/form.rb
+- lib/open_rosa/form_dsl.rb
+- lib/open_rosa/form_list.rb
+- lib/open_rosa/manifest.rb
+- lib/open_rosa/media_file.rb
+- lib/open_rosa/middleware.rb
+- lib/open_rosa/submission.rb
+- lib/open_rosa/version.rb
+- lib/open_rosa/xform.rb
+- sig/openrosa.rbs
+homepage: https://github.com/alexcwatt/openrosa-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/alexcwatt/openrosa-ruby
+  source_code_uri: https://github.com/alexcwatt/openrosa-ruby
+  changelog_uri: https://github.com/alexcwatt/openrosa-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key:
+specification_version: 4
+summary: Manage OpenRosa forms.
+test_files: []