marty 2.5.2 → 2.5.4

data/{spec/dummy/delorean/fields.dl → delorean/marty_fields.dl}

@@ -32,6 +32,14 @@ ClassField: ClassListField
 
 ######################################################################
 
+CheckboxField:
+    xtype           = ":checkboxfield"
+    checked         = false
+    input_value     = true
+    unchecked_value = false
+
+######################################################################
+
 JsonField:
     xtype       = ":textareafield"
     name        = "json_field"

data/delorean/table_report.dl

@@ -0,0 +1,34 @@
+import MartyFields
+import Styles
+
+ReadableField: MartyFields::CheckboxField
+    name        = "readable"
+    field_label = "Disable Encoding"
+
+TableReport:
+    readable    =? nil
+    pt_name     =? nil
+    posting     = Marty::Posting.lookup(pt_name)
+    pt          = posting.created_dt
+    module_name =? nil
+    class_name  =? nil
+    title       =? (class_name || "Table Report") + (
+        if pt_name then "_" + pt_name else "")
+    sort_field  =? nil
+    exclude_attrs =? nil
+
+    result_raw  = Marty::DataChange.do_export(
+        pt,
+        if module_name then module_name + '::' + class_name else class_name,
+        sort_field,
+        exclude_attrs || [],
+        )
+    row_count   = result_raw.length
+    result      = Marty::Helper.to_csv(result_raw, {'readable' : readable})
+    form        = [
+        MartyFields::PostingField,
+        MartyFields::ClassField,
+        ReadableField,
+        ]
+    format      = "csv"
+

data/docker-compose.dummy.yml

@@ -22,9 +22,8 @@ services:
       - "postgres"
     volumes:
       - .:/opt/app:delegated
-
-      # - '~/.bash_history:/root/.bash_history'
-      # - '~/.pry_history:/root/.pry_history'
+      - '.bash_history.docker:/root/.bash_history'
+      - '.pry_history.docker:/root/.pry_history'
     volumes_from:
       - bundle_box
     tty: true

data/lib/marty/aws/base.rb

@@ -11,13 +11,12 @@ class Marty::Aws::Base
               :creds,
               :version,
               :host,
-
-  def self.get url
-    uri = URI.parse(url)
-    req = Net::HTTP.new(uri.host, uri.port)
-    req.read_timeout = req.open_timeout = ENV['AWS_REQUEST_TIMEOUT'] || 0.25
-    req.start {|http| http.get(uri.to_s) }.body
-  end
+              def self.get url
+                uri = URI.parse(url)
+                req = Net::HTTP.new(uri.host, uri.port)
+                req.read_timeout = req.open_timeout = ENV['AWS_REQUEST_TIMEOUT'] || 0.25
+                req.start { |http| http.get(uri.to_s) }.body
+              end
 
   def self.is_aws?
     # FIXME: hack to pass tests on CI
@@ -44,6 +43,7 @@ class Marty::Aws::Base
   end
 
   private
+
   def get_instance_id
     query_meta_data('instance-id').to_s
   end
@@ -53,7 +53,7 @@ class Marty::Aws::Base
   end
 
   def sym obj
-    obj.each_with_object({}){|(k,v),h| h[k.underscore.to_sym] = v}
+    obj.each_with_object({}) { |(k, v), h| h[k.underscore.to_sym] = v }
   end
 
   def get_credentials

data/lib/marty/aws/request.rb

@@ -7,13 +7,13 @@ class Marty::Aws::Request < Marty::Aws::Base
     endpoint = info[:endpoint]
     method   = info[:method] || :get
 
-    default = action ? {'Action' => action, 'Version' => @version} : {}
+    default = action ? { 'Action' => action, 'Version' => @version } : {}
 
     host = "#{@service}.#{@doc[:region]}.amazonaws.com"
 
     url = "https://#{host}/"
     url += endpoint if endpoint
-    url += '?' + (default + params).map{|a, v| "#{a}=#{v}"}.join('&') unless
+    url += '?' + (default + params).map { |a, v| "#{a}=#{v}" }.join('&') unless
       params.empty?
 
     sig = Aws::Sigv4::Signer.new(service:           @service,
@@ -21,7 +21,7 @@ class Marty::Aws::Request < Marty::Aws::Base
                                  access_key_id:     @creds[:access_key_id],
                                  secret_access_key: @creds[:secret_access_key],
                                  session_token:     @creds[:token])
-    signed_url = sig.presign_url(http_method:'GET', url: url)
+    signed_url = sig.presign_url(http_method: 'GET', url: url)
 
     http = Net::HTTP.new(host, 443)
     http.use_ssl = true
@@ -38,7 +38,7 @@ class Marty::Aws::Request < Marty::Aws::Base
 
       ensure_resp(path, obj[key])
     else
-      obj.map{|s| ensure_resp(path.clone, s)}.flatten(1)
+      obj.map { |s| ensure_resp(path.clone, s) }.flatten(1)
     end
   end
 end

data/lib/marty/cache_adapters/mcfly_ruby_cache.rb

@@ -5,6 +5,7 @@ module Marty
         ts = args && args.first
 
         return false if Mcfly.is_infinity(ts)
+
         true
       end
     end

data/lib/marty/content_handler.rb

@@ -1,11 +1,11 @@
 module Marty::ContentHandler
   GEN_FORMATS = {
-    "csv"  => ['text/csv',                 'download'],
-    "zip"  => ['application/zip',          'download'],
-    "xlsx" => ['application/vnd.ms-excel', 'download'],
-    "html" => ['text/html',                'download'],
-    "txt"  => ['text/plain',               'inline'],
-    "json" => ['application/json',         'download'],
+    'csv'  => ['text/csv',                 'download'],
+    'zip'  => ['application/zip',          'download'],
+    'xlsx' => ['application/vnd.ms-excel', 'download'],
+    'html' => ['text/html',                'download'],
+    'txt'  => ['text/plain',               'inline'],
+    'json' => ['application/json',         'download'],
 
     # hacky: default format is JSON
     nil    => ['application/json',         'download'],
@@ -19,29 +19,29 @@ module Marty::ContentHandler
   def self.export(data, format, name)
     begin
       case format
-      when "csv"
+      when 'csv'
         # Somewhat hacky, if data is string => pass through as CSV.
         # Should generalize to other data types, not just CSV.
         res = data.is_a?(String) ? data : Marty::DataExporter.to_csv(data)
-      when "xlsx"
+      when 'xlsx'
         res = Marty::Xl.spreadsheet(data).to_stream.read
-      when "zip"
+      when 'zip'
         res = to_zip(data)
-      when nil, "json"
-        res, format = data.to_json, "json"
-      when "html"
+      when nil, 'json'
+        res, format = data.to_json, 'json'
+      when 'html'
         res = data.to_s
       else
-        res, format = {error: "Unknown format: #{format}"}.to_json, "json"
+        res, format = { error: "Unknown format: #{format}" }.to_json, 'json'
       end
-    rescue => exc
+    rescue StandardError => exc
       res, format =
-        {error: "Failed conversion #{format}: #{exc}"}.to_json, "json"
+        { error: "Failed conversion #{format}: #{exc}" }.to_json, 'json'
     end
 
     type, disposition = GEN_FORMATS[format]
 
-    return [res, type, disposition, "#{name}.#{format}"]
+    [res, type, disposition, "#{name}.#{format}"]
   end
 
   private
@@ -53,24 +53,24 @@ module Marty::ContentHandler
   end
 
   def self.uniq_filename(filename, fset)
-    (0..1000).each { |i|
-      post = i==0 ? "" : " (#{i})"
+    (0..1000).each do |i|
+      post = i == 0 ? '' : " (#{i})"
       fn = filename + post
       return fn unless fset.member? fn
-    }
+    end
     filename
   end
 
   def self.to_zip_stream(stream, path, data)
     fset = Set.new
 
-    data.each { |r|
-      title, format, result = r["title"], r["format"], r["result"]
+    data.each do |r|
+      title, format, result = r['title'], r['format'], r['result']
 
-      log_and_raise "Result has no title" unless title
-      log_and_raise "Result has no result" unless result
+      log_and_raise 'Result has no title' unless title
+      log_and_raise 'Result has no result' unless result
 
-      if format == "zip"
+      if format == 'zip'
         to_zip_stream(stream, path + [title], result)
         next
       end
@@ -82,7 +82,7 @@ module Marty::ContentHandler
 
       stream.put_next_entry((path + [filename]).join('/'))
       stream.write res_data
-    }
+    end
   end
 
   def self.to_zip(data)

data/lib/marty/data_change.rb

@@ -6,9 +6,7 @@ class Marty::DataChange
 
   # will break if DataExporter::export_attrs recurses more than 1 level
   # and a level 2+ child table has a compound mcfly_uniqueness key
-  delorean_fn :changes, sig: [3, 4] do
-    |t0, t1, class_name, ids = nil|
-
+  delorean_fn :changes, sig: [3, 4] do |t0, t1, class_name, ids = nil|
     klass = class_name.constantize
 
     t0 = Mcfly.normalize_infinity t0
@@ -21,38 +19,37 @@ class Marty::DataChange
 
     changes.each_with_object({}) do |(group_id, ol), h|
       h[group_id] = ol.each_with_index.map do |o, i|
-        profile = {"obj" => o.attributes}
+        profile = { 'obj' => o.attributes }
 
         # Create a profile hash for each object in the group.
         # "status" tells us if the object is old/new/mod.  If
         # status=="mod" then "changes" will provide the list of
         # columns which changed.  If the object was deleted during
         # t0-t1 then we set the deleted flag in the profile.
-        profile["deleted"] = (group_id == o.id &&
+        profile['deleted'] = (group_id == o.id &&
                               o.obsoleted_dt != Float::INFINITY &&
                               (t1 == 'infinity' || o.obsoleted_dt < t1)
-                              )
+                             )
         if i == 0
-          profile["status"] = o.created_dt < t0 ? "old" : "new"
+          profile['status'] = o.created_dt < t0 ? 'old' : 'new'
           prev = nil
         else
-          profile["status"], prev = "mod", prev = ol[i-1]
+          profile['status'], prev = 'mod', prev = ol[i - 1]
         end
 
         exp_attrs = Marty::DataExporter.export_attrs(klass, o).flatten(1)
 
         # assumes cols order is same as that returned by export_attrs
 
-        profile["attrs"] = cols_model.each_with_index.with_object([]) do
-          |(col, i), a|
+        profile['attrs'] = cols_model.each_with_index.with_object([]) do |(col, i), a|
           header_current = cols_header[i]
           valcount = Array === header_current ? header_current.count : 1
           changed = o.send(col.to_sym) != prev.send(col.to_sym) if prev
           valcount.times do
-            a.push({
-              "value"     => exp_attrs.shift,
-              "changed"   => changed
-            })
+            a.push(
+              'value'     => exp_attrs.shift,
+              'changed'   => changed
+            )
           end
         end
         profile
@@ -60,9 +57,7 @@ class Marty::DataChange
     end
   end
 
-  delorean_fn :change_summary, sig: 3 do
-    |t0, t1, class_name|
-
+  delorean_fn :change_summary, sig: 3 do |t0, t1, class_name|
     klass = class_name.constantize
 
     t0 = Mcfly.normalize_infinity t0
@@ -72,49 +67,43 @@ class Marty::DataChange
 
     created = updated = deleted = 0
 
-    changes.each { |group_id, ol|
-      ol.each_with_index.map { |o, i|
-        deleted +=1 if (group_id == o.id &&
+    changes.each do |group_id, ol|
+      ol.each_with_index.map do |o, i|
+        deleted += 1 if (group_id == o.id &&
                         o.obsoleted_dt != Float::INFINITY &&
                         (t1 == 'infinity' || o.obsoleted_dt < t1)
                         )
         if i == 0
-          created +=1 unless o.created_dt < t0
+          created += 1 unless o.created_dt < t0
         else
           updated += 1
         end
-      }
-    }
+      end
+    end
 
-    {'created' => created, 'updated' => updated, 'deleted' => deleted}
+    { 'created' => created, 'updated' => updated, 'deleted' => deleted }
   end
 
   delorean_fn :class_list, sig: 0 do
     Rails.configuration.marty.class_list.sort.uniq || []
   end
 
-  delorean_fn :class_headers, sig: 1 do
-    |class_name|
+  delorean_fn :class_headers, sig: 1 do |class_name|
     Marty::DataExporter.export_headers(class_name.constantize, nil, []).flatten.
       map { |f| I18n.t(f, scope: 'attributes', default: f) }
   end
 
-  delorean_fn :user_name, sig: 1 do
-    |user_id|
-
+  delorean_fn :user_name, sig: 1 do |user_id|
     Marty::User.find_by_id(user_id).try(:name)
   end
 
-  delorean_fn :sanitize_classes, sig: 1 do
-    |classes|
+  delorean_fn :sanitize_classes, sig: 1 do |classes|
     classes = classes.split(/,\s*/) if classes.is_a? String
 
     classes.to_set & class_list.to_set
   end
 
-  delorean_fn :do_export, sig: [2, 4] do
-    |pt, klass, sort_field=nil, exclude_attrs=[]|
-
+  delorean_fn :do_export, sig: [2, 4] do |pt, klass, sort_field = nil, exclude_attrs = []|
     # allow classes on class_list or any Enum to be exported
     raise "'#{klass}' not on class_list" unless
       class_list.member?(klass) || klass.constantize.is_a?(Marty::Enum)
@@ -123,15 +112,12 @@ class Marty::DataChange
       do_export(pt, klass.constantize, sort_field, exclude_attrs)
   end
 
-  delorean_fn :do_pg_enum_export, sig: 1 do
-    |k|
+  delorean_fn :do_pg_enum_export, sig: 1 do |k|
     klass = k.constantize
     next (klass.is_a? Marty::PgEnum) ? klass.get_all : []
   end
 
-  delorean_fn :export_changes, sig: 3 do
-    |t0, t1, class_name|
-
+  delorean_fn :export_changes, sig: 3 do |t0, t1, class_name|
     klass = class_name.constantize
 
     t0 = Mcfly.normalize_infinity t0
@@ -142,9 +128,9 @@ class Marty::DataChange
 
     # find all changes from t0 to t1 -- orders by id to get the lower
     # ones since those are the original version in Mcfly.
-    changes = klass.select("DISTINCT ON (group_id) *").
+    changes = klass.select('DISTINCT ON (group_id) *').
       where(change_q, t0, t1, t0, t1).
-      order("group_id, id").
+      order('group_id, id').
       to_a
 
     # update/adds, deletes
@@ -156,16 +142,16 @@ class Marty::DataChange
       else
         # if a version of row existed before t0 => add it to del list
         del << o if klass.
-          where("group_id = ? AND created_dt < ?", o.group_id, t0).exists?
+          where('group_id = ? AND created_dt < ?', o.group_id, t0).exists?
       end
     end
 
-    [chg, del].map {|l|
+    [chg, del].map do |l|
       l.empty? ? nil : Marty::DataExporter.do_export_query_result(klass, l)
-    }
+    end
   end
 
-  def self.get_changed_data(t0, t1, klass, ids=nil)
+  def self.get_changed_data(t0, t1, klass, ids = nil)
     # The following test fails when t0/t1 are infinity.  ActiveSupport
     # doesn't know about infinity.
     # return unless t0 < t1
@@ -183,7 +169,7 @@ class Marty::DataChange
 
     raise "Change count exceeds limit #{MAX_COUNT}" if countq.count > MAX_COUNT
 
-    dataq.order("group_id, created_dt").group_by(&:group_id)
+    dataq.order('group_id, created_dt').group_by(&:group_id)
   end
 
   ######################################################################
@@ -209,21 +195,17 @@ class Marty::DataChange
   # {"source" => {k1=>v1, k2=>v2, ...},
   #  "input"  => {k1=>v1, k2=>v2, ...}}
 
-  delorean_fn :diff, sig: [2, 3] do
-    |klass, input_data, ts='infinity'|
-
+  delorean_fn :diff, sig: [2, 3] do |klass, input_data, ts = 'infinity'|
     ts = Mcfly.normalize_infinity(ts)
     keys = Marty::DataConversion.assoc_keys(klass).map(&:to_s).to_set
 
     only_source, only_input, different, same = [], [], [], []
     found_sources = Set[]
 
-    input_data.each do
-      |input|
-
+    input_data.each do |input|
       input_keys = input.keys
 
-      raise "non-String keys in input data" unless
+      raise 'non-String keys in input data' unless
         input_keys.all? { |x| String === x }
 
       begin
@@ -235,7 +217,7 @@ class Marty::DataChange
         # "different".
         conv =
           Marty::DataConversion.convert_row(klass, input, ts)
-      rescue => exc
+      rescue StandardError => exc
         only_input << input
         next
       end
@@ -263,24 +245,24 @@ class Marty::DataChange
       source_export = Marty::DataExporter.export_obj(source) % input_keys
 
       different << [
-        {"_origin_" => "source"} + source_export,
-        {"_origin_" => "input"} + input,
+        { '_origin_' => 'source' } + source_export,
+        { '_origin_' => 'input' } + input,
       ]
     end
 
     # now find any live source object which have not been visited
     query = klass
 
-    query = query.where("obsoleted_dt >= ? AND created_dt < ?", ts, ts) if
+    query = query.where('obsoleted_dt >= ? AND created_dt < ?', ts, ts) if
       Mcfly.has_mcfly?(klass)
 
     query = query.where.not(id: found_sources.map(&:id))
 
     {
-      "different"   => different,
-      "same"        => same,
-      "only_input"  => only_input,
-      "only_source" => Marty::DataExporter.
+      'different'   => different,
+      'same'        => same,
+      'only_input'  => only_input,
+      'only_source' => Marty::DataExporter.
                       do_export_query_result(klass, query),
     }
   end
@@ -289,9 +271,7 @@ class Marty::DataChange
 
   # Given a Mcfly class_name, find all of the obsoleted Mcfly objects
   # which are referenced by live (non-obsoleted) class instances.
-  delorean_fn :dead_refs, sig: 2 do
-    |ts, class_name|
-
+  delorean_fn :dead_refs, sig: 2 do |ts, class_name|
     klass = class_name.constantize
 
     return unless Mcfly.has_mcfly?(klass)
@@ -299,13 +279,11 @@ class Marty::DataChange
     ts = Mcfly.normalize_infinity(ts)
     col_types = Marty::DataConversion.col_types(klass)
 
-    mcfly_cols = col_types.map { |attr, h|
+    mcfly_cols = col_types.map do |attr, h|
       Hash === h && Mcfly.has_mcfly?(h[:assoc_class]) && h || nil
-    }.compact
-
-    mcfly_cols.each_with_object({}) {
-      |h, res|
+    end.compact
 
+    mcfly_cols.each_with_object({}) do |h, res|
       fk = h[:foreign_key]
       rtable = h[:assoc_class].table_name
       ktable = klass.table_name
@@ -324,9 +302,9 @@ class Marty::DataChange
         where("#{rtable}.group_id = #{rtable}.id").
         all
 
-      arr = arr.map {|obj| Marty::DataExporter.export_attrs(klass, obj, [fk])}
+      arr = arr.map { |obj| Marty::DataExporter.export_attrs(klass, obj, [fk]) }
 
       res[fk] = arr unless arr.empty?
-    }
+    end
   end
 end