db_serializer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 455c86988e110584438e1edbbf8ef7c894e5a32ca6f69f49644d01e35cf9553a
+  data.tar.gz: c2b95f504f522e38992fe027f72cae332c8e7c96017ea1287fb9de6fab5b3b1a
+SHA512:
+  metadata.gz: e35adc11a93293124fe2f39be8aee789fd1b02ddad3028cc111aad698e58d9d28a501870ffb2ab7381948d995fcfe0c6c49ab72951fc26b15310021453b042cd
+  data.tar.gz: 30ad4440828d712480b39b1588502ba5aebfc1a724f0e53661072670dc515e3ae8ea4a891d490479cb15193ddf196d0c0510c5d3b120bee9a734e611f9e6a969

data/README.md

@@ -0,0 +1,71 @@
+# Db Serializer
+
+This gem provide a blazing fast way to serialize Active Record models.
+At the moment only a GeoJSON serializer is implemented
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'db_serializer'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Then you need to include the concern `DbSerializer::GeoJSON` to your model:
+
+```ruby
+# In this example the City model has:
+# - an attribute name of type string
+# - an attribute boundaries of type geometry
+class City < ActiveRecord::Base
+  # Include this concern
+  include DbSerializer::JSON
+
+  # Specify which column contains the geometry
+  # If you don't specify it, by default it will be :geometry
+  db_serializer :boundaries
+end
+```
+
+## Usage
+
+```ruby
+puts City.all.to_geojson([:id, :name])
+
+# If you had such a model, it would output something like this:
+# {
+#   "type": "FeatureCollection", "features": [{
+#     "id": 1, "type": "Feature", "geometry": {
+#       "type": "MultiLineString", "coordinates": [[[x1,y1],[x2,y2]]]
+#     },
+#     "properties": {"id": 1, "name": "Paris"}
+#   }]
+# }
+```
+Note: the output has been pretty printed for readability but please keep in mind that `to_geojson` returns a *string* containing a valid serialized JSON.
+It means that you do not need to use `to_json` on it and that it can be parse with `JSON.parse`.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/leonard-henriquez/db_serializer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/leonard-henriquez/db_serializer/blob/master/CODE_OF_CONDUCT.md).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the db_serializer project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/leonard-henriquez/db_serializer/blob/master/CODE_OF_CONDUCT.md).

data/lib/db_serializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_record'
+
+##
+# Module that contains spatial serializers for ActiveRecord models.
+# The extended class must be an ActiveRecord::Base.
+# It must also have a geometry column (the name of this column can be customized).
+module DbSerializer
+  extend ActiveSupport::Autoload
+
+  autoload :Version
+  autoload :GeoJSON
+  autoload :Utilities
+end

data/lib/db_serializer/geo_json.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module DbSerializer
+  # JSON Serializer
+  module GeoJSON
+    extend ActiveSupport::Concern
+
+    included do
+      @db_serializer_options = {
+        field: :geometry
+      }
+
+      private
+
+      ##
+      # Adds a geojson attribute to the current ActiveRecord::Relation
+      # @param columns [Array<Symbol, String>] list of the columns to include in the GeoJSON
+      # @return [ActiveRecord::Relation] relation with a new attribute named geojson
+      scope :set_geojson_attribute, ->(columns = nil) do
+        columns = select_values if columns.nil?
+        params = {
+          geometry_column: db_serializer_options[:field],
+          field_name: :geojson
+        }
+
+        attribute = DbSerializer::Utilities::SQL.geojson_attribute(columns, params)
+
+        _select!(attribute)
+      end
+    end
+
+    class_methods do
+      ##
+      # Allows to set the options for this gem
+      # @param field [Symbol] name of the attribute containing geometry
+      # @return [Hash]
+      def db_serializer(field = :geometry)
+        @db_serializer_options = {}
+        @db_serializer_options[:field] = field.to_sym
+        db_serializer_options
+      end
+
+      ##
+      # Allows to get the options for this gem
+      # @return [Hash] contains keys :field
+      def db_serializer_options
+        if defined?(@db_serializer_options)
+          @db_serializer_options
+        elsif superclass.respond_to?(:db_serializer_options)
+          superclass.db_serializer_options || {}
+        else
+          {}
+        end
+      end
+
+      ##
+      # Creates a json serialized FeatureCollection of the ActiveRecord::Relation.
+      #
+      # FeatureCollection specs: http://wiki.geojson.org/GeoJSON_draft_version_6#FeatureCollection
+      #
+      # It is already serialized so there is no need to apply +.to_json+.
+      #
+      # @param columns [Array<Symbol, String>]
+      # @return [String] JSON serialized FeatureCollection
+      def to_geojson(columns = nil)
+        features = set_geojson_attribute(columns)
+        query = DbSerializer::Utilities::SQL.feature_collection(features)
+        ActiveRecord::Base.connection.query_value(query)
+      end
+    end
+  end
+end

data/lib/db_serializer/utilities.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module DbSerializer
+  ##
+  # Module defining geographic tools
+  module Utilities
+    ##
+    # SQL utilities for spatial queries
+    module SQL
+      class << self
+        ##
+        # This method returns a string containing a SQL query to build a GeoJSON FeatureCollection.
+        #
+        # The result of the SQL query generated by this method contains one row with one
+        # column. It contains a serialized GeoJSON FeatureCollection.
+        #
+        # Example of GeoJSON FeatureCollection:
+        # <code>
+        # {"type": "FeatureCollection", "features": [{"id": 1, "type":
+        # "Feature", "geometry": {"type": "MultiLineString", "coordinates": [[[x,y]]]},
+        # "properties": {"id": 1, "name": "Paris"}}]}
+        # </code>
+        #
+        # To learn more about FeatureCollections see the specifications:
+        # http://wiki.geojson.org/GeoJSON_draft_version_6#FeatureCollection
+        #
+        #
+        # @example
+        #   features = MyActiveRecordModel.select(geojson_attribute([:id]))
+        #   query = feature_collection(features)
+        #   ActiveRecord::Base.connection.query_value(query)
+        #
+        # @param features [String, ActiveRecord::Relation] query of the features to include
+        # @param opts [Hash]
+        # @option opts [String, Symbol] :geojson_column name of the column containing
+        #   the GeoJSON features to include in the collection
+        # @option opts [String, Symbol] :output_column name of the output column
+        # @return [String] SQL to get a FeatureCollection
+        def feature_collection(features, opts = {})
+          opts = {
+            geojson_column: :geojson,
+            output_column: :json
+          }.merge(opts)
+
+          geojson_column = opts[:geojson_column]
+          output_column = opts[:output_column]
+          inner_query = features.is_a?(String) ? features : features.to_sql
+
+          <<-SQL
+            SELECT jsonb_build_object(
+              'type', 'FeatureCollection',
+              'features', COALESCE(jsonb_agg(features.#{geojson_column}), '[]')
+            ) AS #{output_column} FROM (#{inner_query}) features
+          SQL
+        end
+
+        ##
+        # This method returns a string containing part of a SQL query that can be used
+        # in a +SELECT+ statement to add a GeoJSON feature column to a query.
+        #
+        # The SQL column generated by this method contains a serialized GeoJSON feature.
+        #
+        # Example of GeoJSON feature:
+        # <code>
+        # {"id": 1, "type": "Feature", "geometry":
+        # {"type": "MultiLineString", "coordinates": [[[x,y]]]},
+        # "properties": {"id": 1, "name": "Paris"}}
+        # </code>
+        #
+        # To learn more about GeoJSON features see the specifications:
+        # http://wiki.geojson.org/GeoJSON_draft_version_6#Feature
+        #
+        # @example with SQL:
+        #   geojson = DbSerializer::Utilities::SQL.geojson_attribute([:id])
+        #   records = ActiveRecord::Base.connection.exec_query(
+        #     "SELECT id, geometry, #{geojson} FROM table"
+        #   )
+        #   record = records.first
+        #
+        #   # print a String containing a serialized GeoJSON feature, check example in the note
+        #   puts record['geojson']
+        #
+        # @example with an +ActiveRecord::Base+
+        #   geojson = DbSerializer::Utilities::SQL.geojson_attribute([:id])
+        #   records = Model.select(geojson)
+        #   record = records.first
+        #
+        #   # print a String containing a serialized GeoJSON feature, check example in the note
+        #   puts record.geojson_before_type_cast
+        #
+        #   # print a Hash
+        #   puts record.geojson
+        #
+        # @param columns [Array<String, Symbol>] SQL columns to include in the properties
+        #   of the GeoJSON feature, must be accessible in the underlying table
+        # @param opts [Hash]
+        # @option opts [Symbol] :geometry_column defaults to :geometry
+        # @option opts [Symbol] :output_column defaults to :geojson
+        # @return [String] SQL +SELECT+ statement to add a column named +geojson+ to a SQL query
+        def geojson_attribute(columns, opts = {})
+          opts = {
+            geometry_column: :geometry,
+            output_column: :geojson
+          }.merge(opts)
+
+          filtered_columns = columns.reject { |column| column.to_s == opts[:geometry_column].to_s }
+          columns = filtered_columns.map { |column| "'#{column}',#{column}" }.join(',')
+
+          geometry = "ST_AsGeoJSON(#{opts[:geometry_column]})::jsonb"
+          properties = "json_build_object(#{columns})"
+          output_column = opts[:output_column]
+
+          <<-SQL
+            jsonb_build_object(
+              'type', 'Feature',
+              'id', id,
+              'geometry', #{geometry},
+              'properties', #{properties}
+            ) AS #{output_column}
+          SQL
+        end
+      end
+    end
+  end
+end

data/lib/db_serializer/version.rb

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

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: db_serializer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Leonard Henriquez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-postgis-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Add geometry features on Active Record models
+email:
+- leonard@flatlooker.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/db_serializer.rb
+- lib/db_serializer/geo_json.rb
+- lib/db_serializer/utilities.rb
+- lib/db_serializer/version.rb
+homepage: https://github.com/Flatlooker/db_serializer
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/Flatlooker/db_serializer
+  source_code_uri: https://github.com/Flatlooker/db_serializer.git
+  changelog_uri: https://github.com/Flatlooker/db_serializer
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.3
+signing_key: 
+specification_version: 4
+summary: Add geometry features on Active Record models
+test_files: []