lurker 0.6.2 → 0.6.3

data/lib/lurker/schema.rb

@@ -1,89 +0,0 @@
-require 'yaml'
-
-module Lurker
-  class Schema
-    EXTENSIONS = "extensions".freeze
-    DESCRPTIONS = {
-      'index' => 'listing',
-      'show' => '',
-      'edit' => 'editing',
-      'create' => 'creation',
-      'update' => 'updating',
-      'destroy' => 'descruction'
-    }
-    attr_reader :extensions
-
-    def initialize(json_schema_hash, extensions = {})
-      @hash = json_schema_hash
-
-      existing_extensions = @hash.delete(EXTENSIONS) || {}
-      @extensions = select_extensions(existing_extensions, extensions)
-    end
-
-    def respond_to_missing?(method, include_private = false)
-      @hash.send(:respond_to_missing?, method, include_private)
-    end
-
-    def method_missing(method, *args, &block)
-      @hash.send method, *args, &block
-    end
-
-    def write_to(path)
-      if @hash['prefix'].blank?
-        @hash['prefix'] = "#{default_subject} management"
-      end
-      if @hash['description'].blank?
-        @hash['description'] = default_descrption.strip
-      end
-
-      dirname = File.dirname(path)
-      FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
-
-      File.open(path, "w") do |file|
-        file.write(to_yaml)
-      end
-    end
-
-    def to_yaml
-      YAML.dump(@hash.merge(
-        EXTENSIONS => @extensions
-      ))
-    end
-
-    def ordered!
-      @hash = Hash[@hash.sort]
-      @extensions = Hash[@extensions.sort]
-      self
-    end
-
-    protected
-
-    def serialized_for_diff
-      @serialized_for_diff ||= YAML.dump(@hash).each_line.map do |l|
-        l unless l.match(/description|example/)
-      end.compact.join
-    end
-
-    private
-
-    def select_extensions(existing, given)
-      if Lurker.upgrade? || (existing.blank? && given.present?)
-        given
-      else
-        existing
-      end
-    end
-
-    def default_descrption
-      "#{default_subject.singularize} #{DESCRPTIONS[path_params['action']]}"
-    end
-
-    def default_subject
-      "#{path_params['controller'].to_s.split(/\//).last}"
-    end
-
-    def path_params
-      @extensions['path_params'] || {}
-    end
-  end
-end

data/lib/lurker/schema_modifier/array.rb

@@ -1,28 +0,0 @@
-module Lurker
-  class SchemaModifier
-    class Array
-      def initialize(json_schema_hash)
-        @array = json_schema_hash
-      end
-
-      def merge!(data)
-        build_array
-
-        data.each do |value|
-          Lurker::SchemaModifier.merge!(@array["items"], value)
-        end
-      end
-
-      def append!(data)
-        @array << data
-      end
-
-      private
-
-      def build_array
-        @array["type"] ||= "array"
-        @array["items"] ||= {}
-      end
-    end
-  end
-end

data/lib/lurker/schema_modifier/atom.rb

@@ -1,97 +0,0 @@
-module Lurker
-  class SchemaModifier
-    class Atom
-      TYPE_MAP = {
-        "ActionDispatch::Http::UploadedFile" => "string",
-        "Fixnum" => "integer",
-        "Float" => "number",
-        "Hash" => "object",
-        "Time" => "string",
-        "TrueClass" => "boolean",
-        "FalseClass" => "boolean",
-        "NilClass" => "null"
-      }.freeze
-
-      DATE_TIME_FORMAT = "date-time".freeze
-      COLOR_FORMAT = "color".freeze
-      URI_FORMAT = "uri".freeze
-
-      def initialize(json_schema_hash)
-        @atom = json_schema_hash
-      end
-
-      def merge!(data)
-        atom = build_atom(data)
-        combined? ? append_new(atom) : combine_with(atom)
-      end
-
-      private
-
-      def combine_with(atom)
-        return @atom.clear.merge!(atom) unless @atom.key?("type")
-
-        if @atom["type"] != atom["type"]
-          existing_atom = JsonSchemaHash === @atom ? @atom.to_h : @atom.dup
-          @atom.clear
-          @atom["anyOf"] = [existing_atom, atom]
-        end
-      end
-
-      def append_new(atom)
-        # TODO : If example empty - fill from duplicate
-        return if @atom["anyOf"].detect { |atm| atm["type"] == atom["type"] }
-
-        @atom["anyOf"] << atom
-      end
-
-      def combined?
-        !!@atom["anyOf"]
-      end
-
-      def build_atom(data)
-        atom = {
-          "description" => "",
-          "type" => guess_type(data),
-          "example" => serialize_example(data)
-        }
-
-        if format = guess_format(data)
-          atom["format"] = format
-        end
-
-        atom
-      end
-
-      def serialize_example(data)
-        if data.is_a?(ActionDispatch::Http::UploadedFile)
-          data.headers
-        else
-          data
-        end
-      end
-
-      def guess_type(data)
-        in_type = data.class.to_s
-        TYPE_MAP[in_type] || in_type.downcase
-      end
-
-      def guess_format(data)
-        if data.is_a?(Time)
-          DATE_TIME_FORMAT
-        elsif data.is_a?(String)
-          if data.start_with? "http://"
-            URI_FORMAT
-          elsif data.match(/\#[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?\b/)
-            COLOR_FORMAT
-          else
-            begin
-              DATE_TIME_FORMAT if Time.iso8601(data)
-            rescue
-              nil
-            end
-          end
-        end
-      end
-    end # class Atom
-  end
-end

data/lib/lurker/schema_modifier/hash.rb

@@ -1,30 +0,0 @@
-module Lurker
-  class SchemaModifier
-    class Hash
-      def initialize(json_schema_hash)
-        @hash = json_schema_hash
-      end
-
-      def merge!(data)
-        build_hash
-
-        data.each do |name, value|
-          unless @hash[name]
-            @hash["properties"][name] ||= {}
-            Lurker::SchemaModifier.merge!(@hash["properties"][name], value)
-          end
-        end
-      end
-
-      private
-
-      def build_hash
-        @hash["description"] ||= ""
-        @hash["type"] ||= "object"
-        @hash["additionalProperties"] = false if @hash["additionalProperties"].nil?
-        @hash["required"] ||= []
-        @hash["properties"] ||= {}
-      end
-    end
-  end
-end

data/lib/lurker/schema_modifier.rb

@@ -1,48 +0,0 @@
-module Lurker
-  class SchemaModifier
-    class << self
-      def merge!(schema, data)
-        new(schema, data).merge!
-      end
-
-      def append!(schema, data)
-        new(schema, data).append!
-      end
-    end
-
-    def initialize(schema, data)
-      @schema = schema
-      @data = data
-    end
-
-    def merge!
-      modifier_klass.new(@schema).merge!(@data)
-      @schema
-    end
-
-    def append!
-      schema_klass.new(@schema).append!(@data)
-      @schema
-    end
-
-    private
-
-    def schema_klass
-      klass_from_type(@schema)
-    end
-
-    def modifier_klass
-      klass_from_type(@data)
-    end
-
-    def klass_from_type(anything)
-      if anything.is_a?(::Hash)
-        Lurker::SchemaModifier::Hash
-      elsif anything.is_a?(::Array)
-        Lurker::SchemaModifier::Array
-      else
-        Lurker::SchemaModifier::Atom
-      end
-    end
-  end
-end