jaspion-kilza 1.0.8

data/lib/jaspion.rb

@@ -0,0 +1,6 @@
+require 'jaspion/kilza'
+
+# Base module Jaspion
+module Jaspion
+
+end

data/lib/jaspion/kilza.rb

@@ -0,0 +1,44 @@
+require 'jaspion/kilza/version'
+
+require 'jaspion/kilza/source'
+require 'jaspion/kilza/class'
+require 'jaspion/kilza/property'
+require 'jaspion/kilza/language'
+require 'jaspion/kilza/language/objc'
+require 'jaspion/kilza/language/java'
+
+# Ruby class
+class String
+  # Test if the string can be a number
+  #
+  # @param str [String] string to be tested
+  #
+  # @return [Boolean] true in case of success
+  def number?
+    true if Float(self) rescue false
+  end
+end
+
+# Tranforms a JSON string into Objects
+module Jaspion
+  module Kilza
+    # Removes everything except numbers and letters.
+    #
+    # @param str [String] string to be cleaned
+    #
+    # @return [String] cleaned string
+    def self.clean(str)
+      str = '_' + str if str[0].number?
+      str.gsub(/[^a-zA-Z0-9]/, '_')
+    end
+
+    # Cleans the string and make it lowercase.
+    #
+    # @param str [String] string to be cleaned
+    #
+    # @return [String] cleaned string
+    def self.normalize(str)
+      Jaspion::Kilza.clean(str).downcase
+    end
+  end
+end

data/lib/jaspion/kilza/class.rb

@@ -0,0 +1,88 @@
+module Jaspion
+  module Kilza
+    # Represents one single object class
+    module Class
+      # Class name
+      attr_accessor :name
+
+      # Array with all class dependecies
+      # Specific for each language
+      attr_accessor :imports
+
+      # Array with all class properties
+      attr_accessor :properties
+
+      # Initializes a Class object
+      #
+      # @param name [String] Class Name
+      def initialize(name)
+        @name = Kilza.normalize(name).capitalize
+        @properties = []
+        @imports = []
+      end
+
+      # Adds a new property
+      #
+      # @param property [Kilza::Property] Property to include
+      def push(property)
+        index = @properties.index(property)
+        if !index.nil?
+          current = @properties[index]
+          @properties[index] = update(current, property)
+        else
+          @properties.push(property)
+        end
+      end
+
+      def sources
+        fail 'It should be implemented'
+      end
+
+      # Returns the #Source object of this Class.
+      #
+      # @param lang [String] Language name (java, objc, ...)
+      # @param file_name [String] Source file name
+      #
+      # @return [Kilza::Source] Source object of this Class
+      def code(lang, file_name)
+        cur_path = File.expand_path(__FILE__)
+        erb_path = File.join(File.dirname(cur_path), 'language', lang)
+
+        path = File.join(erb_path, file_name + '.erb')
+        eruby = Erubis::Eruby.new(File.read(path))
+
+        s = Kilza::Source.new
+        s.source = eruby.result(binding)
+        s.file_name = @name.capitalize + '.' + file_name
+        s
+      end
+
+      def to_s
+        properties = []
+        @properties.each { |p| properties.push(p.to_s) }
+        {
+          name: @name,
+          imports: @imports,
+          properties: properties
+        }.to_s
+      end
+
+      protected
+
+      # Compares two properties and fill the src property with relevant
+      # dst property values. If src.type is nilclass and dst.type not, replaces
+      # it with dst.type
+      #
+      # @param property [Kilza::Property] Property to include
+      #
+      # @return [Kilza::Property] src property with new values
+      def update(src, dst)
+        src.type = dst.type if src.null? && !dst.null?
+        src.original_type = dst.original_type if src.null? && !dst.null?
+        src.array = dst.array unless src.array?
+        src.key = dst.key unless src.key
+        src
+      end
+    end
+  end
+end

data/lib/jaspion/kilza/language.rb

@@ -0,0 +1,141 @@
+require 'json'
+require 'erubis'
+
+module Jaspion
+  module Kilza
+    # Represents an program language
+    module Language
+      # Array with all Class classes
+      attr_accessor :classes
+
+      # Name used to represent the first generated class
+      attr_accessor :base_name
+
+      # JSON that will be used to generate objects
+      attr_accessor :json_string
+
+      # String that will be used to prefix reserved words
+      attr_accessor :reserved_delimiter
+
+      # Words that will receive an undescore before property name
+      attr_accessor :reserved_words
+
+      # Array with all properties that will be used to compare other objects
+      attr_accessor :equal_keys
+
+      # Hash table with all language types mapped to target language
+      attr_accessor :types
+
+      def initialize(json_string)
+        @json_string = json_string
+        @classes = []
+        @types = {}
+        @reserved_words = []
+        @reserved_delimiter = '_'
+        @equal_keys = []
+      end
+
+      # Returns all available classes
+      #
+      # @param base_name [String] First class name
+      #
+      # @return [Array] All available classes
+      def classes(base_name)
+        hash = JSON.parse(json_string)
+        hash = { base_name + 'Object' => hash } if hash.is_a?(Array)
+        parse_hash(base_name, hash)
+
+        @classes
+      end
+
+      protected
+
+      # Creates a new Class object and checks for valid name
+      #
+      # @param name [String] name of the class to be created
+      #
+      # @return [Kilza::Class] new class
+      def clazz(name)
+        name = @reserved_delimiter + name unless @reserved_words.index(name).nil?
+        Class.new(name)
+      end
+
+      # Creates a new Property object and checks for valid name
+      #
+      # @param name [String] name of the property to be created
+      # @param type [String] type of the property based on class name
+      # @param array [Boolean] indicates if this property represents an array
+      # @param key [Boolean] indicates if this property can be used to compare
+      # objects
+      #
+      # @return [Kilza::Property] new property
+      def property(name, type, array, key)
+        name = @reserved_delimiter + name unless @reserved_words.index(name).nil?
+        Property.new(name, type, array, key)
+      end
+
+      # Searches for a Kilza::Class inside @classes
+      # and creates a new one if it could not be found
+      #
+      # @param name [String] class name to find
+      #
+      # @return [Kilza::Class] class with the specified name
+      def find(name)
+        name = Kilza.normalize(name).capitalize
+        @classes.each { |cl| return cl if cl.name == name }
+        @classes.push(clazz(name))
+        @classes.last
+      end
+
+      # Parses an element value an verify if it should create a new Classs
+      # inside @classes
+      #
+      # @param class_name [String] Name of the class the element is inside
+      # @param name [String] The element name
+      # @param value [Any] The element value
+      # @param array [Boolean] Indicates the element is inside an Array
+      def parse_el(class_name, name, value, array = false)
+        type = value.class.name.split('::').last.downcase
+
+        return parse_array(class_name, name, value) if type == 'array'
+
+        cur_class = find(class_name)
+        key = @equal_keys.index(name).nil? ? false : true
+        cur_class.push(property(name, type, array, key))
+
+        # if value is nil, consider it as an Object
+        find(name) if type == 'nilclass'
+
+        parse_hash(name, value) if type == 'hash'
+      end
+
+      # Parses an hash calling parse_el for each element
+      #
+      # @param class_name [String] Name of the class the hash is inside
+      # @param hash [Hash] The hash value
+      def parse_hash(class_name, hash)
+        hash.each do |property_name, value|
+          parse_el(class_name, property_name, value)
+        end
+      end
+
+      # Parses an element that represents an array calling parse_el
+      # for each element.
+      # If the array is empty, it creates a new class to represent
+      # each array's element.
+      #
+      # @param class_name [String] Name of the class the array is inside
+      # @param name [String] The element name
+      # @param value [Any] The element value
+      def parse_array(class_name, name, value)
+        if value.length == 0
+          parse_el(class_name, name, nil, true)
+        else
+          value.each do |val|
+            parse_el(class_name, name, val, true)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jaspion/kilza/language/java.rb

@@ -0,0 +1,75 @@
+require 'date'
+
+module Jaspion
+  module Kilza
+    class Java
+      class Class
+        include Jaspion::Kilza::Class
+
+        # Represents the Java class package
+        attr_accessor :package
+
+        def initialize(name, package = nil)
+          super(name)
+          @package = package
+        end
+
+        def sources
+          [code('java', 'java')]
+        end
+      end
+    end
+  end
+end
+
+module Jaspion
+  module Kilza
+    # Objective-C Language parser
+    class Java
+      include Jaspion::Kilza::Language
+
+      def initialize(json_string)
+        super(json_string)
+
+        @reserved_words = %w(
+          abstract continue for new switch assert default goto,
+          package synchronized boolean do if private this break double implements,
+          protected throw byte else import public throws case enum instanceof,
+          null return transient catch extends int short try char final interface static,
+          void class finally long strictfp volatile const float native super while
+        )
+
+        @types = {
+          'nilclass' => 'Object',
+          'string' => 'String',
+          'fixnum' => 'Long',
+          'float' => 'Double',
+          'falseclass' => 'Boolean',
+          'trueclass' => 'Boolean',
+          'hash' => 'Object'
+        }
+
+        @equal_keys = %w(id identifier uid)
+      end
+
+      def clazz(name)
+        Jaspion::Kilza::Java::Class.new(name)
+      end
+
+      def classes(class_name)
+        super(class_name)
+
+        @classes.each do |cl|
+          cl.properties.each do |pr|
+            pr.type = pr.name.capitalize if pr.object? || (pr.array? && pr.null?)
+
+            cl.imports.push('import java.util.ArrayList;') if pr.array? &&
+              cl.imports.index('import java.util.ArrayList;').nil?
+
+            pr.type = @types[pr.type] unless @types[pr.type].nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jaspion/kilza/language/java/java.erb

@@ -0,0 +1,131 @@
+package <%= @package %>;
+
+import org.json.*;
+import java.io.Serializable;
+<% for @import in @imports %>
+<%= @import %>
+<% end %>
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.annotations.SerializedName;
+import com.google.gson.annotations.Expose;
+
+public class <%= @name %> implements Serializable
+{
+<% for @property in @properties %>
+    private static final String FIELD_<%= @property.name.upcase %> = "<%= @property.original_name %>";
+<% end %>
+
+<% for @property in @properties %>
+    @Expose
+    @SerializedName(FIELD_<%= @property.name.upcase %>)
+    <% if @property.array? %>
+    private ArrayList<<%= @property.type %>> <%= @property.name %>;
+    <% else %>
+    private <%= @property.type %> <%= @property.name %>;
+    <% end %>
+<% end %>
+
+    public <%= @name %>() {
+
+    }
+
+    public <%= @name %>(JSONObject jsonObject) {
+        parseObject(jsonObject);
+    }
+
+    public <%= @name %>(String jsonString) {
+        try {
+            parseString(jsonString);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+    }
+
+    protected void parseString(String jsonString) throws JSONException {
+        JSONObject jsonObject = new JSONObject(jsonString);
+        parseObject(jsonObject);
+    }
+
+    protected void parseObject(JSONObject object)
+    {
+<% for @property in @properties %>
+  <% if @property.array? %>
+        if (object.optJSONArray(FIELD_<%= @property.name.upcase %>) != null)
+        {
+            this.<%= @property.name %> = new ArrayList<>();
+            JSONArray <%= @property.name %>JsonArray = object.optJSONArray(FIELD_<%= @property.name.upcase %>);
+            for (int i = 0; i < <%= @property.name %>JsonArray.length(); i++) {
+    <% if @property.object? || @property.null? %>
+                JSONObject <%= @property.name %> = <%= @property.name %>JsonArray.optJSONObject(i);
+    <% else %>
+                <%= @property.type %> <%= @property.name %> = <%= @property.name %>JsonArray.optJSON<%= @property.type %>(i);
+    <% end %>
+                this.<%= @property.name %>.add(new <%= @property.type %>(<%= @property.name %>));
+            }
+        }
+  <% else %>
+    <% if @property.object? %>
+        this.<%= @property.name %> = new <%= @property.type %>(object.optJSONObject(FIELD_<%= @property.name.upcase %>));
+    <% else %>
+      <% if @property.null? %>
+        this.<%= @property.name %> = object.opt(FIELD_<%= @property.name.upcase %>);
+      <% else %>
+        this.<%= @property.name %> = object.opt<%= @property.type %>(FIELD_<%= @property.name.upcase %>);
+      <% end %>
+    <% end %>
+  <% end %>
+<% end %>
+    }
+
+<% for @property in @properties %>
+    public void set<%= @property.name.capitalize %>(<%= @property.array? ? "ArrayList<" + @property.type + ">" : @property.type %> value) {
+        this.<%= @property.name %> = value;
+    }
+
+    <% if @property.array? %>
+    public ArrayList<<%= @property.type %>> get<%= @property.name.capitalize %>() {
+    <% elsif @property.boolean? %>
+    public <%= @property.type %> is<%= @property.name.capitalize %>() {
+    <% else %>
+    public <%= @property.type %> get<%= @property.name.capitalize %>() {
+    <% end %>
+        return this.<%= @property.name %>;
+    }
+
+<% end %>
+<%
+@eq = []
+@hs = []
+for @property in @properties
+  if @property.boolean?
+    @eq.push("((#{@name}) obj).is#{@property.name.capitalize}().equals(#{@property.name})") if @property.key?
+  else
+    @eq.push("((#{@name}) obj).get#{@property.name.capitalize}().equals(#{@property.name})") if @property.key?
+  end
+  @hs.push("#{@property.name}.hashCode()") if @property.key?
+end
+%>
+<% if @eq.length > 0 %>
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof <%= @name %>) {
+            return <%= @eq.join(" &&\n            ") %> ;
+        }
+        return false;
+    }
+<% end %>
+<% if @hs.length > 0 %>
+    @Override
+    public int hashCode(){
+        return (<%= @hs.join(" +\n        ") %>);
+    }
+<% end %>
+
+    @Override
+    public String toString() {
+      Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();
+      return gson.toJson(this);
+    }
+}