mediawiktory 0.0.1

data/lib/mediawiktory/generated/wikisets.rb

@@ -0,0 +1,10 @@
+module MediaWiktory
+  class Wikisets < MWModule
+    symbol :wikisets
+    prefix "ws"
+    param :from, Params::String
+    param :prop, Params::List[Params::Enum["type", "wikisincluded", "wikisnotincluded"]]
+    param :limit, Params::IntegerOrMax
+    param :orderbyname, Params::Boolean
+  end
+end

data/lib/mediawiktory/generated/zeroconfig.rb

@@ -0,0 +1,7 @@
+module MediaWiktory
+  class Zeroconfig < Action
+    symbol :zeroconfig
+    param :type, Params::Enum["config", "message"]
+    param :agent, Params::String
+  end
+end

data/lib/mediawiktory/mw_module.rb

@@ -0,0 +1,320 @@
+module MediaWiktory
+  module Params
+    class Param
+      attr_reader :name, :value
+      
+      def initialize(name, value = nil)
+        @name = name
+        self.value = value if value
+      end
+
+      def value=(val)
+        valid?(val) or
+          fail(ArgumentError, "Invalid value #{val.inspect} for param #{name} (#{self.class})")
+
+        @value = val
+      end
+      
+      def to_param(prefix = nil)
+        {"#{prefix}#{name}" => value_to_param}
+      end
+
+      def value_to_param
+        value.to_s
+      end
+
+      def self.valid?(val)
+        true
+      end
+
+      def valid?(val)
+        self.class.valid?(val)
+      end
+    end
+    
+    class String < Param
+      def self.valid?(val)
+        val.kind_of?(::String)
+      end
+    end
+
+    class Boolean < Param
+      def self.valid?(val)
+        [true, false].include?(val)
+      end
+    end
+
+    class Integer < Param
+      def self.valid?(val)
+        val.kind_of?(::Integer)
+      end
+    end
+
+    class IntegerOrMax < Integer
+      def self.valid?(val)
+        super || val == 'max'
+      end
+    end
+
+    class Timestamp < Param
+      def self.valid?(val)
+        val.kind_of?(::Time)
+      end
+
+      def value_to_param
+        value.iso8601
+      end
+    end
+
+    class Enum < Param
+      class << self
+        def [](*values)
+          Class.new(self){
+            self.allowed_values = values
+          }
+        end
+
+        attr_accessor :allowed_values
+
+        def inspect
+          "#<Enum#{allowed_values}>"
+        end
+
+        alias_method :to_s, :inspect
+      end
+
+      def self.valid?(val)
+        allowed_values or fail(NotImplementedError, "Abstract enum used as a param type")
+        allowed_values.include?(val)
+      end
+    end
+
+    class List < Param
+      class << self
+        def [](type)
+          Class.new(self){
+            self.member_type = type
+          }
+        end
+
+        attr_accessor :member_type
+
+        def inspect
+          "#<List#{member_type}>"
+        end
+
+        alias_method :to_s, :inspect
+      end
+
+      def self.valid?(val)
+        member_type or fail(NotImplementedError, "Abstract list used as param type")
+        val.is_a?(Array) && val.all?{|v| member_type.valid?(v)}
+      end
+
+      def value_to_param
+        value.join('|')
+      end
+    end
+
+    class Module < Param
+      class << self
+        def [](*values)
+          Class.new(self){
+            self.allowed_values = values
+          }
+        end
+
+        attr_accessor :allowed_values
+      end
+      
+      def value=(val)
+        super(val && MWModule.coerce(val))
+      end
+
+      def to_param(prefix = nil)
+        {"#{prefix}#{name}" => value.class.symbol.to_s}.merge(value_to_param)
+      end
+
+      def value_to_param
+        if name == :generator
+          value.to_param.map{|k, v| ["g#{k}", v]}.to_h
+        else
+          value.to_param
+        end
+      end
+
+      def self.valid?(val)
+        allowed_values or fail(NotImplementedError, "Abstract module used as a param type")
+        allowed_values.include?(val.class.symbol)
+      end
+    end
+
+    class Modules < Param
+      class << self
+        def [](*values)
+          Class.new(self){
+            self.allowed_values = values
+          }
+        end
+
+        attr_accessor :allowed_values
+      end
+
+      def value=(val)
+        super(val && coerce_modules(val))
+      end
+
+      def to_param(prefix = nil)
+        {
+          "#{prefix}#{name}" => value.map{|v|v.class.symbol}.join('|')
+        }.merge(value_to_param)
+      end
+
+      def value_to_param
+        if name == :generator
+          value.map(&:to_param).inject({}, :merge).
+            map{|k, v| ["g#{k}", v]}.to_h
+        else
+          value.map(&:to_param).inject({}, :merge)
+        end
+      end
+
+      def self.valid?(val)
+        allowed_values or fail(NotImplementedError, "Abstract module used as a param type")
+        val.all?{|v| allowed_values.include?(v.class.symbol)}
+      end
+
+      private
+
+      def coerce_modules(value)
+        # making array of 1-item hashes
+        value.map{|val|
+          case val
+          when Symbol
+            {val => {}}
+          when Hash
+            val.map{|k, v| {k => v}}
+          when MWModule
+            val
+          else
+            fail(ArgumentError, "#{val} can not be coerced into module")
+          end
+        }.flatten.map{|h| MWModule.coerce(h)}
+      end
+    end
+  end
+
+  class MWModule
+
+    class << self
+      def list
+        @list ||= {}
+      end
+      
+      def symbol(sym = nil)
+        return @symbol unless sym
+        @symbol = sym
+        MWModule.list[sym] = self
+      end
+
+      def prefix(pref = nil)
+        return @prefix unless pref
+        @prefix = pref
+      end
+
+      def coerce(value)
+        case value
+        when Symbol
+          MWModule.list.key?(value) or
+            fail(ArgumentError, "Unsupported module: #{value} for #{self}")
+          MWModule.list[value].new
+          
+        when Hash
+          value.count == 1 or
+            fail(ArgumentError, "Too many values for module initialization")
+
+          name, attr = value.first
+          MWModule.list.key?(name) or
+            fail(ArgumentError, "Unsupported module: #{name} for #{self}")
+
+          attr.is_a?(Hash) or
+            fail(ArgumentError, "Module only can be initialized with a hash, #{attr.class} given")
+
+          MWModule.list[name].new(attr)
+        when MWModule
+          value
+        else
+          fail ArgumentError, "Can not coerce #{value} into module"
+        end
+      end
+
+      def params
+        @params ||= {}
+      end
+
+      def param(name, type)
+        params[name] = type
+        
+        define_method(name){|*arg|
+          return param(name).value if arg.empty?
+          
+          dup.tap{|dup| 
+            case
+            when type.ancestors.include?(Params::List) ||
+                 type.ancestors.include?(Params::Modules)
+              dup.param(name).value = arg.flatten
+            else
+              dup.param(name).value = arg.first
+            end
+          }
+        }
+      end
+
+      def request_method
+        @request_method || :get
+      end
+
+      def post!
+        @request_method = :post
+      end
+    end
+
+    def initialize(**values)
+      @params = Hash.new{|h, name|
+        self.class.params.key?(name) or
+          fail(ArgumentError, "Unknown param: #{name} for #{self}")
+        h[name] = self.class.params[name].new(name)
+      }
+      
+      values.each do |k, v|
+        set(k, v)
+      end
+    end
+
+    def dup
+      self.class.new(to_h)
+    end
+
+    def to_h
+      @params.map{|n, p| [n, p.value]}.to_h
+    end
+
+    def param(name)
+      @params[name]
+    end
+
+    def to_param
+      @params.values.
+        map{|p| p.to_param(self.class.prefix)}.
+        inject({}, :merge)
+    end
+
+    protected
+
+    def set(name, value)
+      self.class.params.key?(name) or
+        fail(ArgumentError, "Unknown param: #{name} for #{self}")
+      @params[name] = self.class.params[name].new(name, value)
+    end
+  end
+end

data/lib/mediawiktory/query.rb

@@ -0,0 +1,60 @@
+require_relative 'array_with_keys'
+
+module MediaWiktory
+  class Query
+    def continue(additional_params)
+      client.get(to_param.merge(additional_params))
+    end
+  
+    class Response < Action::Response
+      def pages
+        @pages ||= ArrayWithKeys.from_hash(raw.query.pages || {})
+      end
+
+      def continue?
+        !raw.continue.nil?
+      end
+
+      def continue!
+        continue? or fail(RuntimeError, "Response can not be continued")
+        
+        merge!(action.perform(raw.continue))
+
+        self
+      end
+
+      def continue
+        dup.continue!
+      end
+
+      private
+
+      def merge!(other)
+        # FIXME: not the brightest code in my life, faithfully
+        # FIXME2: after this merge, only @pages are updated, but @raw.query.pages IS NOT
+        other.pages.to_h.each do |k, p|
+          if (existing = pages[k])
+            merge_page(existing, p)
+          else
+            pages.push(p, p.id)
+          end
+        end
+
+        raw.continue = other.raw.continue
+      end
+
+      def merge_page(existing, other)
+        other.each do |k, v|
+          case existing[k]
+          when Array
+            existing[k].concat(v)
+          when Hash
+            existing[k].merge!(v)
+          else
+            existing[k] = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mediawiktory/version.rb

@@ -0,0 +1,3 @@
+module MediaWiktory
+  VERSION = '0.0.1'
+end

data/lib/mediawiktory.rb

@@ -0,0 +1,16 @@
+require 'addressable/uri'
+require 'faraday'
+
+module MediaWiktory
+  %w[client mw_module action].each do |mod|
+    require_relative "mediawiktory/#{mod}"
+  end
+
+  Dir[File.expand_path('../mediawiktory/generated/*.rb', __FILE__)].each do |gen|
+    require gen
+  end
+
+  %w[query].each do |mod|
+    require_relative "mediawiktory/#{mod}"
+  end
+end

data/lib/nokogiri/more.rb

@@ -0,0 +1,72 @@
+require 'naught'
+
+module Nokogiri
+  module More
+    module NodeChildrenGroups
+      def children_groups(*selectors)
+        groups = []
+        flat = children.select{|node| selectors.any?{|s| node.matches?(s)}}
+        while !flat.empty?
+          groups << make_group(flat, selectors)
+        end
+        groups
+      end
+      
+      #include NodeOnlyFor
+      
+      def each_term
+        children_groups('dt', 'dd')
+      end
+      
+      private
+      
+      def make_group(flat, selectors)
+        sel = selectors.dup
+        group = [[]]
+        while !flat.empty?
+          if flat.first.matches?(sel.first)
+            group.last << flat.shift
+          elsif sel.size > 1 && flat.first.matches?(sel[1])
+            sel.shift
+            group << []
+            group.last << flat.shift
+          else
+            break
+          end
+        end
+        group
+      end
+    end
+
+    NodeNaught = Naught.build do |config|
+      config.black_hole
+
+      # so you can just `at?(selector).tap{|node| ...`
+      # and never be inside `tap`, if it's not found
+      def tap 
+        self
+      end
+    end
+
+    module NodeQuestMethods
+      def at?(selector)
+        at(selector) || NodeNaught.new
+      end
+
+      def at_css?(selector)
+        at_css(selector) || NodeNaught.new
+      end
+
+      def at_xpath?(selector)
+        at_xpath(selector) || NodeNaught.new
+      end
+      
+      def find_child?(selector)
+        find_child(selector) || NodeNaught.new
+      end
+    end
+  end
+
+  Nokogiri::XML::Node.send(:include, More::NodeChildrenGroups)
+  Nokogiri::XML::Node.send(:include, More::NodeQuestMethods)
+end

data/mediawiktory.gemspec

@@ -0,0 +1,30 @@
+require './lib/mediawiktory/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'mediawiktory'
+  s.version  = MediaWiktory::VERSION
+  s.authors  = ['Victor Shepelev']
+  s.email    = 'zverok.offline@gmail.com'
+  s.homepage = 'https://github.com/molybdenum-99/mediawiktory'
+
+  s.summary = 'Full-featured MediaWiki client with Arel-like queries'
+  s.licenses = ['MIT']
+
+  s.files = `git ls-files`.split($RS).reject do |file|
+    file =~ /^(?:
+    spec\/.*
+    |Gemfile
+    |Rakefile
+    |\.rspec
+    |\.gitignore
+    |\.rubocop.yml
+    |\.travis.yml
+    )$/x
+  end
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'faraday'
+  s.add_dependency 'faraday_middleware'
+  s.add_dependency 'hashie'
+  s.add_dependency 'addressable'
+end