superstudio 0.8.2102

data/ext/superstudio/jsonbroker.h

@@ -0,0 +1,12 @@
+#ifndef RUBY_JSONBROKER
+#define RUBY_JSONBROKER
+
+#include <superstudio.h>
+#include <stdio.h>
+#include <json_builder.h>
+
+void json_broker_mark();
+void Init_jsonbroker();
+
+#endif
+

data/ext/superstudio/ss_alloc.c

@@ -0,0 +1,27 @@
+#include "ss_alloc.h"
+
+void *ss_alloc(SSMemoryStack* memory_stack, size_t multiple, size_t size) {
+  SSMemoryStackNode* new_node = calloc(1, sizeof(SSMemoryStackNode));
+  new_node->memory_location = calloc(multiple, size);
+  new_node->previous_node = memory_stack->stack_top;
+
+  memory_stack->stack_top = new_node;
+
+  return memory_stack->stack_top->memory_location; 
+}
+
+void collapse_stack(SSMemoryStack* memory_stack)
+{
+  SSMemoryStackNode* temp_previous;
+  while (memory_stack->stack_top->memory_location)
+  {
+    temp_previous = memory_stack->stack_top->previous_node;
+
+    free(memory_stack->stack_top->memory_location);
+    memory_stack->stack_top->memory_location = NULL;
+    free(memory_stack->stack_top);
+    memory_stack->stack_top = NULL;
+
+    memory_stack->stack_top = temp_previous;
+  }
+}

data/ext/superstudio/ss_alloc.h

@@ -0,0 +1,11 @@
+#ifndef SS_ALLOC_
+#define SS_ALLOC_
+
+#include <stddef.h>
+#include <stdlib.h>
+#include "json_builder.h"
+
+void *ss_alloc(SSMemoryStack* memory_stack, size_t multiple, size_t size);
+void collapse_stack(SSMemoryStack* memory_stack);
+
+#endif // SS_ALLOC_

data/ext/superstudio/superstudio.c

@@ -0,0 +1,10 @@
+#include <superstudio.h>
+
+VALUE mSuperstudio;
+
+void Init_superstudio()
+{
+  mSuperstudio = rb_define_module("Superstudio");
+
+  Init_jsonbroker();
+}

data/ext/superstudio/superstudio.h

@@ -0,0 +1,9 @@
+#ifndef RUBY_SUPERSTUDIO
+#define RUBY_SUPERSTUDIO
+
+#include <ruby.h>
+#include <jsonbroker.h>
+
+extern VALUE mSuperstudio;
+
+#endif

data/lib/generators/superstudio/schema_generator.rb

@@ -0,0 +1,65 @@
+require 'rails/generators'
+require 'rails/generators/base'
+
+module Superstudio
+  module Generators
+    class SchemaGenerator < Rails::Generators::NamedBase
+      include Superstudio::SchemaReader
+
+      argument :file_arg, type: 'string', required: false
+
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Creates a json schema (draft v4) for all the columns in a database table."
+
+      def create_schema_file
+        model_klass = name.classify.constantize
+        model_columns = {}
+
+        model_klass.columns.each do |column|
+          column_type = column.type
+          column_type = :string if [:datetime].include? column.type
+          column_type = :number if [:decimal].include? column.type
+          model_columns[column.name] = column_type
+        end
+
+        file_data = template_header
+        model_columns.each do |name, type|
+          file_data << data_column(name, type)
+        end
+
+        file_data = file_data.chomp(",")
+        file_data << template_footer
+
+        if file_arg.nil?
+          model_klass_name = model_klass.name.gsub(":", "").underscore
+        else
+          model_klass_name = file_arg
+        end
+
+        create_file "#{schemas_directory}/#{model_klass_name}.json.schema", file_data
+      end
+
+      private
+      def template_header
+      %Q({
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "object",
+  "properties": {)
+      end
+
+      def data_column(name, type)
+      %Q(
+    "#{name}": {
+      "type": "#{type}"
+    },)
+      end
+
+      def template_footer
+      %Q(},
+  "required": ["id"]
+})
+      end
+    end
+  end
+end

data/lib/generators/superstudio/schema_map_generator.rb

@@ -0,0 +1,60 @@
+require 'rails/generators'
+require 'rails/generators/base'
+
+module Superstudio
+  module Generators
+    class SchemaMapGenerator < Rails::Generators::NamedBase
+      include Superstudio::SchemaReader
+
+      argument :class_arg, type: 'string', required: false
+
+      source_root File.expand_path("../../templates", __FILE__)
+
+      desc "Creates a simple json schema mapping class, inferring required json nodes and required columns from a json schema (draft v4)."
+
+      def create_map_file
+        file_name = name
+        file_name = file_name << ".json.schema" unless name.end_with?(".json.schema")
+
+        if class_arg.nil?
+          class_name = file_name.chomp(".json.schema").classify
+        else
+          class_name = class_arg.classify
+        end
+
+        interpreted_schema = Superstudio::SqlJsonBuilder.new(nil, file_name)
+
+        file_data = %Q(=begin
+Interpreted schema has the following data bodies. Multiple bodies indicates array nesting - non-included node names should not be included in @json_nodes because they are placeholders for array inserts.
+)
+
+        interpreted_hashes = []
+
+        interpreted_schema.template_bodies.each do |key, template|
+          inter = JSON.parse("{" << template.slice(1..template.length).chomp("}").gsub('{', '"').gsub('}', '"') << "}")
+          temp_string = PP.pp(inter, '')
+          interpreted_hashes << inter
+          file_data << %Q(
+Node Path: #{key.join("->")}
+#{temp_string})
+        end
+        file_data << %Q(=end)
+
+        file_data << %Q(
+class #{class_name}Mapper < Superstudio::SqlJsonBuilder
+  def map_row)
+        interpreted_hashes.each do |hash|
+          hash.each do |name, node|
+            file_data << %Q(
+    @json_nodes[:#{node}] = value_by_column_name("#{name}"))
+          end
+        end
+
+        file_data << %Q(
+  end
+end)
+        create_file "#{schema_maps_directory}/#{class_name.underscore}_mapper.rb", file_data
+      end
+    end
+  end
+end

data/lib/superstudio.rb

@@ -0,0 +1,109 @@
+require 'superstudio/superstudio'
+require 'superstudio/schema_interpreter'
+require 'superstudio/schema_reader'
+require 'superstudio/schema_internal_definer'
+
+module Superstudio
+  class SqlJsonBuilder
+    include Superstudio::SchemaReader
+    include Superstudio::SchemaInterpreter
+    include Superstudio::SchemaInternalDefiner
+
+    attr_accessor :sql_columns, :json_result, :schema, :template_types, :array_paths, :json_nodes, :required_columns, :human_to_internal, :template_bodies
+
+    def initialize(query, file_name = nil)
+      file_class_name = self.class.name
+      file_class_name.slice!("Mapper")
+      file_name ||= file_class_name.underscore << ".json.schema"
+
+      @schema = read_schema(file_name)
+
+      @sql_columns, @row_being_used = [], []
+      @json_result = ""
+      @json_nodes, @required_columns = {}, {}
+
+      @unique_threes_tags, @human_readable_tags, @internal_use_tags, @quoted_tags, @do_not_hash, @depth_tags, @real_depth_tags, @column_names = [], [], [], [], [], [], [], []
+      @type_2_paths, @type_3_paths, @type_4_paths, @type_5_paths = [], [], [], []
+      @type_2_indicator_names, @type_4_indicator_names = ["root"], []
+      @unique_threes_paths = []
+
+      json_schema_interpretation = interpret_json_schema(@schema)
+
+      if query.present?
+        result_set = get_sql_results(query)
+        set_human_to_internal_mappings(json_schema_interpretation)
+        assemble_json(result_set)
+      else
+        create_template(json_schema_interpretation)
+      end
+    end
+
+    private
+    def get_sql_results(query)
+      query = query.to_sql if query.respond_to?(:to_sql)
+      result_set = ActiveRecord::Base.connection.select_all(query)
+    end
+
+    def value_by_column_name(name)
+      value = @row_being_used[@sql_columns.index(name)]
+      value ||= ""
+      return value
+    end
+
+    def value_by_column_number(number)
+      value = @row_being_used[number]
+      value ||= ""
+      return value
+    end
+
+    def create_internal_row
+      working_row = []
+
+      @human_readable_tags.each_with_index do |value, index|
+        working_row << (@json_nodes[value.to_sym].to_s)
+      end
+      return working_row
+    end
+
+    def assemble_json(result_set)
+      @sql_columns = result_set.columns
+
+
+      broker = Superstudio::JsonBroker.new()
+      broker.set_row_count(result_set.count)
+      broker.set_mapper(@internal_use_tags)
+      broker.set_quotes(@quoted_tags)
+      broker.set_depths(@depth_tags, @real_depth_tags)
+      broker.set_hashing(@do_not_hash)
+      broker.set_column_names(@column_names)
+      broker.set_repeating_arrays(@unique_threes_tags)
+      broker.set_single_node_names(@type_2_indicator_names)
+      broker.set_array_node_names(@type_4_indicator_names)
+
+      # p "@internal_use_tags: #{@internal_use_tags}"
+      # p "@quoted_tags: #{@quoted_tags}"
+      # p "@depth_tags: #{@depth_tags}"
+      # p "@real_depth_tags: #{@real_depth_tags}"
+      # p "@do_not_hash: #{@do_not_hash}"
+      # p "@sql_columns: #{@sql_columns}"
+      # p "@column_names: #{@column_names}"
+      # p "@unique_threes_tags: #{@unique_threes_tags}"
+      # p "@type_2_indicator_names: #{@type_2_indicator_names}"
+      # p "@type_4_indicator_names: #{@type_4_indicator_names}"
+      # p "@type_2_paths: #{@type_2_paths}"
+      # p "@type_3_paths: #{@type_3_paths}"
+      # p "@type_4_paths: #{@type_4_paths}"
+
+      result_set.rows.each do |row|
+        @row_being_used = row
+        @json_nodes = {}
+        map_row
+        working_row = create_internal_row()
+        broker.consume_row(working_row)
+      end
+
+      @json_result = broker.finalize_json
+    end
+
+  end
+end

data/lib/superstudio/schema_internal_definer.rb

@@ -0,0 +1,210 @@
+module Superstudio
+  module SchemaInternalDefiner
+    def set_human_to_internal_mappings(expected_mappings)
+      fork_nodes = expected_mappings.uniq { |i| i[:path] }
+      max_depth = expected_mappings.max_by { |x| x[:depth] }[:depth]
+      internal_fork_numbers = convert_fork_paths_to_base_route_numbers(fork_nodes, max_depth)
+      depth_counter = 0
+      while depth_counter <= max_depth
+        # Assign all internal numbers to their respective human-readable forms
+        objects_at_depth = expected_mappings.select { |j| j[:depth] == depth_counter }
+        forks_at_depth = internal_fork_numbers.select { |k,v| v[:depth] == depth_counter }
+        type_5_already_found, type_3_already_found = [], []
+        type_1_count, type_3_count, type_5_count = 0, 0, 0
+
+        objects_at_depth.each do |candidate|
+          # ex. {depth: 1, path: ["root"], name: "id", node_type: "integer"}
+
+          # This isn't going to work properly for value arrays
+          if @type_3_paths.include?(candidate[:path])
+            @column_names << candidate[:path].last
+          else
+            @column_names << candidate[:name]
+          end
+          # byebug
+
+          forks_at_depth.each do |p|
+            if candidate[:path] == p[0]
+              # Add the internal path to the internal mapping
+              if @type_5_paths.include?(p[0])
+                type_5_count += 1
+                handle_array_stop_path(type_5_already_found, p[0], p[1][:internal_path], "#{candidate[:path].join("_B_")}_A_#{candidate[:name]}", candidate[:node_type], p[1][:internal_path], "5.#{type_5_count}", candidate[:depth])
+              elsif @type_3_paths.include?(p[0])
+                type_3_count += 1
+                
+                handle_array_stop_path(type_3_already_found, p[0], p[1][:internal_path], "#{candidate[:path].join("_B_")}_A_#{candidate[:name]}", candidate[:node_type], p[1][:internal_path], "3.#{type_3_count}", candidate[:depth])
+              else
+                type_1_count += 1
+                add_to_describe_arrays("#{candidate[:path].join("_B_")}_P_#{candidate[:name]}", p[1][:internal_path], "1.#{type_1_count}", candidate[:node_type], candidate[:depth])
+              end
+            end
+          end
+          # Unless there are no forks for this depth, then we're at the root node, and we should do this differently
+          if !forks_at_depth.present?
+            # Check the type, increment, send
+            if @type_5_paths.include?(p[0])
+
+              handle_array_stop_path(type_5_already_found, p[0], p[1][:internal_path], "#{candidate[:path].join("_B_")}_A_#{candidate[:name]}", candidate[:node_type], "", "5.#{type_5_count}", candidate[:depth])
+            elsif @type_3_paths.include?(p[0])
+
+              handle_array_stop_path(type_3_already_found, p[0], p[1][:internal_path], "#{candidate[:path].join("_B_")}_A_#{candidate[:name]}", candidate[:node_type], "", "3.#{type_3_count}", candidate[:depth])
+            else
+              type_1_count += 1
+              add_to_describe_arrays("#{candidate[:path].join("_B_")}_P_#{candidate[:name]}", "", "1.#{type_1_count}", candidate[:node_type], candidate[:depth])
+            end
+          end
+        end
+        depth_counter += 1
+      end
+    end
+
+    def handle_array_stop_path(type_already_found, path, internal_use_tag, human_readable_tag, node_type, parent_path, item_path, depth)
+      if type_already_found.include?(path)
+        # Do nothing.
+      else
+        type_already_found << path
+        @internal_use_tags << internal_use_tag
+        @human_readable_tags << human_readable_tag
+      end
+      
+      if @unique_threes_paths.include?(path)
+        @unique_threes_tags << 0
+      else
+        @unique_threes_tags << 1
+      end
+      
+      if node_type == "string"
+        @quoted_tags << 1
+      else
+        @quoted_tags << 0
+      end
+
+      @do_not_hash << 1
+
+      if parent_path.present?
+        item_string = "#{parent_path}-#{item_path}"
+        # Count all of the 4s in the internal string, but remove those that are a count of a type
+        # @real_depth_tags << (item_string.scan(/4/).count - item_string.scan(/\.4/).count)
+        @real_depth_tags << (item_string.scan(/4./).count)
+      else
+        @real_depth_tags << 0
+      end
+
+      @depth_tags << (depth - 1)  # going to have to fix - appears too deep for type 3s
+    end
+
+    def add_to_describe_arrays(human_route, parent_path, item_path, node_type, depth)
+      @unique_threes_tags << 1  # This isn't a type 3
+      @human_readable_tags << human_route
+      @depth_tags << (depth - 1)
+      item_string = item_path
+
+      if node_type == "string"
+        @quoted_tags << 1
+      else
+        @quoted_tags << 0
+      end
+
+      if parent_path.present?
+        item_string = "#{parent_path}-#{item_path}"
+        @internal_use_tags << item_string
+        # Count all of the 4s in the internal string, but remove those that are a count of a type
+        # @real_depth_tags << (item_string.scan(/4/).count - item_string.scan(/\.4/).count)
+        @real_depth_tags << (item_string.scan(/4./).count)
+      else
+        @internal_use_tags << item_string
+        @real_depth_tags << 0
+      end
+
+      if item_string.chr == '3'
+        @do_not_hash << 1
+      else
+        @do_not_hash << 0
+      end
+    end
+
+    def convert_fork_paths_to_base_route_numbers(fork_nodes, max_depth)
+      depth_counter = 0
+      internal_fork_numbers = {}
+      two_at_depth_counter, three_at_depth_counter, four_at_depth_counter, five_at_depth_counter = 0, 0, 0, 0
+
+      while depth_counter <= max_depth
+        # two_at_depth_counter, three_at_depth_counter, four_at_depth_counter, five_at_depth_counter = 0, 0, 0, 0
+        objects_at_depth = fork_nodes.select {|j| j[:depth] == depth_counter}
+        possible_parents = fork_nodes.select {|j| j[:depth] == (depth_counter - 1)}
+
+        objects_at_depth.each do |o|
+          if o[:path].join("_B_") == 'root'
+            internal_fork_numbers[o[:path]] = { internal_path: '', depth: o[:depth] }
+            break
+          end
+
+          if @type_2_paths.include?(o[:path])
+            two_at_depth_counter += 1
+            generate_internal_fork_number_of_type(internal_fork_numbers, possible_parents, o, 2, two_at_depth_counter) 
+          end
+
+          if @type_4_paths.include?(o[:path])
+            four_at_depth_counter += 1
+            generate_internal_fork_number_of_type(internal_fork_numbers, possible_parents, o, 4, four_at_depth_counter)
+          end
+
+          if @type_3_paths.include?(o[:path])
+            three_at_depth_counter += 1
+            # We also need to check some extra possible parents here. It appears that when a type 3 is first, or possibly 
+            # the only child in an object, the object will fail to be accounted for.
+
+            ob = o.dup
+            ob[:path] = ob[:path][0..-2]
+
+            if internal_fork_numbers[ob[:path]].nil?
+
+              @type_4_paths.each_with_index do |four_path, idx|
+                if four_path.length + 1 == o[:depth]
+                  possible_parents << { depth: o[:depth] - 1, path: four_path, name: four_path.last, node_type: "array" }
+                  four_at_depth_counter += 1
+                  generate_internal_fork_number_of_type(internal_fork_numbers, possible_parents, ob, 4, four_at_depth_counter)
+                end
+              end
+            end
+
+            generate_internal_fork_number_of_type(internal_fork_numbers, possible_parents, o, 3, three_at_depth_counter)
+          end
+
+
+          if @type_5_paths.include?(o[:path])
+            five_at_depth_counter += 1
+            generate_internal_fork_number_of_type(internal_fork_numbers, possible_parents, o, 5, five_at_depth_counter)
+          end
+        end
+
+        depth_counter += 1
+      end
+      return internal_fork_numbers
+    end
+
+    def generate_internal_fork_number_of_type(internal_fork_numbers, possible_parents, object_at_depth, type, number)
+      parent = nil
+      if possible_parents
+        possible_parents.each do |pp|
+          parent = pp if object_at_depth[:path][0..-2] == pp[:path]
+        end
+      end
+      
+      if (type == 2)
+        @type_2_indicator_names[number] = object_at_depth[:path].last
+      end
+      if (type == 4)
+        @type_4_indicator_names[number - 1] = object_at_depth[:path].last
+      end
+      internal_path = ""
+      internal_path = "#{internal_fork_numbers[parent[:path]][:internal_path]}" if parent.present?
+      
+      if parent.present? && parent[:path].join("_B_") != 'root' && internal_fork_numbers[parent[:path]][:internal_path] != ''
+        internal_path << "-"
+      end
+      internal_path << "#{type}.#{number}"
+      internal_fork_numbers[object_at_depth[:path]] = { internal_path: internal_path, depth: object_at_depth[:depth] }
+    end
+  end
+end