mediawiktory 0.0.3 → 0.1.0

data/lib/mediawiktory/generator/api.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'open-uri'
+require 'json'
+
+module MediaWiktory
+  class Generator
+    class Api < OpenStruct
+      class << self
+        def from_html(source, **metadata)
+          doc = Nokogiri::HTML(source)
+          modules =
+            doc
+            .at('#mw-content-text').children_groups('h3,h4', 'div,p')
+            .map { |title, components| Module.from_html_nodes(title.first._n.text.to_s, components) }
+
+          new(**metadata.merge(modules: modules))
+        end
+
+        def from_url(url)
+          uri = Addressable::URI.parse(url)
+          uri.query_values = {action: :query, meta: :siteinfo, siprop: :general, format: :json}
+          meta = JSON.parse(open(uri).read)['query']['general']
+          uri.query_values = {action: :help, recursivesubmodules: true}
+          html = open(uri).read
+          from_html(html, site: OpenStruct.new(name: meta['sitename'], base: meta['base']))
+        end
+      end
+
+      def initialize(**source)
+        super(source.merge(
+          main: source[:modules].detect(&:main?),
+          actions: source[:modules].select(&:action?),
+          non_actions: source[:modules].reject { |m| m.main? || m.action? }
+        ))
+        modules.each { |m| m.api = self }
+
+        # "generators" parameter for action=query are special. They are not defined by modules, but
+        # by "You can use this or that module, just add 'g' to it".
+        query = actions.detect { |a| a.name == 'query' } or return
+        query.params.detect { |p| p.name == 'generator' }
+             .tap do |query_generator|
+
+          self.generators =
+            query_generator
+            .modules.map { |mod|
+              mod.merge(
+                name: "g-#{mod.name}",
+                description: "#{mod.description} _Generator module: for fetching pages corresponding to request._",
+                params: mod.params.reject { |p| p.name == 'prop' }.map(&:dup)
+              ).tap { |m| m.prefix = "g#{m.prefix}" }
+            }
+
+          modules.concat(generators)
+          non_actions.concat(generators)
+          query_generator.vals =
+            query_generator.vals.map { |v| {name: v.name, module: "g-#{v.module}"} }
+        end
+      end
+
+      def module(name)
+        candidates = modules.reject(&:action?).select { |m| m.name == name }
+        candidates.empty? and fail ArgumentError, "Module #{name} not found"
+        candidates.count == 1 or fail ArgumentError, "Module #{name} is ambigous"
+        candidates.first
+      end
+
+      include Renderable
+
+      def main_template
+        'api.rb'
+      end
+    end
+  end
+end

data/lib/mediawiktory/generator/module.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module MediaWiktory
+  class Generator
+    class Module < Hashie::Mash
+      disable_warnings
+
+      class << self
+        def from_html_nodes(title, nodes)
+          type, name, prefix = title.scan(/^([a-z]+)=([^(]+)(?:\s+\((.+)\))?$/).flatten
+
+          new(
+            type: type._n.to_sym || :main,
+            name: name || '',
+            prefix: prefix,
+            description: extract_description(nodes),
+            flags: extract_flags(nodes),
+            params: extract_params(nodes, prefix)
+          )
+        end
+
+        private
+
+        def extract_description(nodes)
+          nodes.detect { |n| n.name == 'p' }._n.text.to_s.tr("\n", ' ').strip
+        end
+
+        def extract_flags(nodes)
+          flags = nodes.detect { |n| n['class']._n.include?('apihelp-flags') } or return []
+          flags.search('ul li > span').to_a
+               .map { |el| {id: el.attr('class'), text: el.text} }
+               .map { |h| h.merge(role: h[:id].sub(/^apihelp-(flag-)?/, '')) }
+        end
+
+        def extract_params(nodes, prefix)
+          params = nodes.detect { |n| n['class']._n.include?('apihelp-parameters') } or return []
+          params.at('dl').each_term.to_a
+                .map { |dts, dds| Param.from_html_nodes(dts.first.text, dds, prefix: prefix) }
+        end
+      end
+
+      attr_reader :api
+
+      def initialize(*)
+        super
+        # 'action' should not be rendered as "available default params" for api initializer
+        params.reject! { |p| p.name == 'action' } if main?
+      end
+
+      def prefix=(pre)
+        super
+        params.each { |p| p.prefix = pre }
+      end
+
+      def inspect
+        "#<#{self.class.name} #{name}>"
+      end
+
+      def action?
+        type == :action
+      end
+
+      def main?
+        type == :main
+      end
+
+      include Renderable
+
+      def main_template
+        'action_class.rb'
+      end
+
+      def api=(api)
+        @api = api
+        params.each { |p| p.api = api }
+      end
+
+      def description
+        super.split("\n").join("\n#\n# ")
+      end
+
+      def params
+        # TODO: some actions have "rest of parameters, see there".
+        # Currently, we ignore it
+        (super || []).reject { |p| p.name == '*' || main? && p.name == 'action' }
+      end
+
+      def http_method
+        post? ? 'Post' : 'Get'
+      end
+
+      def post?
+        flags.any? { |f| f.id == 'apihelp-flag-mustbeposted' }
+      end
+
+      def method_name
+        name.sub(/^g-/, '').split('-').join('_')
+      end
+
+      def class_name
+        name.split('-').map(&:capitalize).join
+      end
+    end
+  end
+end

data/lib/mediawiktory/generator/param.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module MediaWiktory
+  class Generator
+    class Param < Hashie::Mash
+      disable_warnings
+
+      class << self
+        def from_html_nodes(name, dds, prefix: nil)
+          new(
+            full_name: name,
+            name: name.sub(/^#{prefix}/, ''),
+            prefix: prefix,
+            description: extract_description(dds),
+            type: extract_type(dds),
+            vals: extract_values(dds)
+
+            # TODO: lost params
+            #   limit: extract_limit(dds),
+            #   default: extract_default(dds)
+
+            # TODO: mandatoriness:
+            # * optional
+            # * mandatory
+            # * this OR that is mandatory
+            # * this AND that can't intersect
+            # * and so on
+          )
+        end
+
+        def extract_description(els)
+          els.detect { |e| e.attr('class') == 'description' }.at('p')._n.text.to_s.strip.tr("\n", ' ')
+        end
+
+        def extract_type(els)
+          # TODO: "Expiry time. May be relative (e.g. 5 months or 2 weeks) or absolute
+          #   (e.g. 2014-09-18T12:34:56Z). If set to infinite, indefinite, or never, the block will
+          #   never expire."
+          els.select { |e| e.attr('class') == 'info' }.each do |el|
+            case el.text
+            when /^Type: ([^\(]+)\s*($|\()/
+              return Regexp.last_match(1).strip
+            when /^Values \(separate with \|/,
+                 /^Separate values with \|/
+              return 'list'
+            when /^One of the following values:/
+              return 'enum'
+            end
+          end
+          'string'
+        end
+
+        def extract_default(els)
+          els.each { |el| return Regexp.last_match(1) if el =~ /^Default:\s*(.+)$/ }
+          nil
+        end
+
+        def extract_values(els)
+          # 1. try dl from definition
+          els.detect { |e| e.attr('class') == 'description' }.tap { |d|
+            if d.at('dl')
+              return d.at('dl').each_term.map { |dts, dds|
+                {name: dts.first.text, description: dds.first.text.tr("\n", ' ')}
+              }
+            end
+          }
+
+          # 2. ...or take from info
+          els.select { |e| e.attr('class') == 'info' }.each do |el|
+            if el.text =~
+               /^(?:One of the following values||Values \(separate with \|.*?\)):\s*(.+)$/
+              if el.search('a').count > 1
+                return el.search('a').reject { |a| a.text == 'alternative' }
+                         .map { |a|
+                         {
+                           name: a.text,
+                           module: a.attr('href').scan(/^.*[\#+](.+)$/).flatten.first
+                         }
+                       }
+              else
+                return Regexp.last_match(1).sub(/^Can be empty, or/, '').split(',')
+                             .map { |s| s.gsub(/^[[:space:]]|[[:space:]]$/, '') }
+              end
+            end
+          end
+
+          nil
+        end
+      end
+
+      attr_accessor :api
+
+      def inspect
+        "#<#{self.class} #{name} (#{type})>"
+      end
+
+      alias_method :to_s, :inspect
+
+      def prefix=(pre)
+        super
+        self.full_name = "#{prefix}#{name}"
+      end
+
+      def full_name
+        self['full_name']._n.include?('-') ? "'#{self['full_name']}'" : self['full_name']
+      end
+
+      def method_name
+        name.tr('-', '_')
+      end
+
+      def modules_hash
+        modules.map { |m| module_in_hash(m) }.join(', ')
+      end
+
+      def enum_values
+        return [] unless vals
+
+        if vals.all? { |v| v.is_a?(String) }
+          vals.map(&:inspect).join(', ')
+        elsif vals.all? { |v| v.is_a?(Hash) && v.key?(:description) }
+          vals.map { |v| v[:name].inspect }.join(', ')
+        elsif modules?
+          vals.map { |v| v[:name].to_sym.inspect }.join(', ')
+        else
+          fail ArgumentError, "Unrenderable values: #{vals}"
+        end
+      end
+
+      def list?
+        type.start_with?('list')
+      end
+
+      def enum?
+        type.start_with?('enum')
+      end
+
+      def impl_type
+        type = real_type.sub(/^list of (.+)s$/, '\1')
+        type = 'string' if type == 'list'
+        type = 'enum of modules' if type == 'module'
+        case type
+        when 'string', 'user name', 'integer', 'integer or max'
+          'string'
+        when 'boolean'
+          'boolean'
+        when 'timestamp'
+          'timestamp'
+        when 'enum'
+          'enum'
+        when 'enum of modules'
+          'enum_of_modules'
+        else
+          fail ArgumentError, "Cannot render #{real_type} to Ruby still"
+        end
+      end
+
+      def ruby_type
+        case real_type
+        when 'string', 'user name', 'enum'
+          'String'
+        when 'boolean'
+          'true, false'
+        when 'integer'
+          'Integer'
+        when 'integer or max'
+          'Integer, "max"'
+        when 'list', 'list of user names', 'list of enums'
+          'Array<String>'
+        when 'list of integers'
+          'Array<Integer>'
+        when 'list of timestamps'
+          'Array<Time>'
+        when 'enum of modules'
+          'Symbol'
+        when 'list of modules'
+          'Array<Symbol>'
+        when 'timestamp'
+          'Time'
+        else
+          fail ArgumentError, "Cannot render #{real_type} to Ruby still"
+        end
+      end
+
+      def module_in_hash(m)
+        "#{m.method_name}: Modules::#{m.class_name}"
+      end
+
+      def param_docs
+        case real_type
+        when 'enum'
+          " One of #{render_vals}."
+        when 'enum of modules'
+          ' Selecting an option includes tweaking methods from corresponding module:'
+        when 'list of modules'
+          ' All selected options include tweaking methods from corresponding modules:'
+        when 'list of enums'
+          " Allowed values: #{render_vals}."
+        end
+      end
+
+      def render_vals
+        if vals.all? { |v| v.is_a?(String) }
+          vals.map(&:inspect).join(', ')
+        elsif vals.all? { |v| v.is_a?(Hash) && v.key?(:description) }
+          vals.map { |v| "#{v[:name].inspect} (#{v[:description].chomp('.')})" }.join(', ')
+        elsif modules?
+        else
+          fail ArgumentError, "Unrenderable values: #{vals}"
+        end
+      end
+
+      def param_def
+        case real_type
+        when 'boolean'
+          '' # just sets `true` if method was called
+        when /^list/
+          '*values'
+        else
+          'value'
+        end
+      end
+
+      def value_conv
+        case real_type
+        when 'boolean'
+          "'true'" # on false, merge(param: something) not rendered at all
+        when 'list of modules'
+          "modules_to_hash(values, #{modules.map { |m| m.name.to_sym }})"
+        when 'list of timestamps'
+          "values.map(&:iso8601).join('|')"
+        when /^list/
+          "values.join('|')"
+        when 'enum of modules'
+          "module_to_hash(value, #{modules.map { |m| m.name.to_sym }})"
+        when 'timestamp'
+          'value.iso8601'
+        else
+          'value.to_s'
+        end
+      end
+
+      def real_type
+        case type
+        when 'enum'
+          modules? ? 'enum of modules' : 'enum'
+        when 'list'
+          if modules?
+            'list of modules'
+          elsif vals
+            'list of enums'
+          else
+            'list'
+          end
+        else
+          type
+        end
+      end
+
+      def modules?
+        vals._n.all? { |v| v.is_a?(Hash) && v.key?(:module) }
+      end
+
+      def modules
+        modules? ? vals.map { |v| api.module(v.module) } : []
+      end
+
+      include Renderable
+    end
+  end
+end